@remix-gg/three 0.1.1

package/dist/collide.js

@@ -0,0 +1,321 @@
+import { Vector3 } from 'three';
+const EPSILON = 1e-8;
+/**
+ * How close counts as touching.
+ *
+ * Contact has to be a band, not float equality. A game places its player at
+ * `y = platformTop` — the obvious authoring choice, and the one an LLM makes
+ * every time — so "resting on" and "exactly coincident with" are the same
+ * state, and every frame after that the body sits within a rounding error of
+ * the surface. Treating that as an overlap is what froze bodies in place: the
+ * resolver saw a t=0 contact, had no normal to slide along, and cancelled
+ * nothing.
+ *
+ * 1e-3 world units is far below anything visible at the scale portrait games
+ * work at (a character is ~1 unit) and far above the float error a few frames
+ * of accumulated motion can produce.
+ */
+const CONTACT_EPSILON = 1e-3;
+/**
+ * Swept AABB against a set of static boxes: how far `box` can move along
+ * `velocity` before it touches something, and the face it touched.
+ *
+ * This is the slab method. Discrete overlap tests are what let a fast-moving
+ * player tunnel straight through the floor on a slow frame; sweeping cannot.
+ *
+ * Contact is measured against `contactEpsilon`, and the three states a real
+ * game spends its time in all resolve here rather than in the caller:
+ *
+ * - **resting** (`box.min.y === obstacle.max.y`) reports a hit at `t = 0` with
+ *   an upward normal, so the caller can cancel gravity and stay grounded;
+ * - **sliding along** that same surface — no motion on the contact axis —
+ *   reports no hit, because touching is not overlapping;
+ * - **leaving** it (a jump) reports no hit, because the overlap window closed
+ *   before this step began.
+ */
+export function sweepAabb(box, velocity, obstacles, contactEpsilon = CONTACT_EPSILON) {
+    let nearest = 1;
+    const normal = new Vector3();
+    let hit = false;
+    for (const obstacle of obstacles) {
+        // -Infinity, not 0. Clamping the entry time to 0 up front makes "enters
+        // exactly now" and "entered some time ago" the same number, and a body that
+        // starts in contact is always the second one. That conflation is what
+        // produced a hit with a (0,0,0) normal, which slides along nothing.
+        let entry = Number.NEGATIVE_INFINITY;
+        let exit = Number.POSITIVE_INFINITY;
+        const axisNormal = new Vector3();
+        let separated = false;
+        for (const axis of AXES) {
+            const delta = velocity[axis];
+            const minDistance = obstacle.min[axis] - box.max[axis];
+            const maxDistance = obstacle.max[axis] - box.min[axis];
+            if (Math.abs(delta) < EPSILON) {
+                // No motion on this axis: if they are apart here they can never touch,
+                // whatever the other axes do — and merely touching counts as apart.
+                // That clause is what lets a body walk along the floor it is standing
+                // on instead of colliding with it once per frame.
+                if (minDistance >= -contactEpsilon || maxDistance <= contactEpsilon) {
+                    separated = true;
+                    break;
+                }
+                continue;
+            }
+            // The face being approached sets the entry time; the face being left sets
+            // the exit. The exit face is pulled in by the contact band so a body in
+            // contact with a surface and moving *off* it reads as already separated
+            // rather than as colliding with the thing it is leaving. Without that, a
+            // jump is cancelled on its first frame by the floor underneath.
+            let axisEntry;
+            let axisExit;
+            let sign;
+            if (delta > 0) {
+                axisEntry = minDistance / delta;
+                axisExit = (maxDistance - contactEpsilon) / delta;
+                sign = -1;
+            }
+            else {
+                axisEntry = maxDistance / delta;
+                axisExit = (minDistance + contactEpsilon) / delta;
+                sign = 1;
+            }
+            if (axisEntry > entry) {
+                entry = axisEntry;
+                axisNormal.set(0, 0, 0);
+                axisNormal[axis] = sign;
+            }
+            if (axisExit < exit)
+                exit = axisExit;
+            if (entry > exit) {
+                separated = true;
+                break;
+            }
+        }
+        if (separated)
+            continue;
+        // The overlap window closed before this step began: the body is moving away
+        // from something it touches, not into it.
+        if (exit <= 0)
+            continue;
+        // A contact already in progress resolves now, at t=0. The normal is the one
+        // recorded for the axis entered last, which is the axis to slide along.
+        const time = entry > 0 ? entry : 0;
+        if (time > 1 || time >= nearest)
+            continue;
+        nearest = time;
+        normal.copy(axisNormal);
+        hit = true;
+    }
+    return { hit, time: nearest, normal };
+}
+const AXES = ['x', 'y', 'z'];
+/**
+ * The displacement that pushes `box` out of everything it is currently inside.
+ *
+ * A sweep cannot help a body that starts overlapping: there is no direction of
+ * travel that leaves the obstacle, so every step reports a contact at t=0 and
+ * the body never moves. Depenetration is the only way out, and games produce
+ * the state constantly — a player authored at `y = platformTop` straddles the
+ * surface by half its height, and anything spawned into a scene it did not
+ * measure lands inside something.
+ *
+ * Per obstacle: the smallest of the six axis-aligned exits (the minimum
+ * translation vector), applied immediately so the next obstacle is measured
+ * against the already-displaced box. Summing every obstacle's MTV instead — the
+ * obvious implementation — double-counts a body resting in a floor built from
+ * two adjacent tiles, because both tiles ask for the same upward push and the
+ * body pops out twice as far as it should.
+ *
+ * Bodies are pushed to exactly touching, not to touching-plus-a-nudge: contact
+ * is a band, and `sweepAabb` already treats a body flush against a surface as
+ * resting on it rather than stuck in it.
+ *
+ * Mutates nothing.
+ */
+export function depenetrate(box, obstacles, contactEpsilon = CONTACT_EPSILON) {
+    const total = new Vector3();
+    const min = box.min.clone();
+    const max = box.max.clone();
+    for (const obstacle of obstacles) {
+        let bestAxis = null;
+        let bestPush = 0;
+        let bestDepth = Number.POSITIVE_INFINITY;
+        for (const axis of AXES) {
+            const forward = obstacle.max[axis] - min[axis];
+            const backward = max[axis] - obstacle.min[axis];
+            if (forward <= contactEpsilon || backward <= contactEpsilon) {
+                bestAxis = null;
+                break;
+            }
+            const depth = Math.min(forward, backward);
+            if (depth < bestDepth) {
+                bestDepth = depth;
+                bestAxis = axis;
+                bestPush = forward < backward ? forward : -backward;
+            }
+        }
+        if (!bestAxis)
+            continue;
+        total[bestAxis] += bestPush;
+        min[bestAxis] += bestPush;
+        max[bestAxis] += bestPush;
+    }
+    return total;
+}
+/**
+ * Is there a surface directly under the body, within the contact band?
+ *
+ * `grounded` has to be a state, not an event. Derived only from a contact found
+ * during this step's sweep it flickers off on every frame where the body is
+ * already resting and has no vertical motion left to collide with — which is
+ * every frame in a game that zeroes vertical velocity while grounded — and a
+ * jump gated on it becomes unreliable in exactly the way players call "the
+ * controls are broken".
+ */
+function restsOnSurface(box, obstacles, contactEpsilon) {
+    for (const obstacle of obstacles) {
+        // Standing with one edge exactly on the lip of a platform is not standing
+        // on it, so the horizontal overlap has to be real rather than a touch.
+        if (box.min.x >= obstacle.max.x - contactEpsilon)
+            continue;
+        if (box.max.x <= obstacle.min.x + contactEpsilon)
+            continue;
+        if (box.min.z >= obstacle.max.z - contactEpsilon)
+            continue;
+        if (box.max.z <= obstacle.min.z + contactEpsilon)
+            continue;
+        const gap = box.min.y - obstacle.max.y;
+        if (gap <= contactEpsilon && gap >= -contactEpsilon)
+            return true;
+    }
+    return false;
+}
+/**
+ * Moves a kinematic AABB through static geometry, sliding along contacts.
+ *
+ * The model, in the order it runs:
+ *
+ * 1. **Depenetrate.** Anything the body starts inside is escaped first, so the
+ *    sweep is always asked a question it can answer.
+ * 2. **Sweep and slide**, up to `maxIterations` times. A contact cancels the
+ *    component of the motion pointing into the surface and keeps the rest, so a
+ *    body resting on the ground still walks along it and a body against a wall
+ *    still slides.
+ * 3. **Probe for ground.** Grounded is a state — a surface within
+ *    `contactEpsilon` under the body — not just a normal seen this step.
+ *
+ * Mutates nothing: `box` is read, and the caller applies the returned position.
+ */
+export function resolveKinematic(box, velocity, obstacles, options = {}) {
+    const maxIterations = options.maxIterations ?? 3;
+    const slop = options.slop ?? 1e-4;
+    const contactEpsilon = options.contactEpsilon ?? CONTACT_EPSILON;
+    const current = box.clone();
+    const pushOut = depenetrate(current, obstacles, contactEpsilon);
+    current.min.add(pushOut);
+    current.max.add(pushOut);
+    const remaining = velocity.clone();
+    const result = velocity.clone();
+    let grounded = false;
+    for (let i = 0; i < maxIterations; i++) {
+        if (remaining.lengthSq() < EPSILON)
+            break;
+        const sweep = sweepAabb(current, remaining, obstacles, contactEpsilon);
+        if (!sweep.hit) {
+            current.min.add(remaining);
+            current.max.add(remaining);
+            break;
+        }
+        // `slop` is a distance, not a fraction of the motion. Stopping the same
+        // fraction short of contact leaves a 3 mm gap after a fast fall and a
+        // 10-micron gap after a slow one, and the fast case then reads as airborne.
+        const advance = Math.max(sweep.time - slop / remaining.length(), 0);
+        const step = remaining.clone().multiplyScalar(advance);
+        current.min.add(step);
+        current.max.add(step);
+        if (sweep.normal.y > 0.5)
+            grounded = true;
+        // Slide: drop the component of the motion pointing into the surface, keep
+        // the rest. Without this a player walking into a wall stops dead instead of
+        // sliding along it.
+        remaining.sub(step);
+        const into = remaining.dot(sweep.normal);
+        remaining.addScaledVector(sweep.normal, -into);
+        const resultInto = result.dot(sweep.normal);
+        if (resultInto < 0)
+            result.addScaledVector(sweep.normal, -resultInto);
+    }
+    if (!grounded)
+        grounded = restsOnSurface(current, obstacles, contactEpsilon);
+    return { position: current.getCenter(new Vector3()), velocity: result, grounded };
+}
+/**
+ * Uniform-grid broadphase.
+ *
+ * Testing every candidate against every other is O(n^2) and a phone notices at
+ * a couple of hundred. Size cells around your typical object.
+ */
+export class Grid {
+    cellSize;
+    cells = new Map();
+    constructor(cellSize) {
+        this.cellSize = cellSize;
+        if (!(cellSize > 0))
+            throw new Error(`Grid: cellSize must be > 0, got ${cellSize}`);
+    }
+    insert(item, bounds) {
+        for (const key of this.keysFor(bounds)) {
+            const cell = this.cells.get(key);
+            if (cell)
+                cell.push(item);
+            else
+                this.cells.set(key, [item]);
+        }
+    }
+    /** Candidates overlapping `bounds`, deduplicated. Still needs a narrow test. */
+    query(bounds, out = []) {
+        out.length = 0;
+        const seen = new Set();
+        for (const key of this.keysFor(bounds)) {
+            for (const item of this.cells.get(key) ?? []) {
+                if (seen.has(item))
+                    continue;
+                seen.add(item);
+                out.push(item);
+            }
+        }
+        return out;
+    }
+    clear() {
+        this.cells.clear();
+    }
+    *keysFor(bounds) {
+        const minX = Math.floor(bounds.min.x / this.cellSize);
+        const maxX = Math.floor(bounds.max.x / this.cellSize);
+        const minY = Math.floor(bounds.min.y / this.cellSize);
+        const maxY = Math.floor(bounds.max.y / this.cellSize);
+        const minZ = Math.floor(bounds.min.z / this.cellSize);
+        const maxZ = Math.floor(bounds.max.z / this.cellSize);
+        for (let x = minX; x <= maxX; x++) {
+            for (let y = minY; y <= maxY; y++) {
+                for (let z = minZ; z <= maxZ; z++)
+                    yield `${x}|${y}|${z}`;
+            }
+        }
+    }
+}
+/** Indices of every box whose closest point is within `radius` of `center`. */
+export function overlapSphere(center, radius, boxes) {
+    const hits = [];
+    const closest = new Vector3();
+    const radiusSq = radius * radius;
+    for (let i = 0; i < boxes.length; i++) {
+        const box = boxes[i];
+        if (!box)
+            continue;
+        box.clampPoint(center, closest);
+        if (closest.distanceToSquared(center) <= radiusSq)
+            hits.push(i);
+    }
+    return hits;
+}

