@typecad/hal 0.1.0-alpha.1

package/dist/shift.js

@@ -0,0 +1,71 @@
+import { rawCpp } from './emit.js';
+import { LSBFIRST, MSBFIRST } from './constants.js';
+export function shiftIn(dataPin, clockPin, bitOrder) {
+    rawCpp(`return shiftIn(${dataPin}, ${clockPin}, ${bitOrder});`);
+    return 0;
+}
+export function shiftOut(dataPin, clockPin, bitOrder, value) {
+    rawCpp(`shiftOut(${dataPin}, ${clockPin}, ${bitOrder}, ${value});`);
+}
+export class Shift {
+    /** Directly shifts a byte out to a pin. */
+    static out(dataPin, clockPin, order, value) {
+        const bitOrder = order === 'lsb' ? LSBFIRST : MSBFIRST;
+        rawCpp(`shiftOut(${dataPin.number}, ${clockPin.number}, ${bitOrder}, ${value});`);
+    }
+    /** Directly shifts a byte in from a pin. */
+    static in(dataPin, clockPin, order) {
+        const bitOrder = order === 'lsb' ? LSBFIRST : MSBFIRST;
+        rawCpp(`return shiftIn(${dataPin.number}, ${clockPin.number}, ${bitOrder});`);
+        return 0;
+    }
+    /** Fluent builder for shifting out. */
+    static write(dataPin, value) {
+        return new ShiftOutBuilder(dataPin, value);
+    }
+    /** Fluent builder for shifting in. */
+    static read(dataPin) {
+        return new ShiftInBuilder(dataPin);
+    }
+}
+class ShiftOutBuilder {
+    constructor(dataPin, value) {
+        this._dataPin = dataPin.number;
+        this._value = value;
+    }
+    clock(clk) {
+        this._clockPin = clk.number;
+        return this;
+    }
+    msbFirst() {
+        if (this._clockPin === undefined)
+            throw new Error("Clock pin must be specified");
+        rawCpp(`shiftOut(${this._dataPin}, ${this._clockPin}, MSBFIRST, ${this._value});`);
+    }
+    lsbFirst() {
+        if (this._clockPin === undefined)
+            throw new Error("Clock pin must be specified");
+        rawCpp(`shiftOut(${this._dataPin}, ${this._clockPin}, LSBFIRST, ${this._value});`);
+    }
+}
+class ShiftInBuilder {
+    constructor(dataPin) {
+        this._dataPin = dataPin.number;
+    }
+    clock(clk) {
+        this._clockPin = clk.number;
+        return this;
+    }
+    msbFirst() {
+        if (this._clockPin === undefined)
+            throw new Error("Clock pin must be specified");
+        rawCpp(`return shiftIn(${this._dataPin}, ${this._clockPin}, MSBFIRST);`);
+        return 0;
+    }
+    lsbFirst() {
+        if (this._clockPin === undefined)
+            throw new Error("Clock pin must be specified");
+        rawCpp(`return shiftIn(${this._dataPin}, ${this._clockPin}, LSBFIRST);`);
+        return 0;
+    }
+}

package/dist/spi.d.ts

@@ -0,0 +1,31 @@
+import type { Pin } from './gpio.js';
+import type { SPIMode, SPISettings } from './types.js';
+export declare class SPIDevice {
+    private _bus;
+    private _cs;
+    constructor(bus: string, chipSelect: number);
+    transfer(data: number | Uint8Array): number;
+    write(data: number | Uint8Array): void;
+    readRegister(register: number, count: number): Uint8Array;
+    writeRegister(register: number, value: number): void;
+}
+export declare class SPIBus {
+    static readonly __includes: string[];
+    private _bus;
+    constructor(bus: string);
+    device(chipSelect: Pin): SPIDevice;
+    begin(): this;
+    end(): void;
+    take(): this | null;
+    release(): void;
+    transfer(value: number | Uint8Array): number;
+    setFrequency(hz: number): void;
+    beginTransaction(settings: SPISettings): void;
+    endTransaction(): void;
+    setMode(mode: SPIMode): void;
+    setBitOrder(order: 'lsb' | 'msb'): void;
+    write(value: number): void;
+    write16(value: number): void;
+}
+/** Map TypeCAD SPI instance number to Arduino C++ object name. SPI0→SPI, SPI1→SPI1 */
+export declare function spiName(instance: number): string;

