like2d 1.0.0

package/dist/gamepad-button-map.d.ts

@@ -0,0 +1,5 @@
+export declare const GAMEPAD_BUTTON_MAP: Record<string, number>;
+export declare const GAMEPAD_BUTTON_NAMES: Record<number, string>;
+export declare function getButtonName(buttonIndex: number): string;
+export declare function getButtonIndex(buttonName: string): number | undefined;
+//# sourceMappingURL=gamepad-button-map.d.ts.map

package/dist/gamepad-button-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad-button-map.d.ts","sourceRoot":"","sources":["../src/gamepad-button-map.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAiCrD,CAAC;AAGF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAiBvD,CAAC;AAEF,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAErE"}

package/dist/gamepad-button-map.js

@@ -0,0 +1,56 @@
+// Button name to index mapping using physical layout
+export const GAMEPAD_BUTTON_MAP = {
+    // Face buttons - physical positions (not labels)
+    'ButtonBottom': 0,
+    'ButtonRight': 1,
+    'ButtonLeft': 2,
+    'ButtonTop': 3,
+    // Bumpers and triggers
+    'LB': 4,
+    'L1': 4,
+    'RB': 5,
+    'R1': 5,
+    'LT': 6,
+    'L2': 6,
+    'RT': 7,
+    'R2': 7,
+    // Menu buttons
+    'Back': 8,
+    'Select': 8,
+    'Start': 9,
+    // Stick presses
+    'LS': 10,
+    'L3': 10,
+    'RS': 11,
+    'R3': 11,
+    // D-Pad
+    'DPadUp': 12,
+    'DPadDown': 13,
+    'DPadLeft': 14,
+    'DPadRight': 15,
+};
+// Reverse mapping: index to primary name
+export const GAMEPAD_BUTTON_NAMES = {
+    0: 'ButtonBottom',
+    1: 'ButtonRight',
+    2: 'ButtonLeft',
+    3: 'ButtonTop',
+    4: 'LB',
+    5: 'RB',
+    6: 'LT',
+    7: 'RT',
+    8: 'Back',
+    9: 'Start',
+    10: 'LS',
+    11: 'RS',
+    12: 'DPadUp',
+    13: 'DPadDown',
+    14: 'DPadLeft',
+    15: 'DPadRight',
+};
+export function getButtonName(buttonIndex) {
+    return GAMEPAD_BUTTON_NAMES[buttonIndex] ?? `Button${buttonIndex}`;
+}
+export function getButtonIndex(buttonName) {
+    return GAMEPAD_BUTTON_MAP[buttonName];
+}

package/dist/gamepad-db.d.ts

@@ -0,0 +1,49 @@
+export interface ControllerMapping {
+    guid: string;
+    name: string;
+    platform: string;
+    buttons: Map<string, number>;
+    axes: Map<string, number>;
+    dpads: Map<string, {
+        hat: number;
+        value: number;
+    }>;
+}
+export declare const SDL_BUTTONS: readonly ["a", "b", "x", "y", "back", "start", "guide", "leftshoulder", "rightshoulder", "lefttrigger", "righttrigger", "leftstick", "rightstick", "dpup", "dpdown", "dpleft", "dpright", "misc1", "misc2", "paddle1", "paddle2", "paddle3", "paddle4", "touchpad"];
+export type SDLButton = (typeof SDL_BUTTONS)[number];
+export declare const SDL_AXES: readonly ["leftx", "lefty", "rightx", "righty"];
+export type SDLAxis = (typeof SDL_AXES)[number];
+export declare class GamepadDatabase {
+    private mappings;
+    private vendorProductIndex;
+    private loaded;
+    load(dbContent: string): void;
+    private extractVendorProductKey;
+    /**
+     * Check if the database has been loaded
+     */
+    isLoaded(): boolean;
+    /**
+     * Get the number of loaded mappings
+     */
+    getMappingCount(): number;
+    /**
+     * Look up a controller mapping by GUID
+     */
+    getMapping(guid: string): ControllerMapping | undefined;
+    getMappingByVendorProduct(vendor: number, product: number): ControllerMapping | undefined;
+    /**
+     * Check if a controller is in the database
+     */
+    hasController(guid: string): boolean;
+    /**
+     * Get all mappings for a specific platform
+     */
+    getMappingsByPlatform(platform: string): ControllerMapping[];
+    /**
+     * Parse a single database line
+     */
+    private parseLine;
+}
+export declare const gamepadDatabase: GamepadDatabase;
+//# sourceMappingURL=gamepad-db.d.ts.map

