@moddable/typings 1.0.0 → 1.0.3

package/commodetto/Poco.d.ts

@@ -79,6 +79,8 @@ declare module "commodetto/Poco" {
     bitmapRemove(bits: Bitmap): void
     compact(): void
 
+    drawQRCode(qrcode:ArrayBuffer, x: number, y: number, scale: number, fore: number)
+
     readonly width: number
     readonly height: number
     readonly pixelsOut: PixelsOut

package/commodetto/outline.d.ts

@@ -59,7 +59,8 @@ declare module "commodetto/outline" {
     clone(): Outline
     rotate(angle: number): Outline
     rotate(angle: number, cx: number, cy: number): Outline
-    scale(x: number, y: number): Outline
+    scale(scale: number): Outline
+    scale(xScale: number, yScale: number): Outline
     translate(x: number, y: number): Outline
 
     readonly bounds: {

package/easing.d.ts

@@ -0,0 +1,34 @@
+type EasingFunction = (value: number) => number;
+
+interface Math {
+    backEaseIn: EasingFunction,
+    backEaseInOut: EasingFunction,
+    backEaseOut: EasingFunction,
+    bounceEaseIn: EasingFunction,
+    bounceEaseInOut: EasingFunction,
+    bounceEaseOut: EasingFunction,
+    circularEaseIn: EasingFunction,
+    circularEaseInOut: EasingFunction,
+    circularEaseOut: EasingFunction,
+    cubicEaseIn: EasingFunction,
+    cubicEaseInOut: EasingFunction,
+    cubicEaseOut: EasingFunction,
+    elasticEaseIn: EasingFunction,
+    elasticEaseInOut: EasingFunction,
+    elasticEaseOut: EasingFunction,
+    exponentialEaseIn: EasingFunction,
+    exponentialEaseInOut: EasingFunction,
+    exponentialEaseOut: EasingFunction,
+    quadEaseIn: EasingFunction,
+    quadEaseInOut: EasingFunction,
+    quadEaseOut: EasingFunction,
+    quartEaseIn: EasingFunction,
+    quartEaseInOut: EasingFunction,
+    quartEaseOut: EasingFunction,
+    quintEaseIn: EasingFunction,
+    quintEaseInOut: EasingFunction,
+    quintEaseOut: EasingFunction,
+    sineEaseIn: EasingFunction,
+    sineEaseInOut: EasingFunction,
+    sineEaseOut: EasingFunction
+}

package/embedded_io/socket/tcp.d.ts

@@ -20,23 +20,25 @@
 
 declare module "embedded:io/socket/tcp" {
   import type { Buffer } from "embedded:io/_common";
-  class TCP {
-    constructor(options: ((({
-      address: string;
-    } | {
-      host: string;
-    }) & {
-      port: number;
-    }) | {
-      from: TCP;
-    }) & {
-      nodelay?: boolean;
-      onReadable?: (this: TCP, bytes: number) => void;
-      onWritable?: (this: TCP, bytes: number) => void;
-      onError?: (this: TCP) => void;
-      format?: "number" | "buffer";
-      target?: any;
-    })
+  export type Options = ((({
+    address: string;
+  } | {
+    host: string;
+  }) & {
+    port: number;
+  }) | {
+    from: TCP;
+  }) & {
+    nodelay?: boolean;
+    onReadable?: (this: TCP, bytes: number) => void;
+    onWritable?: (this: TCP, bytes: number) => void;
+    onError?: (this: TCP) => void;
+    format?: "number" | "buffer";
+    target?: any;
+  };
+  
+  export default class TCP {
+    constructor(options: Options)
     readonly remoteAddress: string | undefined;
     readonly remotePort: number | undefined;
     read(byteLength?: number): number | ArrayBuffer;
@@ -46,6 +48,4 @@ declare module "embedded:io/socket/tcp" {
     get format(): "number" | "buffer"
     set format(value: "number" | "buffer")
   }
-
-  export default TCP;
 }

package/embedded_io/socket/tls.d.ts

@@ -0,0 +1,16 @@
+declare module "embedded:io/socket/tcp/tls" {
+  import { Options as TCPOptions } from "embedded:io/socket/tcp"
+  export type Options = TCPOptions & {
+    host: string
+    secure: Record<string, any> // should be called "tls" according to std?
+  }
+  export default class TLSSocket {
+    constructor(options: Options) 
+    close(): undefined
+    read(count: number|ArrayBufferLike) : undefined|ArrayBufferLike
+    write(buffer: ArrayBufferLike) : number
+    set format(format: string) 
+    get format() : string
+  }
+}
+

package/embedded_network/dns/resolver/udp.d.ts

@@ -0,0 +1,37 @@
+/*
+* Copyright (c) 2022 Shinya Ishikawa
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "embedded:network/dns/resolver/udp" {
+
+  interface Options {
+    host: string
+    onResolved: ((host:string, address:any) => null)
+    onError: ((host:string) => null)
+  }
+
+  class Resolver {
+    constructor(options: Record<string, any>)
+    close(): void
+    resolve(options: Options): void
+
+  }
+
+  export default Resolver
+}

package/embedded_network/http/client.d.ts

@@ -0,0 +1,54 @@
+/*
+* Copyright (c) 2022 Shinya Ishikawa
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "embedded:network/http/client" {
+  import type { Buffer } from "embedded:io/_common"
+
+  export interface ClientOptions {
+    socket: any
+    port?:number
+    host: string
+    dns: any
+    onError?: (err:any)=>void
+  }
+
+  export interface RequestOptions {
+    method?: string
+    path?: string
+    headers?: Map<string, string|string[]>
+    onHeaders?: (this: HTTPRequest, status:number, headers: Map<String, string>) => void
+    onReadable?: (this: HTTPRequest, count: number) => void
+    onWritable?: (this: HTTPRequest, count: number) => void
+    onDone?: (this: HTTPRequest, error: Error|null) => void // note: error is empty Error object
+  }
+
+  export interface HTTPRequest {
+    read(byteLength?: number): ArrayBuffer|undefined;
+    read(buffer: Buffer): void;
+    write(value: Buffer|undefined): void;
+  }
+
+  export default class HTTPClient {
+    constructor(options: ClientOptions)
+    request(options: RequestOptions): HTTPRequest
+    close(): void
+  }
+
+}

package/embedded_network/mqtt/client.d.ts

@@ -0,0 +1,74 @@
+declare module "embedded:network/mqtt/client" {
+  import type { Buffer } from "embedded:io/_common"
+
+  interface onReadableOptions {
+    more: boolean,
+    topic?: string,
+    QoS?: number,
+    byteLength?: number,
+  }
+
+  interface onControlMessage {
+    operation: number, // MQTTClient.CONNACK, etc...
+    id: number, 
+    payload?: Buffer, // for SUBACK
+  }
+
+  interface Will {
+    topic?: string,
+    message?: string|Buffer,
+    QoS?: number,
+    retain?: boolean,
+  }
+
+  interface Options {
+    host: string,
+    port?: number,
+    user?: string,
+    password?: string,
+    id?: string,
+    clean?: boolean,
+    will?: any,
+    keepAlive?: number, // milliseconds
+    onReadable?: (count: number, options: onReadableOptions) => void,
+    onWritable?: (count: number) => void,
+    onControl?: (opcode: number, message: onControlMessage) => void,
+    onClose?: () => void,
+    onError?: (error: any) => void,
+    dns: Record<string, any>,
+    socket: Record<string, any>,
+  }
+
+  interface WriteOptions {
+    operation?: number,
+    id?: number,
+    topic: string,
+    QoS?: number,
+    retain?: boolean,
+    duplicate?: boolean,
+    byteLength?: number,
+    items?: any[], // being lazy here
+  }
+
+  export default class MQTTClient {
+    constructor(options: Options)
+    read(count: number): ArrayBuffer
+    write(data: Buffer, options: WriteOptions): number
+    close(): void
+
+    static CONNECT: 1
+    static CONNACK: 2
+    static PUBLISH: 3
+    static PUBACK: 4
+    static PUBREC: 5
+    static PUBREL: 6
+    static PUBCOMP: 7
+    static SUBSCRIBE: 8
+    static SUBACK: 9
+    static UNSUBSCRIBE: 10
+    static UNSUBACK: 11
+    static PINGREQ: 12
+    static PINGRESP: 13
+    static DISCONNECT: 14  
+  }
+}

package/headers.d.ts

@@ -0,0 +1,25 @@
+/*
+* Copyright (c) 2024 Satoshi Tanaka
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "headers" {
+    class Headers extends Map<String, String> {}
+
+    export { Headers as default };
+}

package/mqtt/js.d.ts

@@ -0,0 +1,337 @@
+// Adapted from https://github.com/mqttjs/MQTT.js
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2015-2016 MQTT.js contributors
+// *MQTT.js contributors listed at <https://github.com/mqttjs/MQTT.js#contributors>*
+// Copyright 2011-2014 by Adam
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+// and associated documentation files (the "Software"), to deal in the Software without restriction,
+// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+// BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+declare module "mqtt/js" {
+
+type QoS = 0 | 1 | 2
+
+export interface IClientOptions /*extends ISecureClientOptions*/ {
+  // port?: number // port is made into a number subsequently
+  // host?: string // host does NOT include port
+  // hostname?: string
+  // path?: string
+  // protocol?: "wss" | "ws" | "mqtt" | "mqtts" | "tcp" | "ssl" | "wx" | "wxs"
+
+  // wsOptions?: ClientOptions | ClientRequestArgs
+  keepalive?: number // 10 seconds, set to 0 to disable
+  clientId?: string // 'mqttxs_' + Math.random().toString(16).substr(2, 8)
+  // protocolId?: string // 'MQTT'
+  // protocolVersion?: number //4
+  clean?: boolean //true, set to false to receive QoS 1 and 2 messages while offline
+  reconnectPeriod?: number //1000 milliseconds, interval between two reconnections
+  connectTimeout?: number //30 * 1000 milliseconds, time to wait before a CONNACK is received
+  username?: string //the username required by your broker, if any
+  password?: string //the password required by your broker, if any
+  // queueQoSZero?: boolean
+  // reschedulePings?: boolean
+  // servers?: Array<{
+  //   host: string
+  //   port: number
+  //   protocol?: "wss" | "ws" | "mqtt" | "mqtts" | "tcp" | "ssl" | "wx" | "wxs"
+  // }>
+  resubscribe?: boolean //  true, set to false to disable re-subscribe functionality
+  //  a message that will sent by the broker automatically when the client disconnect badly
+  will?: {
+    topic: string //  the topic to publish
+    payload: ArrayBuffer | string //  the message to publish
+    qos: QoS //  the QoS
+    retain: boolean //  the retain flag
+    // properies object of will
+    // properties?: {
+    //   willDelayInterval?: number
+    //   payloadFormatIndicator?: boolean
+    //   messageExpiryInterval?: number
+    //   contentType?: string
+    //   responseTopic?: string
+    //   correlationData?: ArrayBuffer
+    //   userProperties?: UserProperties
+    // }
+  }
+  // transformWsUrl?: (url: string, options: IClientOptions, client: MqttClient) => string
+  // properties?: {
+  //   sessionExpiryInterval?: number
+  //   receiveMaximum?: number
+  //   maximumPacketSize?: number
+  //   topicAliasMaximum?: number
+  //   requestResponseInformation?: boolean
+  //   requestProblemInformation?: boolean
+  //   userProperties?: UserProperties
+  //   authenticationMethod?: string
+  //   authenticationData?: Buffer
+  // }
+  // messageIdProvider?: IMessageIdProvider
+}
+
+export interface IClientPublishOptions {
+  qos?: QoS
+  retain?: boolean
+  dup?: boolean // whether or not mark a message as duplicate
+  // MQTT 5.0 properties object
+  // properties?: {
+  //   payloadFormatIndicator?: boolean
+  //   messageExpiryInterval?: number
+  //   topicAlias?: number
+  //   responseTopic?: string
+  //   correlationData?: Buffer
+  //   userProperties?: UserProperties
+  //   subscriptionIdentifier?: number
+  //   contentType?: string
+}
+
+export interface IClientSubscribeOptions {
+  // the QoS
+  qos: QoS
+  // nl?: boolean // no local flag
+  // rap?: boolean // Retain As Published flag
+  // rh?: number // Retain Handling option
+  //  MQTT 5.0 properies object of subscribe
+  // properties?: {
+  //   subscriptionIdentifier?: number
+  //   userProperties?: UserProperties
+  // }
+}
+
+export interface ISubscriptionGrant {
+  topic: string // is a subscribed to topic
+  qos: QoS // is the granted qos level on it
+  //     nl?: boolean // no local flag
+  //     rap?: boolean // Retain As Published flag
+  //     rh?: number // Retain Handling option
+}
+// export interface ISubscriptionRequest {
+//   topic: string // is a subscribed to topic
+//   qos: QoS // is the granted qos level on it
+//   nl?: boolean // no local flag
+//   rap?: boolean // Retain As Published flag
+//   rh?: number // Retain Handling option
+// }
+
+export interface ISubscriptionMap {
+  // object which has topic names as object keys and as value the options, like {'test1': {qos: 0}, 'test2': {qos: 2}}.
+  [topic: string]: {
+    qos: QoS
+    // nl?: boolean
+    // rap?: boolean
+    // rh?: number
+  }
+}
+
+//export type OnConnectCallback = (packet: IConnackPacket) => void
+export type OnConnectCallback = () => void
+//export type OnDisconnectCallback = (packet: IDisconnectPacket) => void
+export type ClientSubscribeCallback = (err: Error, granted: ISubscriptionGrant[]) => void
+export type OnMessageCallback = (
+  topic: string,
+  payload: ArrayBuffer
+  //packet: IPublishPacket
+) => void
+//export type OnPacketCallback = (packet: Packet) => void
+export type OnCloseCallback = () => void
+export type OnErrorCallback = (error: Error) => void
+//export type PacketCallback = (error?: Error, packet?: Packet) => any
+export type PacketCallback = (error?: Error) => any
+//export type CloseCallback = (error?: Error) => void
+export type CloseCallback = () => void
+
+/**
+ * MqttClient constructor
+ *
+ * @param {Stream} stream - stream
+ * @param {Object} [options] - connection options
+ * (see Connection#connect)
+ */
+export class Client /*extends events.EventEmitter*/ {
+  public connected: boolean
+  // public disconnecting: boolean
+  // public disconnected: boolean
+  public reconnecting: boolean
+  // public options: IClientOptions
+  // public queueQoSZero: boolean
+
+  constructor(url: string, options: IClientOptions)
+
+  public on(event: "connect", cb: OnConnectCallback): this
+  public on(event: "message", cb: OnMessageCallback): this
+  //public on(event: "packetsend" | "packetreceive", cb: OnPacketCallback): this
+  //public on(event: "disconnect", cb: OnDisconnectCallback): this
+  public on(event: "error", cb: OnErrorCallback): this
+  public on(event: "close", cb: OnCloseCallback): this
+  public on(event: "end" | "reconnect" | "offline", cb: () => void): this
+  //public on(event: "end" | "reconnect" | "offline" | "outgoingEmpty", cb: () => void): this
+  public on(event: string, cb: Function): this
+
+  // public once(event: "connect", cb: OnConnectCallback): this
+  // public once(event: "message", cb: OnMessageCallback): this
+  // public once(event: "packetsend" | "packetreceive", cb: OnPacketCallback): this
+  // public once(event: "disconnect", cb: OnDisconnectCallback): this
+  // public once(event: "error", cb: OnErrorCallback): this
+  // public once(event: "close", cb: OnCloseCallback): this
+  // public once(event: "end" | "reconnect" | "offline" | "outgoingEmpty", cb: () => void): this
+  // public once(event: string, cb: Function): this
+
+  /**
+   * publish - publish <message> to <topic>
+   *
+   * @param {String} topic - topic to publish to
+   * @param {(String|Buffer)} message - message to publish
+   *
+   * @param {Object}    [opts] - publish options, includes:
+   *   @param {Number}  [opts.qos] - qos level to publish on
+   *   @param {Boolean} [opts.retain] - whether or not to retain the message
+   *   @param {Function}[opts.cbStorePut] - function(){}
+   *       called when message is put into `outgoingStore`
+   *
+   * @param {Function} [callback] - function(err){}
+   *    called when publish succeeds or fails
+   *
+   * @returns {Client} this - for chaining
+   * @api public
+   *
+   * @example client.publish('topic', 'message')
+   * @example
+   *     client.publish('topic', 'message', {qos: 1, retain: true})
+   * @example client.publish('topic', 'message', console.log)
+   */
+  public publish(
+    topic: string,
+    message: string | ArrayBuffer,
+    opts: IClientPublishOptions,
+    callback?: PacketCallback
+  ): this
+  public publish(topic: string, message: string | ArrayBuffer, callback?: PacketCallback): this
+
+  /**
+   * subscribe - subscribe to <topic>
+   *
+   * @param {String, Array, Object} topic - topic(s) to subscribe to, supports objects in the form {'topic': qos}
+   * @param {Object} [opts] - optional subscription options, includes:
+   * @param  {Number} [opts.qos] - subscribe qos level
+   * @param {Function} [callback] - function(err, granted){} where:
+   *    {Error} err - subscription error (none at the moment!)
+   *    {Array} granted - array of {topic: 't', qos: 0}
+   * @returns {MqttClient} this - for chaining
+   * @api public
+   * @example client.subscribe('topic')
+   * @example client.subscribe('topic', {qos: 1})
+   * @example client.subscribe({'topic': 0, 'topic2': 1}, console.log)
+   * @example client.subscribe('topic', console.log)
+   */
+  public subscribe(
+    topic: string | string[],
+    opts: IClientSubscribeOptions,
+    callback?: ClientSubscribeCallback
+  ): this
+  public subscribe(
+    topic: string | string[] | ISubscriptionMap,
+    callback?: ClientSubscribeCallback
+  ): this
+
+  /**
+   * unsubscribe - unsubscribe from topic(s)
+   *
+   * @param {String, Array} topic - topics to unsubscribe from
+   * @param {Object} opts - opts of unsubscribe
+   * @param {Function} [callback] - callback fired on unsuback
+   * @returns {MqttClient} this - for chaining
+   * @api public
+   * @example client.unsubscribe('topic')
+   * @example client.unsubscribe('topic', console.log)
+   * @example client.unsubscribe('topic', opts, console.log)
+   */
+  public unsubscribe(topic: string | string[], opts?: Object, callback?: PacketCallback): this
+
+  /**
+   * end - close connection
+   *
+   * @returns {MqttClient} this - for chaining
+   * @param {Boolean} force - do not wait for all in-flight messages to be acked
+   * @param {Object} opts - opts disconnect
+   * @param {Function} cb - called when the client has been closed
+   *
+   * @api public
+   */
+  public end(force?: boolean, opts?: Object, cb?: CloseCallback): this
+
+  /**
+   * removeOutgoingMessage - remove a message in outgoing store
+   * the outgoing callback will be called withe Error('Message removed') if the message is removed
+   *
+   * @param {Number} mid - messageId to remove message
+   * @returns {MqttClient} this - for chaining
+   * @api public
+   *
+   * @example client.removeOutgoingMessage(client.getLastMessageId());
+   */
+  //public removeOutgoingMessage(mid: number): this
+
+  /**
+   * reconnect - connect again using the same options as connect()
+   *
+   * @param {Object} [opts] - optional reconnect options, includes:
+   *    {Store} incomingStore - a store for the incoming packets
+   *    {Store} outgoingStore - a store for the outgoing packets
+   *    if opts is not given, current stores are used
+   *
+   * @returns {MqttClient} this - for chaining
+   *
+   * @api public
+   */
+  public reconnect(): this
+  //public reconnect(opts?: IClientReconnectOptions): this
+
+  /**
+   * Handle messages with backpressure support, one at a time.
+   * Override at will.
+   *
+   * @param packet packet the packet
+   * @param callback callback call when finished
+   * @api public
+   */
+  //public handleMessage(packet: Packet, callback: PacketCallback): void
+
+  /**
+   * Handle auth packages for MQTT 5 enhanced authentication methods such
+   * as challenge response authentication.
+   *
+   * Challenge-response authentication flow would look something like this:
+   *
+   * --> CONNECT | authMethod = "mathChallenge" -->
+   * <-- AUTH | authMethod = "mathChallenge", authData = "12 + 34" <--
+   * --> AUTH | authMethod = "mathChallenge", authData = "46" -->
+   * <-- CONNACK | reasonCode = SUCCESS <--
+   *
+   * This form of authentication has several advantages over traditional
+   * credential-based approaches. For instance authentication without the direct
+   * exchange of authentication secrets.
+   *
+   * @param packet the auth packet to handle
+   * @param callback call when finished
+   * @api public
+   */
+  //public handleAuth(packet: IAuthPacket, callback: PacketCallback): void
+
+  /**
+   * getLastMessageId
+   */
+  public getLastMessageId(): number
+}
+
+}

package/package.json

@@ -1,8 +1,6 @@
 {
 	"name": "@moddable/typings",
-	"version": "1.0.0",
-	"dependencies": {
-	},
+	"version": "1.0.3",
 	"main": "",
 	"types": [
 		"xs.d.ts",

package/pins/digital.d.ts

@@ -25,7 +25,7 @@ declare module 'pins/digital' {
   type InputPullUpDown = 3
   type Output = 8
   type OutputOpenDrain = 9
-  type Mode = Input | InputPullUp | InputPullDown | InputPullUpDown | Output | OutputOpenDrain
+  export type Mode = Input | InputPullUp | InputPullDown | InputPullUpDown | Output | OutputOpenDrain
   export class Digital {
     public constructor(dictionary: { pin: number; mode: number; port?: string })
     public constructor(pin: number, mode: number)

package/piu/MC.d.ts

@@ -543,38 +543,3 @@ declare module "piu/MC" {
     const rgba: rgba
   }
  }
-
- type PiuInterpolator = (value: number) => number;
- 
- interface Math {
-  backEaseIn: PiuInterpolator,
-  backEaseInOut: PiuInterpolator,
-  backEaseOut: PiuInterpolator,
-  bounceEaseIn: PiuInterpolator,
-  bounceEaseInOut: PiuInterpolator,
-  bounceEaseOut: PiuInterpolator,
-  circularEaseIn: PiuInterpolator,
-  circularEaseInOut: PiuInterpolator,
-  circularEaseOut: PiuInterpolator,
-  cubicEaseIn: PiuInterpolator,
-  cubicEaseInOut: PiuInterpolator,
-  cubicEaseOut: PiuInterpolator,
-  elasticEaseIn: PiuInterpolator,
-  elasticEaseInOut: PiuInterpolator,
-  elasticEaseOut: PiuInterpolator,
-  exponentialEaseIn: PiuInterpolator,
-  exponentialEaseInOut: PiuInterpolator,
-  exponentialEaseOut: PiuInterpolator,
-  quadEaseIn: PiuInterpolator,
-  quadEaseInOut: PiuInterpolator,
-  quadEaseOut: PiuInterpolator,
-  quartEaseIn: PiuInterpolator,
-  quartEaseInOut: PiuInterpolator,
-  quartEaseOut: PiuInterpolator,
-  quintEaseIn: PiuInterpolator,
-  quintEaseInOut: PiuInterpolator,
-  quintEaseOut: PiuInterpolator,
-  sineEaseIn: PiuInterpolator,
-  sineEaseInOut: PiuInterpolator,
-  sineEaseOut: PiuInterpolator
-}

package/qrcode.d.ts

@@ -0,0 +1,32 @@
+/*
+* Copyright (c) 2024 Satoshi Tanaka
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "qrcode" {
+    interface qrcode extends ArrayBuffer {
+        size: number;
+    }
+
+    var qrCode: (options: {
+        input: string | BufferLike,
+        maxVersion?: number
+    }) => qrcode;
+
+    export { qrCode as default };
+}

package/time.d.ts

@@ -26,6 +26,7 @@ declare module "time" {
     timezone: number;
     dst: number;
     ticks: number;
+    delta(start: number, end?: number): number;
   }
   export {Time as default};
-}
+}

package/url.d.ts

@@ -0,0 +1,56 @@
+/*
+* Copyright (c) 2024 Satoshi Tanaka
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "url" {
+
+    class URL {
+        constructor(url: string, base?: string)
+        hash: string;
+        host: string;
+        hostname: string;
+        href: string;
+        readonly origin: string;
+        password: string;
+        pathname: string;
+        port: string;
+        protocol: string;
+        search: string;
+        readonly searchParams: URLSearchParams;
+        username: string;
+        toJSON(): string;
+        toString(): string;
+    }
+
+    class URLSearchParams implements Iterable<[string, string]>{
+        constructor(it?: string[][] | Record<string, string> | string)
+        readonly length: number;
+        append(name: string, value: string): void;
+        delete(name: string, value?: string): void;
+        get(name: string): string | null;
+        getAll(name: string): string[];
+        has(name: string, value?: string): boolean;
+        set(name: string, value: string): void;
+        toString(): string;
+        updatePairs(): void;
+        updateParts(): void;
+        [Symbol.iterator](): IterableIterator<[string, string]>;
+    }
+    export { URL, URLSearchParams }
+}

package/wifi.d.ts

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2019-2020 Bradley Farias
+* Copyright (c) 2019-2024 Bradley Farias
 *
 *   This file is part of the Moddable SDK Tools.
 *
@@ -20,11 +20,11 @@
 
 declare module "wifi" {
   export type WiFiOptions = {
-    bssid?: string,
+    bssid?: ArrayBuffer,
     ssid: string,
     password?: string
   }
-  export type WiFiCallback = (message: "connect" | "gotIP" | "lostIP" | "disconnect") => void
+  export type WiFiCallback = (message: "connect" | "gotIP" | "lostIP" | "disconnect" | "station_connect" | "station_disconnect") => void
   export type WiFiScanCallback = (item: {
     ssid: string,
     authentication: string,
@@ -44,12 +44,14 @@ declare module "wifi" {
   }
 
   class WiFi {
-    static gotIP: "gotIP";
-    static lostIP: "lostIP";
-    static connected: "connect";
-    static disconnected: "disconnect";
-    
-    constructor(options: WiFiOptions, callback: WiFiCallback);
+    static readonly gotIP: "gotIP";
+    static readonly lostIP: "lostIP";
+    static readonly connected: "connect";
+    static readonly disconnected: "disconnect";
+    static readonly station_connected: "station_connect";
+    static readonly station_disconnected: "station_disconnect";
+
+    constructor(options?: WiFiOptions, callback?: WiFiCallback);
     close(): void;
     static scan(options: ScanOptions, callback: WiFiScanCallback): void;
     static mode: StationMode | AccessPointMode;