package/dist/spi.js

@@ -0,0 +1,90 @@
+import { spiBegin, spiEnd, spiTransfer, spiBeginTx, spiEndTx, spiCsLow, spiCsHigh, spiSetMode, spiSetBitOrder, rawCpp } from './emit.js';
+import { include } from './include.js';
+export class SPIDevice {
+    constructor(bus, chipSelect) {
+        this._bus = bus;
+        this._cs = chipSelect;
+    }
+    transfer(data) {
+        include("<SPI.h>");
+        spiCsLow(this._cs);
+        rawCpp(`auto __res = ${this._bus}.transfer(${data});`);
+        spiCsHigh(this._cs);
+        rawCpp(`return __res;`);
+        return 0;
+    }
+    write(data) {
+        include("<SPI.h>");
+        spiCsLow(this._cs);
+        spiTransfer(this._bus, data);
+        spiCsHigh(this._cs);
+    }
+    readRegister(register, count) {
+        include("<SPI.h>");
+        rawCpp(`digitalWrite(${this._cs}, LOW);`);
+        rawCpp(`${this._bus}.transfer(${register});`);
+        rawCpp(`static uint8_t __spi_buf[${count}];`);
+        rawCpp(`for (int i=0; i<${count}; i++) __spi_buf[i] = ${this._bus}.transfer(0x00);`);
+        rawCpp(`digitalWrite(${this._cs}, HIGH);`);
+        rawCpp(`return __spi_buf;`);
+        return new Uint8Array(count);
+    }
+    writeRegister(register, value) {
+        include("<SPI.h>");
+        spiCsLow(this._cs);
+        spiTransfer(this._bus, register);
+        spiTransfer(this._bus, value);
+        spiCsHigh(this._cs);
+    }
+}
+export class SPIBus {
+    constructor(bus) {
+        this._bus = bus;
+    }
+    device(chipSelect) {
+        return new SPIDevice(this._bus, chipSelect.number);
+    }
+    begin() {
+        include("<SPI.h>");
+        spiBegin(this._bus);
+        return this;
+    }
+    end() {
+        spiEnd(this._bus);
+    }
+    take() {
+        return this;
+    }
+    release() {
+        // No-op for standard Arduino.
+    }
+    transfer(value) {
+        return spiTransfer(this._bus, value);
+    }
+    setFrequency(hz) {
+        spiBeginTx(this._bus, `SPISettings(${hz}, MSBFIRST, SPI_MODE0)`);
+    }
+    beginTransaction(settings) {
+        spiBeginTx(this._bus, settings);
+    }
+    endTransaction() {
+        spiEndTx(this._bus);
+    }
+    setMode(mode) {
+        spiSetMode(this._bus, mode);
+    }
+    setBitOrder(order) {
+        spiSetBitOrder(this._bus, order);
+    }
+    write(value) {
+        spiTransfer(this._bus, value);
+    }
+    write16(value) {
+        rawCpp(`${this._bus}.transfer16(${value});`);
+    }
+}
+SPIBus.__includes = ["<SPI.h>"];
+/** Map TypeCAD SPI instance number to Arduino C++ object name. SPI0→SPI, SPI1→SPI1 */
+export function spiName(instance) {
+    return instance === 0 ? "SPI" : `SPI${instance}`;
+}

package/dist/timer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * HardwareTimer provides direct control over the board's hardware timers.
+ *
+ * Hardware timers are distinct from the software-based setInterval/setTimeout
+ * and are typically used for high-precision timing, PWM generation, or
+ * interrupt-driven tasks.
+ */
+export declare class HardwareTimer {
+    private _instance;
+    constructor(instance: number);
+    /**
+     * Sets the timer frequency in Hertz.
+     * Note: The actual frequency may be limited by the hardware's clock dividers.
+     */
+    setFrequency(hz: number): void;
+    /**
+     * Attaches an interrupt handler that executes when the timer overflows.
+     */
+    onOverflow(handler: () => void): void;
+    /**
+     * Starts the timer.
+     */
+    start(): void;
+    /**
+     * Stops the timer.
+     */
+    stop(): void;
+    /**
+     * Returns the bit resolution of the timer (e.g., 8, 16, 32).
+     */
+    getBits(): number;
+}
+export declare const Timer0: HardwareTimer;
+export declare const Timer1: HardwareTimer;
+export declare const Timer2: HardwareTimer;