package/dist/gamepad-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad-db.d.ts","sourceRoot":"","sources":["../src/gamepad-db.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IAEjB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE1B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpD;AAGD,eAAO,MAAM,WAAW,qQASd,CAAC;AAEX,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAGrD,eAAO,MAAM,QAAQ,iDAGX,CAAC;AAEX,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAwC;IACxD,OAAO,CAAC,kBAAkB,CAAwC;IAClE,OAAO,CAAC,MAAM,CAAS;IAEvB,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IA0B7B,OAAO,CAAC,uBAAuB;IAU/B;;OAEG;IACH,QAAQ,IAAI,OAAO;IAInB;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAIvD,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAKzF;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIpC;;OAEG;IACH,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAa5D;;OAEG;IACH,OAAO,CAAC,SAAS;CAiFlB;AAGD,eAAO,MAAM,eAAe,iBAAwB,CAAC"}

package/dist/gamepad-db.js

@@ -0,0 +1,192 @@
+// SDL Game Controller Database parser
+// Parses the gamecontrollerdb.txt file format
+// SDL button names that we care about for standard layout
+export const SDL_BUTTONS = [
+    'a', 'b', 'x', 'y',
+    'back', 'start', 'guide',
+    'leftshoulder', 'rightshoulder',
+    'lefttrigger', 'righttrigger',
+    'leftstick', 'rightstick',
+    'dpup', 'dpdown', 'dpleft', 'dpright',
+    'misc1', 'misc2', 'paddle1', 'paddle2', 'paddle3', 'paddle4',
+    'touchpad',
+];
+// SDL axis names
+export const SDL_AXES = [
+    'leftx', 'lefty',
+    'rightx', 'righty',
+];
+export class GamepadDatabase {
+    constructor() {
+        Object.defineProperty(this, "mappings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "vendorProductIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "loaded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    load(dbContent) {
+        this.mappings.clear();
+        this.vendorProductIndex.clear();
+        const lines = dbContent.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const mapping = this.parseLine(trimmed);
+            if (mapping) {
+                this.mappings.set(mapping.guid, mapping);
+                const vpKey = this.extractVendorProductKey(mapping.guid);
+                if (vpKey !== null && !this.vendorProductIndex.has(vpKey)) {
+                    this.vendorProductIndex.set(vpKey, mapping);
+                }
+            }
+        }
+        this.loaded = true;
+    }
+    extractVendorProductKey(guid) {
+        if (guid.length < 20)
+            return null;
+        const vendorHex = guid.substring(8, 12);
+        const productHex = guid.substring(16, 20);
+        const vendor = parseInt(vendorHex.substring(2, 4) + vendorHex.substring(0, 2), 16);
+        const product = parseInt(productHex.substring(2, 4) + productHex.substring(0, 2), 16);
+        if (isNaN(vendor) || isNaN(product))
+            return null;
+        return 0x10000 * vendor + product;
+    }
+    /**
+     * Check if the database has been loaded
+     */
+    isLoaded() {
+        return this.loaded;
+    }
+    /**
+     * Get the number of loaded mappings
+     */
+    getMappingCount() {
+        return this.mappings.size;
+    }
+    /**
+     * Look up a controller mapping by GUID
+     */
+    getMapping(guid) {
+        return this.mappings.get(guid.toLowerCase());
+    }
+    getMappingByVendorProduct(vendor, product) {
+        const key = 0x10000 * vendor + product;
+        return this.vendorProductIndex.get(key);
+    }
+    /**
+     * Check if a controller is in the database
+     */
+    hasController(guid) {
+        return this.mappings.has(guid.toLowerCase());
+    }
+    /**
+     * Get all mappings for a specific platform
+     */
+    getMappingsByPlatform(platform) {
+        const result = [];
+        const platformLower = platform.toLowerCase();
+        for (const mapping of this.mappings.values()) {
+            if (mapping.platform.toLowerCase() === platformLower) {
+                result.push(mapping);
+            }
+        }
+        return result;
+    }
+    /**
+     * Parse a single database line
+     */
+    parseLine(line) {
+        // Format: GUID,Name,mapping pairs...,platform:Platform,
+        const parts = line.split(',');
+        if (parts.length < 3) {
+            return null;
+        }
+        const guid = parts[0].toLowerCase().trim();
+        const name = parts[1].trim();
+        const buttons = new Map();
+        const axes = new Map();
+        const dpads = new Map();
+        let platform = '';
+        // Parse mapping pairs (key:value)
+        for (let i = 2; i < parts.length; i++) {
+            const part = parts[i].trim();
+            if (!part)
+                continue;
+            // Check for platform specifier
+            if (part.startsWith('platform:')) {
+                platform = part.substring('platform:'.length).trim();
+                continue;
+            }
+            // Parse key:value pairs
+            const colonIndex = part.indexOf(':');
+            if (colonIndex === -1)
+                continue;
+            const key = part.substring(0, colonIndex).trim();
+            const value = part.substring(colonIndex + 1).trim();
+            if (!key || !value)
+                continue;
+            // Parse button mapping (b0, b1, etc.)
+            if (value.startsWith('b')) {
+                const buttonIndex = parseInt(value.substring(1), 10);
+                if (!isNaN(buttonIndex)) {
+                    buttons.set(key, buttonIndex);
+                }
+            }
+            // Parse axis mapping (a0, a1, etc.)
+            else if (value.startsWith('a')) {
+                const axisIndex = parseInt(value.substring(1), 10);
+                if (!isNaN(axisIndex)) {
+                    axes.set(key, axisIndex);
+                }
+            }
+            // Parse hat mapping (h0.1, h0.4, etc.) - used for D-pad
+            else if (value.startsWith('h')) {
+                const hatParts = value.substring(1).split('.');
+                if (hatParts.length === 2) {
+                    const hatIndex = parseInt(hatParts[0], 10);
+                    const hatValue = parseInt(hatParts[1], 10);
+                    if (!isNaN(hatIndex) && !isNaN(hatValue)) {
+                        dpads.set(key, { hat: hatIndex, value: hatValue });
+                    }
+                }
+            }
+            // Parse axis-as-button mappings (+a0, -a0) - some controllers use axes for D-pad
+            else if (value.startsWith('+a') || value.startsWith('-a')) {
+                const axisIndex = parseInt(value.substring(2), 10);
+                const direction = value[0];
+                if (!isNaN(axisIndex)) {
+                    // Store as special button with axis info
+                    // We'll handle this in the mapping layer
+                    buttons.set(`${key}:${direction}`, axisIndex);
+                }
+            }
+        }
+        return {
+            guid,
+            name,
+            platform,
+            buttons,
+            axes,
+            dpads,
+        };
+    }
+}
+// Singleton instance
+export const gamepadDatabase = new GamepadDatabase();