package/dist/forgiveness.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Input forgiveness: act on the player's intent, not their timing.
+ *
+ * A finger on glass is a noisy signal. Reaction time, display latency and the
+ * physical travel of a tap all blur *when* the player meant to act, and a game
+ * that demands the exact frame punishes the hardware more than the player.
+ * The fix is two tiny windows, invisible when they work:
+ *
+ * - a GRACE WINDOW forgives acting slightly late — the jump pressed a few
+ *   frames after running off the ledge still counts ("coyote time");
+ * - an INPUT BUFFER forgives acting slightly early — the jump pressed just
+ *   before landing fires on the exact frame it becomes legal.
+ *
+ * Both are countdowns stepped by the fixed timestep, so the forgiveness is the
+ * same number of milliseconds on every display. 0.08–0.15s is the useful
+ * range; below it nobody is helped, above it inputs visibly fire "on their
+ * own". Players never notice these windows — they notice their absence, as
+ * "the controls ate my tap".
+ */
+export type GraceWindow = {
+    /** The condition is true now (grounded, in range, alive). Call every step it holds. */
+    refresh(): void;
+    /** Advance the countdown. Once per fixed step. */
+    update(step: number): void;
+    /** Still within the window — the condition held less than `seconds` ago. */
+    readonly active: boolean;
+    /**
+     * Take the grace: returns whether it was active, then closes the window so
+     * one ledge cannot grant two jumps.
+     */
+    consume(): boolean;
+};
+/**
+ * Coyote time, generalised: "was the condition true within the last N
+ * seconds" as a first-class object.
+ *
+ *     const coyote = createGraceWindow(0.1)
+ *     update(game, step) {
+ *       coyote.update(step)
+ *       if (grounded) coyote.refresh()
+ *     }
+ *     game.input.on('tap', () => {
+ *       if (coyote.consume()) jump()
+ *     })
+ */
+export declare function createGraceWindow(seconds: number): GraceWindow;
+export type InputBuffer = {
+    /** The player acted. Call from the gesture handler, legal or not. */
+    press(): void;
+    /** Advance the countdown. Once per fixed step. */
+    update(step: number): void;
+    /**
+     * Was there a press within the window? True consumes it, so one tap fires
+     * one action. Poll this at the moment the action becomes legal.
+     */
+    consume(): boolean;
+    readonly pending: boolean;
+};
+/**
+ * The other half: remember a too-early input and fire it the frame it becomes
+ * legal, instead of throwing it away.
+ *
+ *     const jumpBuffer = createInputBuffer(0.12)
+ *     game.input.on('tap', () => jumpBuffer.press())
+ *     update(game, step) {
+ *       jumpBuffer.update(step)
+ *       if (grounded && jumpBuffer.consume()) jump()
+ *     }
+ */
+export declare function createInputBuffer(seconds: number): InputBuffer;
+//# sourceMappingURL=forgiveness.d.ts.map

