@gjsify/gamepad 0.1.9

package/lib/types/haptic-actuator.d.ts

@@ -0,0 +1,16 @@
+import type Manette from '@girs/manette-0.2';
+import type { GamepadHapticActuator, GamepadHapticEffectType, GamepadEffectParameters, GamepadHapticsResult } from './gamepad.js';
+/**
+ * Wraps libmanette's rumble support as a W3C GamepadHapticActuator.
+ *
+ * libmanette supports dual-rumble with strong/weak magnitude control
+ * via `Device.rumble(strong_magnitude, weak_magnitude, milliseconds)`.
+ * Magnitudes are in the range 0–65535 (uint16).
+ */
+export declare class ManetteHapticActuator implements GamepadHapticActuator {
+    readonly effects: readonly GamepadHapticEffectType[];
+    private _device;
+    constructor(device: Manette.Device);
+    playEffect(type: GamepadHapticEffectType, params?: GamepadEffectParameters): Promise<GamepadHapticsResult>;
+    reset(): Promise<GamepadHapticsResult>;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,9 @@
+export { GamepadButton } from './gamepad-button.js';
+export { Gamepad } from './gamepad.js';
+export type { GamepadMappingType, GamepadHapticActuator, GamepadHapticEffectType, GamepadHapticsResult, GamepadEffectParameters, } from './gamepad.js';
+export { GamepadEvent } from './gamepad-event.js';
+export type { GamepadEventInit } from './gamepad-event.js';
+export { GamepadManager } from './gamepad-manager.js';
+export { ManetteHapticActuator } from './haptic-actuator.js';
+export { MANETTE_TO_W3C_BUTTON, ManetteButton, W3CButton, W3C_BUTTON_COUNT } from './button-mapping.js';
+export { MANETTE_TO_W3C_AXIS, ManetteAxis, W3CAxis, W3C_AXIS_COUNT, TRIGGER_PRESS_THRESHOLD } from './axis-mapping.js';

package/lib/types/register.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@gjsify/gamepad",
+  "version": "0.1.9",
+  "description": "Gamepad Web API for GJS using libmanette as backend",
+  "type": "module",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    },
+    "./register": {
+      "types": "./lib/types/register.d.ts",
+      "default": "./lib/esm/register.js"
+    }
+  },
+  "sideEffects": [
+    "./lib/esm/register.js"
+  ],
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
+    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+    "build:types": "tsc",
+    "build:test": "yarn build:test:gjs",
+    "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.mjs"
+  },
+  "keywords": [
+    "gjs",
+    "gamepad",
+    "libmanette",
+    "controller"
+  ],
+  "dependencies": {
+    "@gjsify/dom-events": "^0.1.9"
+  },
+  "devDependencies": {
+    "@girs/gjs": "^4.0.0-rc.2",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-rc.2",
+    "@girs/manette-0.2": "^0.2.13-4.0.0-rc.2",
+    "@gjsify/cli": "^0.1.9",
+    "@gjsify/unit": "^0.1.9",
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.2"
+  }
+}

package/src/axis-mapping.ts

