node-ch347 0.0.1

package/dist/flash.js

@@ -0,0 +1,597 @@
+"use strict";
+/**
+ * CH347 SPI Flash Programmer
+ *
+ * Supports common SPI flash chips (W25Qxx, GD25Qxx, MX25Lxx, etc.)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CH347Flash = void 0;
+const fs = __importStar(require("fs/promises"));
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const DEFAULT_TIMEOUT_MS = 30000; // 30 seconds for chip erase
+const POLL_INTERVAL_MS = 1; // 1ms polling
+class CH347Flash {
+    spi;
+    flashInfo = null;
+    constructor(spi) {
+        this.spi = spi;
+    }
+    /**
+     * Read JEDEC ID from flash chip
+     */
+    async readJedecId() {
+        const cmd = Buffer.from([constants_1.FLASH_CMD_READ_JEDEC_ID, 0, 0, 0]);
+        const response = await this.spi.transfer(cmd);
+        const manufacturerId = response[1];
+        const memoryType = response[2];
+        const capacity = response[3];
+        const jedecId = (manufacturerId << 16) | (memoryType << 8) | capacity;
+        // Look up in database
+        const dbEntry = types_1.FlashDatabase[jedecId];
+        let size = 0;
+        let name;
+        if (dbEntry) {
+            size = dbEntry.size;
+            name = dbEntry.name;
+        }
+        else {
+            // Calculate size from capacity byte (2^capacity bytes)
+            size = capacity > 0 ? 1 << capacity : 0;
+        }
+        const manufacturerName = types_1.FlashManufacturers[manufacturerId];
+        if (!name && manufacturerName) {
+            name = `${manufacturerName} (0x${jedecId.toString(16)})`;
+        }
+        this.flashInfo = {
+            manufacturerId,
+            memoryType,
+            capacity,
+            jedecId,
+            size,
+            name,
+        };
+        // Try to read SFDP parameters
+        await this.readSFDPBasicParams();
+        return this.flashInfo;
+    }
+    /**
+     * Read SFDP (Serial Flash Discoverable Parameters) data
+     * @param address 24-bit address in SFDP space
+     * @param length Number of bytes to read
+     */
+    async readSFDP(address, length) {
+        // Command: 0x5A + 24-bit address + 1 dummy byte + read data
+        const cmd = Buffer.alloc(5 + length);
+        cmd[0] = constants_1.FLASH_CMD_READ_SFDP;
+        cmd[1] = (address >> 16) & 0xff;
+        cmd[2] = (address >> 8) & 0xff;
+        cmd[3] = address & 0xff;
+        cmd[4] = 0x00; // dummy byte
+        const response = await this.spi.transfer(cmd);
+        return response.subarray(5);
+    }
+    /**
+     * Estimate erase timeout based on block size
+     */
+    estimateEraseTimeout(size) {
+        if (size <= 4096)
+            return 3000; // 4KB: 3s
+        if (size <= 32768)
+            return 5000; // 32KB: 5s
+        if (size <= 65536)
+            return 5000; // 64KB: 5s
+        return 10000; // Larger: 10s
+    }
+    /**
+     * Read and parse SFDP Basic Flash Parameter Table
+     * Populates flashInfo with discovered erase types and page size
+     */
+    async readSFDPBasicParams() {
+        if (!this.flashInfo)
+            return;
+        try {
+            // Read SFDP header (8 bytes at address 0x00)
+            const header = await this.readSFDP(0, 8);
+            // Validate signature "SFDP" (little-endian: 0x50444653)
+            const signature = header.readUInt32LE(0);
+            if (signature !== 0x50444653) {
+                return; // SFDP not supported
+            }
+            // Read first parameter header (8 bytes at address 0x08)
+            const paramHeader = await this.readSFDP(8, 8);
+            const tableLength = paramHeader[3] * 4; // length in DWORDs -> bytes
+            const tableAddress = paramHeader[4] | (paramHeader[5] << 8) | (paramHeader[6] << 16);
+            // Read Basic Flash Parameter Table (BFPT)
+            const bfpt = await this.readSFDP(tableAddress, Math.min(tableLength, 64));
+            // Parse erase types from DWORDs 8-9 (bytes 28-35)
+            // Each erase type is 2 bytes: [size_code, command]
+            // size_code: 2^N bytes, command: erase opcode
+            const eraseTypes = [];
+            for (let i = 0; i < 4; i++) {
+                const offset = 28 + i * 2;
+                if (offset + 1 >= bfpt.length)
+                    break;
+                const sizeCode = bfpt[offset]; // 2^N bytes
+                const command = bfpt[offset + 1];
+                if (sizeCode > 0 && command > 0) {
+                    const size = 1 << sizeCode;
+                    eraseTypes.push({
+                        command,
+                        size,
+                        timeoutMs: this.estimateEraseTimeout(size),
+                    });
+                }
+            }
+            // Parse page size from DWORD 11 (byte 40, bits 7-4)
+            let pageSize = constants_1.FLASH_PAGE_SIZE; // default 256
+            if (bfpt.length > 40) {
+                const pageSizeCode = (bfpt[40] >> 4) & 0x0f;
+                if (pageSizeCode > 0) {
+                    pageSize = 1 << pageSizeCode;
+                }
+            }
+            // Update flash info with SFDP data
+            this.flashInfo.sfdpSupported = true;
+            this.flashInfo.pageSize = pageSize;
+            this.flashInfo.eraseTypes = eraseTypes.sort((a, b) => b.size - a.size);
+        }
+        catch {
+            // SFDP read failed - chip may not support it, use defaults
+            this.flashInfo.sfdpSupported = false;
+        }
+    }
+    /**
+     * Read status register
+     */
+    async readStatus() {
+        const cmd = Buffer.from([constants_1.FLASH_CMD_READ_STATUS, 0]);
+        const response = await this.spi.transfer(cmd);
+        return response[1];
+    }
+    /**
+     * Wait for flash to be ready (WIP bit cleared)
+     */
+    async waitReady(timeoutMs = DEFAULT_TIMEOUT_MS) {
+        const startTime = Date.now();
+        while (true) {
+            const status = await this.readStatus();
+            if ((status & constants_1.FLASH_STATUS_WIP) === 0) {
+                return;
+            }
+            if (Date.now() - startTime > timeoutMs) {
+                throw new Error('Flash operation timeout');
+            }
+            await this.delay(POLL_INTERVAL_MS);
+        }
+    }
+    /**
+     * Enable write operations
+     */
+    async writeEnable() {
+        await this.spi.command(Buffer.from([constants_1.FLASH_CMD_WRITE_ENABLE]));
+        // Verify write enable latch is set
+        const status = await this.readStatus();
+        if ((status & constants_1.FLASH_STATUS_WEL) === 0) {
+            throw new Error('Failed to enable write');
+        }
+    }
+    /**
+     * Disable write operations
+     */
+    async writeDisable() {
+        await this.spi.command(Buffer.from([constants_1.FLASH_CMD_WRITE_DISABLE]));
+    }
+    /**
+     * Read data from flash
+     */
+    async read(address, length, onProgress) {
+        const result = Buffer.alloc(length);
+        const chunkSize = 4096; // Read in 4KB chunks for progress reporting
+        let offset = 0;
+        while (offset < length) {
+            const readLen = Math.min(chunkSize, length - offset);
+            const addr = address + offset;
+            // Build read command
+            const cmd = Buffer.alloc(4 + readLen);
+            cmd[0] = constants_1.FLASH_CMD_READ_DATA;
+            cmd[1] = (addr >> 16) & 0xff;
+            cmd[2] = (addr >> 8) & 0xff;
+            cmd[3] = addr & 0xff;
+            const response = await this.spi.transfer(cmd);
+            response.copy(result, offset, 4, 4 + readLen);
+            offset += readLen;
+            if (onProgress) {
+                onProgress({
+                    operation: 'read',
+                    current: offset,
+                    total: length,
+                    percentage: Math.round((offset / length) * 100),
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Write a single page (up to 256 bytes)
+     */
+    async writePage(address, data) {
+        if (data.length > constants_1.FLASH_PAGE_SIZE) {
+            throw new Error(`Data exceeds page size: ${data.length} > ${constants_1.FLASH_PAGE_SIZE}`);
+        }
+        await this.writeEnable();
+        // Build page program command
+        const cmd = Buffer.alloc(4 + data.length);
+        cmd[0] = constants_1.FLASH_CMD_PAGE_PROGRAM;
+        cmd[1] = (address >> 16) & 0xff;
+        cmd[2] = (address >> 8) & 0xff;
+        cmd[3] = address & 0xff;
+        data.copy(cmd, 4);
+        await this.spi.command(cmd);
+        await this.waitReady(1000); // Page program timeout 1 second
+    }
+    /**
+     * Write data to flash (handles page boundaries)
+     */
+    async write(address, data, onProgress) {
+        let offset = 0;
+        while (offset < data.length) {
+            // Calculate bytes remaining in current page
+            const pageOffset = (address + offset) % constants_1.FLASH_PAGE_SIZE;
+            const pageRemaining = constants_1.FLASH_PAGE_SIZE - pageOffset;
+            const writeLen = Math.min(pageRemaining, data.length - offset);
+            // Write page
+            const chunk = data.subarray(offset, offset + writeLen);
+            await this.writePage(address + offset, chunk);
+            offset += writeLen;
+            if (onProgress) {
+                onProgress({
+                    operation: 'write',
+                    current: offset,
+                    total: data.length,
+                    percentage: Math.round((offset / data.length) * 100),
+                });
+            }
+        }
+    }
+    /**
+     * Erase a 4KB sector
+     */
+    async eraseSector(address) {
+        // Align to sector boundary
+        const sectorAddress = address & ~(constants_1.FLASH_SECTOR_SIZE - 1);
+        await this.writeEnable();
+        const cmd = Buffer.from([
+            constants_1.FLASH_CMD_SECTOR_ERASE,
+            (sectorAddress >> 16) & 0xff,
+            (sectorAddress >> 8) & 0xff,
+            sectorAddress & 0xff,
+        ]);
+        await this.spi.command(cmd);
+        await this.waitReady(3000); // Sector erase timeout 3 seconds
+    }
+    /**
+     * Erase a 32KB block
+     */
+    async eraseBlock32K(address) {
+        const blockAddress = address & ~(constants_1.FLASH_BLOCK_SIZE_32K - 1);
+        await this.writeEnable();
+        const cmd = Buffer.from([
+            constants_1.FLASH_CMD_BLOCK_ERASE_32K,
+            (blockAddress >> 16) & 0xff,
+            (blockAddress >> 8) & 0xff,
+            blockAddress & 0xff,
+        ]);
+        await this.spi.command(cmd);
+        await this.waitReady(5000); // Block erase timeout 5 seconds
+    }
+    /**
+     * Erase a 64KB block
+     */
+    async eraseBlock64K(address) {
+        const blockAddress = address & ~(constants_1.FLASH_BLOCK_SIZE_64K - 1);
+        await this.writeEnable();
+        const cmd = Buffer.from([
+            constants_1.FLASH_CMD_BLOCK_ERASE_64K,
+            (blockAddress >> 16) & 0xff,
+            (blockAddress >> 8) & 0xff,
+            blockAddress & 0xff,
+        ]);
+        await this.spi.command(cmd);
+        await this.waitReady(5000); // Block erase timeout 5 seconds
+    }
+    /**
+     * Erase entire chip
+     */
+    async eraseChip(onProgress) {
+        await this.writeEnable();
+        await this.spi.command(Buffer.from([constants_1.FLASH_CMD_CHIP_ERASE]));
+        // Poll for completion with progress
+        const startTime = Date.now();
+        const timeout = DEFAULT_TIMEOUT_MS;
+        while (true) {
+            const status = await this.readStatus();
+            if ((status & constants_1.FLASH_STATUS_WIP) === 0) {
+                if (onProgress) {
+                    onProgress({
+                        operation: 'erase',
+                        current: 100,
+                        total: 100,
+                        percentage: 100,
+                    });
+                }
+                return;
+            }
+            const elapsed = Date.now() - startTime;
+            if (elapsed > timeout) {
+                throw new Error('Chip erase timeout');
+            }
+            if (onProgress) {
+                // Estimate progress based on typical chip erase time
+                const estimatedTime = 30000; // 30 seconds typical
+                const progress = Math.min(99, Math.round((elapsed / estimatedTime) * 100));
+                onProgress({
+                    operation: 'erase',
+                    current: progress,
+                    total: 100,
+                    percentage: progress,
+                });
+            }
+            await this.delay(100);
+        }
+    }
+    /**
+     * Erase using a specific erase type (from SFDP discovery)
+     */
+    async eraseWithType(address, eraseType) {
+        // Align to erase boundary
+        const alignedAddress = address & ~(eraseType.size - 1);
+        await this.writeEnable();
+        const cmd = Buffer.from([
+            eraseType.command,
+            (alignedAddress >> 16) & 0xff,
+            (alignedAddress >> 8) & 0xff,
+            alignedAddress & 0xff,
+        ]);
+        await this.spi.command(cmd);
+        await this.waitReady(eraseType.timeoutMs);
+    }
+    /**
+     * Get default erase types (fallback when SFDP not available)
+     */
+    getDefaultEraseTypes() {
+        return [
+            { command: constants_1.FLASH_CMD_BLOCK_ERASE_64K, size: constants_1.FLASH_BLOCK_SIZE_64K, timeoutMs: 5000 },
+            { command: constants_1.FLASH_CMD_BLOCK_ERASE_32K, size: constants_1.FLASH_BLOCK_SIZE_32K, timeoutMs: 5000 },
+            { command: constants_1.FLASH_CMD_SECTOR_ERASE, size: constants_1.FLASH_SECTOR_SIZE, timeoutMs: 3000 },
+        ];
+    }
+    /**
+     * Erase range (uses optimal erase commands from SFDP or defaults)
+     */
+    async eraseRange(address, length, onProgress) {
+        const endAddress = address + length;
+        let currentAddress = address;
+        let erased = 0;
+        // Use SFDP-discovered erase types or fall back to defaults
+        const eraseTypes = this.flashInfo?.eraseTypes ?? this.getDefaultEraseTypes();
+        while (currentAddress < endAddress) {
+            const remaining = endAddress - currentAddress;
+            // Find the largest erase type that fits
+            let usedEraseType = null;
+            for (const eraseType of eraseTypes) {
+                if ((currentAddress % eraseType.size === 0) &&
+                    remaining >= eraseType.size) {
+                    usedEraseType = eraseType;
+                    break; // eraseTypes are sorted by size descending
+                }
+            }
+            if (usedEraseType) {
+                await this.eraseWithType(currentAddress, usedEraseType);
+                currentAddress += usedEraseType.size;
+                erased += usedEraseType.size;
+            }
+            else {
+                // Fallback to smallest erase type available
+                const smallestErase = eraseTypes[eraseTypes.length - 1];
+                await this.eraseWithType(currentAddress, smallestErase);
+                currentAddress += smallestErase.size;
+                erased += smallestErase.size;
+            }
+            if (onProgress) {
+                onProgress({
+                    operation: 'erase',
+                    current: Math.min(erased, length),
+                    total: length,
+                    percentage: Math.round((Math.min(erased, length) / length) * 100),
+                });
+            }
+        }
+    }
+    /**
+     * Verify data matches flash contents
+     */
+    async verify(address, data, onProgress) {
+        const readData = await this.read(address, data.length, (progress) => {
+            if (onProgress) {
+                onProgress({
+                    ...progress,
+                    operation: 'verify',
+                });
+            }
+        });
+        return data.equals(readData);
+    }
+    /**
+     * Check if a sector needs to be erased to write new data
+     * Flash can only program 1→0, so we need to erase if any bit needs to go 0→1
+     */
+    sectorNeedsErase(original, newData) {
+        for (let i = 0; i < newData.length; i++) {
+            // If (original & new) !== new, some bits need to go from 0 to 1, requiring erase
+            if ((original[i] & newData[i]) !== newData[i]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a sector has any changes
+     */
+    sectorHasChanges(original, newData) {
+        return !original.equals(newData);
+    }
+    /**
+     * Program flash (smart erase + write + verify)
+     * Only erases and writes sectors that have actual changes
+     */
+    async program(address, data, options = {}) {
+        const { erase = true, verify = true, onProgress } = options;
+        // Read original content to compare
+        const original = await this.read(address, data.length);
+        // Analyze which sectors need erasing and which need writing
+        const sectorsToErase = [];
+        const sectorsToWrite = [];
+        const startSector = Math.floor(address / constants_1.FLASH_SECTOR_SIZE);
+        const endAddress = address + data.length;
+        const endSector = Math.ceil(endAddress / constants_1.FLASH_SECTOR_SIZE);
+        for (let sector = startSector; sector < endSector; sector++) {
+            const sectorStart = sector * constants_1.FLASH_SECTOR_SIZE;
+            const sectorEnd = sectorStart + constants_1.FLASH_SECTOR_SIZE;
+            // Calculate overlap between this sector and our data range
+            const overlapStart = Math.max(sectorStart, address);
+            const overlapEnd = Math.min(sectorEnd, endAddress);
+            // Get the corresponding slices
+            const dataOffset = overlapStart - address;
+            const dataSlice = data.subarray(dataOffset, dataOffset + (overlapEnd - overlapStart));
+            const originalSlice = original.subarray(dataOffset, dataOffset + (overlapEnd - overlapStart));
+            if (this.sectorHasChanges(originalSlice, dataSlice)) {
+                sectorsToWrite.push(sector);
+                if (erase && this.sectorNeedsErase(originalSlice, dataSlice)) {
+                    sectorsToErase.push(sector);
+                }
+            }
+        }
+        // Calculate progress steps
+        const totalWork = sectorsToErase.length + sectorsToWrite.length + (verify ? 1 : 0);
+        let completedWork = 0;
+        const reportProgress = (operation) => {
+            if (onProgress) {
+                onProgress({
+                    operation,
+                    current: completedWork,
+                    total: totalWork,
+                    percentage: totalWork > 0 ? Math.round((completedWork / totalWork) * 100) : 100,
+                });
+            }
+        };
+        // Erase only the sectors that need it
+        for (const sector of sectorsToErase) {
+            await this.eraseSector(sector * constants_1.FLASH_SECTOR_SIZE);
+            completedWork++;
+            reportProgress('erase');
+        }
+        // Write only the sectors that have changes
+        for (const sector of sectorsToWrite) {
+            const sectorStart = sector * constants_1.FLASH_SECTOR_SIZE;
+            const sectorEnd = sectorStart + constants_1.FLASH_SECTOR_SIZE;
+            const overlapStart = Math.max(sectorStart, address);
+            const overlapEnd = Math.min(sectorEnd, endAddress);
+            const dataOffset = overlapStart - address;
+            const dataSlice = data.subarray(dataOffset, dataOffset + (overlapEnd - overlapStart));
+            await this.write(overlapStart, dataSlice);
+            completedWork++;
+            reportProgress('write');
+        }
+        // Verify
+        if (verify) {
+            const verified = await this.verify(address, data);
+            completedWork++;
+            reportProgress('verify');
+            if (!verified) {
+                throw new Error('Verification failed');
+            }
+        }
+        return true;
+    }
+    /**
+     * Program flash from a binary file
+     * @param filePath Path to the binary file to write
+     * @param address Starting address in flash (default: 0, requires file size to match flash size)
+     * @param options Programming options (erase, verify, progress callback)
+     */
+    async programFile(filePath, address, options = {}) {
+        const data = await fs.readFile(filePath);
+        // If no address specified, default to 0 but require file size to match flash size
+        if (address === undefined) {
+            if (!this.flashInfo?.size) {
+                throw new Error('Flash size unknown. Call readJedecId() first or specify an address.');
+            }
+            if (data.length !== this.flashInfo.size) {
+                throw new Error(`File size (${data.length} bytes) does not match flash size (${this.flashInfo.size} bytes). ` +
+                    `Specify an address explicitly to write partial data.`);
+            }
+            address = 0;
+        }
+        return this.program(address, data, options);
+    }
+    /**
+     * Read flash contents and save to a binary file
+     * @param filePath Path to save the binary file
+     * @param address Starting address in flash (default: 0)
+     * @param length Number of bytes to read (if not specified, reads entire flash based on JEDEC ID)
+     * @param onProgress Progress callback
+     */
+    async readToFile(filePath, address = 0, length, onProgress) {
+        const readLength = length ?? this.flashInfo?.size;
+        if (!readLength) {
+            throw new Error('Length not specified and flash size unknown. Call readJedecId() first or specify length.');
+        }
+        const data = await this.read(address, readLength, onProgress);
+        await fs.writeFile(filePath, data);
+    }
+    /**
+     * Get flash info (call readJedecId first)
+     */
+    getFlashInfo() {
+        return this.flashInfo;
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+exports.CH347Flash = CH347Flash;
+//# sourceMappingURL=flash.js.map

package/dist/gpio.d.ts

@@ -0,0 +1,67 @@
+/**
+ * CH347 GPIO Control
+ *
+ * Protocol from ch347-gpio.c:
+ * - GPIO buffer is 11 bytes: [0xCC, length(8), 0x00, pin0, pin1, pin2, pin3, pin4, pin5, pin6, pin7]
+ * - Each pin byte has control bits:
+ *   - Bit 7 (0x80): In response, indicates output direction
+ *   - Bit 6 (0x40): Enable pin change (out) / Current value (in)
+ *   - Bit 5-4 (0x30): Set direction to output
+ *   - Bit 3 (0x08): Set pin value high
+ */
+import { CH347USB } from './usb';
+import { GPIOConfig, GPIOState } from './types';
+export declare class CH347GPIO {
+    private usb;
+    private pinStates;
+    constructor(usb: CH347USB);
+    /**
+     * Build GPIO command buffer
+     */
+    private buildCommandBuffer;
+    /**
+     * Parse GPIO response buffer
+     */
+    private parseResponse;
+    /**
+     * Read all GPIO states
+     */
+    readAll(): Promise<GPIOState[]>;
+    /**
+     * Read single GPIO pin state
+     */
+    read(pin: number): Promise<GPIOState>;
+    /**
+     * Configure GPIO pin direction
+     */
+    setDirection(pin: number, direction: 'input' | 'output'): Promise<void>;
+    /**
+     * Set GPIO output value
+     */
+    write(pin: number, value: boolean): Promise<void>;
+    /**
+     * Set multiple GPIO pins at once
+     */
+    writeMultiple(pins: {
+        pin: number;
+        value: boolean;
+    }[]): Promise<void>;
+    /**
+     * Configure multiple GPIO pins
+     */
+    configure(configs: GPIOConfig[]): Promise<void>;
+    /**
+     * Pulse a GPIO pin (useful for buttons)
+     */
+    pulse(pin: number, durationMs?: number, activeHigh?: boolean): Promise<void>;
+    /**
+     * Toggle GPIO pin
+     */
+    toggle(pin: number): Promise<boolean>;
+    /**
+     * Get cached pin states (call readAll() to refresh)
+     */
+    getPinStates(): GPIOState[];
+    private delay;
+}
+//# sourceMappingURL=gpio.d.ts.map