package/dist/timer.js

@@ -0,0 +1,50 @@
+import { rawCpp, boardResolve } from './emit.js';
+import { callback } from './callback.js';
+/**
+ * HardwareTimer provides direct control over the board's hardware timers.
+ *
+ * Hardware timers are distinct from the software-based setInterval/setTimeout
+ * and are typically used for high-precision timing, PWM generation, or
+ * interrupt-driven tasks.
+ */
+export class HardwareTimer {
+    constructor(instance) {
+        this._instance = instance;
+    }
+    /**
+     * Sets the timer frequency in Hertz.
+     * Note: The actual frequency may be limited by the hardware's clock dividers.
+     */
+    setFrequency(hz) {
+        rawCpp(`Timer${this._instance}.setFrequency(${hz});`);
+    }
+    /**
+     * Attaches an interrupt handler that executes when the timer overflows.
+     */
+    onOverflow(handler) {
+        rawCpp(`Timer${this._instance}.onOverflow(${callback(handler)});`);
+    }
+    /**
+     * Starts the timer.
+     */
+    start() {
+        rawCpp(`Timer${this._instance}.start();`);
+    }
+    /**
+     * Stops the timer.
+     */
+    stop() {
+        rawCpp(`Timer${this._instance}.stop();`);
+    }
+    /**
+     * Returns the bit resolution of the timer (e.g., 8, 16, 32).
+     */
+    getBits() {
+        // "peripherals.timer" (singular) matches the board-resolver's array-key
+        // derivation (TIMER_INSTANCES → peripherals.timer.<index>.*).
+        return boardResolve("peripherals.timer." + this._instance + ".bits");
+    }
+}
+export const Timer0 = new HardwareTimer(0);
+export const Timer1 = new HardwareTimer(1);
+export const Timer2 = new HardwareTimer(2);

package/dist/timing.d.ts

@@ -0,0 +1,29 @@
+export declare class TimingClass {
+    static readonly __instance_name = "Timing";
+    millis(): number;
+    micros(): number;
+    delay(ms: number): void;
+    delayMicroseconds(us: number): void;
+    freeHeap(): number;
+    setInterval(handler: () => void, timeout: number): number;
+    setTimeout(handler: () => void, timeout: number): number;
+    clearInterval(id: number): void;
+    clearTimeout(id: number): void;
+}
+export declare const Timing: TimingClass;
+export declare function delay(ms: number): void;
+export declare function millis(): number;
+export declare function micros(): number;
+export declare function delayMicroseconds(us: number): void;
+export declare function freeHeap(): number;
+export declare function setInterval(handler: () => void, timeout: number): number;
+export declare function setTimeout(handler: () => void, timeout: number): number;
+export declare function clearInterval(id: number): void;
+export declare function clearTimeout(id: number): void;
+/** Re-map a number from one range to another. Passes through to the Arduino
+ *  core `map()` macro — the transpiler lowers this to a bare `map(...)` call,
+ *  so the target framework must provide the implementation (Arduino.h does). */
+export declare function map(value: number, fromLow: number, fromHigh: number, toLow: number, toHigh: number): number;
+/** Constrain a number to a range. Passes through to the Arduino core
+ *  `constrain()` macro — see note on `map()` above. */
+export declare function constrain(value: number, low: number, high: number): number;

package/dist/timing.js

