@woosh/meep-engine 2.165.5 → 2.165.7

package/src/engine/input/analog/apply_radial_dead_zone.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Scaled radial dead zone with inner and outer bounds.
+ *
+ * Input inside {@link inner} reads as neutral, input at or beyond {@link outer} reads as full deflection, and
+ * everything between is rescaled to span the full [0,1] range. The boundary is a circle, so the dead area is
+ * isotropic - unlike a per-axis gate, which admits up to `inner * sqrt(2)` of resting magnitude on the diagonal
+ * and has a direction-dependent threshold.
+ *
+ * Continuous at {@link inner}: magnitude approaches 0 from above rather than jumping to `inner`, so a consumer
+ * mapping magnitude to speed gets no pop as the stick leaves the dead zone.
+ *
+ * This is gameplay policy, not device policy - the same stick wants a different dead zone for locomotion, for
+ * aiming, and for menu navigation. Pick the values at the call site.
+ *
+ * @param {Vector2} result written with the shaped value, magnitude in [0,1]
+ * @param {number} x
+ * @param {number} y
+ * @param {number} inner magnitude at or below which input reads as neutral. Precondition: >= 0
+ * @param {number} outer magnitude at or above which input reads as full deflection. Precondition: > inner
+ * @returns {void}
+ */
+export function apply_radial_dead_zone(result: Vector2, x: number, y: number, inner: number, outer: number): void;
+//# sourceMappingURL=apply_radial_dead_zone.d.ts.map

package/src/engine/input/analog/apply_radial_dead_zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_radial_dead_zone.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/analog/apply_radial_dead_zone.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2DANW,MAAM,KACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,IAAI,CAkBhB"}

package/src/engine/input/analog/apply_radial_dead_zone.js

@@ -0,0 +1,38 @@
+/**
+ * Scaled radial dead zone with inner and outer bounds.
+ *
+ * Input inside {@link inner} reads as neutral, input at or beyond {@link outer} reads as full deflection, and
+ * everything between is rescaled to span the full [0,1] range. The boundary is a circle, so the dead area is
+ * isotropic - unlike a per-axis gate, which admits up to `inner * sqrt(2)` of resting magnitude on the diagonal
+ * and has a direction-dependent threshold.
+ *
+ * Continuous at {@link inner}: magnitude approaches 0 from above rather than jumping to `inner`, so a consumer
+ * mapping magnitude to speed gets no pop as the stick leaves the dead zone.
+ *
+ * This is gameplay policy, not device policy - the same stick wants a different dead zone for locomotion, for
+ * aiming, and for menu navigation. Pick the values at the call site.
+ *
+ * @param {Vector2} result written with the shaped value, magnitude in [0,1]
+ * @param {number} x
+ * @param {number} y
+ * @param {number} inner magnitude at or below which input reads as neutral. Precondition: >= 0
+ * @param {number} outer magnitude at or above which input reads as full deflection. Precondition: > inner
+ * @returns {void}
+ */
+export function apply_radial_dead_zone(result, x, y, inner, outer) {
+    const magnitude = Math.sqrt(x * x + y * y);
+
+    if (magnitude <= inner) {
+        result.set(0, 0);
+
+        return;
+    }
+
+    /*
+    Normalize the direction and rescale the magnitude in one multiplication, division by magnitude is the
+    normalization
+     */
+    const scale = Math.min((magnitude - inner) / (outer - inner), 1) / magnitude;
+
+    result.set(x * scale, y * scale);
+}

package/src/engine/input/devices/GamepadDevice.d.ts