package/dist/gamepad-mapping.d.ts

@@ -0,0 +1,31 @@
+export interface ButtonMapping {
+    toStandard: Map<number, number>;
+    fromStandard: Map<number, number>;
+    controllerName: string;
+    hasMapping: boolean;
+}
+export declare class GamepadMapping {
+    private mappings;
+    private dbLoaded;
+    loadDatabase(): Promise<void>;
+    /**
+     * Load database from raw text content
+     */
+    loadDatabaseFromText(content: string): void;
+    /**
+     * Get or create a button mapping for a specific gamepad
+     */
+    getMapping(gamepad: Gamepad): ButtonMapping;
+    /**
+     * Clear all cached mappings
+     */
+    clear(): void;
+    /**
+     * Create a new button mapping for a gamepad
+     */
+    private createMapping;
+    private findDatabaseMapping;
+    private extractVendorProduct;
+}
+export declare const gamepadMapping: GamepadMapping;
+//# sourceMappingURL=gamepad-mapping.d.ts.map

package/dist/gamepad-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad-mapping.d.ts","sourceRoot":"","sources":["../src/gamepad-mapping.ts"],"names":[],"mappings":"AA6CA,MAAM,WAAW,aAAa;IAE5B,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEhC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAElC,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAoC;IACpD,OAAO,CAAC,QAAQ,CAAS;IAEnB,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BnC;;OAEG;IACH,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAK3C;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,aAAa;IAa3C;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,OAAO,CAAC,aAAa;IAuDrB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,oBAAoB;CAuB7B;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/gamepad-mapping.js