package/dist/forgiveness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forgiveness.d.ts","sourceRoot":"","sources":["../src/forgiveness.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,WAAW,GAAG;IACxB,uFAAuF;IACvF,OAAO,IAAI,IAAI,CAAA;IACf,kDAAkD;IAClD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAmB9D;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,qEAAqE;IACrE,KAAK,IAAI,IAAI,CAAA;IACb,kDAAkD;IAClD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B;;;OAGG;IACH,OAAO,IAAI,OAAO,CAAA;IAClB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAmB9D"}

package/dist/forgiveness.js

@@ -0,0 +1,85 @@
+/**
+ * Input forgiveness: act on the player's intent, not their timing.
+ *
+ * A finger on glass is a noisy signal. Reaction time, display latency and the
+ * physical travel of a tap all blur *when* the player meant to act, and a game
+ * that demands the exact frame punishes the hardware more than the player.
+ * The fix is two tiny windows, invisible when they work:
+ *
+ * - a GRACE WINDOW forgives acting slightly late — the jump pressed a few
+ *   frames after running off the ledge still counts ("coyote time");
+ * - an INPUT BUFFER forgives acting slightly early — the jump pressed just
+ *   before landing fires on the exact frame it becomes legal.
+ *
+ * Both are countdowns stepped by the fixed timestep, so the forgiveness is the
+ * same number of milliseconds on every display. 0.08–0.15s is the useful
+ * range; below it nobody is helped, above it inputs visibly fire "on their
+ * own". Players never notice these windows — they notice their absence, as
+ * "the controls ate my tap".
+ */
+/**
+ * Coyote time, generalised: "was the condition true within the last N
+ * seconds" as a first-class object.
+ *
+ *     const coyote = createGraceWindow(0.1)
+ *     update(game, step) {
+ *       coyote.update(step)
+ *       if (grounded) coyote.refresh()
+ *     }
+ *     game.input.on('tap', () => {
+ *       if (coyote.consume()) jump()
+ *     })
+ */
+export function createGraceWindow(seconds) {
+    if (!(seconds > 0))
+        throw new Error(`createGraceWindow: seconds must be > 0, got ${seconds}`);
+    let remaining = 0;
+    return {
+        refresh() {
+            remaining = seconds;
+        },
+        update(step) {
+            remaining = Math.max(remaining - step, 0);
+        },
+        get active() {
+            return remaining > 0;
+        },
+        consume() {
+            const wasActive = remaining > 0;
+            remaining = 0;
+            return wasActive;
+        },
+    };
+}
+/**
+ * The other half: remember a too-early input and fire it the frame it becomes
+ * legal, instead of throwing it away.
+ *
+ *     const jumpBuffer = createInputBuffer(0.12)
+ *     game.input.on('tap', () => jumpBuffer.press())
+ *     update(game, step) {
+ *       jumpBuffer.update(step)
+ *       if (grounded && jumpBuffer.consume()) jump()
+ *     }
+ */
+export function createInputBuffer(seconds) {
+    if (!(seconds > 0))
+        throw new Error(`createInputBuffer: seconds must be > 0, got ${seconds}`);
+    let remaining = 0;
+    return {
+        press() {
+            remaining = seconds;
+        },
+        update(step) {
+            remaining = Math.max(remaining - step, 0);
+        },
+        consume() {
+            const wasPending = remaining > 0;
+            remaining = 0;
+            return wasPending;
+        },
+        get pending() {
+            return remaining > 0;
+        },
+    };
+}