@@ -0,0 +1,53 @@
+import { rawCpp, getMillis, getMicros, getFreeHeap, delayMs, delayMicro } from './emit.js';
+import { callback } from './callback.js';
+export class TimingClass {
+    millis() { return getMillis(); }
+    micros() { return getMicros(); }
+    delay(ms) { delayMs(ms); }
+    delayMicroseconds(us) { delayMicro(us); }
+    freeHeap() {
+        return getFreeHeap();
+    }
+    setInterval(handler, timeout) {
+        rawCpp(`return __tc_setInterval(${callback(handler)}, ${timeout});`);
+        return 0;
+    }
+    setTimeout(handler, timeout) {
+        rawCpp(`return __tc_setTimeout(${callback(handler)}, ${timeout});`);
+        return 0;
+    }
+    clearInterval(id) {
+        rawCpp(`__tc_clearInterval(${id});`);
+    }
+    clearTimeout(id) {
+        rawCpp(`__tc_clearTimeout(${id});`);
+    }
+}
+TimingClass.__instance_name = "Timing";
+export const Timing = new TimingClass();
+export function delay(ms) { delayMs(ms); }
+export function millis() { return getMillis(); }
+export function micros() { return getMicros(); }
+export function delayMicroseconds(us) { delayMicro(us); }
+export function freeHeap() { return Timing.freeHeap(); }
+export function setInterval(handler, timeout) {
+    rawCpp(`return __tc_setInterval(${callback(handler)}, ${timeout});`);
+    return 0;
+}
+export function setTimeout(handler, timeout) {
+    rawCpp(`return __tc_setTimeout(${callback(handler)}, ${timeout});`);
+    return 0;
+}
+export function clearInterval(id) {
+    rawCpp(`__tc_clearInterval(${id});`);
+}
+export function clearTimeout(id) {
+    rawCpp(`__tc_clearTimeout(${id});`);
+}
+/** Re-map a number from one range to another. Passes through to the Arduino
+ *  core `map()` macro — the transpiler lowers this to a bare `map(...)` call,
+ *  so the target framework must provide the implementation (Arduino.h does). */
+export function map(value, fromLow, fromHigh, toLow, toHigh) { return 0; }
+/** Constrain a number to a range. Passes through to the Arduino core
+ *  `constrain()` macro — see note on `map()` above. */
+export function constrain(value, low, high) { return 0; }

package/dist/types.d.ts

@@ -0,0 +1,48 @@
+/** A digital value is a plain boolean. */
+export type DigitalValue = boolean;
+/** An analog value is a plain number (resolution-dependent). */
+export type AnalogValue = number;
+export declare enum PinMode {
+    INPUT = "INPUT",
+    OUTPUT = "OUTPUT",
+    INPUT_PULLUP = "INPUT_PULLUP",
+    INPUT_PULLDOWN = "INPUT_PULLDOWN",
+    OUTPUT_OPEN_DRAIN = "OUTPUT_OPEN_DRAIN",
+    ANALOG = "ANALOG"
+}
+export declare enum InterruptMode {
+    RISING = "RISING",
+    FALLING = "FALLING",
+    CHANGE = "CHANGE",
+    LOW = "LOW",
+    HIGH = "HIGH"
+}
+export type InterruptHandler = () => void;
+export interface PinGroupMember {
+    readonly number: number;
+    readonly gpio: number;
+    write(value: DigitalValue): void;
+    high(): void;
+    low(): void;
+    toggle(): void;
+    read(): DigitalValue;
+    isHigh(): boolean;
+    isLow(): boolean;
+}
+export interface IPinGroup<T extends PinGroupMember = PinGroupMember> {
+    readonly name: string;
+    readonly pins: ReadonlyArray<T>;
+    writePattern(pattern: number): void;
+    readPattern(): number;
+    fill(value: DigitalValue): void;
+}
+export declare function createPinGroup<T extends PinGroupMember>(pins: T[]): IPinGroup<T>;
+export type ArchitectureIdentifier = 'avr' | 'esp32' | 'esp32s2' | 'esp32s3' | 'esp32c3' | 'esp32c6' | 'rp2040' | 'samd' | 'stm32' | 'nrf52' | (string & {});
+export type I2CAddress = number;
+export type SPIBitOrder = 'msb' | 'lsb';
+export type SPIMode = 0 | 1 | 2 | 3;
+export interface SPISettings {
+    frequency: number;
+    mode: SPIMode;
+    bitOrder: SPIBitOrder;
+}