@@ -0,0 +1,50 @@
+// Gamepad Web API — axis mapping from libmanette to W3C standard gamepad layout
+// Reference: https://w3c.github.io/gamepad/#remapping
+//
+// NOTE: Unlike buttons (which use Linux BTN_* hardware codes), libmanette 0.2
+// axis events use SDL logical indices: 0=leftx, 1=lefty, 2=rightx, 3=righty,
+// 4=lefttrigger, 5=righttrigger. The hardware ABS_* code is available via
+// event.get_hardware_code() but the main axis index from get_absolute() is
+// the SDL-mapped logical index.
+
+/**
+ * SDL logical axis indices as reported by Manette.Event.get_absolute().
+ * These are the SDL gamepad mapping indices, NOT Linux ABS_* hardware codes.
+ */
+export const ManetteAxis = {
+    LEFT_X: 0,          // SDL leftx
+    LEFT_Y: 1,          // SDL lefty
+    RIGHT_X: 2,         // SDL rightx
+    RIGHT_Y: 3,         // SDL righty
+    LEFT_TRIGGER: 4,    // SDL lefttrigger
+    RIGHT_TRIGGER: 5,   // SDL righttrigger
+} as const;
+
+/**
+ * W3C standard gamepad axis indices.
+ * https://w3c.github.io/gamepad/#remapping
+ */
+export const W3CAxis = {
+    LEFT_STICK_X: 0,
+    LEFT_STICK_Y: 1,
+    RIGHT_STICK_X: 2,
+    RIGHT_STICK_Y: 3,
+} as const;
+
+/** Total number of axes in the W3C standard mapping. */
+export const W3C_AXIS_COUNT = 4;
+
+/**
+ * Maps SDL logical axis → W3C axis index.
+ * Stick axes (0–3) map 1:1. Trigger axes (4–5) are NOT in this map —
+ * they are handled separately in gamepad-manager as buttons[6]/buttons[7].
+ */
+export const MANETTE_TO_W3C_AXIS: ReadonlyMap<number, number> = new Map([
+    [ManetteAxis.LEFT_X,  W3CAxis.LEFT_STICK_X],
+    [ManetteAxis.LEFT_Y,  W3CAxis.LEFT_STICK_Y],
+    [ManetteAxis.RIGHT_X, W3CAxis.RIGHT_STICK_X],
+    [ManetteAxis.RIGHT_Y, W3CAxis.RIGHT_STICK_Y],
+]);
+
+/** Threshold above which an analog trigger is considered "pressed". */
+export const TRIGGER_PRESS_THRESHOLD = 0.5;

package/src/button-mapping.ts