package/dist/game.d.ts

@@ -0,0 +1,69 @@
+import { type ColorRepresentation, Scene, type Texture, WebGLRenderer } from 'three';
+import { type AssetManifest, type Assets } from './assets.js';
+import { type AudioBus } from './audio.js';
+import { type CameraRig } from './camera.js';
+import { type Hud } from './hud/index.js';
+import { type Input } from './input/index.js';
+import { type Platform } from './platform/index.js';
+import { DisposalScope } from './scene/dispose.js';
+import { type FitMode, type Viewport } from './viewport.js';
+export type RemixGameOptions = {
+    /** The guaranteed-visible design box. Defaults to 720x1080. */
+    design?: {
+        width: number;
+        height: number;
+    };
+    fit?: FitMode;
+    camera?: CameraRig;
+    background?: ColorRepresentation | Texture | null;
+    /** DPR ceiling. 2 is already past what anyone can see at arm's length. */
+    maxPixelRatio?: number;
+    fixedStep?: number;
+    maxStepsPerFrame?: number;
+    assets?: AssetManifest;
+    /** Where the canvas and HUD are mounted. Defaults to `document.body`. */
+    container?: HTMLElement;
+    onProgress?: (loaded: number, total: number) => void;
+    setup: (game: RemixGame) => void | Promise<void>;
+    /**
+     * Rebuilds a run. Wired to the platform's `play_again` automatically.
+     *
+     * A run, not the game: everything `setup` built survives, scene contents and
+     * HUD elements alike. Reset values here, build once in `setup`.
+     */
+    restart?: (game: RemixGame) => void;
+    update?: (game: RemixGame, step: number) => void;
+    render?: (game: RemixGame, dt: number, alpha: number) => void;
+};
+export type RemixGame = {
+    readonly renderer: WebGLRenderer;
+    readonly scene: Scene;
+    readonly rig: CameraRig;
+    readonly camera: CameraRig['camera'];
+    readonly viewport: Viewport;
+    readonly input: Input;
+    readonly assets: Assets;
+    readonly audio: AudioBus;
+    readonly hud: Hud;
+    readonly platform: Platform;
+    /** Cleared on every `restart()`. Register anything created after setup. */
+    readonly transient: DisposalScope;
+    readonly time: {
+        readonly elapsed: number;
+        readonly delta: number;
+        readonly frame: number;
+    };
+    readonly running: boolean;
+    gameOver(score: number): void;
+    restart(): void;
+    pause(): void;
+    resume(): void;
+    dispose(): void;
+};
+/**
+ * The one bootstrap call. A game never constructs a `WebGLRenderer` itself,
+ * because every one of the settings below is a decision that only looks
+ * cosmetic until it costs 30 fps on a phone.
+ */
+export declare function createGame(options: RemixGameOptions): Promise<RemixGame>;
+//# sourceMappingURL=game.d.ts.map

