@moddable/typings 7.2.0 → 8.0.0

package/embedded/storage/files.d.ts

@@ -66,8 +66,8 @@ declare module "embedded:storage/files" {
 		status(path: string, options?: DirectoryStatusOptions): Status;
 
 		createDirectory(path: string): boolean;
-		createLink(path: string, target: string): void;
-		readLink(path: string): string;
+		createLink?(path: string, target: string): void;
+		readLink?(path: string): string;
 
 		scan(path?: string): IterableIterator<string>;
 		[Symbol.iterator](): IterableIterator<string>;

package/mod/config.d.ts

@@ -0,0 +1,24 @@
+/*
+* Copyright (c) 2026 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 "mod/config" {
+  var Config: {file: {root: string}} & Record<string, any>;
+  export {Config as default};
+}

package/mod/index.d.ts

@@ -0,0 +1 @@
+// Blank

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@moddable/typings",
-	"version": "7.2.0",
+	"version": "8.0.0",
 	"main": "",
 	"types": [
 		"xs.d.ts",

package/pebble/global.d.ts

@@ -85,33 +85,34 @@ declare function clearTimeout(id: number): void;
 declare const URL: typeof import('url').URL;
 declare const URLSearchParams: typeof import('url').URLSearchParams;
 declare const Headers: typeof import('headers').default;
-declare const localStorage: import('web/webstorage').default;
+declare const localStorage: import('webstorage').default;
 declare const WebSocket: typeof import('web/websocket').default;
-declare const fetch: typeof import('web/fetch').fetch;
+declare const fetch: typeof import('fetch').fetch;
 
 /*
   Piu
 */
 
-declare const Application: ApplicationConstructor;
-declare const Behavior: BehaviorConstructor;
-declare const Column: ColumnConstructor;
-declare const Container: ContainerConstructor;
-declare const Content: ContentConstructor;
-declare const Label: LabelConstructor;
-declare const Link: LinkConstructor;
-declare const Locals: Locals;
-declare const Port: PortConstructor;
-declare const Row: RowConstructor;
-declare const Skin: SkinConstructor;
-declare const Style: StyleConstructor;
-declare const Text: TextConstructor;
-declare const Texture: TextureConstructor;
-declare const Transition: TransitionConstructor;
-
-declare const InverterConstructor: InverterConstructor;
-declare const RoundRect: RoundRectConstructor;
-declare const ScreenBufferConstructor: ScreenBufferConstructor;
+type Application = import("piu/MC-types").Application;
+type Behavior = import("piu/MC-types").Behavior;
+type Column = import("piu/MC-types").Column;
+type Container = import("piu/MC-types").Container;
+type Content = import("piu/MC-types").Content;
+type ContentDictionary = import("piu/MC-types").ContentDictionary;
+type Label = import("piu/MC-types").Label;
+type Link = import("piu/MC-types").Link;
+type Locals = import("piu/MC-types").Locals;
+type Port = import("piu/MC-types").Port;
+type Row = import("piu/MC-types").Row;
+type Skin = import("piu/MC-types").Skin;
+type Style = import("piu/MC-types").Style;
+type Text = import("piu/MC-types").Text;
+type Texture = import("piu/MC-types").Texture;
+type Transition = import("piu/MC-types").Transition;
+
+declare const Inverter: InverterConstructor;
+declare const RonndRect: RoundRectConstructor;
+declare const ScreenBuffer: ScreenBufferConstructor;
 declare const SVGImage: SVGImageConsructor;
 
 /*

package/pebble/piu.d.ts

@@ -25,6 +25,7 @@
 interface SVGImageDictionary extends ContentDictionary {
 	clip?: boolean;
 	id?: number;
+	path?: string;
 }
 
 interface SVGImage extends Content {
@@ -46,6 +47,7 @@ interface SVGImage extends Content {
 interface SVGImageConsructor {
 	new(behaviorData?: any, dictionary?: SVGImageDictionary): SVGImage;
 	template<T>(this: T, fn: (arg: any) => SVGImageDictionary): T;
+  (behaviorData?: any, dictionary?: SVGImageDictionary): SVGImage;
 }
 
 /*
@@ -65,6 +67,7 @@ interface RoundRect extends Content {
 interface RoundRectConstructor {
 	new(behaviorData?: any, dictionary?: RoundRectDictionary): RoundRect;
 	template<T>(this: T, fn: (arg: any) => RoundRectDictionary): T;
+	(behaviorData?: any, dictionary?: RoundRectDictionary): RoundRect;
 
 	readonly topLeft: 1;
 	readonly topRight: 2;

package/piu/MC-types.d.ts

@@ -18,387 +18,387 @@
  *
  */
 
-/* type aliases */
-type Coordinates = {
-  top?: number;
-  right?: number;
-  bottom?: number;
-  left?: number;
-};
-type Position = {
-  x?: number;
-  y?: number;
-};
-type Size = {
-  width?: number;
-  height?: number;
-};
-type Bounds = Position & Size;
-type Color = string;
-type ContentState = {
-  state?: number;
-  variant?: number;
-};
-type TimeProperty = {
-  time?: number;
-  duration?: number;
-  fraction?: number;
-  interval?: number;
-  loop?: boolean;
-};
-type TouchProperty = {
-  active?: boolean;
-  backgroundTouch?: boolean;
-  exclusiveTouch?: boolean;
-  multipleTouch?: boolean;
-};
-
-// TODO: more accurate constructor parameters
-type TemplateStyle<P, C extends new (...args: any) => any> = {
-  new (dictionary?: P): InstanceType<C>;
-  template: TemplateStyleFactory<C>;
-};
-type TemplateStyleFactory<T extends new (...args: any) => any> = (
-  param: ConstructorParameters<T>[0]
-) => TemplateStyle<Partial<ConstructorParameters<T>[1]>, T>;
-
-type TemplateComponent<P, C extends new (...args: any) => any> = {
-  new (behaviorData?: any, dictionary?: P): InstanceType<C>;
-  template: TemplateComponentFactory<C>;
-};
-type TemplateComponentFactory<T extends new (...args: any) => any> = (
-  func: (param: any) => ConstructorParameters<T>[1]
-) => TemplateComponent<Parameters<typeof func>[0], T>;
-
-interface Behavior<T extends Content = Content>{
-  onCreate?(content: T, data: object, context: any): void;
-  onDisplaying?(content: T): void;
-  onFinished?(content: T): void;
-  onTimeChanged?(content: T): void;
-  onTouchBegan?(content: T, id: number, x: number, y: number, ticks: number): void;
-  onTouchCancelled?(content: T, id: number): void;
-  onTouchended?( content: T, id: number, x: number, y: number, ticks: number): void;
-  onTouchMoved?( content: T, id: number, x: number, y: number, ticks: number): void;
-  // TODO: complete callbacks
-}
-
-interface BehaviorConstructor<T extends Content = Content> {
-  new(): Behavior<T>;
-}
-
-interface Content {
-  // TODO: consider type parameter to avoid any
-  adjust(x: number, y: number): void;
-  bubble(id: string, ...extras: any[]): void;
-  captureTouch(id: string, x: number, y: number, ticks: number): void;
-  defer(id: string, ...extras: any[]): void;
-  delegate(id: string, ...extras: any[]): void;
-  distribute(id: string, ...extras: any[]): void;
-  focus(): void;
-  hit(x: number, y: number): Content | undefined;
-  measure(): Size;
-  moveBy(x: number, y: number): void;
-  render(): void;
-  sizeBy(width: number, height: number): void;
-  start(): void;
-  stop(): void;
-
-  readonly previous: Content | null;
-  readonly next: Content | null;
-  readonly container: Container | null;
-  readonly index: number;
-  name: string;
-  active: boolean;
-  anchor: string;
-  behavior: object;
-  coordinates: Coordinates;
-  bounds: Bounds;
-  backgroundTouch: boolean;
-  exclusiveTouch: boolean;
-  multipleTouch: boolean;
-
-  time: number;
-  duration: number;
-  fraction: number;
-  interval: number;
-  loop: boolean;
-  running: boolean;
-  offset: undefined | Position;
-  position: undefined | Position;
-  size: Size;
-  state: number;
-  variant: number;
-  skin: Skin | null;
-  style: Style | null;
-  visible: boolean;
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-interface ContentDictionary
-  extends Coordinates,
-    Size,
-    ContentState,
-    TimeProperty,
-    TouchProperty {
-  name?: string;
-  anchor?: string;
-  Behavior?: BehaviorConstructor;
-  skin?: Skin | SkinDictionary;
-  Skin?: SkinConstructor;
-  style?: Style | StyleDictionary;
-  Style?: StyleConstructor;
-  visible?: boolean;
-}
-interface ContentConstructor {
-  new(behaviorData?: any, dictionary?: ContentDictionary): Content;
-  (behaviorData?: any, dictionary?: ContentDictionary): Content;
-  readonly prototype: Content;
-
-  template: TemplateComponentFactory<ContentConstructor>;
-}
-
-interface Style {
-  measure(string: string): Size;
-}
-interface StyleDictionaryBase {
-  color?: Color | Color[];
-  font?: string;
-  horizontal?: string;
-  top?: number;
-}
-interface StyleConstructor {
-  new(dictionary: StyleDictionary): Style;
-
-  template<T>(this: T, dictionary: StyleDictionary): T;
-}
-
-interface TextStyleDictionary extends StyleDictionaryBase {
-  leading?: number;
-  right?: number;
-  bottom?: number;
-  left?: number;
-}
-interface LabelStyleDictionary extends StyleDictionaryBase {
-  vertical?: string;
-}
-type StyleDictionary = LabelStyleDictionary | TextStyleDictionary;
-
-interface Texture {
-  readonly height: number;
-  readonly width: number;
-}
-interface TextureDictionary {
-  path: string;
-}
-interface TextureConstructor {
-  new(path: string): Texture;
-  new(dictionary: TextureDictionary): Texture;
-  readonly prototype: Texture;
-
-  template: TemplateStyleFactory<TextureConstructor>;
-}
-
-interface Skin {
-  borders: Coordinates;
-  fill: Color | Color[];
-  stroke: Color | Color[];
-  texture: Texture;
-  color: Color;
-  bounds: Bounds;
-  height: number;
-  width: number;
-  states?: number;
-  variants?: number;
-  tiles?: Coordinates;
-  top?: number;
-  right?: number;
-  bottom?: number;
-  left?: number;
-}
-interface SkinConstructor {
-  new(dictionary: SkinDictionary): Skin;
-  readonly prototype: Skin;
-
-  template: TemplateStyleFactory<SkinConstructor>;
-}
-
-interface TextureSkinDictionary extends Coordinates, Bounds {
-  texture?: Texture | TextureDictionary;
-  Texture?: TextureConstructor;
-  color?: Color | Color[];
-  states?: number;
-  variants?: number;
-  tiles?: Coordinates;
-}
-interface ColorSkinDictionary {
-  borders?: Coordinates;
-  fill?: Color | Color[];
-  stroke?: Color | Color[];
-}
-type SkinDictionary = ColorSkinDictionary | TextureSkinDictionary;
-
-interface Transition {
-  onBegin(container: Container, ...extras: any[]): void;
-  onEnd(container: Container, ...extras: any[]): void;
-  onStep(fraction: number): void;
-  duration?: number;
-}
-interface TransitionConstructor {
-  new(duration: number, interpolator?: (value: number) => number, first?: any, last?: any): Transition
-}
-
-interface Container extends Content {
-  clip: boolean;
-  readonly first: Content | null;
-  readonly last: Content | null;
-  readonly length: number;
-  readonly transitioning: boolean;
-  add(content: Content): void;
-  content(at: number | string): Content | undefined;
-  empty(start?: number, stop?: number): void;
-  firstThat(id: string, ...extras: any[]): void;
-  insert(content: Content, before: Content): void;
-  lastThat(id: string, ...extras: any[]): void;
-  remove(content: Content): void;
-  replace(content: Content, by: Content): void;
-  run(transition: Transition, ...extras: any[]): void;
-  swap(content0: Content, content1: Content): void;
-  onTransitionBeginning(container: Container): void;
-  onTransitionEnded(container: Container): void;
-}
-interface ContainerDictionary extends ContentDictionary {
-  clip?: boolean;
-  contents?: Content[];
-}
-interface ContainerConstructor {
-  new(behaviorData?: any, dictionary?: ContainerDictionary): Container;
-  (behaviorData?: any, dictionary?: ContainerDictionary): Container;
-
-  template<T>(this: T, fn: (arg: any) => ContainerDictionary): T;
-}
-
-interface Label extends Content {
-  string: string;
-}
-interface LabelDictionary extends ContentDictionary {
-  string?: string;
-}
-interface LabelConstructor {
-  new(behaviorData?: any, dictionary?: LabelDictionary): Label;
-  (behaviorData?: any, dictionary?: LabelDictionary): Label;
-
-  template<T>(this: T, fn: (arg: any) => LabelDictionary): T;
-}
-
-interface Port extends Content {
-  drawContent(
-    x: number,
-    y: number,
-    width: number,
-    height: number
-  ): void;
-  drawLabel(
-    string: string,
-    x: number,
-    y: number,
-    width: number,
-    height: number
-  ): void;
-  drawSkin(
-    skin: Skin,
-    x: number,
-    y: number,
-    width: number,
-    height: number,
-    variant?: number,
-    state?: number
-  ): void;
-  drawString(
-    string: string,
-    style: Style,
-    color: Color,
-    x: number,
-    y: number,
-    width: number,
-    height: number
-  ): void;
-  drawStyle(
-    string: string,
-    style: Style,
-    x: number,
-    y: number,
-    width: number,
-    height: number,
-    ellipsis?: boolean,
-    state?: number
-  ): void;
-  drawTexture(
-    texture: Texture,
-    color: Color,
-    x: number,
-    y: number,
-    sx: number,
-    sy: number,
-    sw: number,
-    sh: number
-  ): void;
-  fillColor(
-    color: Color,
-    x: number,
-    y: number,
-    width: number,
-    height: number
-  ): void;
-  fillTexture(
-    texture: Texture,
-    color: Color,
-    x: number,
-    y: number,
-    width: number,
-    height: number,
-    sx?: number,
-    sy?: number,
-    sw?: number,
-    sh?: number
-  ): void;
-  invalidate(
-    x?: number,
-    y?: number,
-    width?: number,
-    height?: number
-  ): void;
-  measureString(string: string, style: Style): Size;
-  popClip(): void;
-  pushClip(
-    x?: number,
-    y?: number,
-    width?: number,
-    height?: number
-  ): void;
-  onDraw(
-    port: Port,
-    x: number,
-    y: number,
-    width: number,
-    height: number
-  ): void;
-}
-interface PortConstructor extends ContentConstructor {
-}
-
-interface TextBlock {
-    behavior?: object | null;
-    style?: Style | null;
-    spans: (string | TextSpan)[] | string,
-}
-
-interface TextSpan extends TextBlock {
-    link?: any
-}
-
-interface Text extends Content {
+  /* type aliases */
+export type Coordinates = {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+  };
+export type Position = {
+    x?: number;
+    y?: number;
+  };
+export type Size = {
+    width?: number;
+    height?: number;
+  };
+export type Bounds = Position & Size;
+export type Color = string;
+export type ContentState = {
+    state?: number;
+    variant?: number;
+  };
+export type TimeProperty = {
+    time?: number;
+    duration?: number;
+    fraction?: number;
+    interval?: number;
+    loop?: boolean;
+  };
+export type TouchProperty = {
+    active?: boolean;
+    backgroundTouch?: boolean;
+    exclusiveTouch?: boolean;
+    multipleTouch?: boolean;
+  };
+
+  // TODO: more accurate constructor parameters
+export type TemplateStyle<P, C extends new (...args: any) => any> = {
+    new (dictionary?: P): InstanceType<C>;
+    template: TemplateStyleFactory<C>;
+  };
+export type TemplateStyleFactory<T extends new (...args: any) => any> = (
+    param: ConstructorParameters<T>[0]
+  ) => TemplateStyle<Partial<ConstructorParameters<T>[1]>, T>;
+
+export type TemplateComponent<P, C extends new (...args: any) => any> = {
+    new (behaviorData?: any, dictionary?: P): InstanceType<C>;
+    template: TemplateComponentFactory<C>;
+  };
+export type TemplateComponentFactory<T extends new (...args: any) => any> = (
+    func: (param: any) => ConstructorParameters<T>[1]
+  ) => TemplateComponent<Parameters<typeof func>[0], T>;
+
+export interface Behavior<T extends Content = Content> {
+    onCreate?(content: T, data: object, context: any): void;
+    onDisplaying?(content: T): void;
+    onFinished?(content: T): void;
+    onTimeChanged?(content: T): void;
+    onTouchBegan?(content: T, id: number, x: number, y: number, ticks: number): void;
+    onTouchCancelled?(content: T, id: number): void;
+    onTouchended?(content: T, id: number, x: number, y: number, ticks: number): void;
+    onTouchMoved?(content: T, id: number, x: number, y: number, ticks: number): void;
+    // TODO: complete callbacks
+  }
+
+export interface BehaviorConstructor<T extends Content = Content> {
+    new(): Behavior<T>;
+  }
+
+export interface Content {
+    // TODO: consider type parameter to avoid any
+    adjust(x: number, y: number): void;
+    bubble(id: string, ...extras: any[]): void;
+    captureTouch(id: string, x: number, y: number, ticks: number): void;
+    defer(id: string, ...extras: any[]): void;
+    delegate(id: string, ...extras: any[]): void;
+    distribute(id: string, ...extras: any[]): void;
+    focus(): void;
+    hit(x: number, y: number): Content | undefined;
+    measure(): Size;
+    moveBy(x: number, y: number): void;
+    render(): void;
+    sizeBy(width: number, height: number): void;
+    start(): void;
+    stop(): void;
+
+    readonly previous: Content | null;
+    readonly next: Content | null;
+    readonly container: Container | null;
+    readonly index: number;
+    name: string;
+    active: boolean;
+    anchor: string;
+    behavior: object;
+    coordinates: Coordinates;
+    bounds: Bounds;
+    backgroundTouch: boolean;
+    exclusiveTouch: boolean;
+    multipleTouch: boolean;
+
+    time: number;
+    duration: number;
+    fraction: number;
+    interval: number;
+    loop: boolean;
+    running: boolean;
+    offset: undefined | Position;
+    position: undefined | Position;
+    size: Size;
+    state: number;
+    variant: number;
+    skin: Skin | null;
+    style: Style | null;
+    visible: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }
+export interface ContentDictionary
+    extends Coordinates,
+      Size,
+      ContentState,
+      TimeProperty,
+      TouchProperty {
+    name?: string;
+    anchor?: string;
+    Behavior?: BehaviorConstructor;
+    skin?: Skin | SkinDictionary;
+    Skin?: SkinConstructor;
+    style?: Style | StyleDictionary;
+    Style?: StyleConstructor;
+    visible?: boolean;
+  }
+export interface ContentConstructor {
+    new(behaviorData?: any, dictionary?: ContentDictionary): Content;
+    (behaviorData?: any, dictionary?: ContentDictionary): Content;
+    readonly prototype: Content;
+
+    template: TemplateComponentFactory<ContentConstructor>;
+  }
+
+export interface Style {
+    measure(string: string): Size;
+  }
+export interface StyleDictionaryBase {
+    color?: Color | Color[];
+    font?: string;
+    horizontal?: string;
+    top?: number;
+  }
+export interface StyleConstructor {
+    new(dictionary: StyleDictionary): Style;
+
+    template<T>(this: T, dictionary: StyleDictionary): T;
+  }
+
+export interface TextStyleDictionary extends StyleDictionaryBase {
+    leading?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+  }
+export interface LabelStyleDictionary extends StyleDictionaryBase {
+    vertical?: string;
+  }
+export type StyleDictionary = LabelStyleDictionary | TextStyleDictionary;
+
+export interface Texture {
+    readonly height: number;
+    readonly width: number;
+  }
+export interface TextureDictionary {
+    path: string;
+  }
+export interface TextureConstructor {
+    new(path: string): Texture;
+    new(dictionary: TextureDictionary): Texture;
+    readonly prototype: Texture;
+
+    template: TemplateStyleFactory<TextureConstructor>;
+  }
+
+export interface Skin {
+    borders: Coordinates;
+    fill: Color | Color[];
+    stroke: Color | Color[];
+    texture: Texture;
+    color: Color;
+    bounds: Bounds;
+    height: number;
+    width: number;
+    states?: number;
+    variants?: number;
+    tiles?: Coordinates;
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+  }
+export interface SkinConstructor {
+    new(dictionary: SkinDictionary): Skin;
+    readonly prototype: Skin;
+
+    template: TemplateStyleFactory<SkinConstructor>;
+  }
+
+export interface TextureSkinDictionary extends Coordinates, Bounds {
+    texture?: Texture | TextureDictionary;
+    Texture?: TextureConstructor;
+    color?: Color | Color[];
+    states?: number;
+    variants?: number;
+    tiles?: Coordinates;
+  }
+export interface ColorSkinDictionary {
+    borders?: Coordinates;
+    fill?: Color | Color[];
+    stroke?: Color | Color[];
+  }
+export type SkinDictionary = ColorSkinDictionary | TextureSkinDictionary;
+
+export interface Transition {
+    onBegin(container: Container, ...extras: any[]): void;
+    onEnd(container: Container, ...extras: any[]): void;
+    onStep(fraction: number): void;
+    duration?: number;
+  }
+export interface TransitionConstructor {
+    new(duration: number, interpolator?: (value: number) => number, first?: any, last?: any): Transition
+  }
+
+export interface Container extends Content {
+    clip: boolean;
+    readonly first: Content | null;
+    readonly last: Content | null;
+    readonly length: number;
+    readonly transitioning: boolean;
+    add(content: Content): void;
+    content(at: number | string): Content | undefined;
+    empty(start?: number, stop?: number): void;
+    firstThat(id: string, ...extras: any[]): void;
+    insert(content: Content, before: Content): void;
+    lastThat(id: string, ...extras: any[]): void;
+    remove(content: Content): void;
+    replace(content: Content, by: Content): void;
+    run(transition: Transition, ...extras: any[]): void;
+    swap(content0: Content, content1: Content): void;
+    onTransitionBeginning(container: Container): void;
+    onTransitionEnded(container: Container): void;
+  }
+export interface ContainerDictionary extends ContentDictionary {
+    clip?: boolean;
+    contents?: Content[];
+  }
+export interface ContainerConstructor {
+    new(behaviorData?: any, dictionary?: ContainerDictionary): Container;
+    (behaviorData?: any, dictionary?: ContainerDictionary): Container;
+
+    template<T>(this: T, fn: (arg: any) => ContainerDictionary): T;
+  }
+
+export interface Label extends Content {
+    string: string;
+  }
+export interface LabelDictionary extends ContentDictionary {
+    string?: string;
+  }
+export interface LabelConstructor {
+    new(behaviorData?: any, dictionary?: LabelDictionary): Label;
+    (behaviorData?: any, dictionary?: LabelDictionary): Label;
+
+    template<T>(this: T, fn: (arg: any) => LabelDictionary): T;
+  }
+
+export interface Port extends Content {
+    drawContent(
+      x: number,
+      y: number,
+      width: number,
+      height: number
+    ): void;
+    drawLabel(
+      string: string,
+      x: number,
+      y: number,
+      width: number,
+      height: number
+    ): void;
+    drawSkin(
+      skin: Skin,
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      variant?: number,
+      state?: number
+    ): void;
+    drawString(
+      string: string,
+      style: Style,
+      color: Color,
+      x: number,
+      y: number,
+      width: number,
+      height: number
+    ): void;
+    drawStyle(
+      string: string,
+      style: Style,
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      ellipsis?: boolean,
+      state?: number
+    ): void;
+    drawTexture(
+      texture: Texture,
+      color: Color,
+      x: number,
+      y: number,
+      sx: number,
+      sy: number,
+      sw: number,
+      sh: number
+    ): void;
+    fillColor(
+      color: Color,
+      x: number,
+      y: number,
+      width: number,
+      height: number
+    ): void;
+    fillTexture(
+      texture: Texture,
+      color: Color,
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      sx?: number,
+      sy?: number,
+      sw?: number,
+      sh?: number
+    ): void;
+    invalidate(
+      x?: number,
+      y?: number,
+      width?: number,
+      height?: number
+    ): void;
+    measureString(string: string, style: Style): Size;
+    popClip(): void;
+    pushClip(
+      x?: number,
+      y?: number,
+      width?: number,
+      height?: number
+    ): void;
+    onDraw(
+      port: Port,
+      x: number,
+      y: number,
+      width: number,
+      height: number
+    ): void;
+  }
+export interface PortConstructor extends ContentConstructor {
+  }
+
+export interface TextBlock {
+      behavior?: object | null;
+      style?: Style | null;
+      spans: (string | TextSpan)[] | string,
+  }
+
+export interface TextSpan extends TextBlock {
+      link?: any
+  }
+
+export interface Text extends Content {
   blocks: TextBlock[],
   string: string;
   begin(): void;
@@ -409,63 +409,63 @@ interface Text extends Content {
   endBlock(): void;
   endSpan(): void;
 }
-interface TextDictionary extends ContentDictionary {
+export interface TextDictionary extends ContentDictionary {
   blocks?: TextBlock[],
   string?: string;
 }
-interface TextConstructor {
+export interface TextConstructor {
   new(behaviorData?: any, dictionary?: TextDictionary): Text;
   (behaviorData?: any, dictionary?: TextDictionary): Text;
 
   template<T>(this: T, fn: (arg: any) => TextDictionary): T;
 }
 
-interface Application extends Container {
+export interface Application extends Container {
   displayListLength: number;
   commandListLength: number;
   touchCount: number;
 }
-interface ApplicationDictionary extends ContainerDictionary {
+export interface ApplicationDictionary extends ContainerDictionary {
   displayListLength?: number;
   commandListLength?: number;
   touchCount?: number;
   pixels?: number;
 }
-interface ApplicationConstructor {
+export interface ApplicationConstructor {
   new(behaviorData?: any, dictionary?: ApplicationDictionary): Application;
 
   template<T>(this: T, fn: (arg: any) => ApplicationDictionary): T;
 }
 
-interface Column extends Container {
+export interface Column extends Container {
 }
-interface ColumnConstructor extends ContainerConstructor {
+export interface ColumnConstructor extends ContainerConstructor {
 }
 
-interface Layout extends Container {
+export interface Layout extends Container {
   onFitHorizontally(layout: Layout, width: number): void;
   onFitVertically(layout: Layout, height: number): void;
   onMeasureHorizontally(layout: Layout, width: number): void;
   onMeasureVertically(layout: Layout, height: number): void;
 }
-interface LayoutConstructor extends ContainerConstructor {
+export interface LayoutConstructor extends ContainerConstructor {
 }
 
-interface Image extends Content {
+export interface Image extends Content {
   readonly frameCount: never;
   frameIndex: number;
 }
-interface ImageDictionary extends ContentDictionary {
+export interface ImageDictionary extends ContentDictionary {
   path: string;
 }
-interface ImageConstructor {
+export interface ImageConstructor {
   new(behaviorData?: any, dictionary?: ImageDictionary): Image;
   (behaviorData?: any, dictionary?: ImageDictionary): Image;
 
   template<T>(this: T, fn: (arg: any) => ImageDictionary): T;
 }
 
-interface Die extends Layout {
+export interface Die extends Layout {
   set(x: number, y: number, width: number, height: number): Die;
   sub(x: number, y: number, width: number, height: number): Die;
   and(x: number, y: number, width: number, height: number): Die;
@@ -477,15 +477,15 @@ interface Die extends Layout {
   attach(content: Content): void;
   detach(): void;
 }
-interface DieConstructor extends LayoutConstructor {
+export interface DieConstructor extends LayoutConstructor {
 }
 
-interface Row extends Container {
+export interface Row extends Container {
 }
-interface RowConstructor extends ContainerConstructor {
+export interface RowConstructor extends ContainerConstructor {
 }
 
-interface Scroller extends Container {
+export interface Scroller extends Container {
   readonly constraint: Position;
   loop: boolean;
   scroll: Position;
@@ -495,49 +495,52 @@ interface Scroller extends Container {
   scrollTo(x: number, y: number): void;
   onScrolled(scroller: Scroller): void;
 }
-interface ScrollerDictionary extends ContainerDictionary {
+export interface ScrollerDictionary extends ContainerDictionary {
   loop?: boolean;
 }
-interface ScrollerConstructor {
+export interface ScrollerConstructor {
   new(behaviorData?: any, dictionary?: ScrollerDictionary): Scroller;
   (behaviorData?: any, dictionary?: ScrollerDictionary): Scroller;
 
   template<T>(this: T, fn: (arg: any) => ScrollerDictionary): T;
 }
 
-interface LinkDictionary {
+export interface LinkDictionary {
   Behavior?: BehaviorConstructor;
 }
-interface Link {
+export interface Link {
   readonly container: Container;
   state: number;
   captureTouch(id: number, x: number, y: number, ticks: number): void;
 }
-interface LinkConstructor {
+export interface LinkConstructor {
   new(behaviorData?: any, dictionary?: LinkDictionary): Link;
   (behaviorData?: any, dictionary?: LinkDictionary): Link;
 
   template<T>(this: T, fn: (arg: any) => LinkDictionary): T;
 }
 
-interface Locals {
+export interface Locals {
   new(name?: string, language?: string): Locals
   language: string;
   get(textToLocalize: string): string
 }
 
-interface blendColors {
+export interface blendColors {
   (a: number, c1: number, c2: number): Color
 }
-interface hsl {
+export interface hsl {
   (h: number, s: number, l: number): Color
 }
-interface hsla {
+export interface hsla {
   (h: number, s: number, l: number, a: number): Color
 }
-interface rgb {
+export interface rgb {
   (r: number, g: number, b: number): Color
 }
-interface rgba {
+export interface rgba {
   (r: number, g: number, b: number, a: number): Color
 }
+
+
+export {};

package/piu/MC.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2025 Shinya Ishikawa
+ * Copyright (c) 2020-2026 Shinya Ishikawa
  *
  *   This file is part of the Moddable SDK Tools.
  *
@@ -18,111 +18,37 @@
  *
  */
 
-/// <reference path="./MC-types.d.ts" />
-
 declare module "piu/MC" {
   import {} from "commodetto/Poco";   // for global screen
+  import type * as MC from "piu/MC-types";
 
   global {
-    const Skin: SkinConstructor
-    const Texture: TextureConstructor
-    const Style: StyleConstructor
-    const Behavior: BehaviorConstructor
-    const Content: ContentConstructor
-    const Container: ContainerConstructor
-    const Application: ApplicationConstructor
-    const Scroller: ScrollerConstructor
-    const Row: RowConstructor
-    const Column: ColumnConstructor
-    const Layout: LayoutConstructor
-    const Image: ImageConstructor
-    const Die: DieConstructor
-    const Port: PortConstructor
-    const Label: LabelConstructor
-    const Transition: TransitionConstructor
-    const Text: TextConstructor
-    const Link: LinkConstructor
-    const application: Application
-    const Locals: Locals
-    const blendColors: blendColors
-    const hsl: hsl
-    const hsla: hsla
-    const rgb: rgb
-    const rgba: rgba
+    const Skin: MC.SkinConstructor
+    const Texture: MC.TextureConstructor
+    const Style: MC.StyleConstructor
+    const Behavior: MC.BehaviorConstructor
+    const Content: MC.ContentConstructor
+    const Container: MC.ContainerConstructor
+    const Application: MC.ApplicationConstructor
+    const Scroller: MC.ScrollerConstructor
+    const Row: MC.RowConstructor
+    const Column: MC.ColumnConstructor
+    const Layout: MC.LayoutConstructor
+    const Image: MC.ImageConstructor
+    const Die: MC.DieConstructor
+    const Port: MC.PortConstructor
+    const Label: MC.LabelConstructor
+    const Transition: MC.TransitionConstructor
+    const Text: MC.TextConstructor
+    const Link: MC.LinkConstructor
+    const application: MC.Application
+    const Locals: MC.Locals
+    const blendColors: MC.blendColors
+    const hsl: MC.hsl
+    const hsla: MC.hsla
+    const rgb: MC.rgb
+    const rgba: MC.rgba
   }
 
-  export {
-    Coordinates,
-    Position,
-    Size,
-    Bounds,
-    Color,
-    ContentState,
-    TimeProperty,
-    TouchProperty,
-    TemplateStyle,
-    TemplateStyleFactory,
-    TemplateComponent,
-    TemplateComponentFactory,
-    Behavior,
-    BehaviorConstructor,
-    Content,
-    ContentDictionary,
-    ContentConstructor,
-    Style,
-    StyleDictionaryBase,
-    StyleConstructor,
-    TextStyleDictionary,
-    LabelStyleDictionary,
-    StyleDictionary,
-    Texture,
-    TextureDictionary,
-    TextureConstructor,
-    Skin,
-    SkinConstructor,
-    TextureSkinDictionary,
-    ColorSkinDictionary,
-    SkinDictionary,
-    Transition,
-    TransitionConstructor,
-    Container,
-    ContainerDictionary,
-    ContainerConstructor,
-    Label,
-    LabelDictionary,
-    LabelConstructor,
-    Port,
-    PortConstructor,
-    TextBlock,
-    TextSpan,
-    Text,
-    TextDictionary,
-    TextConstructor,
-    Application,
-    ApplicationDictionary,
-    ApplicationConstructor,
-    Column,
-    ColumnConstructor,
-    Layout,
-    LayoutConstructor,
-    Image,
-    ImageDictionary,
-    ImageConstructor,
-    Die,
-    DieConstructor,
-    Row,
-    RowConstructor,
-    Scroller,
-    ScrollerDictionary,
-    ScrollerConstructor,
-    LinkDictionary,
-    Link,
-    LinkConstructor,
-    Locals,
-    blendColors,
-    hsl,
-    hsla,
-    rgb,
-    rgba,
-  }
+  export * from "piu/MC-types";
 }

package/web/fetch.d.ts

@@ -1,4 +1,24 @@
-declare module "web/fetch" {
+/*
+* Copyright (c) 2025-2026 Moddable Tech, Inc.
+*
+*   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 "fetch" {
   import {URL, URLSearchParams} from "url"
   import Headers from "headers"
 

package/web/websocket.d.ts

@@ -1,3 +1,23 @@
+/*
+* Copyright (c) 2025-2026 Moddable Tech, Inc.
+*
+*   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 "web/websocket" {
   import Headers from "headers"
 

package/web/webstorage.d.ts

@@ -1,11 +1,33 @@
-declare class WebStorage {
-  constructor(kvp: any);
-  get length(): number;
-  key(index: number): string | null;
-  getItem(key: string): string | null;
-  setItem(key: string, value: string): void;
-  remove(key: string): void;
-  clear(): void;
-}
+/*
+* Copyright (c) 2025-2026 Moddable Tech, Inc.
+*
+*   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 "webstorage" {
+  class WebStorage {
+    constructor(kvp: any);
+    get length(): number;
+    key(index: number): string | null;
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    remove(key: string): void;
+    clear(): void;
+  }
 
-export default WebStorage;
+  export default WebStorage;
+}