package/dist/types.js

@@ -0,0 +1,67 @@
+// ---------------------------------------------------------------------------
+// @typecad/hal — Public type definitions
+//
+// Transpiler-shim type surface: enums, type aliases, and the pin-group API
+// consumed by the HAL's transpiler-shim classes (Pin/OutputPin/InputPin,
+// I2CBus/SPIBus/SerialPort) and re-exported for downstream type-checking.
+//
+// Runtime-contract interfaces (BasePin, II2CBus, ISPIBus, ISerialPort, the
+// status enums, capability guards, etc.) have been relocated to
+// @typecad/simulator/src/contracts.ts — they describe the runtime objects the
+// simulator implements, not the transpiler shims that live here.
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Pin mode enum
+// ---------------------------------------------------------------------------
+export var PinMode;
+(function (PinMode) {
+    PinMode["INPUT"] = "INPUT";
+    PinMode["OUTPUT"] = "OUTPUT";
+    PinMode["INPUT_PULLUP"] = "INPUT_PULLUP";
+    PinMode["INPUT_PULLDOWN"] = "INPUT_PULLDOWN";
+    PinMode["OUTPUT_OPEN_DRAIN"] = "OUTPUT_OPEN_DRAIN";
+    PinMode["ANALOG"] = "ANALOG";
+})(PinMode || (PinMode = {}));
+// ---------------------------------------------------------------------------
+// Interrupt mode enum
+// ---------------------------------------------------------------------------
+export var InterruptMode;
+(function (InterruptMode) {
+    InterruptMode["RISING"] = "RISING";
+    InterruptMode["FALLING"] = "FALLING";
+    InterruptMode["CHANGE"] = "CHANGE";
+    InterruptMode["LOW"] = "LOW";
+    InterruptMode["HIGH"] = "HIGH";
+})(InterruptMode || (InterruptMode = {}));
+export function createPinGroup(pins) {
+    return {
+        name: 'PinGroup',
+        pins: Object.freeze(pins),
+        writePattern(pattern) {
+            for (let i = 0; i < this.pins.length; i++) {
+                const bit = (pattern >> i) & 1;
+                const pin = this.pins[i];
+                if ('write' in pin && typeof pin.write === 'function') {
+                    pin.write(bit === 1);
+                }
+            }
+        },
+        readPattern() {
+            let value = 0;
+            for (let i = 0; i < this.pins.length; i++) {
+                const pin = this.pins[i];
+                if ('isHigh' in pin && typeof pin.isHigh === 'function' && pin.isHigh()) {
+                    value |= (1 << i);
+                }
+            }
+            return value;
+        },
+        fill(value) {
+            for (const pin of this.pins) {
+                if ('write' in pin && typeof pin.write === 'function') {
+                    pin.write(value);
+                }
+            }
+        },
+    };
+}

package/dist/uart.d.ts

@@ -0,0 +1,21 @@
+export declare class SerialPort {
+    static readonly __includes: string[];
+    private _port;
+    constructor(port: string);
+    begin(baud?: number): this;
+    end(): void;
+    print(value: any): void;
+    println(value: any): void;
+    printf(format: string, ...args: any[]): void;
+    write(data: any): void;
+    read(): number;
+    readLine(): string;
+    peek(): number;
+    available(): number;
+    flush(): void;
+    waitForConnection(timeout?: number): Promise<void>;
+    take(): this | null;
+    release(): void;
+}
+/** Map TypeCAD UART instance number to Arduino C++ object name. UART0→Serial, UART1→Serial1 */
+export declare function serialName(instance: number): string;

package/dist/uart.js