@@ -1,26 +1,143 @@
-import Signal from "../../../core/events/signal/Signal";
-import {GamepadHandle} from "./gamepad/GamepadHandle";
-
+/**
+ * Provides gamepad input on top of the Gamepad API.
+ * see https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API
+ *
+ * Unlike mouse/keyboard, the Gamepad API offers no events for button/axis state changes, state must be polled instead.
+ * While running, the device polls automatically once per animation frame. {@link GamepadDevice#poll} can also be
+ * invoked manually for finer control (e.g. from a fixed-rate simulation loop).
+ *
+ * NOTE: when a gamepad disconnects, any "pressed" buttons will be automatically released with appropriate signals,
+ * preventing inputs from getting "stuck".
+ *
+ * The device reports what the hardware reports, corrected for what the hardware gets wrong (see
+ * {@link GamepadStickCalibration}). What to do with the result - dead zone, response curve, which world
+ * direction a stick means - is game policy and lives in the consumer.
+ *
+ * @example
+ *   // locomotion from either stick or D-pad
+ *   const pad = engine.devices.gamepad.main;
+ *
+ *   if (pad.connected) {
+ *       const left = pad.stickLeft.value;
+ *
+ *       gamepad_write_dpad_vector(dpad, pad);
+ *       apply_radial_dead_zone(stick, left.x, left.y, 0.15, 0.95);
+ *
+ *       // fusion and frame are game policy, and this is the whole of it
+ *       const x = stick.x !== 0 || stick.y !== 0 ? stick.x : dpad.x;
+ *       const y = stick.x !== 0 || stick.y !== 0 ? stick.y : dpad.y;
+ *
+ *       move.set(x, -y); // this game is y-up, the negation is stated once, here, on purpose
+ *   }
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
 export class GamepadDevice {
-    constructor()
-
-    start(): void
-
-    stop(): void
-
-    poll(): void
-
-    deadZone: number
-
-    readonly pads: GamepadHandle[]
-
-    readonly main: GamepadHandle | undefined
-
+    /**
+     * @readonly
+     */
     readonly on: {
-        connected: Signal<GamepadHandle>,
-        disconnected: Signal<GamepadHandle>,
-        down: Signal<number /*buttonIndex*/, GamepadHandle>,
-        up: Signal<number /*buttonIndex*/, GamepadHandle>,
-        axis: Signal<number /*axisIndex*/, number /*value*/, GamepadHandle>
-    }
+        /**
+         * Fires when a gamepad is connected
+         * @type {Signal<GamepadHandle>}
+         */
+        connected: any;
+        /**
+         * Fires when a gamepad is disconnected
+         * @type {Signal<GamepadHandle>}
+         */
+        disconnected: any;
+        /**
+         * Fires when any button on any gamepad is pressed, dispatches (buttonIndex, pad)
+         * @type {Signal<number, GamepadHandle>}
+         */
+        down: any;
+        /**
+         * Fires when any button on any gamepad is released, dispatches (buttonIndex, pad)
+         * @type {Signal<number, GamepadHandle>}
+         */
+        up: any;
+        /**
+         * Fires when any axis on any gamepad changes, dispatches (axisIndex, value, pad)
+         * @type {Signal<number, number, GamepadHandle>}
+         */
+        axis: any;
+    };
+    /**
+     * Known gamepads, indexed by {@link Gamepad.index}. May be sparse.
+     * Handles are retained after disconnection and re-used on re-connection, so they are safe to hold references to.
+     *
+     * A slot can be re-occupied by a different pad, so a handle does not represent one piece of hardware for
+     * its whole life. Anything learned about the hardware is dropped on connection, see
+     * {@link GamepadHandle#forgetCalibration}.
+     *
+     * @readonly
+     * @type {GamepadHandle[]}
+     */
+    readonly pads: GamepadHandle[];
+    /**
+     * The active gamepad, for the common single-player case.
+     *
+     * Always present, check {@link GamepadHandle#connected} to know whether there is hardware behind it. Binds
+     * to the first pad that connects, and when that pad is lost it rebinds to the oldest pad still connected.
+     * With nothing connected it stays present with everything released.
+     *
+     * Not a member of {@link pads}, it is a separate handle fed from the same hardware snapshot as the pad it
+     * mirrors. That makes it a stable binding target: signal identity survives disconnection and pad swaps, so
+     * paths like "gamepad/main/buttons/0/down" resolve before any hardware exists and never go stale.
+     *
+     * Stick calibration is the one thing that does not survive a swap - it describes a specific stick, so it is
+     * dropped whenever main moves to a different pad. See {@link GamepadStick#forgetCalibration}.
+     *
+     * @readonly
+     * @type {GamepadHandle}
+     *
+     * @example
+     *   const pad = engine.devices.gamepad.main;
+     *
+     *   if (pad.connected) {
+     *       const is_jumping = pad.buttons[GamepadButtons.a].is_down;
+     *   }
+     */
+    readonly main: GamepadHandle;
+    /**
+     * @private
+     * @type {boolean}
+     */
+    private isRunning;
+    /**
+     * @deprecated see {@link GamepadDevice#deadZone}
+     * @param {number} value
+     */
+    set deadZone(arg: number);
+    /**
+     * @deprecated sticks learn their own noise radius, see {@link GamepadStickCalibration}. Writing this
+     * overrides the learned value on every stick and stops them calibrating, which is only what you want when
+     * a value is being restored from a settings screen or a saved profile.
+     *
+     * Applies to pads connected later as well, and because it locks the calibration it also survives
+     * reconnection, where a learned value would not.
+     *
+     * @returns {number}
+     */
+    get deadZone(): number;
+    /**
+     * Read current state of all gamepads and dispatch signals for any changes.
+     * Invoked automatically once per animation frame while the device is running.
+     */
+    poll(): void;
+    /**
+     * Starts listening for gamepad connections and polling gamepad state.
+     * @returns {void}
+     */
+    start(): void;
+    /**
+     * Stops listening for gamepad connections and polling gamepad state.
+     * @returns {void}
+     */
+    stop(): void;
+    #private;
 }
