vasille 4.3.0 → 5.0.0

package/types/index.d.ts

@@ -7,9 +7,8 @@ export { Listener } from "./models/listener.js";
 export { MapModel } from "./models/map-model.js";
 export { SetModel } from "./models/set-model.js";
 export { App, Portal } from "./node/app.js";
-export { Fragment, Tag, TextNode, DebugNode, SwitchedNode } from "./node/node.js";
+export { Fragment, Tag, TextNode, SwitchedNode } from "./node/node.js";
 export { Expression, type KindOfIValue } from "./value/expression.js";
-export { Forward, Backward } from "./value/pointer.js";
 export { Reference } from "./value/reference.js";
 export { ArrayView } from "./views/array-view.js";
 export { BaseView } from "./views/base-view.js";
@@ -18,4 +17,4 @@ export { SetView } from "./views/set-view.js";
 export { userError } from "./core/errors.js";
 export { type ListenableModel } from "./models/model.js";
 export { Watch } from "./node/watch.js";
-export { type Runner } from "./node/runner.js";
+export { type IRunner as Runner } from "./node/runner.js";

package/types/node/app.d.ts

@@ -1,27 +1,26 @@
 import { Fragment, Root } from "./node.js";
-import { Runner } from "./runner.js";
+import { IRunner } from "./runner.js";
 /**
  * Represents a Vasille.js application
  * @class App
  * @extends Root
  */