@@ -0,0 +1,58 @@
+import { uartBegin, uartEnd, uartPrint, uartPrintln, uartPrintf, uartWrite, uartRead, uartPeek, uartAvailable, uartFlush, rawCpp } from './emit.js';
+export class SerialPort {
+    constructor(port) {
+        this._port = port;
+    }
+    begin(baud = 9600) {
+        uartBegin(this._port, baud);
+        return this;
+    }
+    end() {
+        uartEnd(this._port);
+    }
+    print(value) {
+        uartPrint(this._port, value);
+    }
+    println(value) {
+        uartPrintln(this._port, value);
+    }
+    printf(format, ...args) {
+        uartPrintf(this._port, format, args);
+    }
+    write(data) {
+        uartWrite(this._port, data);
+    }
+    read() {
+        return uartRead(this._port);
+    }
+    readLine() {
+        rawCpp(`return ${this._port}.readStringUntil('\\n');`);
+        return "";
+    }
+    peek() {
+        return uartPeek(this._port);
+    }
+    available() {
+        return uartAvailable(this._port);
+    }
+    flush() {
+        uartFlush(this._port);
+    }
+    waitForConnection(timeout) {
+        rawCpp(`while (!${this._port}) { delay(10); }`);
+        return Promise.resolve();
+    }
+    take() {
+        // Basic implementation for single-threaded Arduino; 
+        // real locking would be framework-specific.
+        return this;
+    }
+    release() {
+        // No-op for standard Arduino.
+    }
+}
+SerialPort.__includes = ["<Arduino.h>"];
+/** Map TypeCAD UART instance number to Arduino C++ object name. UART0→Serial, UART1→Serial1 */
+export function serialName(instance) {
+    return instance === 0 ? "Serial" : `Serial${instance}`;
+}

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Helper to inflate peripheral instances from a definition list into a sparse array
+ * for named destructuring.
+ *
+ * @example
+ * export const [UART0, UART1] = createHALInstances(UART_INSTANCES, i => new SerialPort(serialName(i)));
+ */
+export declare function createHALInstances<T>(instances: readonly {
+    instance: number;
+}[], factory: (instance: number) => T): T[];

package/dist/utils.js

@@ -0,0 +1,14 @@
+/**
+ * Helper to inflate peripheral instances from a definition list into a sparse array
+ * for named destructuring.
+ *
+ * @example
+ * export const [UART0, UART1] = createHALInstances(UART_INSTANCES, i => new SerialPort(serialName(i)));
+ */
+export function createHALInstances(instances, factory) {
+    const result = [];
+    for (const item of instances) {
+        result[item.instance] = factory(item.instance);
+    }
+    return result;
+}

package/dist/wdt.d.ts

@@ -0,0 +1,7 @@
+export declare class WDTClass {
+    static readonly __instance_name = "WDT";
+    enable(timeout: number | string): void;
+    reset(): void;
+    disable(): void;
+}
+export declare const WDT: WDTClass;

package/dist/wdt.js

@@ -0,0 +1,14 @@
+import { wdtEnable, wdtReset, wdtDisable } from './emit.js';
+export class WDTClass {
+    enable(timeout) {
+        wdtEnable(timeout);
+    }
+    reset() {
+        wdtReset();
+    }
+    disable() {
+        wdtDisable();
+    }
+}
+WDTClass.__instance_name = "WDT";
+export const WDT = new WDTClass();

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@typecad/hal",
+  "version": "0.1.0-alpha.1",
+  "description": "TypeCAD hardware abstraction layer — GPIO, I2C, SPI, UART as regular TypeScript",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test:hw": "npm exec -- cuttlefish-test",
+    "test:hw:basics": "npm exec -- cuttlefish-test tests/01-gpio.test.ts"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/justind000/typecode.git",
+    "directory": "packages/hal"
+  },
+  "homepage": "https://github.com/justind000/typecode/tree/main/packages/hal",
+  "bugs": {
+    "url": "https://github.com/justind000/typecode/issues"
+  },
+  "keywords": [
+    "arduino",
+    "cpp",
+    "cuttlefish",
+    "embedded",
+    "firmware",
+    "gpio",
+    "hal",
+    "hardware-abstraction",
+    "i2c",
+    "microcontroller",
+    "spi",
+    "typecad",
+    "typescript",
+    "uart"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "author": "typecad0",
+  "devDependencies": {
+    "@typecad/expect": "0.1.0-alpha.1",
+    "@typecad/board-arduino-uno": "0.1.0-alpha.1",
+    "@typecad/mcu-atmega328p": "0.1.0-alpha.1"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  }
+}