+import { GamepadHandle } from "./gamepad/GamepadHandle.js";
+//# sourceMappingURL=GamepadDevice.d.ts.map

package/src/engine/input/devices/GamepadDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GamepadDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/GamepadDevice.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH;IAEI;;OAEG;IACH;QACI;;;WAGG;mBADO,OAAO,aAAa,CAAC;QAG/B;;;WAGG;sBADO,OAAO,aAAa,CAAC;QAG/B;;;WAGG;cADO,OAAO,MAAM,EAAE,aAAa,CAAC;QAGvC;;;WAGG;YADO,OAAO,MAAM,EAAE,aAAa,CAAC;QAGvC;;;WAGG;cADO,OAAO,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC;MAGjD;IAEF;;;;;;OAMG;IACH,eAFU,aAAa,EAAE,CAEf;IAEV;;;;OAIG;IACH,UAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAAkB;IAQlB;;;;;OAKG;IACH,0BAaC;IAmFD;;;OAGG;IACH,aA+BC;IAQD;;;OAGG;IACH,SAFa,IAAI,CAmBhB;IAED;;;OAGG;IACH,QAFa,IAAI,CA6BhB;;CACJ;mBAvRkB,uCAAuC;8BAE5B,4BAA4B"}
+{"version":3,"file":"GamepadDevice.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/GamepadDevice.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAEI;;OAEG;IACH;QACI;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;QAEH;;;WAGG;;MAEL;IAEF;;;;;;;;;;OAUG;IACH,eAFU,aAAa,EAAE,CAEf;IAEV;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,eATU,aAAa,CASI;IAE3B;;;OAGG;IACH,kBAAkB;IAyClB;;;OAGG;IACH,0BAeC;IAjCD;;;;;;;;;OASG;IACH,uBAEC;IAmND;;;OAGG;IACH,aA+BC;IAQD;;;OAGG;IACH,SAFa,IAAI,CAmBhB;IAED;;;OAGG;IACH,QAFa,IAAI,CA+BhB;;CACJ;8BA/c6B,4BAA4B"}

package/src/engine/input/devices/GamepadDevice.js

@@ -13,6 +13,27 @@ import { GamepadHandle } from "./gamepad/GamepadHandle.js";
  * NOTE: when a gamepad disconnects, any "pressed" buttons will be automatically released with appropriate signals,
  * preventing inputs from getting "stuck".
  *
