vasille 2.3.9 → 3.0.2

package/lib/node/node.js

@@ -1,86 +1,25 @@
-import { Reactive, ReactivePrivate } from "../core/core";
+import { Reactive } from "../core/core";
 import { IValue } from "../core/ivalue";
 import { Reference } from "../value/reference";
 import { Expression } from "../value/expression";
 import { AttributeBinding } from "../binding/attribute";
 import { StaticClassBinding, DynamicalClassBinding } from "../binding/class";
-import { StyleBinding } from "../binding/style";
+import { stringifyStyleValue, StyleBinding } from "../binding/style";
 import { internalError, userError } from "../core/errors";
-/**
- * Represents a Vasille.js node
- * @class FragmentPrivate
- * @extends ReactivePrivate
- */
-export class FragmentPrivate extends ReactivePrivate {
-    constructor() {
-        super();
-        this.$seal();
-    }
-    /**
-     * Pre-initializes the base of a fragment
-     * @param app {App} the app node
-     * @param parent {Fragment} the parent node
-     */
-    preinit(app, parent) {
-        this.app = app;
-        this.parent = parent;
-    }
-    /**
-     * Unlinks all bindings
-     */
-    $destroy() {
-        this.next = null;
-        this.prev = null;
-        super.$destroy();
-    }
-}
+import { config } from "../core/config";
 /**
  * This class is symbolic
  * @extends Reactive
  */