@@ -0,0 +1,87 @@
+// Gamepad Web API — button mapping from libmanette to W3C standard gamepad layout
+// Reference: https://w3c.github.io/gamepad/#remapping
+//
+// IMPORTANT: libmanette 0.2 delivers Linux input event codes (BTN_*) in
+// Event.get_button(), NOT the Manette.Button enum values from the docs.
+// The enum (SOUTH=5, EAST=7, …) describes the semantic meaning, but the
+// actual values transmitted over signals are the kernel BTN_* constants.
+// Reference: linux/input-event-codes.h
+
+/**
+ * Linux BTN_* input event codes as reported by Manette.Event.get_button().
+ * These are the actual values libmanette 0.2 passes in button-press/release signals.
+ */
+export const LinuxButton = {
+    BTN_SOUTH:     304,   // 0x130 — A (Xbox), B (Nintendo), Cross (PlayStation)
+    BTN_EAST:      305,   // 0x131 — B (Xbox), A (Nintendo), Circle (PlayStation)
+    BTN_C:         306,   // 0x132
+    BTN_NORTH:     307,   // 0x133 — Y (Xbox), X (Nintendo), Triangle (PlayStation)
+    BTN_WEST:      308,   // 0x134 — X (Xbox), Y (Nintendo), Square (PlayStation)
+    BTN_Z:         309,   // 0x135
+    BTN_TL:        310,   // 0x136 — Left shoulder (L, LB)
+    BTN_TR:        311,   // 0x137 — Right shoulder (R, RB)
+    BTN_TL2:       312,   // 0x138 — Left trigger (LT, L2)
+    BTN_TR2:       313,   // 0x139 — Right trigger (RT, R2)
+    BTN_SELECT:    314,   // 0x13a — Select / Back / Share
+    BTN_START:     315,   // 0x13b — Start / Menu / Options
+    BTN_MODE:      316,   // 0x13c — Home / Guide / PS
+    BTN_THUMBL:    317,   // 0x13d — Left stick click (L3)
+    BTN_THUMBR:    318,   // 0x13e — Right stick click (R3)
+    BTN_DPAD_UP:   544,   // 0x220
+    BTN_DPAD_DOWN: 545,   // 0x221
+    BTN_DPAD_LEFT: 546,   // 0x222
+    BTN_DPAD_RIGHT:547,   // 0x223
+} as const;
+
+/**
+ * W3C standard gamepad button indices.
+ * https://w3c.github.io/gamepad/#remapping
+ */
+export const W3CButton = {
+    FACE_1: 0,          // A (Xbox), B (Nintendo), Cross (PlayStation)
+    FACE_2: 1,          // B (Xbox), A (Nintendo), Circle (PlayStation)
+    FACE_3: 2,          // X (Xbox), Y (Nintendo), Square (PlayStation)
+    FACE_4: 3,          // Y (Xbox), X (Nintendo), Triangle (PlayStation)
+    LEFT_BUMPER: 4,
+    RIGHT_BUMPER: 5,
+    LEFT_TRIGGER: 6,    // Analog trigger — also populated from axis events
+    RIGHT_TRIGGER: 7,   // Analog trigger — also populated from axis events
+    SELECT: 8,
+    START: 9,
+    LEFT_STICK: 10,
+    RIGHT_STICK: 11,
+    DPAD_UP: 12,
+    DPAD_DOWN: 13,
+    DPAD_LEFT: 14,
+    DPAD_RIGHT: 15,
+    HOME: 16,
+} as const;
+
+/** Total number of buttons in the W3C standard mapping. */
+export const W3C_BUTTON_COUNT = 17;
+
+/**
+ * Maps Linux BTN_* code → W3C standard button index.
+ */
+export const MANETTE_TO_W3C_BUTTON: ReadonlyMap<number, number> = new Map([
+    [LinuxButton.BTN_SOUTH,      W3CButton.FACE_1],
+    [LinuxButton.BTN_EAST,       W3CButton.FACE_2],
+    [LinuxButton.BTN_WEST,       W3CButton.FACE_3],
+    [LinuxButton.BTN_NORTH,      W3CButton.FACE_4],
+    [LinuxButton.BTN_TL,         W3CButton.LEFT_BUMPER],
+    [LinuxButton.BTN_TR,         W3CButton.RIGHT_BUMPER],
+    [LinuxButton.BTN_TL2,        W3CButton.LEFT_TRIGGER],
+    [LinuxButton.BTN_TR2,        W3CButton.RIGHT_TRIGGER],
+    [LinuxButton.BTN_SELECT,     W3CButton.SELECT],
+    [LinuxButton.BTN_START,      W3CButton.START],
+    [LinuxButton.BTN_THUMBL,     W3CButton.LEFT_STICK],
+    [LinuxButton.BTN_THUMBR,     W3CButton.RIGHT_STICK],
+    [LinuxButton.BTN_DPAD_UP,    W3CButton.DPAD_UP],
+    [LinuxButton.BTN_DPAD_DOWN,  W3CButton.DPAD_DOWN],
+    [LinuxButton.BTN_DPAD_LEFT,  W3CButton.DPAD_LEFT],
+    [LinuxButton.BTN_DPAD_RIGHT, W3CButton.DPAD_RIGHT],
+    [LinuxButton.BTN_MODE,       W3CButton.HOME],
+]);
+
+// Keep the old name exported for backward compat in tests/examples
+export { LinuxButton as ManetteButton };

package/src/gamepad-button.ts

@@ -0,0 +1,22 @@
+// Gamepad Web API — GamepadButton
+// Reference: https://w3c.github.io/gamepad/#dom-gamepadbutton
+
+/**
+ * Represents the state of a single button on a gamepad.
+ * https://w3c.github.io/gamepad/#dom-gamepadbutton
+ */
+export class GamepadButton {
+    pressed: boolean;
+    touched: boolean;
+    value: number;
+
+    constructor(pressed = false, touched = false, value = 0) {
+        this.pressed = pressed;
+        this.touched = touched;
+        this.value = value;
+    }
+
+    get [Symbol.toStringTag]() {
+        return 'GamepadButton';
+    }
+}

package/src/gamepad-event.ts