+ * The device reports what the hardware reports, corrected for what the hardware gets wrong (see
+ * {@link GamepadStickCalibration}). What to do with the result - dead zone, response curve, which world
+ * direction a stick means - is game policy and lives in the consumer.
+ *
+ * @example
+ *   // locomotion from either stick or D-pad
+ *   const pad = engine.devices.gamepad.main;
+ *
+ *   if (pad.connected) {
+ *       const left = pad.stickLeft.value;
+ *
+ *       gamepad_write_dpad_vector(dpad, pad);
+ *       apply_radial_dead_zone(stick, left.x, left.y, 0.15, 0.95);
+ *
+ *       // fusion and frame are game policy, and this is the whole of it
+ *       const x = stick.x !== 0 || stick.y !== 0 ? stick.x : dpad.x;
+ *       const y = stick.x !== 0 || stick.y !== 0 ? stick.y : dpad.y;
+ *
+ *       move.set(x, -y); // this game is y-up, the negation is stated once, here, on purpose
+ *   }
+ *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026
  */
@@ -53,17 +74,40 @@ export class GamepadDevice {
      * Known gamepads, indexed by {@link Gamepad.index}. May be sparse.
      * Handles are retained after disconnection and re-used on re-connection, so they are safe to hold references to.
      *
+     * A slot can be re-occupied by a different pad, so a handle does not represent one piece of hardware for
+     * its whole life. Anything learned about the hardware is dropped on connection, see
+     * {@link GamepadHandle#forgetCalibration}.
+     *
      * @readonly
      * @type {GamepadHandle[]}
      */
     pads = [];
 
     /**
-     * Axis values with magnitude below this threshold are treated as 0.
-     * Compensates for analog stick noise/drift around the neutral position.
-     * @type {number}
+     * The active gamepad, for the common single-player case.
+     *
+     * Always present, check {@link GamepadHandle#connected} to know whether there is hardware behind it. Binds
+     * to the first pad that connects, and when that pad is lost it rebinds to the oldest pad still connected.
+     * With nothing connected it stays present with everything released.
+     *
+     * Not a member of {@link pads}, it is a separate handle fed from the same hardware snapshot as the pad it
+     * mirrors. That makes it a stable binding target: signal identity survives disconnection and pad swaps, so
+     * paths like "gamepad/main/buttons/0/down" resolve before any hardware exists and never go stale.
+     *
+     * Stick calibration is the one thing that does not survive a swap - it describes a specific stick, so it is
+     * dropped whenever main moves to a different pad. See {@link GamepadStick#forgetCalibration}.
+     *
+     * @readonly
+     * @type {GamepadHandle}
+     *
+     * @example
+     *   const pad = engine.devices.gamepad.main;
+     *
+     *   if (pad.connected) {
+     *       const is_jumping = pad.buttons[GamepadButtons.a].is_down;
+     *   }
      */
-    deadZone = 0.1;
+    main = new GamepadHandle();
 
     /**
      * @private
@@ -78,24 +122,71 @@ export class GamepadDevice {
     #animationFrameId = -1;
 
     /**
-     * First connected gamepad, or undefined if none are connected.
-     * Convenience accessor for the common single-player case.
+     * Pad currently mirrored by {@link main}, or undefined when nothing is connected
+     * @type {GamepadHandle|undefined}
+     */
+    #mainSource = undefined;
+
+    /**
+     * Incremented on every connection, stamped onto handles so the oldest connected pad can be identified
+     * @type {number}
+     */
+    #connectionSequence = 0;
+
+    /**
+     * Manually specified noise radius, applied to every stick in place of a learned one.
+     * Undefined while sticks are calibrating themselves, which is the normal case.
+     * @type {number|undefined}
+     */
+    #deadZoneOverride = undefined;
+
+    /**
+     * @deprecated sticks learn their own noise radius, see {@link GamepadStickCalibration}. Writing this
+     * overrides the learned value on every stick and stops them calibrating, which is only what you want when
+     * a value is being restored from a settings screen or a saved profile.
      *
-     * @returns {GamepadHandle|undefined}
+     * Applies to pads connected later as well, and because it locks the calibration it also survives
+     * reconnection, where a learned value would not.
+     *
+     * @returns {number}
+     */
+    get deadZone() {
+        return this.#deadZoneOverride !== undefined ? this.#deadZoneOverride : 0;
+    }
+
+    /**
+     * @deprecated see {@link GamepadDevice#deadZone}
+     * @param {number} value
      */
-    get main() {
+    set deadZone(value) {
+        this.#deadZoneOverride = value;
+
         const pads = this.pads;
         const n = pads.length;
 
         for (let i = 0; i < n; i++) {
             const pad = pads[i];
 
-            if (pad !== undefined && pad.connected) {
-                return pad;
+            if (pad !== undefined) {
+                this.#applyDeadZoneOverride(pad);
             }
         }
 
-        return undefined;
+        this.#applyDeadZoneOverride(this.main);
+    }
+
+    /**
+     *
+     * @param {GamepadHandle} pad
+     */
+    #applyDeadZoneOverride(pad) {
+        const noiseRadius = this.#deadZoneOverride;
+
+        pad.stickLeft.calibration.set(0, 0, noiseRadius);
+        pad.stickLeft.calibration.locked = true;
+
+        pad.stickRight.calibration.set(0, 0, noiseRadius);
+        pad.stickRight.calibration.locked = true;
     }
 
     /**
@@ -116,6 +207,10 @@ export class GamepadDevice {
             pad.on.up.add(buttonIndex => this.on.up.send2(buttonIndex, pad));
             pad.on.axis.add((axisIndex, value) => this.on.axis.send3(axisIndex, value, pad));
 
+            if (this.#deadZoneOverride !== undefined) {
+                this.#applyDeadZoneOverride(pad);
+            }
+
             this.pads[index] = pad;
         }
 
@@ -130,11 +225,23 @@ export class GamepadDevice {
     #connect(gamepad) {
         const pad = this.#obtainHandle(gamepad.index);
 
-        pad.update(gamepad, this.deadZone);
+        const is_new_connection = !pad.connected;
 
-        if (!pad.connected) {
+        if (is_new_connection) {
             pad.connected = true;
+            pad.connectionIndex = this.#connectionSequence++;
+
+            /*
+            Handles are reused per hardware slot, and a slot can be re-occupied by a different pad, so what was
+            learned about the previous occupant does not carry over
+             */
+            pad.forgetCalibration();
+        }
 
+        pad.update(gamepad);
+
+        // state is fully refreshed before the connection is announced
+        if (is_new_connection) {
             this.on.connected.send1(pad);
         }
 
@@ -156,9 +263,86 @@ export class GamepadDevice {
         // release everything to avoid stuck inputs
         pad.reset();
 
+        if (this.#mainSource === pad) {
+            this.#unbindMain();
+        }
+
         this.on.disconnected.send1(pad);
     }
 
+    /**
+     * Oldest pad that is still connected, or undefined when there are none
+     *
+     * @returns {GamepadHandle|undefined}
+     */
+    #findOldestConnectedPad() {
+        const pads = this.pads;
+        const n = pads.length;
+
+        let oldest = undefined;
+
+        for (let i = 0; i < n; i++) {
+            const pad = pads[i];
+
+            if (pad === undefined || !pad.connected) {
+                continue;
+            }
+
+            if (oldest === undefined || pad.connectionIndex < oldest.connectionIndex) {
+                oldest = pad;
+            }
+        }
+
+        return oldest;
+    }
+
+    /**
+     * Detach {@link main} from the pad it was mirroring.
+     *
+     * Everything is released, so a button held on the outgoing pad never stays stuck. A successor is picked by
+     * the next {@link GamepadDevice#poll}, which is also the only place that re-presses whatever is genuinely
+     * held on the incoming pad.
+     */
+    #unbindMain() {
+        this.#mainSource = undefined;
+
+        this.main.reset();
+        this.main.connected = false;
+    }
+
+    /**
+     * Bind {@link main} to the oldest connected pad if it isn't bound, then refresh it from hardware.
+     *
+     * Sole feed point for {@link main}. It is given the same snapshot as the pad it mirrors rather than
+     * proxying that pad, so its switches and signals keep their identity across disconnection and pad swaps.
+     *
+     * @param {(Gamepad|null)[]} gamepads native gamepad list for this pass
+     */
+    #refreshMain(gamepads) {
+        if (this.#mainSource === undefined) {
+            const successor = this.#findOldestConnectedPad();
+
+            if (successor === undefined) {
+                // nothing connected, main stays present and released
+                return;
+            }
+
+            this.#mainSource = successor;
+            this.main.connected = true;
+
+            // main now represents different hardware, with a different rest position
+            this.main.forgetCalibration();
+        }
+
+        const snapshot = gamepads[this.#mainSource.index];
+
+        if (snapshot === null || snapshot === undefined) {
+            return;
+        }
+
+        this.main.update(snapshot);
+    }
+
     /**
      *
      * @param {GamepadEvent} event
@@ -210,10 +394,10 @@ export class GamepadDevice {
             Some browsers only dispatch "gamepadconnected" after a button is pressed,
             so connection is detected during polling as well
              */