-export class Fragment extends Reactive {
-    /**
-     * Constructs a Vasille Node
-     * @param input
-     * @param $ {FragmentPrivate}
-     */
-    constructor(input, $) {
-        super(input, $ || new FragmentPrivate);
+export class Root extends Reactive {
+    constructor() {
+        super(...arguments);
         /**
          * The children list
          * @type Array
          */
-        this.children = new Set;
-        this.lastChild = null;
-    }
-    /**
-     * Gets the app of node
-     */
-    get app() {
-        return this.$.app;
-    }
-    /**
-     * Prepare to init fragment
-     * @param app {AppNode} app of node
-     * @param parent {Fragment} parent of node
-     * @param data {*} additional data
-     */
-    preinit(app, parent, data) {
-        const $ = this.$;
-        $.preinit(app, parent);
-    }
-    init() {
-        const ret = super.init();
-        this.ready();
-        return ret;
-    }
-    compose(input) {
-        input.slot && input.slot(this);
-        return {};
-    }
-    /** To be overloaded: ready event handler */
-    ready() {
-        // empty
+        this.children = new Set();
+        this.lastChild = undefined;
     }
     /**
      * Pushes a node to children immediately
@@ -88,15 +27,12 @@ export class Fragment extends Reactive {
      * @protected
      */
     pushNode(node) {
-        if (this.lastChild) {
-            this.lastChild.$.next = node;
-        }
-        node.$.prev = this.lastChild;
+        node.parent = this;
         this.lastChild = node;
         this.children.add(node);
     }
     /**
-     * Find first node in element if so exists
+     * Find the first node in the element if so exists
      * @return {?Element}
      * @protected
      */
@@ -107,53 +43,21 @@ export class Fragment extends Reactive {
         });
         return first;
     }
-    /**
-     * Append a node to end of element
-     * @param node {Node} node to insert
-     */
-    appendNode(node) {
-        const $ = this.$;
-        if ($.next) {
-            $.next.insertAdjacent(node);
-        }
-        else {
-            $.parent.appendNode(node);
-        }
-    }
-    /**
-     * Insert a node as a sibling of this
-     * @param node {Node} node to insert
-     */
-    insertAdjacent(node) {
-        const child = this.findFirstChild();
-        const $ = this.$;
-        if (child) {
-            child.parentElement.insertBefore(node, child);
-        }
-        else if ($.next) {
-            $.next.insertAdjacent(node);
-        }
-        else {
-            $.parent.appendNode(node);
-        }
-    }
     /**
      * Defines a text fragment
      * @param text {String | IValue} A text fragment string
      * @param cb {function (TextNode)} Callback if previous is slot name
      */
-    text(text, cb) {
-        const $ = this.$;
-        const node = new TextNode();
-        node.preinit($.app, this, text);
+    text(text) {
+        const node = new TextNode({ text });
         this.pushNode(node);
-        cb && cb(node);
+        node.compose();
     }
     debug(text) {
-        if (this.$.app.debugUi) {
-            const node = new DebugNode();
-            node.preinit(this.$.app, this, text);
+        if (config.debugUi) {
+            const node = new DebugNode({ text });
             this.pushNode(node);
+            node.compose();
         }
     }
     /**
@@ -162,18 +66,11 @@ export class Fragment extends Reactive {
      * @param input
      * @param cb {function(Tag, *)} callback
      */
-    tag(tagName, input, cb
-    // @ts-expect-error
-    ) {
-        const $ = this.$;
-        const node = new Tag(input);
+    tag(tagName, input, cb) {
+        const tag = new Tag(input, tagName);
         input.slot = cb || input.slot;
-        node.preinit($.app, this, tagName);
-        node.init();
-        this.pushNode(node);
-        node.ready();
-        // @ts-expect-error
-        return node.node;
+        this.pushNode(tag);
+        tag.compose();
     }
     /**
      * Defines a custom element
@@ -181,12 +78,9 @@ export class Fragment extends Reactive {
      * @param callback {function($ : *)}
      */
     create(node, callback) {
-        const $ = this.$;
-        node.$.parent = this;
-        node.preinit($.app, this);
-        node.input.slot = callback || node.input.slot;
         this.pushNode(node);
-        return node.init();
+        node.compose();
+        callback === null || callback === void 0 ? void 0 : callback(node);
     }
     /**
      * Defines an if node
@@ -196,18 +90,15 @@ export class Fragment extends Reactive {
      */
     if(cond, cb) {
         const node = new SwitchedNode();
-        node.preinit(this.$.app, this);
-        node.init();
         this.pushNode(node);
         node.addCase(this.case(cond, cb));
-        node.ready();
     }
     else(cb) {
         if (this.lastChild instanceof SwitchedNode) {
             this.lastChild.addCase(this.default(cb));
         }
         else {
-            throw userError('wrong `else` function use', 'logic-error');
+            throw userError("wrong `else` function use", "logic-error");
         }
     }
     elif(cond, cb) {
@@ -215,7 +106,7 @@ export class Fragment extends Reactive {
             this.lastChild.addCase(this.case(cond, cb));
         }
         else {
-            throw userError('wrong `elif` function use', 'logic-error');
+            throw userError("wrong `elif` function use", "logic-error");
         }
     }
     /**
@@ -234,139 +125,139 @@ export class Fragment extends Reactive {
     default(cb) {
         return { cond: trueIValue, cb };
     }
-    insertBefore(node) {
-        const $ = this.$;
-        node.$.prev = $.prev;
-        node.$.next = this;
-        if ($.prev) {
-            $.prev.$.next = node;
+    destroy() {
+        this.children.forEach(child => child.destroy());
+        this.children.clear();
+        this.lastChild = undefined;
+        super.destroy();
+    }
+}
+export class Fragment extends Root {
+    constructor(input, name) {
+        super(input);
+        this.name = name;
+    }
+    /**
+     * Pushes a node to children immediately
+     * @param node {Fragment} A node to push
+     * @protected
+     */
+    pushNode(node) {
+        if (this.lastChild) {
+            this.lastChild.next = node;
         }
-        $.prev = node;
+        node.prev = this.lastChild;
+        super.pushNode(node);
     }
-    insertAfter(node) {
-        const $ = this.$;
-        node.$.prev = this;
-        node.$.next = $.next;
-        $.next = node;
+    /**
+     * Append a node to end of element
+     * @param node {Node} node to insert
+     */
+    appendNode(node) {
+        if (this.next) {
+            this.next.insertAdjacent(node);
+        }
+        else {
+            this.parent.appendNode(node);
+        }
     }
-    remove() {
-        const $ = this.$;
-        if ($.next) {
-            $.next.$.prev = $.prev;
+    /**
+     * Insert a node as a sibling of this
+     * @param node {Node} node to insert
+     */
+    insertAdjacent(node) {
+        const child = this.findFirstChild();
+        if (child) {
+            const parent = child.parentElement;
+            if (parent) {
+                child.parentElement.insertBefore(node, child);
+            }
+        }
+        else if (this.next) {
+            this.next.insertAdjacent(node);
         }
-        if ($.prev) {
-            $.prev.$.next = $.next;
+        else {
+            this.parent.appendNode(node);
         }
     }
-    $destroy() {
-        this.children.forEach(child => child.$destroy());
-        this.children.clear();
-        this.lastChild = null;
-        if (this.$.parent.lastChild === this) {
-            this.$.parent.lastChild = this.$.prev;
+    compose() {
+        // do nothing
+        // to override it
+    }
+    insertBefore(node) {
+        node.prev = this.prev;
+        node.next = this;
+        if (this.prev) {
+            this.prev.next = node;
         }
-        super.$destroy();
+        this.prev = node;
     }
-}
-const trueIValue = new Reference(true);
-/**
- * The private part of a text node
- * @class TextNodePrivate
- * @extends FragmentPrivate
- */
-export class TextNodePrivate extends FragmentPrivate {
-    constructor() {
-        super();
-        this.$seal();
+    insertAfter(node) {
+        node.prev = this;
+        node.next = this.next;
+        this.next = node;
     }
-    /**
-     * Pre-initializes a text node
-     * @param app {AppNode} the app node
-     * @param parent
-     * @param text {IValue}
-     */
-    preinitText(app, parent, text) {
-        super.preinit(app, parent);
-        this.node = document.createTextNode(text instanceof IValue ? text.$ : text);
-        if (text instanceof IValue) {
-            this.bindings.add(new Expression((v) => {
-                this.node.replaceData(0, -1, v);
-            }, true, text));
+    remove() {
+        if (this.next) {
+            this.next.prev = this.prev;
+        }
+        if (this.prev) {
+            this.prev.next = this.next;
         }
     }
-    /**
-     * Clear node data
-     */
-    $destroy() {
-        super.$destroy();
+    destroy() {
+        if (this.parent.lastChild === this) {
+            this.parent.lastChild = this.prev;
+        }
+        super.destroy();
     }
 }
+const trueIValue = new Reference(true);
 /**
  * Represents a text node
  * @class TextNode
  * @extends Fragment
  */
 export class TextNode extends Fragment {
-    constructor($ = new TextNodePrivate()) {
-        super({}, $);
-        this.$seal();
+    constructor(input) {
+        super(input, ":text");
     }
-    preinit(app, parent, text) {
-        const $ = this.$;
-        if (!text) {
-            throw internalError('wrong TextNode::$preninit call');
+    compose() {
+        var _a, _b;
+        const text = this.input.text;
+        this.node = document.createTextNode((_b = (_a = (text instanceof IValue ? text.$ : text)) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : "");
+        if (text instanceof IValue) {
+            this.register(new Expression((v) => {
+                var _a;
+                this.node.replaceData(0, -1, (_a = v === null || v === void 0 ? void 0 : v.toString()) !== null && _a !== void 0 ? _a : "");
+            }, text));
         }
-        $.preinitText(app, parent, text);
-        $.parent.appendNode($.node);
+        this.parent.appendNode(this.node);
     }
     findFirstChild() {
-        return this.$.node;
+        return this.node;
     }
-    $destroy() {
-        this.$.node.remove();
-        this.$.$destroy();
-        super.$destroy();
+    destroy() {
+        this.node.remove();
+        super.destroy();
     }
 }
 /**
- * The private part of a base node
- * @class INodePrivate
- * @extends FragmentPrivate
+ * Vasille node which can manipulate an element node
+ * @class INode
+ * @extends Fragment
  */
-export class INodePrivate extends FragmentPrivate {
+export class INode extends Fragment {
     constructor() {
-        super();
+        super(...arguments);
         /**
          * Defines if node is unmounted
          * @type {boolean}
          */
         this.unmounted = false;
-        this.$seal();
-    }
-    $destroy() {
-        super.$destroy();
-    }
-}
-/**
- * Vasille node which can manipulate an element node
- * @class INode
- * @extends Fragment
- */
-export class INode extends Fragment {
-    /**
-     * Constructs a base node
-     * @param input
-     * @param $ {?INodePrivate}
-     */
-    constructor(input, $) {
-        super(input, $ || new INodePrivate);
-        this.$seal();
     }
-    /**
-     * Get the bound node
-     */
-    get node() {
-        return this.$.node;
+    get element() {
+        return this.node;
     }
     /**
      * Bind attribute value
@@ -374,9 +265,7 @@ export class INode extends Fragment {
      * @param value {IValue} value
      */
     attr(name, value) {
-        const $ = this.$;
-        const attr = new AttributeBinding(this, name, value);
-        $.bindings.add(attr);
+        this.register(new AttributeBinding(this, name, value));
     }
     /**
      * Set attribute value
@@ -384,13 +273,13 @@ export class INode extends Fragment {
      * @param value {string} value
      */
     setAttr(name, value) {
-        if (typeof value === 'boolean') {
+        if (typeof value === "boolean") {
             if (value) {
-                this.$.node.setAttribute(name, "");
+                this.node.setAttribute(name, "");
             }
         }
-        else {
-            this.$.node.setAttribute(name, `${value}`);
+        else if (value !== null && value !== undefined) {
+            this.node.setAttribute(name, `${value}`);
         }
         return this;
     }
@@ -399,25 +288,21 @@ export class INode extends Fragment {
      * @param cl {string} Class name
      */
     addClass(cl) {
-        this.$.node.classList.add(cl);
-        return this;
+        this.node.classList.add(cl);
     }
     /**
      * Adds some CSS classes
-     * @param cls {...string} classes names
+     * @param cl {string} classes names
      */
-    removeClasse(cl) {
-        this.$.node.classList.remove(cl);
-        return this;
+    removeClass(cl) {
+        this.node.classList.remove(cl);
     }
     /**
      * Bind a CSS class
      * @param className {IValue}
      */
     bindClass(className) {
-        const $ = this.$;
-        $.bindings.add(new DynamicalClassBinding(this, className));
-        return this;
+        this.register(new DynamicalClassBinding(this, className));
     }
     /**
      * Bind a floating class name
@@ -425,8 +310,7 @@ export class INode extends Fragment {
      * @param className {string} class name
      */
     floatingClass(cond, className) {
-        this.$.bindings.add(new StaticClassBinding(this, className, cond));
-        return this;
+        this.register(new StaticClassBinding(this, className, cond));
     }
     /**
      * Defines a style attribute
@@ -434,14 +318,12 @@ export class INode extends Fragment {
      * @param value {IValue} value
      */
     style(name, value) {
-        const $ = this.$;
-        if ($.node instanceof HTMLElement) {
-            $.bindings.add(new StyleBinding(this, name, value));
+        if (this.node instanceof HTMLElement) {
+            this.register(new StyleBinding(this, name, value));
         }
         else {
-            throw userError('style can be applied to HTML elements only', 'non-html-element');
+            throw userError("style can be applied to HTML elements only", "non-html-element");
         }
-        return this;
     }
     /**
      * Sets a style property value
@@ -449,8 +331,8 @@ export class INode extends Fragment {
      * @param value {string} Property value
      */
     setStyle(prop, value) {
-        if (this.$.node instanceof HTMLElement) {
-            this.$.node.style.setProperty(prop, value);
+        if (this.node instanceof HTMLElement) {
+            this.node.style.setProperty(prop, stringifyStyleValue(value));
         }
         else {
             throw userError("Style can be set for HTML elements only", "non-html-element");
@@ -464,31 +346,39 @@ export class INode extends Fragment {
      * @param options {Object | boolean} addEventListener options
      */
     listen(name, handler, options) {
-        this.$.node.addEventListener(name, handler, options);
-        return this;
+        this.node.addEventListener(name, handler, options);
     }
     insertAdjacent(node) {
-        this.$.node.parentNode.insertBefore(node, this.$.node);
+        const parent = this.node.parentNode;
+        if (parent) {
+            parent.insertBefore(node, this.node);
+        }
     }
     /**
      * A v-show & ngShow alternative
      * @param cond {IValue} show condition
      */
     bindShow(cond) {
-        const $ = this.$;
-        const node = $.node;
+        const node = this.node;
         if (node instanceof HTMLElement) {
             let lastDisplay = node.style.display;
             const htmlNode = node;
-            return this.bindAlive(cond, () => {
-                lastDisplay = htmlNode.style.display;
-                htmlNode.style.display = 'none';
-            }, () => {
-                htmlNode.style.display = lastDisplay;
-            });
+            this.register(new Expression(cond => {
+                if (cond) {
+                    if (htmlNode.style.display === "none") {
+                        htmlNode.style.display = lastDisplay;
+                    }
+                }
+                else {
+                    if (htmlNode.style.display !== "none") {
+                        lastDisplay = htmlNode.style.display;
+                        htmlNode.style.display = "none";
+                    }
+                }
+            }, cond));
         }
         else {
-            throw userError('the element must be a html element', 'bind-show');
+            throw userError("the element must be a html element", "bind-show");
         }
     }
     /**
@@ -496,8 +386,7 @@ export class INode extends Fragment {
      * @param value {IValue}
      */
     bindDomApi(name, value) {
-        const $ = this.$;
-        const node = $.node;
+        const node = this.node;
         if (node instanceof HTMLElement) {
             node[name] = value.$;
             this.watch((v) => {
@@ -508,91 +397,71 @@ export class INode extends Fragment {
             throw userError("HTML can be bound for HTML nodes only", "dom-error");
         }
     }
-    applyOptions(options) {
-        options["v:attr"] && Object.keys(options["v:attr"]).forEach(name => {
-            const value = options["v:attr"][name];
+    applyAttrs(attrs) {
+        for (const name in attrs) {
+            const value = attrs[name];
             if (value instanceof IValue) {
                 this.attr(name, value);
             }
             else {
                 this.setAttr(name, value);
             }
-        });
-        if (options.class) {
-            const handleClass = (name, value) => {
-                if (value instanceof IValue) {
-                    this.floatingClass(value, name);
-                }
-                else if (value && name !== '$') {
-                    this.addClass(name);
-                }
-                else {
-                    this.removeClasse(name);
-                }
-            };
-            if (Array.isArray(options.class)) {
-                options.class.forEach(item => {
-                    if (item instanceof IValue) {
-                        this.bindClass(item);
-                    }
-                    else if (typeof item == "string") {
-                        this.addClass(item);
-                    }
-                    else {
-                        Reflect.ownKeys(item).forEach((name) => {
-                            handleClass(name, item[name]);
-                        });
-                    }
-                });
-            }
-            else {
-                options.class.$.forEach(item => {
-                    this.bindClass(item);
-                });
-                Reflect.ownKeys(options.class).forEach((name) => {
-                    handleClass(name, options.class[name]);
-                });
-            }
         }
-        options.style && Object.keys(options.style).forEach(name => {
-            const value = options.style[name];
+    }
+    applyStyle(style) {
+        for (const name in style) {
+            const value = style[name];
             if (value instanceof IValue) {
                 this.style(name, value);
             }
-            else if (typeof value === "string") {
+            else {
                 this.setStyle(name, value);
             }
-            else {
-                if (value[0] instanceof IValue) {
-                    this.style(name, this.expr((v) => v + value[1], value[0]));
-                }
-                else {
-                    this.setStyle(name, value[0] + value[1]);
-                }
+        }
+    }
+    applyBind(bind) {
+        const inode = this.node;
+        for (const k in bind) {
+            const value = bind[k];
+            if (!(value instanceof IValue)) {
+                inode[k] = value;
+                return;
             }
-        });
-        options["v:events"] && Object.keys(options["v:events"]).forEach(name => {
-            this.listen(name, options["v:events"][name]);
-        });
-        if (options["v:bind"]) {
-            const inode = this.node;
-            Reflect.ownKeys(options["v:bind"]).forEach((k) => {
-                const value = options["v:bind"][k];
-                if (k === 'value' && (inode instanceof HTMLInputElement || inode instanceof HTMLTextAreaElement)) {
-                    inode.oninput = () => value.$ = inode.value;
+            this.bindDomApi(k, value);
+        }
+    }
+    applyOptions(options) {
+        options.attr && this.applyAttrs(options.attr);
+        options.class &&
+            options.class.forEach(item => {
+                if (item instanceof IValue) {
+                    this.bindClass(item);
                 }
-                else if (k === 'checked' && inode instanceof HTMLInputElement) {
-                    inode.oninput = () => value.$ = inode.checked;
+                else if (typeof item == "string") {
+                    this.addClass(item);
                 }
-                else if (k === 'volume' && inode instanceof HTMLMediaElement) {
-                    inode.onvolumechange = () => value.$ = inode.volume;
+                else {
+                    for (const name in item) {
+                        const value = item[name];
+                        if (value instanceof IValue) {
+                            this.floatingClass(value, name);
+                        }
+                        else if (value && name !== "$") {
+                            this.addClass(name);
+                        }
+                        else {
+                            this.removeClass(name);
+                        }
+                    }
                 }
-                this.bindDomApi(k, value);
             });
+        options.style && this.applyStyle(options.style);
+        if (options.events) {
+            for (const name of Object.keys(options.events)) {
+                this.listen(name, options.events[name]);
+            }
         }
-        options["v:set"] && Object.keys(options["v:set"]).forEach(key => {
-            this.node[key] = options["v:set"][key];
-        });
+        options.bind && this.applyBind(options.bind);
     }
 }
 /**
@@ -601,34 +470,31 @@ export class INode extends Fragment {
  * @extends INode
  */
 export class Tag extends INode {
-    constructor(input) {
-        super(input);
-        this.$seal();
+    constructor(input, tagName) {
+        super(input, tagName);
     }
-    preinit(app, parent, tagName) {
-        if (!tagName || typeof tagName !== "string") {
-            throw internalError('wrong Tag::$preinit call');
+    compose() {
+        var _a, _b, _c, _d;
+        if (!this.name) {
+            throw internalError("wrong Tag constructor call");
         }
-        const node = document.createElement(tagName);
-        const $ = this.$;
-        $.preinit(app, parent);
-        $.node = node;
-        $.parent.appendNode(node);
-    }
-    compose(input) {
-        input.slot && input.slot(this);
-        return {};
+        const node = document.createElement(this.name);
+        this.node = node;
+        this.applyOptions(this.input);
+        this.parent.appendNode(node);
+        (_b = (_a = this.input).callback) === null || _b === void 0 ? void 0 : _b.call(_a, this.node);
+        (_d = (_c = this.input).slot) === null || _d === void 0 ? void 0 : _d.call(_c, this);
     }
     findFirstChild() {
-        return this.$.unmounted ? null : this.$.node;
+        return this.unmounted ? undefined : this.node;
     }
     insertAdjacent(node) {
-        if (this.$.unmounted) {
-            if (this.$.next) {
-                this.$.next.insertAdjacent(node);
+        if (this.unmounted) {
+            if (this.next) {
+                this.next.insertAdjacent(node);
             }
             else {
-                this.$.parent.appendNode(node);
+                this.parent.appendNode(node);
             }
         }
         else {
@@ -636,30 +502,37 @@ export class Tag extends INode {
         }
     }
     appendNode(node) {
-        this.$.node.appendChild(node);
+        this.node.appendChild(node);
+    }
+    extent(options) {
+        this.applyOptions(options);
     }
     /**
      * Mount/Unmount a node
      * @param cond {IValue} show condition
      */
     bindMount(cond) {
-        const $ = this.$;
-        this.bindAlive(cond, () => {
-            $.node.remove();
-            $.unmounted = true;
-        }, () => {
-            if ($.unmounted) {
-                this.insertAdjacent($.node);
-                $.unmounted = false;
+        this.register(new Expression(cond => {
+            if (cond) {
+                if (this.unmounted) {
+                    this.insertAdjacent(this.node);
+                    this.unmounted = false;
+                }
             }
-        });
+            else {
+                if (!this.unmounted) {
+                    this.node.remove();
+                    this.unmounted = true;
+                }
+            }
+        }, cond));
     }
     /**
      * Runs GC
      */
-    $destroy() {
+    destroy() {
         this.node.remove();
-        super.$destroy();
+        super.destroy();
     }
 }
 /**
@@ -667,180 +540,80 @@ export class Tag extends INode {
  * @class Extension
  * @extends INode
  */
-export class Extension extends INode {
-    preinit(app, parent) {
-        const $ = this.$;
-        let it = parent;
-        while (it && !(it instanceof INode)) {
-            it = it.parent;
-        }
-        if (it && it instanceof INode) {
-            $.node = it.node;
+export class Extension extends Fragment {
+    tag(tagName, input) {
+        var _a;
+        let parent = this.parent;
+        const target = tagName.toLowerCase();
+        while (parent instanceof Fragment && !(parent instanceof Tag)) {
+            parent = parent.parent;
         }
-        $.preinit(app, parent);
-        if (!it) {
-            throw userError("A extension node can be encapsulated only in a tag/extension/component", "virtual-dom");
+        if (parent instanceof Tag && parent.element.tagName.toLowerCase() === target) {
+            parent.extent(input);
+            (_a = input.slot) === null || _a === void 0 ? void 0 : _a.call(input, parent);
         }
     }
-    extend(options) {
-        this.applyOptions(options);
-    }
-    $destroy() {
-        super.$destroy();
-    }
-}
-/**
- * Node which cas has just a child
- * @class Component
- * @extends Extension
- */
-export class Component extends Extension {
-    init() {
-        const ret = super.composeNow();
-        this.ready();
-        super.applyOptionsNow();
-        return ret;
-    }
-    ready() {
-        super.ready();
-        if (this.children.size !== 1) {
-            throw userError("Component must have a child only", "dom-error");
-        }
-        const child = this.lastChild;
-        if (child instanceof Tag || child instanceof Component) {
-            const $ = this.$;
-            $.node = child.node;
-        }
-        else {
-            throw userError("Component child must be Tag or Component", "dom-error");
-        }
-    }
-    preinit(app, parent) {
-        this.$.preinit(app, parent);
-    }
-}
-/**
- * Private part of switch node
- * @class SwitchedNodePrivate
- * @extends INodePrivate
- */
-export class SwitchedNodePrivate extends FragmentPrivate {
-    constructor() {
-        super();
-        /**
-         * Array of possible cases
-         * @type {Array<{cond : IValue<boolean>, cb : function(Fragment)}>}
-         */
-        this.cases = [];
-        this.$seal();
-    }
-    /**
-     * Runs GC
-     */
-    $destroy() {
-        this.cases.forEach(c => {
-            delete c.cond;
-            delete c.cb;
-        });
-        this.cases.splice(0);
-        super.$destroy();
-    }
 }
 /**
- * Defines a node witch can switch its children conditionally
+ * Defines a node which can switch its children conditionally
  */
 export class SwitchedNode extends Fragment {
     /**
      * Constructs a switch node and define a sync function
      */
     constructor() {
-        super({}, new SwitchedNodePrivate);
-        this.$.sync = () => {
-            const $ = this.$;
+        super({}, ":switch");
+        /**
+         * Array of possible cases
+         * @type {Array<{cond : IValue<unknown>, cb : function(Fragment)}>}
+         */
+        this.cases = [];
+        this.sync = () => {
             let i = 0;
-            for (; i < $.cases.length; i++) {
-                if ($.cases[i].cond.$) {
+            for (; i < this.cases.length; i++) {
+                if (this.cases[i].cond.$) {
                     break;
                 }
             }
-            if (i === $.index) {
+            if (i === this.index) {
                 return;
             }
             if (this.lastChild) {
-                this.lastChild.$destroy();
+                this.lastChild.destroy();
                 this.children.clear();
-                this.lastChild = null;
+                this.lastChild = undefined;
             }
-            if (i !== $.cases.length) {
-                $.index = i;
-                this.createChild($.cases[i].cb);
+            if (i !== this.cases.length) {
+                this.index = i;
+                this.createChild(this.cases[i].cb);
             }
             else {
-                $.index = -1;
+                this.index = -1;
             }
         };
-        this.$seal();
     }
     addCase(case_) {
-        this.$.cases.push(case_);
-        case_.cond.$on(this.$.sync);
-        this.$.sync();
+        this.cases.push(case_);
+        case_.cond.on(this.sync);
+        this.sync();
     }
     /**
      * Creates a child node
      * @param cb {function(Fragment)} Call-back
      */
     createChild(cb) {
-        const node = new Fragment({});
-        node.preinit(this.$.app, this);
-        node.init();
+        const node = new Fragment({}, ":case");
+        node.parent = this;
         this.lastChild = node;
         this.children.add(node);
         cb(node);
     }
-    ready() {
-        const $ = this.$;
-        $.cases.forEach(c => {
-            c.cond.$on($.sync);
-        });
-        $.sync();
-    }
-    $destroy() {
-        const $ = this.$;
-        $.cases.forEach(c => {
-            c.cond.$off($.sync);
+    destroy() {
+        this.cases.forEach(c => {
+            c.cond.off(this.sync);
         });
-        super.$destroy();
-    }
-}
-/**
- * The private part of a text node
- */
-export class DebugPrivate extends FragmentPrivate {
-    constructor() {
-        super();
-        this.$seal();
-    }
-    /**
-     * Pre-initializes a text node
-     * @param app {App} the app node
-     * @param parent {Fragment} parent node
-     * @param text {String | IValue}
-     */
-    preinitComment(app, parent, text) {
-        super.preinit(app, parent);
-        this.node = document.createComment(text.$);
-        this.bindings.add(new Expression((v) => {
-            this.node.replaceData(0, -1, v);
-        }, true, text));
-        this.parent.appendNode(this.node);
-    }
-    /**
-     * Clear node data
-     */
-    $destroy() {
-        this.node.remove();
-        super.$destroy();
+        this.cases.splice(0);
+        super.destroy();
     }
 }
 /**
@@ -849,27 +622,24 @@ export class DebugPrivate extends FragmentPrivate {
  * @extends Fragment
  */
 export class DebugNode extends Fragment {
-    constructor() {
-        super({});
-        /**
-         * private data
-         * @type {DebugNode}
-         */
-        this.$ = new DebugPrivate();
-        this.$seal();
-    }
-    preinit(app, parent, text) {
-        const $ = this.$;
-        if (!text) {
-            throw internalError('wrong DebugNode::$preninit call');
-        }
-        $.preinitComment(app, parent, text);
+    constructor(input) {
+        super(input, ":debug");
+    }
+    compose() {
+        var _a, _b;
+        const text = this.input.text;
+        this.node = document.createComment((_b = (_a = text.$) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : "");
+        this.register(new Expression((v) => {
+            var _a;
+            this.node.replaceData(0, -1, (_a = v === null || v === void 0 ? void 0 : v.toString()) !== null && _a !== void 0 ? _a : "");
+        }, text));
+        this.parent.appendNode(this.node);
     }
     /**
      * Runs garbage collector
      */
-    $destroy() {
-        this.$.$destroy();
-        super.$destroy();
+    destroy() {
+        this.node.remove();
+        super.destroy();
     }
 }