@@ -0,0 +1,191 @@
+// Gamepad button mapping layer
+// Bridges SDL database mappings with our internal button naming system
+import { gamepadDatabase } from './gamepad-db';
+import { getButtonIndex } from './gamepad-button-map';
+// Map SDL button names to our internal button names
+const SDL_TO_INTERNAL_BUTTON = {
+    // Face buttons
+    'a': 'ButtonBottom',
+    'b': 'ButtonRight',
+    'x': 'ButtonLeft',
+    'y': 'ButtonTop',
+    // Bumpers and triggers
+    'leftshoulder': 'LB',
+    'rightshoulder': 'RB',
+    'lefttrigger': 'LT',
+    'righttrigger': 'RT',
+    // Menu buttons
+    'back': 'Back',
+    'start': 'Start',
+    'guide': 'Guide',
+    // Stick presses
+    'leftstick': 'LS',
+    'rightstick': 'RS',
+    // D-Pad
+    'dpup': 'DPadUp',
+    'dpdown': 'DPadDown',
+    'dpleft': 'DPadLeft',
+    'dpright': 'DPadRight',
+    // Misc buttons
+    'misc1': 'Misc1',
+    'misc2': 'Misc2',
+    'paddle1': 'Paddle1',
+    'paddle2': 'Paddle2',
+    'paddle3': 'Paddle3',
+    'paddle4': 'Paddle4',
+    'touchpad': 'Touchpad',
+};
+export class GamepadMapping {
+    constructor() {
+        Object.defineProperty(this, "mappings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "dbLoaded", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    async loadDatabase() {
+        if (this.dbLoaded)
+            return;
+        const sources = ['/like/gamecontrollerdb.txt', './gamecontrollerdb.txt'];
+        for (const src of sources) {
+            try {
+                const res = await fetch(src);
+                if (res.ok) {
+                    gamepadDatabase.load(await res.text());
+                    this.dbLoaded = true;
+                    break;
+                }
+            }
+            catch { }
+        }
+        if (!this.dbLoaded) {
+            try {
+                // @ts-ignore - Vite handles ?raw imports
+                const module = await import('./gamecontrollerdb.txt?raw');
+                if (typeof module.default === 'string') {
+                    gamepadDatabase.load(module.default);
+                    this.dbLoaded = true;
+                }
+            }
+            catch { }
+        }
+        if (this.dbLoaded) {
+            console.log(`[Gamepad] Loaded ${gamepadDatabase.getMappingCount()} controller mappings`);
+        }
+    }
+    /**
+     * Load database from raw text content
+     */
+    loadDatabaseFromText(content) {
+        gamepadDatabase.load(content);
+        this.dbLoaded = true;
+    }
+    /**
+     * Get or create a button mapping for a specific gamepad
+     */
+    getMapping(gamepad) {
+        // Use the gamepad's id as a key (this contains the GUID in most browsers)
+        const key = `${gamepad.id}_${gamepad.index}`;
+        if (this.mappings.has(key)) {
+            return this.mappings.get(key);
+        }
+        const mapping = this.createMapping(gamepad);
+        this.mappings.set(key, mapping);
+        return mapping;
+    }
+    /**
+     * Clear all cached mappings
+     */
+    clear() {
+        this.mappings.clear();
+    }
+    /**
+     * Create a new button mapping for a gamepad
+     */
+    createMapping(gamepad) {
+        const toStandard = new Map();
+        const fromStandard = new Map();
+        // If browser provides "standard" mapping, trust it - don't override with DB
+        if (gamepad.mapping === 'standard') {
+            for (let i = 0; i < gamepad.buttons.length; i++) {
+                toStandard.set(i, i);
+                fromStandard.set(i, i);
+            }
+            return {
+                toStandard,
+                fromStandard,
+                controllerName: gamepad.id,
+                hasMapping: true,
+            };
+        }
+        // Try to find a mapping in the database
+        const dbMapping = this.findDatabaseMapping(gamepad);
+        if (dbMapping) {
+            for (const [sdlButton, controllerButtonIndex] of dbMapping.buttons) {
+                const internalName = SDL_TO_INTERNAL_BUTTON[sdlButton];
+                if (internalName) {
+                    const standardIndex = getButtonIndex(internalName);
+                    if (standardIndex !== undefined) {
+                        toStandard.set(controllerButtonIndex, standardIndex);
+                        fromStandard.set(standardIndex, controllerButtonIndex);
+                    }
+                }
+            }
+            return {
+                toStandard,
+                fromStandard,
+                controllerName: dbMapping.name,
+                hasMapping: true,
+            };
+        }
+        // No database mapping found - use default layout
+        for (let i = 0; i < gamepad.buttons.length; i++) {
+            toStandard.set(i, i);
+            fromStandard.set(i, i);
+        }
+        return {
+            toStandard,
+            fromStandard,
+            controllerName: gamepad.id,
+            hasMapping: false,
+        };
+    }
+    findDatabaseMapping(gamepad) {
+        if (!this.dbLoaded)
+            return undefined;
+        const vp = this.extractVendorProduct(gamepad);
+        if (vp) {
+            return gamepadDatabase.getMappingByVendorProduct(vp.vendor, vp.product);
+        }
+        return undefined;
+    }
+    extractVendorProduct(gamepad) {
+        const id = gamepad.id;
+        const vendorProductMatch = id.match(/Vendor:\s*([0-9a-fA-F]+)\s+Product:\s*([0-9a-fA-F]+)/i);
+        if (vendorProductMatch) {
+            const vendor = parseInt(vendorProductMatch[1], 16);
+            const product = parseInt(vendorProductMatch[2], 16);
+            if (!isNaN(vendor) && !isNaN(product)) {
+                return { vendor, product };
+            }
+        }
+        const hexMatch = id.match(/^([0-9a-fA-F]{4})[\s-]+([0-9a-fA-F]{4})/);
+        if (hexMatch) {
+            const vendor = parseInt(hexMatch[1], 16);
+            const product = parseInt(hexMatch[2], 16);
+            if (!isNaN(vendor) && !isNaN(product)) {
+                return { vendor, product };
+            }
+        }
+        return null;
+    }
+}
+// Singleton instance
+export const gamepadMapping = new GamepadMapping();

package/dist/gamepad.d.ts

@@ -0,0 +1,56 @@
+import { getButtonName, getButtonIndex } from './gamepad-button-map';
+import { ButtonMapping } from './gamepad-mapping';
+export { getButtonName, getButtonIndex };
+export interface GamepadButtonEvent {
+    gamepadIndex: number;
+    buttonIndex: number;
+    buttonName: string;
+    rawButtonIndex: number;
+}
+export interface StickPosition {
+    x: number;
+    y: number;
+}
+export declare class Gamepad {
+    private buttonTrackers;
+    private connectedGamepads;
+    private buttonMappings;
+    constructor();
+    init(): Promise<void>;
+    private extractVendorProduct;
+    private setupEventListeners;
+    update(): {
+        pressed: GamepadButtonEvent[];
+        released: GamepadButtonEvent[];
+    };
+    isConnected(gamepadIndex: number): boolean;
+    /**
+     * Check if a button is currently pressed on a specific gamepad
+     * Uses mapped button indices (standard layout)
+     */
+    isButtonDown(gamepadIndex: number, button: number | string): boolean;
+    isButtonDownOnAny(button: number | string): boolean;
+    getPressedButtons(gamepadIndex: number): Set<number>;
+    getConnectedGamepads(): number[];
+    /**
+     * Get the raw Gamepad object for a specific index
+     */
+    getGamepad(gamepadIndex: number): globalThis.Gamepad | undefined;
+    /**
+     * Get the button mapping for a specific gamepad
+     */
+    getButtonMapping(gamepadIndex: number): ButtonMapping | undefined;
+    /**
+     * Check if a gamepad has a known mapping from the database
+     */
+    hasMapping(gamepadIndex: number): boolean;
+    /**
+     * Get the controller name for a specific gamepad
+     */
+    getControllerName(gamepadIndex: number): string | undefined;
+    getAxis(gamepadIndex: number, axisIndex: number): number;
+    getLeftStick(gamepadIndex: number): StickPosition;
+    getRightStick(gamepadIndex: number): StickPosition;
+}
+export declare const gamepad: Gamepad;
+//# sourceMappingURL=gamepad.d.ts.map

package/dist/gamepad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamepad.d.ts","sourceRoot":"","sources":["../src/gamepad.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAErE,OAAO,EAAkB,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC;AAEzC,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAkBD,qBAAa,OAAO;IAClB,OAAO,CAAC,cAAc,CAAgD;IACtE,OAAO,CAAC,iBAAiB,CAAyC;IAClE,OAAO,CAAC,cAAc,CAAoC;;IAMpD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,OAAO,CAAC,oBAAoB;IAwB5B,OAAO,CAAC,mBAAmB;IA6B3B,MAAM,IAAI;QAAE,OAAO,EAAE,kBAAkB,EAAE,CAAC;QAAC,QAAQ,EAAE,kBAAkB,EAAE,CAAA;KAAE;IA0D3E,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAI1C;;;OAGG;IACH,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAOpE,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IASnD,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAKpD,oBAAoB,IAAI,MAAM,EAAE;IAIhC;;OAEG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU,CAAC,OAAO,GAAG,SAAS;IAIhE;;OAEG;IACH,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAIjE;;OAEG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAKzC;;OAEG;IACH,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAK3D,OAAO,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAMxD,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa;IAMjD,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa;CAKnD;AAED,eAAO,MAAM,OAAO,SAAgB,CAAC"}