-export declare class App<Node, Element, TagOptions extends object, T extends object = object> extends Root<Node, Element, TagOptions> {
+export declare class App<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Root<Node, Element, TagOptions, Runner> {
     private readonly node;
     /**
      * Constructs an app node
      * @param node {Element} The root of application
-     * @param runner {Runner} A adapter which execute DOM manipulation
+     * @param runner {IRunner} A adapter which execute DOM manipulation
      */
-    constructor(node: Element, runner: Runner<Node, Element, TagOptions>);
+    constructor(node: Element, runner: Runner);
     appendNode(node: Node): void;
 }
-interface PortalOptions<Node, Element, TagOptions extends object> {
+export interface PortalOptions<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions>> {
     node: Element;
-    slot?: (ctx: Fragment<Node, Element, TagOptions>) => void;
+    slot?: (ctx: Fragment<Node, Element, TagOptions, Runner>) => void;
 }
-export declare class Portal<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions> {
+export declare class Portal<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Fragment<Node, Element, TagOptions, Runner> {
     private readonly node;
-    constructor(input: PortalOptions<Node, Element, TagOptions>, runner: Runner<Node, Element, TagOptions>);
+    constructor(input: PortalOptions<Node, Element, TagOptions, Runner>, runner: Runner);
     appendNode(node: Node): void;
 }
-export {};

package/types/node/node.d.ts

@@ -1,19 +1,18 @@
 import { Reactive } from "../core/core.js";
-import { IValue } from "../core/ivalue.js";
-import { Runner } from "./runner.js";
+import { IRunner } from "./runner.js";
 /**
  * This class is symbolic
  * @extends Reactive
  */
-export declare abstract class Root<Node, Element, TagOptions extends object> extends Reactive {
+export declare abstract class Root<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Reactive {
     /**
      * The children list
      * @type Array
      */
     readonly children: Set<Fragment<Node, Element, TagOptions>>;
-    readonly runner: Runner<Node, Element, TagOptions>;
+    readonly runner: Runner;
     lastChild: Fragment<Node, Element, TagOptions> | undefined;
-    protected constructor(runner: Runner<Node, Element, TagOptions>);
+    protected constructor(runner: Runner);
     /**
      * Pushes a node to children immediately
      * @param node {Fragment} A node to push
@@ -36,7 +35,6 @@ export declare abstract class Root<Node, Element, TagOptions extends object> ext
      * @param text {String | IValue} A text fragment string
      */
     text(text: unknown): void;
-    debug(text: IValue<unknown>): void;
     /**
      * Defines a tag element
      * @param tagName {String} the tag name
@@ -52,9 +50,9 @@ export declare abstract class Root<Node, Element, TagOptions extends object> ext
     create<T extends Fragment<Node, Element, TagOptions>>(node: T, callback?: (ctx: T) => void): void;
     destroy(): void;
 }
-export declare class Fragment<Node, Element, TagOptions extends object> extends Root<Node, Element, TagOptions> {
+export declare class Fragment<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Root<Node, Element, TagOptions, Runner> {
     parent: Root<Node, Element, TagOptions>;
-    constructor(runner: Runner<Node, Element, TagOptions>);
+    constructor(runner: Runner);
     /**
      * Next node
      * @type {?Fragment}
@@ -95,10 +93,10 @@ export interface TextProps {
  * @class TextNode
  * @extends Fragment
  */
-export declare abstract class TextNode<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions> {
+export declare abstract class TextNode<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Fragment<Node, Element, TagOptions, Runner> {
     protected handler: ((v: unknown) => void) | null;
     protected readonly data: unknown;
-    constructor(input: TextProps, runner: Runner<Node, Element, TagOptions>);
+    constructor(input: TextProps, runner: Runner);
     abstract compose(): void;
     protected abstract findFirstChild(): Node;
     destroy(): void;
@@ -108,7 +106,7 @@ export declare abstract class TextNode<Node, Element, TagOptions extends object>
  * @class INode
  * @extends Fragment
  */
-export declare abstract class INode<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions> {
+export declare abstract class INode<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Fragment<Node, Element, TagOptions, Runner> {
     /**
      * The element of vasille node
      * @type Element
@@ -123,22 +121,22 @@ export declare abstract class INode<Node, Element, TagOptions extends object> ex
  * @class Tag
  * @extends INode
  */
-export declare abstract class Tag<Node, Element, TagOptions extends object> extends INode<Node, Element, TagOptions> {
+export declare abstract class Tag<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends INode<Node, Element, TagOptions, Runner> {
     readonly name: string;
     readonly options: TagOptions;
-    constructor(options: TagOptions, runner: Runner<Node, Element, TagOptions>, tagName: string);
+    constructor(options: TagOptions, runner: Runner, tagName: string);
     abstract compose(): void;
     protected findFirstChild(): Node | Element | undefined;
     appendNode(node: Node): void;
 }
-interface SwitchedNodeCase<Node, Element, TagOptions extends object> {
-    $case: IValue<unknown>;
-    slot: (node: Fragment<Node, Element, TagOptions>) => void;
+export interface SwitchedNodeCase<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions>> {
+    $case: unknown;
+    slot: (node: Fragment<Node, Element, TagOptions, Runner>) => void;
 }
 /**
  * Defines a node which can switch its children conditionally
  */
-export declare class SwitchedNode<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions> {
+export declare class SwitchedNode<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Fragment<Node, Element, TagOptions, Runner> {
     /**
      * Index of current true condition
      * @type number
@@ -157,23 +155,8 @@ export declare class SwitchedNode<Node, Element, TagOptions extends object> exte
     /**
      * Constructs a switch node and define a sync function
      */
-    constructor(runner: Runner<Node, Element, TagOptions>, cases: SwitchedNodeCase<Node, Element, TagOptions>[], _default?: (node: Fragment<Node, Element, TagOptions>) => void);
+    constructor(runner: Runner, cases: SwitchedNodeCase<Node, Element, TagOptions, Runner>[], _default?: (node: Fragment<Node, Element, TagOptions>) => void);
     compose(): void;
     destroy(): void;
+    protected newChild(_index: number): Fragment<Node, Element, TagOptions, Runner>;
 }
-export interface DebugProps {
-    text: IValue<unknown>;
-}
-/**
- * Represents a debug node
- * @class DebugNode
- * @extends Fragment
- */
-export declare abstract class DebugNode<Node, Element, TagOptions extends object> extends Fragment<Node, Element, TagOptions> {
-    protected handler: ((v: unknown) => void) | null;
-    protected readonly data: IValue<unknown>;
-    constructor(input: DebugProps, runner: Runner<Node, Element, TagOptions>);
-    abstract compose(): void;
-    destroy(): void;
-}
-export {};

package/types/node/runner.d.ts

@@ -1,13 +1,10 @@
-import { IValue } from "../core/ivalue.js";
-import { DebugNode, Tag, TextNode } from "./node.js";
+import { Tag, TextNode } from "./node.js";
 /**
  * A runner executes DOM manipulations
  */
-export interface Runner<Node, Element, TagOptions extends object> {
-    debugUi: boolean;
+export interface IRunner<Node, Element, TagOptions extends object> {
     insertBefore(node: Node, before: Node | Element): void;
     appendChild(node: Element, child: Node | Element): void;
     textNode(text: unknown): TextNode<Node, Element, TagOptions>;
-    debugNode(text: IValue<unknown>): DebugNode<Node, Element, TagOptions>;
     tag(tagName: string, input: TagOptions, cb?: (ctx: Tag<Node, Element, TagOptions>) => void): Tag<Node, Element, TagOptions>;
 }

package/types/node/watch.d.ts

@@ -1,21 +1,20 @@
 import { Fragment } from "./node.js";
 import { IValue } from "../core/ivalue.js";
-import { Runner } from "./runner.js";
-interface WatchOptions<Node, Element, TagOptions extends object, T> {
+import { IRunner } from "./runner.js";
+export interface WatchOptions<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions>, T> {
     model: IValue<T>;
-    slot?: (ctx: Fragment<Node, Element, TagOptions>, value: T) => void;
+    slot?: (ctx: Fragment<Node, Element, TagOptions, Runner>, value: T) => void;
 }
 /**
  * Watch Node
  * @class Watch
  * @extends Fragment
  */
-export declare class Watch<Node, Element, TagOptions extends object, T> extends Fragment<Node, Element, TagOptions> {
+export declare class Watch<Node, Element, TagOptions extends object, T, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends Fragment<Node, Element, TagOptions, Runner> {
     private readonly model;
     private readonly slot?;
     private handler?;
-    constructor(input: WatchOptions<Node, Element, TagOptions, T>, runner: Runner<Node, Element, TagOptions>);
+    constructor(input: WatchOptions<Node, Element, TagOptions, Runner, T>, runner: Runner);
     compose(): void;
     destroy(): void;
 }
-export {};

package/types/runner/web/runner.d.ts

@@ -1,42 +1,38 @@
-import { TextNode as AbstractTextNode, DebugNode as AbstractDebugNode, Tag as AbstractTag, Runner as IRunner, IValue } from "../../index.js";
+import { TextNode as AbstractTextNode, Tag as AbstractTag, Runner as IRunner, IValue } from "../../index.js";
 export type AttrType<T> = IValue<T | string | null> | T | string | null | undefined;
 export type StyleType<T> = T | number | number[] | IValue<string | number | number[]>;
 export interface TagOptions {
-    attr?: Record<string, AttrType<number | boolean>>;
-    class?: (string | IValue<string> | Record<string, boolean | IValue<boolean>>)[];
-    style?: Record<string, StyleType<string>>;
-    events?: Record<string, ((...args: unknown[]) => unknown) | [(...args: unknown[]) => unknown, object | boolean]>;
-    bind?: Record<string, any>;
-    slot?: (ctx: Tag) => void;
-    callback?: (node: Element) => void;
+    /** attributes */
+    a?: Record<string, AttrType<number | boolean>>;
+    /** classes */
+    c?: (string | IValue<string> | Record<string, boolean | IValue<boolean>>)[];
+    /** style */
+    s?: Record<string, StyleType<string>>;
+    /** events */
+    e?: Record<string, ((...args: unknown[]) => unknown) | [(...args: unknown[]) => unknown, object | boolean]>;
+    /** bindings */
+    b?: Record<string, any>;
+    /** slot */
+    l?: (ctx: Tag<typeof this, Runner<typeof this>>) => void;
+    /** callback */
+    k?: (node: Element) => void;
 }
-export declare class TextNode extends AbstractTextNode<Node, Element, TagOptions> {
-    readonly runner: Runner;
+export declare class TextNode<Options extends TagOptions, RunnerT extends Runner<Options>> extends AbstractTextNode<Node, Element, Options, RunnerT> {
     protected node: Text;
     compose(): void;
     destroy(): void;
     protected findFirstChild(): Node;
 }
-export declare class DebugNode extends AbstractDebugNode<Node, Element, TagOptions> {
-    readonly runner: Runner;
-    protected node: Comment;
-    compose(): void;
-    destroy(): void;
-    protected findFirstChild(): Node | Element | undefined;
-}
-export declare class Tag extends AbstractTag<Node, Element, TagOptions> {
-    readonly runner: Runner;
+export declare class Tag<Options extends TagOptions, RunnerT extends Runner<Options>> extends AbstractTag<Node, Element, Options, RunnerT> {
     compose(): void;
     destroy(): void;
     protected applyOptions(options: TagOptions): void;
 }
-export declare class Runner implements IRunner<Node, Element, TagOptions> {
-    readonly debugUi: boolean;
+export declare class Runner<Options extends TagOptions> implements IRunner<Node, Element, Options> {
     readonly document: Document;
-    constructor(debugUi: boolean, document: Document);
+    constructor(document: Document);
     insertBefore(node: Node, before: Element | Node): void;
     appendChild(node: Element, child: Element | Node): void;
-    textNode(text: unknown): AbstractTextNode<Node, Element, TagOptions>;
-    debugNode(text: IValue<unknown>): AbstractDebugNode<Node, Element, TagOptions>;
-    tag(tagName: string, input: TagOptions, cb?: ((ctx: AbstractTag<Node, Element, TagOptions>) => void) | undefined): AbstractTag<Node, Element, TagOptions>;
+    textNode(text: unknown): AbstractTextNode<Node, Element, Options>;
+    tag(tagName: string, input: Options, cb?: ((ctx: AbstractTag<Node, Element, Options>) => void) | undefined): AbstractTag<Node, Element, Options>;
 }

package/types/value/expression.d.ts

@@ -1,5 +1,6 @@
 import { Reactive } from "../core/core.js";
 import { Destroyable } from "../core/destroyable.js";
+import { Reference } from "./reference.js";
 import { IValue } from "../core/ivalue.js";
 export type KindOfIValue<T extends unknown[]> = {
     [K in keyof T]: IValue<T[K]> | undefined;
@@ -27,7 +28,7 @@ export declare class Expression<T, Args extends unknown[]> extends IValue<T> imp
     /**
      * The buffer to keep the last calculated value
      */
-    private sync;
+    protected sync: Reference<T>;
     /**
      * Creates a function bounded to N values
      */

package/types/views/array-view.d.ts

@@ -1,3 +1,4 @@
+import { IRunner } from "../node/runner.js";
 import { BaseView } from "./base-view.js";
 import { ArrayModel } from "../models/array-model.js";
 import { Fragment } from "../node/node.js";
@@ -6,7 +7,7 @@ import { Fragment } from "../node/node.js";
  * @class ArrayView
  * @extends BaseView
  */
-export declare class ArrayView<Node, Element, TagOptions extends object, T> extends BaseView<Node, Element, TagOptions, T, T, ArrayModel<T>> {
-    createChild(id: T, item: T, before?: Fragment<Node, Element, TagOptions>): any;
+export declare class ArrayView<Node, Element, TagOptions extends object, T, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends BaseView<Node, Element, TagOptions, T, T, ArrayModel<T>, Runner> {
+    createChild(id: T, item: T, before?: Fragment<Node, Element, TagOptions, Runner>): any;
     compose(): void;
 }

package/types/views/base-view.d.ts

@@ -1,7 +1,7 @@
-import { Runner } from "../node/runner.js";
+import { IRunner } from "../node/runner.js";
 import { RepeatNode, RepeatNodeOptions } from "./repeat-node.js";
 import { ListenableModel } from "../models/model.js";
-export interface BaseViewOptions<Node, Element, TagOptions extends object, K, T, Model extends ListenableModel<K, T>> extends RepeatNodeOptions<Node, Element, TagOptions, T, K> {
+export interface BaseViewOptions<Node, Element, TagOptions extends object, K, T, Model extends ListenableModel<K, T>, Runner extends IRunner<Node, Element, TagOptions>> extends RepeatNodeOptions<Node, Element, TagOptions, Runner, T, K> {
     model: Model;
 }
 /**
@@ -9,7 +9,7 @@ export interface BaseViewOptions<Node, Element, TagOptions extends object, K, T,
  * @class BaseView
  * @extends RepeatNode
  */
-export declare class BaseView<Node, Element, TagOptions extends object, K, T, Model extends ListenableModel<K, T>> extends RepeatNode<Node, Element, TagOptions, K, T, BaseViewOptions<Node, Element, TagOptions, K, T, Model>> {
+export declare class BaseView<Node, Element, TagOptions extends object, K, T, Model extends ListenableModel<K, T>, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends RepeatNode<Node, Element, TagOptions, K, T, Runner, BaseViewOptions<Node, Element, TagOptions, K, T, Model, Runner>> {
     model: Model;
     /**
      * Handler to catch values addition
@@ -21,7 +21,7 @@ export declare class BaseView<Node, Element, TagOptions extends object, K, T, Mo
      * @type {Function}
      */
     protected removeHandler: (index: K, value: T) => void;
-    constructor(input: BaseViewOptions<Node, Element, TagOptions, K, T, Model>, runner: Runner<Node, Element, TagOptions>);
+    constructor(input: BaseViewOptions<Node, Element, TagOptions, K, T, Model, Runner>, runner: Runner);
     compose(): void;
     destroy(): void;
 }

package/types/views/map-view.d.ts

@@ -1,3 +1,4 @@
+import { IRunner } from "../node/runner.js";
 import { BaseView } from "./base-view.js";
 import { MapModel } from "../models/map-model.js";
 /**
@@ -5,6 +6,6 @@ import { MapModel } from "../models/map-model.js";
  * @class MapView
  * @extends BaseView
  */
-export declare class MapView<Node, Element, TagOptions extends object, K, T> extends BaseView<Node, Element, TagOptions, K, T, MapModel<K, T>> {
+export declare class MapView<Node, Element, TagOptions extends object, K, T, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends BaseView<Node, Element, TagOptions, K, T, MapModel<K, T>, Runner> {
     compose(): void;
 }

package/types/views/repeat-node.d.ts

@@ -1,6 +1,6 @@
 import { Fragment } from "../node/node.js";
-import { Runner } from "../node/runner.js";
-export interface RepeatNodeOptions<Node, Element, TagOptions extends object, T, IdT> {
+import { IRunner } from "../node/runner.js";
+export interface RepeatNodeOptions<Node, Element, TagOptions extends object, Runner extends IRunner<Node, Element, TagOptions>, T, IdT> {
     slot?: (ctx: Fragment<Node, Element, TagOptions>, value: T, index: IdT) => void;
 }
 /**
@@ -8,15 +8,16 @@ export interface RepeatNodeOptions<Node, Element, TagOptions extends object, T,
  * @class RepeatNode
  * @extends Fragment
  */
-export declare class RepeatNode<Node, Element, TagOptions extends object, IdT, T, Opts extends RepeatNodeOptions<Node, Element, TagOptions, T, IdT> = RepeatNodeOptions<Node, Element, TagOptions, T, IdT>> extends Fragment<Node, Element, TagOptions> {
+export declare class RepeatNode<Node, Element, TagOptions extends object, IdT, T, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>, Opts extends RepeatNodeOptions<Node, Element, TagOptions, Runner, T, IdT> = RepeatNodeOptions<Node, Element, TagOptions, Runner, T, IdT>> extends Fragment<Node, Element, TagOptions, Runner> {
     /**
      * Children node hash
      * @type {Map}
      */
-    protected nodes: Map<IdT, Fragment<Node, Element, TagOptions>>;
-    protected slot?: ((ctx: Fragment<Node, Element, TagOptions>, value: T, index: IdT) => void) | undefined;
-    constructor(input: Opts, runner: Runner<Node, Element, TagOptions>);
-    createChild(id: IdT, item: T, before?: Fragment<Node, Element, TagOptions>): any;
+    protected nodes: Map<IdT, Fragment<Node, Element, TagOptions, Runner>>;
+    protected slot: ((ctx: Fragment<Node, Element, TagOptions>, value: T, index: IdT) => void) | undefined;
+    constructor(input: Opts, runner: Runner);
+    createChild(id: IdT, item: T, before?: Fragment<Node, Element, TagOptions, Runner>): any;
     destroyChild(id: IdT, item: T): void;
     destroy(): void;
+    protected newChild(_id: IdT, _item: T): Fragment<Node, Element, TagOptions, Runner>;
 }

package/types/views/set-view.d.ts

@@ -1,4 +1,4 @@
-import { Runner } from "../node/runner.js";
+import { IRunner } from "../node/runner.js";
 import { BaseView, BaseViewOptions } from "./base-view.js";
 import { SetModel } from "../models/set-model.js";
 /**
@@ -6,7 +6,7 @@ import { SetModel } from "../models/set-model.js";
  * @class SetView
  * @extends BaseView
  */
-export declare class SetView<Node, Element, TagOptions extends object, T> extends BaseView<Node, Element, TagOptions, T, T, SetModel<T>> {
-    constructor(input: BaseViewOptions<Node, Element, TagOptions, T, T, SetModel<T>>, runner: Runner<Node, Element, TagOptions>);
+export declare class SetView<Node, Element, TagOptions extends object, T, Runner extends IRunner<Node, Element, TagOptions> = IRunner<Node, Element, TagOptions>> extends BaseView<Node, Element, TagOptions, T, T, SetModel<T>, Runner> {
+    constructor(input: BaseViewOptions<Node, Element, TagOptions, T, T, SetModel<T>, Runner>, runner: Runner);
     compose(): void;
 }

package/lib/value/pointer.js

@@ -1,61 +0,0 @@
-import { Reference } from "./reference.js";
-/**
- * Forward only link type
- * @class Forward
- * @extends Reference
- */
-export class Forward extends Reference {
-    /**
-     * forwarded value
-     * @type IValue
-     */
-    target;
-    /**
-     * Handler to receive updates from forwarded value
-     */
-    handler;
-    /**
-     * Constructs a value forwarder
-     * @param value {IValue} is source of forwarded data
-     * @param ctx lifetime context
-     */
-    constructor(value, ctx) {
-        super(value.V);
-        this.handler = (v) => {
-            this.V = v;
-        };
-        this.target = value;
-        value.on(this.handler);
-        ctx?.bind(this);
-    }
-    destroy() {
-        this.target.off(this.handler);
-    }
-}
-/**
- * Backward only link type
- * @class Backward
- * @extends Reference
- */
-export class Backward extends Reference {
-    /**
-     * target, which receive the updates
-     * @type IValue
-     */
-    target;
-    /**
-     * Constructs a value backward stream
-     * @param value {IValue} target, which receive the updates
-     */
-    constructor(value) {
-        super(value.V);
-        this.target = value;
-    }
-    get V() {
-        return super.V;
-    }
-    set V(value) {
-        super.V = value;
-        this.target.V = value;
-    }
-}

package/types/value/pointer.d.ts

@@ -1,46 +0,0 @@
-import { Reactive } from "../core/core.js";
-import { Destroyable } from "../core/destroyable.js";
-import { IValue } from "../core/ivalue.js";
-import { Reference } from "./reference.js";
-/**
- * Forward only link type
- * @class Forward
- * @extends Reference
- */
-export declare class Forward<T> extends Reference<T> implements Destroyable {
-    /**
-     * forwarded value
-     * @type IValue
-     */
-    protected target: IValue<T>;
-    /**
-     * Handler to receive updates from forwarded value
-     */
-    protected readonly handler: (value: T) => void;
-    /**
-     * Constructs a value forwarder
-     * @param value {IValue} is source of forwarded data
-     * @param ctx lifetime context
-     */
-    constructor(value: IValue<T>, ctx?: Reactive);
-    destroy(): void;
-}
-/**
- * Backward only link type
- * @class Backward
- * @extends Reference
- */
-export declare class Backward<T> extends Reference<T> {
-    /**
-     * target, which receive the updates
-     * @type IValue
-     */
-    protected target: IValue<T>;
-    /**
-     * Constructs a value backward stream
-     * @param value {IValue} target, which receive the updates
-     */
-    constructor(value: IValue<T>);
-    get V(): T;
-    set V(value: T);
-}