@@ -0,0 +1,29 @@
+// Gamepad Web API — GamepadEvent
+// Reference: https://w3c.github.io/gamepad/#dom-gamepadevent
+
+import { Event } from '@gjsify/dom-events';
+import type { Gamepad } from './gamepad.js';
+
+export interface GamepadEventInit {
+    gamepad: Gamepad;
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+
+/**
+ * Fired on the Window when a gamepad is connected or disconnected.
+ * https://w3c.github.io/gamepad/#dom-gamepadevent
+ */
+export class GamepadEvent extends Event {
+    readonly gamepad: Gamepad;
+
+    constructor(type: string, eventInitDict: GamepadEventInit) {
+        super(type, eventInitDict);
+        this.gamepad = eventInitDict.gamepad;
+    }
+
+    get [Symbol.toStringTag]() {
+        return 'GamepadEvent';
+    }
+}

package/src/gamepad-manager.ts

@@ -0,0 +1,299 @@
+// Gamepad Web API — GamepadManager
+// Bridges libmanette's event-driven model to the W3C polling-based Gamepad API.
+// Reference: https://w3c.github.io/gamepad/
+// Reimplemented for GJS using libmanette (gi://Manette)
+
+import type Manette from '@girs/manette-0.2';
+import { GamepadButton } from './gamepad-button.js';
+import { Gamepad } from './gamepad.js';
+import { GamepadEvent } from './gamepad-event.js';
+import { ManetteHapticActuator } from './haptic-actuator.js';
+import { MANETTE_TO_W3C_BUTTON, W3C_BUTTON_COUNT } from './button-mapping.js';
+import { MANETTE_TO_W3C_AXIS, ManetteAxis, W3C_AXIS_COUNT, TRIGGER_PRESS_THRESHOLD } from './axis-mapping.js';
+import { W3CButton } from './button-mapping.js';
+
+/** Internal mutable state for a single connected gamepad. */
+interface DeviceState {
+    device: Manette.Device;
+    index: number;
+    connected: boolean;
+    timestamp: number;
+    buttons: Float64Array;
+    buttonsPressed: boolean[];
+    axes: Float64Array;
+    hapticActuator: ManetteHapticActuator;
+    signalIds: number[];
+}
+
+const MAX_GAMEPADS = 4;
+
+/**
+ * Singleton manager that wraps Manette.Monitor and maintains gamepad state.
+ *
+ * libmanette fires GObject signals on button/axis changes. This manager
+ * caches the latest state so that `getGamepads()` can return a snapshot
+ * matching the W3C Gamepad API's polling model.
+ */
+export class GamepadManager {
+    private _monitor: Manette.Monitor | null = null;
+    private _slots: (DeviceState | null)[] = new Array(MAX_GAMEPADS).fill(null);
+    private _monitorSignalIds: number[] = [];
+    private _ManetteModule: typeof Manette | null = null;
+    private _initPromise: Promise<void> | null = null;
+    private _initialized = false;
+
+    /**
+     * Lazily initialize the Manette.Monitor.
+     * Called on first `getGamepads()` invocation.
+     */
+    private _ensureInit(): void {
+        if (this._initialized) return;
+        if (this._initPromise) return;
+
+        this._initPromise = this._init();
+    }
+
+    private async _init(): Promise<void> {
+        try {
+            const mod = await import('gi://Manette');
+            this._ManetteModule = mod.default;
+        } catch {
+            // libmanette not available — getGamepads() will return empty array
+            this._initialized = true;
+            return;
+        }
+
+        const monitor = new this._ManetteModule.Monitor();
+        this._monitor = monitor;
+
+        // Enumerate already-connected devices
+        const iter = monitor.iterate();
+        let result = iter.next();
+        while (result[0]) {
+            const device = result[1];
+            if (device) {
+                this._onDeviceConnected(device);
+            }
+            result = iter.next();
+        }
+
+        // Listen for future connect/disconnect
+        this._monitorSignalIds.push(
+            monitor.connect('device-connected', (_monitor: Manette.Monitor, device: Manette.Device) => {
+                this._onDeviceConnected(device);
+            }),
+            monitor.connect('device-disconnected', (_monitor: Manette.Monitor, device: Manette.Device) => {
+                this._onDeviceDisconnected(device);
+            }),
+        );
+
+        this._initialized = true;
+    }
+
+    private _onDeviceConnected(device: Manette.Device): void {
+        // Find a free slot
+        let slotIndex = -1;
+        for (let i = 0; i < MAX_GAMEPADS; i++) {
+            if (this._slots[i] === null) {
+                slotIndex = i;
+                break;
+            }
+        }
+        if (slotIndex === -1) return; // All slots occupied
+
+        const state: DeviceState = {
+            device,
+            index: slotIndex,
+            connected: true,
+            timestamp: performance.now(),
+            buttons: new Float64Array(W3C_BUTTON_COUNT),
+            buttonsPressed: new Array(W3C_BUTTON_COUNT).fill(false),
+            axes: new Float64Array(W3C_AXIS_COUNT),
+            hapticActuator: new ManetteHapticActuator(device),
+            signalIds: [],
+        };
+
+        // Wire up device signals
+        state.signalIds.push(
+            device.connect('button-press-event', (_device: Manette.Device, event: Manette.Event) => {
+                this._onButtonPress(state, event);
+            }),
+            device.connect('button-release-event', (_device: Manette.Device, event: Manette.Event) => {
+                this._onButtonRelease(state, event);
+            }),
+            device.connect('absolute-axis-event', (_device: Manette.Device, event: Manette.Event) => {
+                this._onAxisChange(state, event);
+            }),
+            device.connect('hat-axis-event', (_device: Manette.Device, event: Manette.Event) => {
+                this._onHatChange(state, event);
+            }),
+            device.connect('disconnected', () => {
+                this._onDeviceDisconnected(device);
+            }),
+        );
+
+        this._slots[slotIndex] = state;
+
+        // Dispatch gamepadconnected event
+        const snapshot = this._createSnapshot(state);
+        if (snapshot) {
+            globalThis.dispatchEvent?.(new GamepadEvent('gamepadconnected', { gamepad: snapshot }) as unknown as Event);
+        }
+    }
+
+    private _onDeviceDisconnected(device: Manette.Device): void {
+        const state = this._findStateByDevice(device);
+        if (!state) return;
+
+        // Disconnect all device signals
+        for (const id of state.signalIds) {
+            device.disconnect(id);
+        }
+
+        state.connected = false;
+        const snapshot = this._createSnapshot(state);
+        this._slots[state.index] = null;
+
+        // Dispatch gamepaddisconnected event
+        if (snapshot) {
+            globalThis.dispatchEvent?.(new GamepadEvent('gamepaddisconnected', { gamepad: snapshot }) as unknown as Event);
+        }
+    }
+
+    private _onButtonPress(state: DeviceState, event: Manette.Event): void {
+        const [ok, button] = event.get_button();
+        if (!ok) return;
+
+        const w3cIdx = MANETTE_TO_W3C_BUTTON.get(button);
+        if (w3cIdx === undefined) return;
+
+        state.buttons[w3cIdx] = 1.0;
+        state.buttonsPressed[w3cIdx] = true;
+        state.timestamp = performance.now();
+    }
+
+    private _onButtonRelease(state: DeviceState, event: Manette.Event): void {
+        const [ok, button] = event.get_button();
+        if (!ok) return;
+
+        const w3cIdx = MANETTE_TO_W3C_BUTTON.get(button);
+        if (w3cIdx === undefined) return;
+
+        state.buttons[w3cIdx] = 0.0;
+        state.buttonsPressed[w3cIdx] = false;
+        state.timestamp = performance.now();
+    }
+
+    private _onAxisChange(state: DeviceState, event: Manette.Event): void {
+        const [ok, axis, value] = event.get_absolute();
+        if (!ok) return;
+
+        const w3cAxisIdx = MANETTE_TO_W3C_AXIS.get(axis);
+        if (w3cAxisIdx !== undefined) {
+            // Stick axis → axes array
+            state.axes[w3cAxisIdx] = value;
+        } else if (axis === ManetteAxis.LEFT_TRIGGER) {
+            // Left trigger (SDL idx 4) → buttons[6] with analog value
+            const normalized = (value + 1) / 2; // libmanette: -1..1 → 0..1
+            state.buttons[W3CButton.LEFT_TRIGGER] = normalized;
+            state.buttonsPressed[W3CButton.LEFT_TRIGGER] = normalized > TRIGGER_PRESS_THRESHOLD;
+        } else if (axis === ManetteAxis.RIGHT_TRIGGER) {
+            // Right trigger (SDL idx 5) → buttons[7] with analog value
+            const normalized = (value + 1) / 2;
+            state.buttons[W3CButton.RIGHT_TRIGGER] = normalized;
+            state.buttonsPressed[W3CButton.RIGHT_TRIGGER] = normalized > TRIGGER_PRESS_THRESHOLD;
+        }
+
+        state.timestamp = performance.now();
+    }
+
+    private _onHatChange(state: DeviceState, event: Manette.Event): void {
+        const [ok, hatAxis, hatValue] = event.get_hat();
+        if (!ok) return;
+
+        // Hat axes: 0 = horizontal (left/right), 1 = vertical (up/down)
+        // Values: -1, 0, 1
+        if (hatAxis === 0) {
+            // Horizontal: negative = left, positive = right
+            state.buttonsPressed[W3CButton.DPAD_LEFT] = hatValue < 0;
+            state.buttons[W3CButton.DPAD_LEFT] = hatValue < 0 ? 1.0 : 0.0;
+            state.buttonsPressed[W3CButton.DPAD_RIGHT] = hatValue > 0;
+            state.buttons[W3CButton.DPAD_RIGHT] = hatValue > 0 ? 1.0 : 0.0;
+        } else if (hatAxis === 1) {
+            // Vertical: negative = up, positive = down
+            state.buttonsPressed[W3CButton.DPAD_UP] = hatValue < 0;
+            state.buttons[W3CButton.DPAD_UP] = hatValue < 0 ? 1.0 : 0.0;
+            state.buttonsPressed[W3CButton.DPAD_DOWN] = hatValue > 0;
+            state.buttons[W3CButton.DPAD_DOWN] = hatValue > 0 ? 1.0 : 0.0;
+        }
+
+        state.timestamp = performance.now();
+    }
+
+    private _findStateByDevice(device: Manette.Device): DeviceState | null {
+        for (const state of this._slots) {
+            if (state && state.device === device) return state;
+        }
+        return null;
+    }
+
+    private _createSnapshot(state: DeviceState): Gamepad {
+        const buttons: GamepadButton[] = [];
+        for (let i = 0; i < W3C_BUTTON_COUNT; i++) {
+            buttons.push(new GamepadButton(
+                state.buttonsPressed[i],
+                state.buttonsPressed[i] || state.buttons[i] > 0,
+                state.buttons[i],
+            ));
+        }
+
+        return new Gamepad({
+            id: state.device.get_name() ?? `Gamepad (${state.device.get_guid()})`,
+            index: state.index,
+            connected: state.connected,
+            timestamp: state.timestamp,
+            mapping: 'standard',
+            axes: Array.from(state.axes),
+            buttons,
+            vibrationActuator: state.hapticActuator,
+        });
+    }
+
+    /**
+     * Returns a snapshot array matching the W3C `navigator.getGamepads()` contract.
+     * Each non-null entry is a frozen Gamepad object with current state.
+     */
+    getGamepads(): (Gamepad | null)[] {
+        this._ensureInit();
+
+        const result: (Gamepad | null)[] = [];
+        for (let i = 0; i < MAX_GAMEPADS; i++) {
+            const state = this._slots[i];
+            result.push(state ? this._createSnapshot(state) : null);
+        }
+        return result;
+    }
+
+    /** Cleanup — disconnect all signal handlers. */
+    dispose(): void {
+        for (const state of this._slots) {
+            if (state) {
+                for (const id of state.signalIds) {
+                    state.device.disconnect(id);
+                }
+            }
+        }
+        this._slots.fill(null);
+
+        if (this._monitor) {
+            for (const id of this._monitorSignalIds) {
+                this._monitor.disconnect(id);
+            }
+            this._monitorSignalIds = [];
+            this._monitor = null;
+        }
+
+        this._initialized = false;
+        this._initPromise = null;
+    }
+}