-            const pad = this.#connect(gamepad);
-
-            pad.update(gamepad, this.deadZone);
+            this.#connect(gamepad);
         }
+
+        this.#refreshMain(gamepads);
     }
 
     #update = () => {
@@ -276,5 +460,7 @@ export class GamepadDevice {
                 pad.reset();
             }
         }
+
+        this.main.reset();
     }
 }

package/src/engine/input/devices/InputDeviceSwitch.d.ts

@@ -1,11 +1,44 @@
-import Signal from "../../../core/events/signal/Signal";
-
-export class InputDeviceSwitch {
-    readonly up: Signal
-    readonly down: Signal
-    readonly is_down: boolean
-    readonly is_up: boolean
-
-    press():void
-    release():void
-}
+/**
+ * Representation of an input device key/button
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class InputDeviceSwitch {
+    /**
+     * Switch press
+     * @readonly
+     * @type {Signal<>}
+     */
+    readonly down: any;
+    /**
+     * Switch release
+     * @readonly
+     * @type {Signal<>}
+     */
+    readonly up: any;
+    /**
+     * is button currently being pressed?
+     * Do not modify directly
+     * @type {boolean}
+     */
+    is_down: boolean;
+    /**
+     * Convenience accessor, dual of {@link is_down}
+     * @returns {boolean}
+     */
+    get is_up(): boolean;
+    /**
+     * Execute press, will trigger {@link down} signal if previous state was up
+     * Idempotent
+     * NOTE: make sure you understand the implications of using this
+     */
+    press(): void;
+    /**
+     * Execute release, will trigger {@link up} signal if previous state was down
+     * Idempotent
+     * NOTE: make sure you understand the implications of using this
+     */
+    release(): void;
+}
+//# sourceMappingURL=InputDeviceSwitch.d.ts.map

package/src/engine/input/devices/InputDeviceSwitch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputDeviceSwitch.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/InputDeviceSwitch.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IAEI;;;;OAIG;IACH,eAFU,MAAQ,CAEC;IAEnB;;;;OAIG;IACH,aAFU,MAAQ,CAED;IAEjB;;;;OAIG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,cAOC;IAED;;;;OAIG;IACH,gBAOC;CACJ;mBAlEkB,uCAAuC"}
+{"version":3,"file":"InputDeviceSwitch.d.ts","sourceRoot":"","sources":["../../../../../src/engine/input/devices/InputDeviceSwitch.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IAEI;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,cAOC;IAED;;;;OAIG;IACH,gBAOC;CACJ"}