package/dist/game.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"game.d.ts","sourceRoot":"","sources":["../src/game.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAExB,KAAK,EACL,KAAK,OAAO,EACZ,aAAa,EACd,MAAM,OAAO,CAAA;AACd,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EAAgB,MAAM,aAAa,CAAA;AAC3E,OAAO,EAAE,KAAK,QAAQ,EAAe,MAAM,YAAY,CAAA;AACvD,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,aAAa,CAAA;AACzD,OAAO,EAAE,KAAK,GAAG,EAAa,MAAM,gBAAgB,CAAA;AACpD,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,kBAAkB,CAAA;AAE1D,OAAO,EAAE,KAAK,QAAQ,EAA4B,MAAM,qBAAqB,CAAA;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAkB,MAAM,eAAe,CAAA;AAE3E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,+DAA+D;IAC/D,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1C,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,UAAU,CAAC,EAAE,mBAAmB,GAAG,OAAO,GAAG,IAAI,CAAA;IACjD,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,yEAAyE;IACzE,SAAS,CAAC,EAAE,WAAW,CAAA;IACvB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACpD,KAAK,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAChD;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAA;IACnC,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAChD,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9D,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;IAChC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAA;IACpC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAA;IACxB,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IACjB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC3F,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,OAAO,IAAI,IAAI,CAAA;IACf,KAAK,IAAI,IAAI,CAAA;IACb,MAAM,IAAI,IAAI,CAAA;IACd,OAAO,IAAI,IAAI,CAAA;CAChB,CAAA;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,CAsM9E"}