native-document 1.0.138 → 1.0.139

package/dist/native-document.components.min.js

@@ -1,1025 +1,1132 @@
 var NativeComponents = (function (exports) {
     'use strict';
 
-    /**
-     *
-     * @class
-     */
-    function BaseComponent() {
-        this.$description = {};
+    let DebugManager$2 = {};
+    {
+        DebugManager$2 = {
+            log() {},
+            warn() {},
+            error() {},
+            disable() {}
+        };
     }
+    var DebugManager$1 = DebugManager$2;
 
-    Object.defineProperty( BaseComponent.prototype, 'nd', {
-        get: function() {
-            if(this.$element) {
-                return this.$element.nd;
-            }
-            this.$storeElement(this.toNdElement());
-            return this.$element?.nd;
-        }
-    });
-
-
-    BaseComponent.extends = function(Component, ...parents) {
-        const MainParent = parents[0] || BaseComponent;
-        Component.prototype = Object.create(MainParent.prototype);
-
-        if(parents.length > 0) {
-            for(const parent of parents) {
-                Object.assign(Component.prototype, parent.prototype);
-            }
-        }
-        Component.prototype.constructor = Component;
-    };
-
-    BaseComponent.use = function(Component, ...traits) {
-        if(traits.length > 0) {
-            for(const trait of traits) {
-                Object.assign(Component.prototype, trait.prototype);
-            }
-        }
-    };
-
-    BaseComponent.obs = (value) => {
-        return value.__$Observable ? value : Observable(value);
-    };
-
-    BaseComponent.prototype.$storeElement = function(element) {
-        this.$element = element;
-        return this;
-    };
-
-    BaseComponent.prototype.refSelf = function(target, name) {
-        target[name] = this;
-        return this;
-    };
-
-    BaseComponent.prototype.$build = function() {
-        const ComponentClass = this.constructor;
-        const renderer = this.$description.render || ComponentClass.defaultTemplate;
-
-        if (!renderer) {
-            throw new Error(`No renderer for ${ComponentClass.name}`);
-        }
-
-        return renderer(this.$description, this);
-    };
-
-    BaseComponent.prototype.toNdElement = function() {
-        if (this.$element) {
-            return this.$element;
-        }
-        this.$element = this.$build();
-        return this.$element;
-    };
-
-    BaseComponent.prototype.toJSON = function() {
-        if(!this.$description) {
-            return {};
-        }
-        return { ...this.$description };
-    };
-
-    BaseComponent.prototype.render = function(renderFn) {
-        if (typeof renderFn !== 'function') {
-            throw new Error('Custom renderer must be a function');
+    class NativeDocumentError extends Error {
+        constructor(message, context = {}) {
+            super(message);
+            this.name = 'NativeDocumentError';
+            this.context = context;
+            this.timestamp = new Date().toISOString();
         }
-        this.$description.render = renderFn;
-        return this;
-    };
-
-    function HasEventEmitter() {
-
-        this.__$events = null;
-
     }
 
-    HasEventEmitter.prototype.on = function(eventName, callback) {
-        if(!this.__$events) {
-            this.__$events = new Map();
-        }
-        if(!this.__$events.has(eventName)) {
-            this.__$events.set(eventName, callback);
-            return;
-        }
-        const existingCallback = this.__$events.get(eventName);
-        if(!Array.isArray(existingCallback)) {
-            this.__$events.set(eventName, [existingCallback, callback]);
-            return;
-        }
-        existingCallback.push(callback);
-    };
-
-    HasEventEmitter.prototype.hasListeners = function(eventName) {
-        return !!this.__$events.get(eventName);
-    };
-
-    HasEventEmitter.prototype.trigger = async function(eventName, ...args) {
-        const callbacks = this.__$events.get(eventName);
-        if(!callbacks) {
-            // throw new NativeDocumentError(this.constructor.name, 'Event '+eventName+' not found');
-            return;
-        }
-
-        if(typeof callbacks === 'function') {
-            return await Promise.resolve(callbacks.apply(this, args))
-        }
-
-        let result = null;
-        for(let i = 0, length = callbacks.length; i < length; i++) {
-            result = await Promise.resolve(await callbacks[i].apply(this, args));
-        }
-        return result;
-    };
-    HasEventEmitter.prototype.emit = HasEventEmitter.prototype.trigger;
-
-    /**
-     * Valid children types that can be rendered in the DOM
-     * @typedef {HTMLElement|Text|DocumentFragment|string|Array<ValidChildren>} ValidChildren
-     */
-
     /**
-     * Component for creating accordion interfaces with expandable/collapsible items
-     * @param {{ items?: Array<AccordionItem>, multiple?: boolean, variant?: string, renderContent?: (field: Accordion) => HTMLElement }} config
-     * @returns {Accordion}
-     * @class
+     *
+     * @param {ObservableItem} $observable
+     * @param {Function} $checker
+     * @class ObservableChecker
      */
-    function Accordion(config = {}) {
-        if (!(this instanceof Accordion)) {
-            return new Accordion(config);
-        }
-
-        this.$description = {
-            items: [],
-            multiple: null,
-            variant: null,
-            renderContent: null,
-            ...config
-        };
+    function ObservableChecker($observable, $checker) {
+        this.observable = $observable;
+        this.checker = $checker;
+        this.unSubscriptions = [];
     }
 
-    BaseComponent.extends(Accordion, HasEventEmitter);
-
-    Accordion.defaultTemplate = null;
-
+    ObservableChecker.prototype.__$Observable = true;
+    ObservableChecker.prototype.__$isObservableChecker = true;
 
     /**
-     * Sets the default template for all Accordion instances
-     * @param {{accordion: (accordion: Accordion) => ValidChildren}} template - Template object containing accordion factory function
+     * Subscribes to changes in the checked/transformed value.
+     *
+     * @param {Function} callback - Function called with the transformed value when observable changes
+     * @returns {Function} Unsubscribe function
+     * @example
+     * const count = Observable(5);
+     * const doubled = count.check(n => n * 2);
+     * doubled.subscribe(value => console.log(value)); // Logs: 10
      */
-    Accordion.use = function(template) {
-        Accordion.defaultTemplate = template.accordion;
+    ObservableChecker.prototype.subscribe = function(callback) {
+        const unSubscribe = this.observable.subscribe((value) => {
+            callback && callback(this.checker(value));
+        });
+        this.unSubscriptions.push(unSubscribe);
+        return unSubscribe;
     };
 
     /**
-     * Adds an accordion item to the collection
-     * @param {AccordionItem} accordionItem - The accordion item to add
-     * @returns {Accordion}
+     * Creates a new ObservableChecker by applying another transformation.
+     * Allows chaining transformations.
+     *
+     * @param {(value: *) => *} callback - Transformation function to apply to the current checked value
+     * @returns {ObservableChecker} New ObservableChecker with chained transformation
+     * @example
+     * const count = Observable(5);
+     * const result = count.check(n => n * 2).check(n => n + 1);
+     * result.val(); // 11
      */
-    Accordion.prototype.item = function(accordionItem) {
-        this.$description.items.push(accordionItem);
-        return this;
+    ObservableChecker.prototype.check = function(callback) {
+        return this.observable.check(() => callback(this.val()));
     };
 
     /**
-     * Sets the accordion items collection
-     * @param {Array<AccordionItem>} items - Array of accordion items
-     * @returns {Accordion}
+     * Gets the current transformed/checked value.
+     *
+     * @returns {*} The result of applying the checker function to the observable's current value
+     * @example
+     * const count = Observable(5);
+     * const doubled = count.check(n => n * 2);
+     * doubled.val(); // 10
      */
-    Accordion.prototype.items = function(items) {
-        this.$description.items = items;
-        return this;
+    ObservableChecker.prototype.val = function() {
+        return this.checker && this.checker(this.observable.val());
     };
 
     /**
-     * Alias for item method
-     * @param {AccordionItem} accordionItem - The accordion item to add
-     * @returns {Accordion}
+     * Sets the value of the underlying observable (not the transformed value).
+     *
+     * @param {*} value - New value for the underlying observable
+     * @example
+     * const count = Observable(5);
+     * const doubled = count.check(n => n * 2);
+     * doubled.set(10); // Sets count to 10, doubled.val() returns 20
      */
-    Accordion.prototype.addItem = Accordion.prototype.item;
+    ObservableChecker.prototype.set = function(value) {
+        return this.observable.set(value);
+    };
 
     /**
-     * Removes an item by its id
-     * @param {string} id - The id of the item to remove
-     * @returns {Accordion}
+     * Manually triggers the underlying observable to notify subscribers.
+     *
+     * @example
+     * const count = Observable(5);
+     * const doubled = count.check(n => n * 2);
+     * doubled.trigger(); // Notifies all subscribers
      */
-    Accordion.prototype.removeItemById = function(id) {
-        if (this.$description.items) {
-            this.$description.items = this.$description.items.filter(item => item.id !== id);
-        }
-        return this;
+    ObservableChecker.prototype.trigger = function() {
+        return this.observable.trigger();
     };
 
     /**
-     * Removes items matching the filter function
-     * @param {Function} filter - Filter function to determine which items to keep
-     * @returns {Accordion}
+     * Cleans up the underlying observable and all its subscriptions.
      */
-    Accordion.prototype.remove = function(filter) {
-        if (this.$description.items) {
-            this.$description.items = this.$description.items.filter(filter);
-        }
-        return this;
+    ObservableChecker.prototype.cleanup = function() {
+        return this.observable.cleanup();
     };
 
-    /**
-     * Enables or disables multiple items expansion
-     * @param {boolean} [enabled=true] - Whether multiple items can be expanded simultaneously
-     * @returns {Accordion}
-     */
-    Accordion.prototype.multiple = function(enabled = true) {
-        this.$description.multiple = enabled;
-        return this;
-    };
+    const DocumentObserver = {
+        mounted: new WeakMap(),
+        beforeUnmount: new WeakMap(),
+        mountedSupposedSize: 0,
+        unmounted: new WeakMap(),
+        unmountedSupposedSize: 0,
+        observer: null,
+        initObserver: () => {
+            if(DocumentObserver.observer) {
+                return;
+            }
+            DocumentObserver.observer = new MutationObserver(DocumentObserver.checkMutation);
+            DocumentObserver.observer.observe(document.body, {
+                childList: true,
+                subtree: true,
+            });
+        },
 
-    /**
-     * Sets the variant style for the accordion
-     * @param {string} name - The variant name
-     * @returns {Accordion}
-     */
-    Accordion.prototype.variant = function(name) {
-        this.$description.variant = name;
-        return this;
-    };
+        executeMountedCallback(node) {
+            const data = DocumentObserver.mounted.get(node);
+            if(!data) {
+                return;
+            }
+            data.inDom = true;
+            if(!data.mounted) {
+                return;
+            }
+            if(Array.isArray(data.mounted)) {
+                for(const cb of data.mounted) {
+                    cb(node);
+                }
+                return;
+            }
+            data.mounted(node);
+        },
 
-    /**
-     * Sets the accordion variant to 'bordered'
-     * @returns {Accordion}
-     */
-    Accordion.prototype.bordered = function() {
-        return this.variant('bordered');
+        executeUnmountedCallback(node) {
+            const data = DocumentObserver.unmounted.get(node);
+            if(!data) {
+                return;
+            }
+            data.inDom = false;
+            if(!data.unmounted) {
+                return;
+            }
+
+            let shouldRemove = false;
+            if(Array.isArray(data.unmounted)) {
+                for(const cb of data.unmounted) {
+                    if(cb(node) === true) {
+                        shouldRemove = true;
+                    }
+                }
+            } else {
+                shouldRemove = data.unmounted(node) === true;
+            }
+
+            if(shouldRemove) {
+                data.disconnect();
+                node.nd?.remove();
+            }
+        },
+
+        checkMutation: function(mutationsList) {
+            console.log('mutationsList', mutationsList);
+            for(const mutation of mutationsList) {
+                if(DocumentObserver.mountedSupposedSize > 0) {
+                    for(const node of mutation.addedNodes) {
+                        DocumentObserver.executeMountedCallback(node);
+                        if(!node.querySelectorAll) {
+                            continue;
+                        }
+                        const children = node.querySelectorAll('[data--nd-mounted]');
+                        for(const child of children) {
+                            DocumentObserver.executeMountedCallback(child);
+                        }
+                    }
+                }
+
+                if (DocumentObserver.unmountedSupposedSize > 0) {
+                    for (const node of mutation.removedNodes) {
+                        DocumentObserver.executeUnmountedCallback(node);
+                        if(!node.querySelectorAll) {
+                            continue;
+                        }
+                        const children = node.querySelectorAll('[data--nd-unmounted]');
+                        for(const child of children) {
+                            DocumentObserver.executeUnmountedCallback(child);
+                        }
+                    }
+                }
+            }
+        },
+
+        /**
+         * @param {HTMLElement} element
+         * @param {boolean} inDom
+         * @returns {{ disconnect: Function, mounted: Function, unmounted: Function, off: Function }}
+         */
+        watch: function(element, inDom = false) {
+            let mountedRegistered   = false;
+            let unmountedRegistered = false;
+
+            DocumentObserver.initObserver();
+
+            let data = {
+                inDom,
+                mounted: null,
+                unmounted: null,
+                disconnect: () => {
+                    if (mountedRegistered) {
+                        DocumentObserver.mounted.delete(element);
+                        DocumentObserver.mountedSupposedSize--;
+                    }
+                    if (unmountedRegistered) {
+                        DocumentObserver.unmounted.delete(element);
+                        DocumentObserver.unmountedSupposedSize--;
+                    }
+                    data = null;
+                }
+            };
+
+            const addListener = (type, callback) => {
+                if (!data[type]) {
+                    data[type] = callback;
+                    return;
+                }
+                if (!Array.isArray(data[type])) {
+                    data[type] = [data[type], callback];
+                    return;
+                }
+                data[type].push(callback);
+            };
+
+            const removeListener = (type, callback) => {
+                if(!data?.[type]) {
+                    return;
+                }
+                if(Array.isArray(data[type])) {
+                    const index = data[type].indexOf(callback);
+                    if(index > -1) {
+                        data[type].splice(index, 1);
+                    }
+                    if(data[type].length === 1) {
+                        data[type] = data[type][0];
+                    }
+                    if(data[type].length === 0) {
+                        data[type] = null;
+                    }
+                    return;
+                }
+                data[type] = null;
+            };
+
+            return {
+                disconnect: () => data?.disconnect(),
+
+                mounted: (callback) => {
+                    addListener('mounted', callback);
+                    DocumentObserver.mounted.set(element, data);
+                    if (!mountedRegistered) {
+                        DocumentObserver.mountedSupposedSize++;
+                        mountedRegistered = true;
+                    }
+                },
+
+                unmounted: (callback) => {
+                    addListener('unmounted', callback);
+                    DocumentObserver.unmounted.set(element, data);
+                    if (!unmountedRegistered) {
+                        DocumentObserver.unmountedSupposedSize++;
+                        unmountedRegistered = true;
+                    }
+                },
+
+                off: (type, callback) => {
+                    removeListener(type, callback);
+                }
+            };
+        }
     };
 
-    /**
-     * Sets the accordion variant to 'separated'
-     * @returns {Accordion}
-     */
-    Accordion.prototype.separated = function() {
-        return this.variant('separated');
+    function NDElement(element) {
+        this.$element = element;
+    }
+
+    NDElement.prototype.__$isNDElement = true;
+
+    NDElement.prototype.valueOf = function() {
+        return this.$element;
     };
 
-    /**
-     * Sets the accordion variant to 'flush'
-     * @returns {Accordion}
-     */
-    Accordion.prototype.flush = function() {
-        return this.variant('flush');
+    NDElement.prototype.ref = function(target, name) {
+        target[name] = this.$element;
+        return this;
     };
 
-    /**
-     * Retrieves an accordion item by its key
-     * @param {string} key - The key of the item to retrieve
-     * @returns {AccordionItem|undefined}
-     */
-    Accordion.prototype.getByKey = function(key) {
-        return this.$description.items.find(item => item.key === key);
+    NDElement.prototype.refSelf = function(target, name) {
+        target[name] = new NDElement(this.$element);
+        return this;
     };
 
-    /**
-     * Expands or collapses an accordion item by key
-     * @param {string} key - The key of the item
-     * @param {boolean} [state=true] - Whether to expand (true) or collapse (false)
-     * @returns {Accordion}
-     */
-    Accordion.prototype.expanded = function(key, state = true) {
-        const item = this.getByKey(key);
-        if(item) {
-            if (state && !this.$description.multiple) {
-                this.collapseAll();
+    NDElement.prototype.unmountChildren = function() {
+        let element = this.$element;
+        for(let i = 0, length = element.children.length; i < length; i++) {
+            let elementChildren = element.children[i];
+            if(!elementChildren.$ndProx) {
+                elementChildren.nd?.remove();
             }
-            item.expanded(state);
-            this.emit(state ? 'expand' : 'collapse', key, state);
+            elementChildren = null;
         }
+        element = null;
         return this;
     };
 
-    /**
-     * Expands all accordion items
-     * @returns {Accordion}
-     */
-    Accordion.prototype.expandAll = function() {
-        this.$description.items.forEach(item => item.expanded(true));
+    NDElement.prototype.remove = function() {
+        let element = this.$element;
+        element.nd.unmountChildren();
+        element.$ndProx = null;
+
+        $lifeCycleObservers.delete(element);
+
+        element = null;
         return this;
     };
 
-    /**
-     * Collapses all accordion items
-     * @returns {Accordion}
-     */
-    Accordion.prototype.collapseAll = function() {
-        this.$description.items.forEach(item => item.expanded(false));
+    const $lifeCycleObservers = new WeakMap();
+    NDElement.prototype.lifecycle = function(states) {
+        const el = this.$element;
+        if (!$lifeCycleObservers.has(el)) {
+            $lifeCycleObservers.set(el, DocumentObserver.watch(el));
+        }
+        const observer = $lifeCycleObservers.get(el);
+
+        if(states.mounted) {
+            this.$element.setAttribute('data--nd-mounted', '1');
+            observer.mounted(states.mounted);
+        }
+        if(states.unmounted) {
+            this.$element.setAttribute('data--nd-unmounted', '1');
+            observer.unmounted(states.unmounted);
+        }
         return this;
     };
 
-    /**
-     * Checks if an accordion item is expanded
-     * @param {string} key - The key of the item to check
-     * @returns {boolean|undefined}
-     */
-    Accordion.prototype.isExpanded = function(key) {
-        return this.getByKey(key)?.isExpanded?.();
+    NDElement.prototype.mounted = function(callback) {
+        return this.lifecycle({ mounted: callback });
     };
 
-    /**
-     * Registers a handler for the expand event
-     * @param {Function} handler - The event handler
-     * @returns {Accordion}
-     */
-    Accordion.prototype.onExpand = function(handler) {
-        this.on('expand', handler);
-        return this;
+    NDElement.prototype.unmounted = function(callback) {
+        return this.lifecycle({ unmounted: callback });
     };
 
-    /**
-     * Registers a handler for the collapse event
-     * @param {Function} handler - The event handler
-     * @returns {Accordion}
-     */
-    Accordion.prototype.onCollapse = function(handler) {
-        this.on('collapse', handler);
-        return this;
-    };
+    NDElement.prototype.beforeUnmount = function(id, callback) {
+        const el = this.$element;
 
-    /**
-     * Sets the content render function
-     * @param {Function} renderFn - Function to render content
-     * @returns {Accordion}
-     */
-    Accordion.prototype.renderContent = function(renderFn) {
-        this.$description.renderContent = renderFn;
+        if(!DocumentObserver.beforeUnmount.has(el)) {
+            DocumentObserver.beforeUnmount.set(el, new Map());
+            const originalRemove = el.remove.bind(el);
+
+            let  $isUnmounting = false;
+
+            el.remove = async () => {
+                if($isUnmounting) {
+                    return;
+                }
+                $isUnmounting = true;
+
+                try {
+                    const callbacks = DocumentObserver.beforeUnmount.get(el);
+                    for (const cb of callbacks.values()) {
+                        await cb.call(this, el);
+                    }
+                } finally {
+                    originalRemove();
+                    $isUnmounting = false;
+                }
+            };
+        }
+
+        DocumentObserver.beforeUnmount.get(el).set(id, callback);
         return this;
     };
 
-    /**
-     * Builds the accordion component
-     * @private
-     */
-    Accordion.prototype.$build = function() {
-        // TODO: Implementation
-        // this.$description.items.forEach(item => {
-        //     item.onExpand(() => {
-        //         if (!this.$description.multiple) {
-        //             this.$description.items
-        //                 .filter(i => i !== item)
-        //                 .forEach(i => i.expanded(false));
-        //         }
-        //     });
-        // });
+    NDElement.prototype.htmlElement = function() {
+        return this.$element;
     };
 
-    let DebugManager$1 = {};
-    {
-        DebugManager$1 = {
-            log() {},
-            warn() {},
-            error() {},
-            disable() {}
-        };
-    }
-    var DebugManager$2 = DebugManager$1;
+    NDElement.prototype.node = NDElement.prototype.htmlElement;
 
-    class NativeDocumentError extends Error {
-        constructor(message, context = {}) {
-            super(message);
-            this.name = 'NativeDocumentError';
-            this.context = context;
-            this.timestamp = new Date().toISOString();
+    NDElement.prototype.shadow = function(mode, style = null) {
+        const $element = this.$element;
+        const children = Array.from($element.childNodes);
+        const shadowRoot = $element.attachShadow({ mode });
+        if(style) {
+            const styleNode = document.createElement("style");
+            styleNode.textContent = style;
+            shadowRoot.appendChild(styleNode);
         }
-    }
-
-    /**
-     *
-     * @param {ObservableItem} $observable
-     * @param {Function} $checker
-     * @class ObservableChecker
-     */
-    function ObservableChecker($observable, $checker) {
-        this.observable = $observable;
-        this.checker = $checker;
-        this.unSubscriptions = [];
-    }
-
-    ObservableChecker.prototype.__$Observable = true;
-    ObservableChecker.prototype.__$isObservableChecker = true;
+        $element.append = shadowRoot.append.bind(shadowRoot);
+        $element.appendChild = shadowRoot.appendChild.bind(shadowRoot);
+        shadowRoot.append(...children);
 
-    /**
-     * Subscribes to changes in the checked/transformed value.
-     *
-     * @param {Function} callback - Function called with the transformed value when observable changes
-     * @returns {Function} Unsubscribe function
-     * @example
-     * const count = Observable(5);
-     * const doubled = count.check(n => n * 2);
-     * doubled.subscribe(value => console.log(value)); // Logs: 10
-     */
-    ObservableChecker.prototype.subscribe = function(callback) {
-        const unSubscribe = this.observable.subscribe((value) => {
-            callback && callback(this.checker(value));
-        });
-        this.unSubscriptions.push(unSubscribe);
-        return unSubscribe;
+        return this;
     };
 
-    /**
-     * Creates a new ObservableChecker by applying another transformation.
-     * Allows chaining transformations.
-     *
-     * @param {(value: *) => *} callback - Transformation function to apply to the current checked value
-     * @returns {ObservableChecker} New ObservableChecker with chained transformation
-     * @example
-     * const count = Observable(5);
-     * const result = count.check(n => n * 2).check(n => n + 1);
-     * result.val(); // 11
-     */
-    ObservableChecker.prototype.check = function(callback) {
-        return this.observable.check(() => callback(this.val()));
+    NDElement.prototype.openShadow = function(style = null) {
+        return this.shadow('open', style);
     };
 
-    /**
-     * Gets the current transformed/checked value.
-     *
-     * @returns {*} The result of applying the checker function to the observable's current value
-     * @example
-     * const count = Observable(5);
-     * const doubled = count.check(n => n * 2);
-     * doubled.val(); // 10
-     */
-    ObservableChecker.prototype.val = function() {
-        return this.checker && this.checker(this.observable.val());
+    NDElement.prototype.closedShadow = function(style = null) {
+        return this.shadow('closed', style);
     };
 
     /**
-     * Sets the value of the underlying observable (not the transformed value).
+     * Extends the current NDElement instance with custom methods.
+     * Methods are bound to the instance and available for chaining.
      *
-     * @param {*} value - New value for the underlying observable
+     * @param {Object} methods - Object containing method definitions
+     * @returns {this} The NDElement instance with added methods for chaining
      * @example
-     * const count = Observable(5);
-     * const doubled = count.check(n => n * 2);
-     * doubled.set(10); // Sets count to 10, doubled.val() returns 20
+     * element.nd.with({
+     *   highlight() {
+     *     this.$element.style.background = 'yellow';
+     *     return this;
+     *   }
+     * }).highlight().onClick(() => console.log('Clicked'));
      */
-    ObservableChecker.prototype.set = function(value) {
-        return this.observable.set(value);
+    NDElement.prototype.with = function(methods) {
+        if (!methods || typeof methods !== 'object') {
+            throw new NativeDocumentError('extend() requires an object of methods');
+        }
+
+        for (const name in methods) {
+            const method = methods[name];
+
+            if (typeof method !== 'function') {
+                console.warn(`⚠️ extends(): "${name}" is not a function, skipping`);
+                continue;
+            }
+
+            this[name] = method.bind(this);
+        }
+
+        return this;
     };
 
     /**
-     * Manually triggers the underlying observable to notify subscribers.
+     * Extends the NDElement prototype with new methods available to all NDElement instances.
+     * Use this to add global methods to all NDElements.
      *
+     * @param {Object} methods - Object containing method definitions to add to prototype
+     * @returns {typeof NDElement} The NDElement constructor
+     * @throws {NativeDocumentError} If methods is not an object or contains non-function values
      * @example
-     * const count = Observable(5);
-     * const doubled = count.check(n => n * 2);
-     * doubled.trigger(); // Notifies all subscribers
+     * NDElement.extend({
+     *   fadeIn() {
+     *     this.$element.style.opacity = '1';
+     *     return this;
+     *   }
+     * });
+     * // Now all NDElements have .fadeIn() method
+     * Div().nd.fadeIn();
      */
-    ObservableChecker.prototype.trigger = function() {
-        return this.observable.trigger();
-    };
+    NDElement.extend = function(methods) {
+        if (!methods || typeof methods !== 'object') {
+            throw new NativeDocumentError('NDElement.extend() requires an object of methods');
+        }
 
-    /**
-     * Cleans up the underlying observable and all its subscriptions.
-     */
-    ObservableChecker.prototype.cleanup = function() {
-        return this.observable.cleanup();
-    };
+        if (Array.isArray(methods)) {
+            throw new NativeDocumentError('NDElement.extend() requires an object, not an array');
+        }
 
-    const DocumentObserver = {
-        mounted: new WeakMap(),
-        beforeUnmount: new WeakMap(),
-        mountedSupposedSize: 0,
-        unmounted: new WeakMap(),
-        unmountedSupposedSize: 0,
-        observer: null,
-        initObserver: () => {
-            if(DocumentObserver.observer) {
-                return;
-            }
-            DocumentObserver.observer = new MutationObserver(DocumentObserver.checkMutation);
-            DocumentObserver.observer.observe(document.body, {
-                childList: true,
-                subtree: true,
-            });
-        },
+        const protectedMethods = new Set([
+            'constructor', 'valueOf', '$element', '$observer',
+            'ref', 'remove', 'cleanup', 'with', 'extend', 'attach',
+            'lifecycle', 'mounted', 'unmounted', 'unmountChildren'
+        ]);
 
-        executeMountedCallback(node) {
-            const data = DocumentObserver.mounted.get(node);
-            if(!data) {
-                return;
-            }
-            data.inDom = true;
-            if(!data.mounted) {
-                return;
-            }
-            if(Array.isArray(data.mounted)) {
-                for(const cb of data.mounted) {
-                    cb(node);
-                }
-                return;
+        for (const name in methods) {
+            if (!Object.hasOwn(methods, name)) {
+                continue;
             }
-            data.mounted(node);
-        },
 
-        executeUnmountedCallback(node) {
-            const data = DocumentObserver.unmounted.get(node);
-            if(!data) {
-                return;
+            const method = methods[name];
+
+            if (typeof method !== 'function') {
+                DebugManager$1.warn('NDElement.extend', `"${name}" is not a function, skipping`);
+                continue;
             }
-            data.inDom = false;
-            if(!data.unmounted) {
-                return;
+
+            if (protectedMethods.has(name)) {
+                DebugManager$1.error('NDElement.extend', `Cannot override protected method "${name}"`);
+                throw new NativeDocumentError(`Cannot override protected method "${name}"`);
             }
 
-            let shouldRemove = false;
-            if(Array.isArray(data.unmounted)) {
-                for(const cb of data.unmounted) {
-                    if(cb(node) === true) {
-                        shouldRemove = true;
-                    }
-                }
-            } else {
-                shouldRemove = data.unmounted(node) === true;
+            if (NDElement.prototype[name]) {
+                DebugManager$1.warn('NDElement.extend', `Overwriting existing prototype method "${name}"`);
             }
 
-            if(shouldRemove) {
-                data.disconnect();
-                node.nd?.remove();
+            NDElement.prototype[name] = method;
+        }
+
+        return NDElement;
+    };
+
+    const COMMON_NODE_TYPES = {
+        ELEMENT: 1,
+        TEXT: 3,
+        COMMENT: 8,
+        DOCUMENT_FRAGMENT: 11
+    };
+
+    const VALID_TYPES = [];
+    VALID_TYPES[COMMON_NODE_TYPES.ELEMENT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.TEXT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.DOCUMENT_FRAGMENT] = true;
+    VALID_TYPES[COMMON_NODE_TYPES.COMMENT] = true;
+
+    const Validator = {
+        isObservable(value) {
+            return  value?.__$isObservable;
+        },
+        isTemplateBinding(value) {
+            return  value?.__$isTemplateBinding;
+        },
+        isObservableWhenResult(value) {
+            return value && (value.__$isObservableWhen || (typeof value === 'object' && '$target' in value && '$observer' in value));
+        },
+        isArrayObservable(value) {
+            return  value?.__$isObservableArray;
+        },
+        isProxy(value) {
+            return value?.__isProxy__
+        },
+        isObservableOrProxy(value) {
+            return Validator.isObservable(value) || Validator.isProxy(value);
+        },
+        isAnchor(value) {
+            return value?.__Anchor__
+        },
+        isObservableChecker(value) {
+            return value?.__$isObservableChecker || value instanceof ObservableChecker;
+        },
+        isArray(value) {
+            return Array.isArray(value);
+        },
+        isString(value) {
+            return typeof value === 'string';
+        },
+        isNumber(value) {
+            return typeof value === 'number';
+        },
+        isBoolean(value) {
+            return typeof value === 'boolean';
+        },
+        isFunction(value) {
+            return typeof value === 'function';
+        },
+        isAsyncFunction(value) {
+            return typeof value === 'function' && value.constructor.name === 'AsyncFunction';
+        },
+        isObject(value) {
+            return typeof value === 'object' && value !== null;
+        },
+        isJson(value) {
+            return !(typeof value !== 'object' || value === null || Array.isArray(value) || value.constructor.name !== 'Object')
+        },
+        isElement(value) {
+            return value && VALID_TYPES[value.nodeType];
+        },
+        isDOMNode(value) {
+            return VALID_TYPES[value.nodeType];
+        },
+        isFragment(value) {
+            return value?.nodeType === COMMON_NODE_TYPES.DOCUMENT_FRAGMENT;
+        },
+        isStringOrObservable(value) {
+            return this.isString(value) || this.isObservable(value);
+        },
+        isValidChild(child) {
+            return child === null ||
+                this.isElement(child) ||
+                this.isObservable(child) ||
+                this.isNDElement(child) ||
+                ['string', 'number', 'boolean'].includes(typeof child);
+        },
+        isNDElement(child) {
+            return child?.__$isNDElement || child instanceof NDElement;
+        },
+        isValidChildren(children) {
+            if (!Array.isArray(children)) {
+                children = [children];
             }
+
+            const invalid = children.filter(child => !this.isValidChild(child));
+            return invalid.length === 0;
         },
+        validateChildren(children) {
+            if (!Array.isArray(children)) {
+                children = [children];
+            }
 
-        checkMutation: function(mutationsList) {
-            console.log('mutationsList', mutationsList);
-            for(const mutation of mutationsList) {
-                if(DocumentObserver.mountedSupposedSize > 0) {
-                    for(const node of mutation.addedNodes) {
-                        DocumentObserver.executeMountedCallback(node);
-                        if(!node.querySelectorAll) {
-                            continue;
-                        }
-                        const children = node.querySelectorAll('[data--nd-mounted]');
-                        for(const child of children) {
-                            DocumentObserver.executeMountedCallback(child);
-                        }
-                    }
-                }
+            const invalid = children.filter(child => !this.isValidChild(child));
+            if (invalid.length > 0) {
+                throw new NativeDocumentError(`Invalid children detected: ${invalid.map(i => typeof i).join(', ')}`);
+            }
 
-                if (DocumentObserver.unmountedSupposedSize > 0) {
-                    for (const node of mutation.removedNodes) {
-                        DocumentObserver.executeUnmountedCallback(node);
-                        if(!node.querySelectorAll) {
-                            continue;
-                        }
-                        const children = node.querySelectorAll('[data--nd-unmounted]');
-                        for(const child of children) {
-                            DocumentObserver.executeUnmountedCallback(child);
-                        }
-                    }
-                }
+            return children;
+        },
+        /**
+         * Check if the data contains observables.
+         * @param {Array|Object} data
+         * @returns {boolean}
+         */
+        containsObservables(data) {
+            if(!data) {
+                return false;
             }
+            return Validator.isObject(data)
+                && Object.values(data).some(value => Validator.isObservable(value));
         },
-
         /**
-         * @param {HTMLElement} element
-         * @param {boolean} inDom
-         * @returns {{ disconnect: Function, mounted: Function, unmounted: Function, off: Function }}
+         * Check if the data contains an observable reference.
+         * @param {string} data
+         * @returns {boolean}
          */
-        watch: function(element, inDom = false) {
-            let mountedRegistered   = false;
-            let unmountedRegistered = false;
+        containsObservableReference(data) {
+            if(!data || typeof data !== 'string') {
+                return false;
+            }
+            return /\{\{#ObItem::\([0-9]+\)\}\}/.test(data);
+        },
+        validateAttributes(attributes) {},
 
-            DocumentObserver.initObserver();
+        validateEventCallback(callback) {
+            if (typeof callback !== 'function') {
+                throw new NativeDocumentError('Event callback must be a function');
+            }
+        }
+    };
 
-            let data = {
-                inDom,
-                mounted: null,
-                unmounted: null,
-                disconnect: () => {
-                    if (mountedRegistered) {
-                        DocumentObserver.mounted.delete(element);
-                        DocumentObserver.mountedSupposedSize--;
-                    }
-                    if (unmountedRegistered) {
-                        DocumentObserver.unmounted.delete(element);
-                        DocumentObserver.unmountedSupposedSize--;
+    function createMultiSourceFilter(sources, callbackFn){
+        const observables = sources.filter(Validator.isObservable);
+
+        const getValues = () => sources.map(src =>
+            Validator.isObservable(src) ? src.val() : src
+        );
+
+        return {
+            dependencies: observables.length > 0 ? observables : null,
+            callback: (value) => callbackFn(value, getValues())
+        };
+    }
+
+    function match(patternObservableOrValue, asRegexObservableOrValue = true, flagsObservableOrValue = ''){
+        return createMultiSourceFilter(
+            [patternObservableOrValue, asRegexObservableOrValue, flagsObservableOrValue],
+            (value, [pattern, asRegex, flags]) => {
+                if (!pattern) return true;
+
+                if (asRegex){
+                    try {
+                        const regex = new RegExp(pattern, flags);
+                        return regex.test(String(value));
+                    } catch (error){
+                        console.warn('Invalid regex pattern:', pattern, error);
+                        return false;
                     }
-                    data = null;
                 }
-            };
 
-            const addListener = (type, callback) => {
-                if (!data[type]) {
-                    data[type] = callback;
-                    return;
+                if (!flags || flags === ''){
+                    return String(value).toLowerCase().includes(String(pattern).toLowerCase());
                 }
-                if (!Array.isArray(data[type])) {
-                    data[type] = [data[type], callback];
+                return String(value).includes(String(pattern));
+            }
+        );
+    }
+
+    const cssPropertyAccumulator = function(initialValue = {}) {
+        let data = Validator.isString(initialValue) ? initialValue.split(';').filter(Boolean) : initialValue;
+        const isArray = Validator.isArray(data);
+
+        return {
+            add(key, value) {
+                if(isArray) {
+                    data.push(key+':  '+value);
                     return;
                 }
-                data[type].push(callback);
-            };
+                data[key] = value;
+            },
+            value() {
+                if(isArray) {
+                    return data.join(';').concat(';');
+                }
+                return { ...data };
+            },
+        };
+    };
 
-            const removeListener = (type, callback) => {
-                if(!data?.[type]) {
+    const classPropertyAccumulator = function(initialValue = []) {
+        let data = Validator.isString(initialValue) ? initialValue.split(" ").filter(Boolean) : initialValue;
+        const isArray = Validator.isArray(data);
+
+        return {
+            add(key, value = true) {
+                if(isArray) {
+                    data.push(key);
                     return;
                 }
-                if(Array.isArray(data[type])) {
-                    const index = data[type].indexOf(callback);
-                    if(index > -1) {
-                        data[type].splice(index, 1);
-                    }
-                    if(data[type].length === 1) {
-                        data[type] = data[type][0];
-                    }
-                    if(data[type].length === 0) {
-                        data[type] = null;
-                    }
-                    return;
+                data[key] = value;
+            },
+            value() {
+                if(isArray) {
+                    return data.join(' ');
                 }
-                data[type] = null;
-            };
+                return { ...data };
+            },
+        };
+    };
 
-            return {
-                disconnect: () => data?.disconnect(),
+    /**
+     *
+     * @class
+     */
+    function BaseComponent() {
+        this.$description = {};
+        this.$editableProps = null;
+    }
 
-                mounted: (callback) => {
-                    addListener('mounted', callback);
-                    DocumentObserver.mounted.set(element, data);
-                    if (!mountedRegistered) {
-                        DocumentObserver.mountedSupposedSize++;
-                        mountedRegistered = true;
-                    }
-                },
+    Object.defineProperty( BaseComponent.prototype, 'nd', {
+        get: function() {
+            if(this.$element) {
+                return this.$element.nd;
+            }
+            this.$storeElement(this.toNdElement());
+            return this.$element?.nd;
+        }
+    });
 
-                unmounted: (callback) => {
-                    addListener('unmounted', callback);
-                    DocumentObserver.unmounted.set(element, data);
-                    if (!unmountedRegistered) {
-                        DocumentObserver.unmountedSupposedSize++;
-                        unmountedRegistered = true;
-                    }
-                },
 
-                off: (type, callback) => {
-                    removeListener(type, callback);
-                }
-            };
+    BaseComponent.extends = function(Component, ...parents) {
+        const MainParent = parents[0] || BaseComponent;
+        Component.prototype = Object.create(MainParent.prototype);
+
+        if(parents.length > 0) {
+            for(const parent of parents) {
+                Object.assign(Component.prototype, parent.prototype);
+            }
         }
+        Component.prototype.constructor = Component;
     };
 
-    function NDElement(element) {
+    BaseComponent.use = function(Component, ...traits) {
+        if(traits.length > 0) {
+            for(const trait of traits) {
+                Object.assign(Component.prototype, trait.prototype);
+            }
+        }
+    };
+
+    BaseComponent.obs = (value) => {
+        return value.__$Observable ? value : Observable(value);
+    };
+
+    BaseComponent.prototype.$storeElement = function(element) {
         this.$element = element;
-    }
+        return this;
+    };
 
-    NDElement.prototype.__$isNDElement = true;
+    BaseComponent.prototype.refSelf = function(target, name) {
+        target[name] = this;
+        return this;
+    };
 
-    NDElement.prototype.valueOf = function() {
+    BaseComponent.prototype.$build = function() {
+        const ComponentClass = this.constructor;
+        const renderer = this.$description.render || ComponentClass.defaultTemplate;
+
+        if (!renderer) {
+            throw new Error(`No renderer for ${ComponentClass.name}`);
+        }
+
+        return renderer(this.$description, this);
+    };
+
+    BaseComponent.prototype.toNdElement = function() {
+        if (this.$element) {
+            return this.$element;
+        }
+        this.$element = this.$build();
         return this.$element;
     };
 
-    NDElement.prototype.ref = function(target, name) {
-        target[name] = this.$element;
-        return this;
+    BaseComponent.prototype.toJSON = function() {
+        if(!this.$description) {
+            return {};
+        }
+        return { ...this.$description };
     };
 
-    NDElement.prototype.refSelf = function(target, name) {
-        target[name] = new NDElement(this.$element);
+    BaseComponent.prototype.render = function(renderFn) {
+        if (typeof renderFn !== 'function') {
+            throw new Error('Custom renderer must be a function');
+        }
+        this.$description.render = renderFn;
         return this;
     };
 
-    NDElement.prototype.unmountChildren = function() {
-        let element = this.$element;
-        for(let i = 0, length = element.children.length; i < length; i++) {
-            let elementChildren = element.children[i];
-            if(!elementChildren.$ndProx) {
-                elementChildren.nd?.remove();
-            }
-            elementChildren = null;
+    BaseComponent.prototype.getEditableProps = function() {
+        if(!this.$editableProps) {
+            const rawProps = this.$description.props || {};
+            this.$editableProps = {
+                ...rawProps,
+                class: classPropertyAccumulator(this.$description.props.class),
+                style: cssPropertyAccumulator(this.$description.props.style)
+            };
         }
-        element = null;
-        return this;
+
+        return this.$editableProps;
+    };
+
+    BaseComponent.prototype.resolveProps = function() {
+        if(!this.$editableProps) {
+            return { ...this.$description.props };
+        }
+        const props = { ...this.$editableProps };
+        if(props.class) {
+            props.class = props.class.value();
+        }
+        if(props.style) {
+            props.style = props.style.value();
+        }
+        return props;
+    };
+
+    function HasEventEmitter() {
+
+        this.__$events = null;
+
+    }
+
+    HasEventEmitter.prototype.on = function(eventName, callback) {
+        if(!this.__$events) {
+            this.__$events = new Map();
+        }
+        if(!this.__$events.has(eventName)) {
+            this.__$events.set(eventName, callback);
+            return;
+        }
+        const existingCallback = this.__$events.get(eventName);
+        if(!Array.isArray(existingCallback)) {
+            this.__$events.set(eventName, [existingCallback, callback]);
+            return;
+        }
+        existingCallback.push(callback);
     };
 
-    NDElement.prototype.remove = function() {
-        let element = this.$element;
-        element.nd.unmountChildren();
-        element.$ndProx = null;
-
-        $lifeCycleObservers.delete(element);
-
-        element = null;
-        return this;
+    HasEventEmitter.prototype.hasListeners = function(eventName) {
+        return !!this.__$events.get(eventName);
     };
 
-    const $lifeCycleObservers = new WeakMap();
-    NDElement.prototype.lifecycle = function(states) {
-        const el = this.$element;
-        if (!$lifeCycleObservers.has(el)) {
-            $lifeCycleObservers.set(el, DocumentObserver.watch(el));
+    HasEventEmitter.prototype.trigger = async function(eventName, ...args) {
+        const callbacks = this.__$events.get(eventName);
+        if(!callbacks) {
+            // throw new NativeDocumentError(this.constructor.name, 'Event '+eventName+' not found');
+            return;
         }
-        const observer = $lifeCycleObservers.get(el);
 
-        if(states.mounted) {
-            this.$element.setAttribute('data--nd-mounted', '1');
-            observer.mounted(states.mounted);
+        if(typeof callbacks === 'function') {
+            return await Promise.resolve(callbacks.apply(this, args))
         }
-        if(states.unmounted) {
-            this.$element.setAttribute('data--nd-unmounted', '1');
-            observer.unmounted(states.unmounted);
+
+        let result = null;
+        for(let i = 0, length = callbacks.length; i < length; i++) {
+            result = await Promise.resolve(await callbacks[i].apply(this, args));
         }
-        return this;
+        return result;
     };
+    HasEventEmitter.prototype.emit = HasEventEmitter.prototype.trigger;
 
-    NDElement.prototype.mounted = function(callback) {
-        return this.lifecycle({ mounted: callback });
-    };
+    /**
+     * Valid children types that can be rendered in the DOM
+     * @typedef {HTMLElement|Text|DocumentFragment|string|Array<ValidChildren>} ValidChildren
+     */
 
-    NDElement.prototype.unmounted = function(callback) {
-        return this.lifecycle({ unmounted: callback });
-    };
+    /**
+     * Component for creating accordion interfaces with expandable/collapsible items
+     * @param {{ items?: Array<AccordionItem>, multiple?: boolean, variant?: string, renderContent?: (field: Accordion) => HTMLElement }} config
+     * @returns {Accordion}
+     * @class
+     */
+    function Accordion(config = {}) {
+        if (!(this instanceof Accordion)) {
+            return new Accordion(config);
+        }
 
-    NDElement.prototype.beforeUnmount = function(id, callback) {
-        const el = this.$element;
+        this.$description = {
+            items: [],
+            multiple: null,
+            variant: null,
+            renderContent: null,
+            ...config
+        };
+    }
 
-        if(!DocumentObserver.beforeUnmount.has(el)) {
-            DocumentObserver.beforeUnmount.set(el, new Map());
-            const originalRemove = el.remove.bind(el);
+    BaseComponent.extends(Accordion, HasEventEmitter);
 
-            let  $isUnmounting = false;
+    Accordion.defaultTemplate = null;
 
-            el.remove = async () => {
-                if($isUnmounting) {
-                    return;
-                }
-                $isUnmounting = true;
 
-                try {
-                    const callbacks = DocumentObserver.beforeUnmount.get(el);
-                    for (const cb of callbacks.values()) {
-                        await cb.call(this, el);
-                    }
-                } finally {
-                    originalRemove();
-                    $isUnmounting = false;
-                }
-            };
-        }
+    /**
+     * Sets the default template for all Accordion instances
+     * @param {{accordion: (accordion: Accordion) => ValidChildren}} template - Template object containing accordion factory function
+     */
+    Accordion.use = function(template) {
+        Accordion.defaultTemplate = template.accordion;
+    };
 
-        DocumentObserver.beforeUnmount.get(el).set(id, callback);
+    /**
+     * Adds an accordion item to the collection
+     * @param {AccordionItem} accordionItem - The accordion item to add
+     * @returns {Accordion}
+     */
+    Accordion.prototype.item = function(accordionItem) {
+        this.$description.items.push(accordionItem);
         return this;
     };
 
-    NDElement.prototype.htmlElement = function() {
-        return this.$element;
+    /**
+     * Sets the accordion items collection
+     * @param {Array<AccordionItem>} items - Array of accordion items
+     * @returns {Accordion}
+     */
+    Accordion.prototype.items = function(items) {
+        this.$description.items = items;
+        return this;
     };
 
-    NDElement.prototype.node = NDElement.prototype.htmlElement;
+    /**
+     * Alias for item method
+     * @param {AccordionItem} accordionItem - The accordion item to add
+     * @returns {Accordion}
+     */
+    Accordion.prototype.addItem = Accordion.prototype.item;
 
-    NDElement.prototype.shadow = function(mode, style = null) {
-        const $element = this.$element;
-        const children = Array.from($element.childNodes);
-        const shadowRoot = $element.attachShadow({ mode });
-        if(style) {
-            const styleNode = document.createElement("style");
-            styleNode.textContent = style;
-            shadowRoot.appendChild(styleNode);
+    /**
+     * Removes an item by its id
+     * @param {string} id - The id of the item to remove
+     * @returns {Accordion}
+     */
+    Accordion.prototype.removeItemById = function(id) {
+        if (this.$description.items) {
+            this.$description.items = this.$description.items.filter(item => item.id !== id);
         }
-        $element.append = shadowRoot.append.bind(shadowRoot);
-        $element.appendChild = shadowRoot.appendChild.bind(shadowRoot);
-        shadowRoot.append(...children);
-
         return this;
     };
 
-    NDElement.prototype.openShadow = function(style = null) {
-        return this.shadow('open', style);
+    /**
+     * Removes items matching the filter function
+     * @param {Function} filter - Filter function to determine which items to keep
+     * @returns {Accordion}
+     */
+    Accordion.prototype.remove = function(filter) {
+        if (this.$description.items) {
+            this.$description.items = this.$description.items.filter(filter);
+        }
+        return this;
     };
 
-    NDElement.prototype.closedShadow = function(style = null) {
-        return this.shadow('closed', style);
+    /**
+     * Enables or disables multiple items expansion
+     * @param {boolean} [enabled=true] - Whether multiple items can be expanded simultaneously
+     * @returns {Accordion}
+     */
+    Accordion.prototype.multiple = function(enabled = true) {
+        this.$description.multiple = enabled;
+        return this;
     };
 
     /**
-     * Extends the current NDElement instance with custom methods.
-     * Methods are bound to the instance and available for chaining.
-     *
-     * @param {Object} methods - Object containing method definitions
-     * @returns {this} The NDElement instance with added methods for chaining
-     * @example
-     * element.nd.with({
-     *   highlight() {
-     *     this.$element.style.background = 'yellow';
-     *     return this;
-     *   }
-     * }).highlight().onClick(() => console.log('Clicked'));
+     * Sets the variant style for the accordion
+     * @param {string} name - The variant name
+     * @returns {Accordion}
      */
-    NDElement.prototype.with = function(methods) {
-        if (!methods || typeof methods !== 'object') {
-            throw new NativeDocumentError('extend() requires an object of methods');
-        }
-
-        for (const name in methods) {
-            const method = methods[name];
-
-            if (typeof method !== 'function') {
-                console.warn(`⚠️ extends(): "${name}" is not a function, skipping`);
-                continue;
-            }
-
-            this[name] = method.bind(this);
-        }
-
+    Accordion.prototype.variant = function(name) {
+        this.$description.variant = name;
         return this;
     };
 
     /**
-     * Extends the NDElement prototype with new methods available to all NDElement instances.
-     * Use this to add global methods to all NDElements.
-     *
-     * @param {Object} methods - Object containing method definitions to add to prototype
-     * @returns {typeof NDElement} The NDElement constructor
-     * @throws {NativeDocumentError} If methods is not an object or contains non-function values
-     * @example
-     * NDElement.extend({
-     *   fadeIn() {
-     *     this.$element.style.opacity = '1';
-     *     return this;
-     *   }
-     * });
-     * // Now all NDElements have .fadeIn() method
-     * Div().nd.fadeIn();
+     * Sets the accordion variant to 'bordered'
+     * @returns {Accordion}
      */
-    NDElement.extend = function(methods) {
-        if (!methods || typeof methods !== 'object') {
-            throw new NativeDocumentError('NDElement.extend() requires an object of methods');
-        }
-
-        if (Array.isArray(methods)) {
-            throw new NativeDocumentError('NDElement.extend() requires an object, not an array');
-        }
-
-        const protectedMethods = new Set([
-            'constructor', 'valueOf', '$element', '$observer',
-            'ref', 'remove', 'cleanup', 'with', 'extend', 'attach',
-            'lifecycle', 'mounted', 'unmounted', 'unmountChildren'
-        ]);
-
-        for (const name in methods) {
-            if (!Object.hasOwn(methods, name)) {
-                continue;
-            }
+    Accordion.prototype.bordered = function() {
+        return this.variant('bordered');
+    };
 
-            const method = methods[name];
+    /**
+     * Sets the accordion variant to 'separated'
+     * @returns {Accordion}
+     */
+    Accordion.prototype.separated = function() {
+        return this.variant('separated');
+    };
 
-            if (typeof method !== 'function') {
-                DebugManager$2.warn('NDElement.extend', `"${name}" is not a function, skipping`);
-                continue;
-            }
+    /**
+     * Sets the accordion variant to 'flush'
+     * @returns {Accordion}
+     */
+    Accordion.prototype.flush = function() {
+        return this.variant('flush');
+    };
 
-            if (protectedMethods.has(name)) {
-                DebugManager$2.error('NDElement.extend', `Cannot override protected method "${name}"`);
-                throw new NativeDocumentError(`Cannot override protected method "${name}"`);
-            }
+    /**
+     * Retrieves an accordion item by its key
+     * @param {string} key - The key of the item to retrieve
+     * @returns {AccordionItem|undefined}
+     */
+    Accordion.prototype.getByKey = function(key) {
+        return this.$description.items.find(item => item.key === key);
+    };
 
-            if (NDElement.prototype[name]) {
-                DebugManager$2.warn('NDElement.extend', `Overwriting existing prototype method "${name}"`);
+    /**
+     * Expands or collapses an accordion item by key
+     * @param {string} key - The key of the item
+     * @param {boolean} [state=true] - Whether to expand (true) or collapse (false)
+     * @returns {Accordion}
+     */
+    Accordion.prototype.expanded = function(key, state = true) {
+        const item = this.getByKey(key);
+        if(item) {
+            if (state && !this.$description.multiple) {
+                this.collapseAll();
             }
-
-            NDElement.prototype[name] = method;
+            item.expanded(state);
+            this.emit(state ? 'expand' : 'collapse', key, state);
         }
-
-        return NDElement;
+        return this;
     };
 
-    const COMMON_NODE_TYPES = {
-        ELEMENT: 1,
-        TEXT: 3,
-        COMMENT: 8,
-        DOCUMENT_FRAGMENT: 11
+    /**
+     * Expands all accordion items
+     * @returns {Accordion}
+     */
+    Accordion.prototype.expandAll = function() {
+        this.$description.items.forEach(item => item.expanded(true));
+        return this;
     };
 
-    const VALID_TYPES = [];
-    VALID_TYPES[COMMON_NODE_TYPES.ELEMENT] = true;
-    VALID_TYPES[COMMON_NODE_TYPES.TEXT] = true;
-    VALID_TYPES[COMMON_NODE_TYPES.DOCUMENT_FRAGMENT] = true;
-    VALID_TYPES[COMMON_NODE_TYPES.COMMENT] = true;
+    /**
+     * Collapses all accordion items
+     * @returns {Accordion}
+     */
+    Accordion.prototype.collapseAll = function() {
+        this.$description.items.forEach(item => item.expanded(false));
+        return this;
+    };
 
-    const Validator = {
-        isObservable(value) {
-            return  value?.__$isObservable;
-        },
-        isTemplateBinding(value) {
-            return  value?.__$isTemplateBinding;
-        },
-        isObservableWhenResult(value) {
-            return value && (value.__$isObservableWhen || (typeof value === 'object' && '$target' in value && '$observer' in value));
-        },
-        isArrayObservable(value) {
-            return  value?.__$isObservableArray;
-        },
-        isProxy(value) {
-            return value?.__isProxy__
-        },
-        isObservableOrProxy(value) {
-            return Validator.isObservable(value) || Validator.isProxy(value);
-        },
-        isAnchor(value) {
-            return value?.__Anchor__
-        },
-        isObservableChecker(value) {
-            return value?.__$isObservableChecker || value instanceof ObservableChecker;
-        },
-        isArray(value) {
-            return Array.isArray(value);
-        },
-        isString(value) {
-            return typeof value === 'string';
-        },
-        isNumber(value) {
-            return typeof value === 'number';
-        },
-        isBoolean(value) {
-            return typeof value === 'boolean';
-        },
-        isFunction(value) {
-            return typeof value === 'function';
-        },
-        isAsyncFunction(value) {
-            return typeof value === 'function' && value.constructor.name === 'AsyncFunction';
-        },
-        isObject(value) {
-            return typeof value === 'object' && value !== null;
-        },
-        isJson(value) {
-            return !(typeof value !== 'object' || value === null || Array.isArray(value) || value.constructor.name !== 'Object')
-        },
-        isElement(value) {
-            return value && VALID_TYPES[value.nodeType];
-        },
-        isDOMNode(value) {
-            return VALID_TYPES[value.nodeType];
-        },
-        isFragment(value) {
-            return value?.nodeType === COMMON_NODE_TYPES.DOCUMENT_FRAGMENT;
-        },
-        isStringOrObservable(value) {
-            return this.isString(value) || this.isObservable(value);
-        },
-        isValidChild(child) {
-            return child === null ||
-                this.isElement(child) ||
-                this.isObservable(child) ||
-                this.isNDElement(child) ||
-                ['string', 'number', 'boolean'].includes(typeof child);
-        },
-        isNDElement(child) {
-            return child?.__$isNDElement || child instanceof NDElement;
-        },
-        isValidChildren(children) {
-            if (!Array.isArray(children)) {
-                children = [children];
-            }
+    /**
+     * Checks if an accordion item is expanded
+     * @param {string} key - The key of the item to check
+     * @returns {boolean|undefined}
+     */
+    Accordion.prototype.isExpanded = function(key) {
+        return this.getByKey(key)?.isExpanded?.();
+    };
 
-            const invalid = children.filter(child => !this.isValidChild(child));
-            return invalid.length === 0;
-        },
-        validateChildren(children) {
-            if (!Array.isArray(children)) {
-                children = [children];
-            }
+    /**
+     * Registers a handler for the expand event
+     * @param {Function} handler - The event handler
+     * @returns {Accordion}
+     */
+    Accordion.prototype.onExpand = function(handler) {
+        this.on('expand', handler);
+        return this;
+    };
 
-            const invalid = children.filter(child => !this.isValidChild(child));
-            if (invalid.length > 0) {
-                throw new NativeDocumentError(`Invalid children detected: ${invalid.map(i => typeof i).join(', ')}`);
-            }
+    /**
+     * Registers a handler for the collapse event
+     * @param {Function} handler - The event handler
+     * @returns {Accordion}
+     */
+    Accordion.prototype.onCollapse = function(handler) {
+        this.on('collapse', handler);
+        return this;
+    };
 
-            return children;
-        },
-        /**
-         * Check if the data contains observables.
-         * @param {Array|Object} data
-         * @returns {boolean}
-         */
-        containsObservables(data) {
-            if(!data) {
-                return false;
-            }
-            return Validator.isObject(data)
-                && Object.values(data).some(value => Validator.isObservable(value));
-        },
-        /**
-         * Check if the data contains an observable reference.
-         * @param {string} data
-         * @returns {boolean}
-         */
-        containsObservableReference(data) {
-            if(!data || typeof data !== 'string') {
-                return false;
-            }
-            return /\{\{#ObItem::\([0-9]+\)\}\}/.test(data);
-        },
-        validateAttributes(attributes) {},
+    /**
+     * Sets the content render function
+     * @param {Function} renderFn - Function to render content
+     * @returns {Accordion}
+     */
+    Accordion.prototype.renderContent = function(renderFn) {
+        this.$description.renderContent = renderFn;
+        return this;
+    };
 
-        validateEventCallback(callback) {
-            if (typeof callback !== 'function') {
-                throw new NativeDocumentError('Event callback must be a function');
-            }
-        }
+    /**
+     * Builds the accordion component
+     * @private
+     */
+    Accordion.prototype.$build = function() {
+        // TODO: Implementation
+        // this.$description.items.forEach(item => {
+        //     item.onExpand(() => {
+        //         if (!this.$description.multiple) {
+        //             this.$description.items
+        //                 .filter(i => i !== item)
+        //                 .forEach(i => i.expanded(false));
+        //         }
+        //     });
+        // });
     };
 
     const BOOLEAN_ATTRIBUTES = new Set([
@@ -1102,7 +1209,7 @@ var NativeComponents = (function (exports) {
                     }
                 }
                 if (cleanedCount > 0) {
-                    DebugManager$2.log('Memory Auto Clean', `🧹 Cleaned ${cleanedCount} orphaned observables`);
+                    DebugManager$1.log('Memory Auto Clean', `🧹 Cleaned ${cleanedCount} orphaned observables`);
                 }
             }
         };
@@ -3241,43 +3348,6 @@ var NativeComponents = (function (exports) {
         });
     };
 
-    function createMultiSourceFilter(sources, callbackFn){
-        const observables = sources.filter(Validator.isObservable);
-
-        const getValues = () => sources.map(src =>
-            Validator.isObservable(src) ? src.val() : src
-        );
-
-        return {
-            dependencies: observables.length > 0 ? observables : null,
-            callback: (value) => callbackFn(value, getValues())
-        };
-    }
-
-    function match(patternObservableOrValue, asRegexObservableOrValue = true, flagsObservableOrValue = ''){
-        return createMultiSourceFilter(
-            [patternObservableOrValue, asRegexObservableOrValue, flagsObservableOrValue],
-            (value, [pattern, asRegex, flags]) => {
-                if (!pattern) return true;
-
-                if (asRegex){
-                    try {
-                        const regex = new RegExp(pattern, flags);
-                        return regex.test(String(value));
-                    } catch (error){
-                        console.warn('Invalid regex pattern:', pattern, error);
-                        return false;
-                    }
-                }
-
-                if (!flags || flags === ''){
-                    return String(value).toLowerCase().includes(String(pattern).toLowerCase());
-                }
-                return String(value).includes(String(pattern));
-            }
-        );
-    }
-
     const mutationMethods = ['push', 'pop', 'shift', 'unshift', 'reverse', 'sort', 'splice'];
     const noMutationMethods = ['map', 'forEach', 'filter', 'reduce', 'some', 'every', 'find', 'findIndex', 'concat', 'includes', 'indexOf'];
 
@@ -3958,7 +4028,7 @@ var NativeComponents = (function (exports) {
         const $getStoreOrThrow = (method, name) => {
             const item = $stores.get(name);
             if (!item) {
-                DebugManager$2.error('Store', `Store.${method}('${name}') : store not found. Did you call Store.create('${name}') first?`);
+                DebugManager$1.error('Store', `Store.${method}('${name}') : store not found. Did you call Store.create('${name}') first?`);
                 throw new NativeDocumentError(
                     `Store.${method}('${name}') : store not found.`
                 );
@@ -3971,7 +4041,7 @@ var NativeComponents = (function (exports) {
          */
         const $applyReadOnly = (observer, name, context) => {
             const readOnlyError = (method) => () => {
-                DebugManager$2.error('Store', `Store.${context}('${name}') is read-only. '${method}()' is not allowed.`);
+                DebugManager$1.error('Store', `Store.${context}('${name}') is read-only. '${method}()' is not allowed.`);
                 throw new NativeDocumentError(
                     `Store.${context}('${name}') is read-only.`
                 );
@@ -4002,7 +4072,7 @@ var NativeComponents = (function (exports) {
              */
             create(name, value) {
                 if ($stores.has(name)) {
-                    DebugManager$2.warn('Store', `Store.create('${name}') : a store with this name already exists. Use Store.get('${name}') to retrieve it.`);
+                    DebugManager$1.warn('Store', `Store.create('${name}') : a store with this name already exists. Use Store.get('${name}') to retrieve it.`);
                     throw new NativeDocumentError(
                         `Store.create('${name}') : a store with this name already exists.`
                     );
@@ -4023,7 +4093,7 @@ var NativeComponents = (function (exports) {
              */
             createResettable(name, value) {
                 if ($stores.has(name)) {
-                    DebugManager$2.warn('Store', `Store.createResettable('${name}') : a store with this name already exists.`);
+                    DebugManager$1.warn('Store', `Store.createResettable('${name}') : a store with this name already exists.`);
                     throw new NativeDocumentError(
                         `Store.createResettable('${name}') : a store with this name already exists.`
                     );
@@ -4059,7 +4129,7 @@ var NativeComponents = (function (exports) {
              */
             createComposed(name, computation, dependencies) {
                 if ($stores.has(name)) {
-                    DebugManager$2.warn('Store', `Store.createComposed('${name}') : a store with this name already exists.`);
+                    DebugManager$1.warn('Store', `Store.createComposed('${name}') : a store with this name already exists.`);
                     throw new NativeDocumentError(
                         `Store.createComposed('${name}') : a store with this name already exists.`
                     );
@@ -4082,7 +4152,7 @@ var NativeComponents = (function (exports) {
                     }
                     const depItem = $stores.get(depName);
                     if (!depItem) {
-                        DebugManager$2.error('Store', `Store.createComposed('${name}') : dependency '${depName}' not found. Create it first.`);
+                        DebugManager$1.error('Store', `Store.createComposed('${name}') : dependency '${depName}' not found. Create it first.`);
                         throw new NativeDocumentError(
                             `Store.createComposed('${name}') : dependency store '${depName}' not found.`
                         );
@@ -4116,13 +4186,13 @@ var NativeComponents = (function (exports) {
             reset(name) {
                 const item = $getStoreOrThrow('reset', name);
                 if (item.composed) {
-                    DebugManager$2.error('Store', `Store.reset('${name}') : composed stores cannot be reset. Their value is derived from dependencies.`);
+                    DebugManager$1.error('Store', `Store.reset('${name}') : composed stores cannot be reset. Their value is derived from dependencies.`);
                     throw new NativeDocumentError(
                         `Store.reset('${name}') : composed stores cannot be reset.`
                     );
                 }
                 if (!item.resettable) {
-                    DebugManager$2.error('Store', `Store.reset('${name}') : this store is not resettable. Use Store.createResettable('${name}', value) instead of Store.create().`);
+                    DebugManager$1.error('Store', `Store.reset('${name}') : this store is not resettable. Use Store.createResettable('${name}', value) instead of Store.create().`);
                     throw new NativeDocumentError(
                         `Store.reset('${name}') : this store is not resettable. Use Store.createResettable('${name}', value) instead of Store.create().`
                     );
@@ -4143,7 +4213,7 @@ var NativeComponents = (function (exports) {
                 const item = $getStoreOrThrow('use', name);
 
                 if (item.composed) {
-                    DebugManager$2.error('Store', `Store.use('${name}') : composed stores are read-only. Use Store.follow('${name}') instead.`);
+                    DebugManager$1.error('Store', `Store.use('${name}') : composed stores are read-only. Use Store.follow('${name}') instead.`);
                     throw new NativeDocumentError(
                         `Store.use('${name}') : composed stores are read-only. Use Store.follow('${name}') instead.`
                     );
@@ -4210,7 +4280,7 @@ var NativeComponents = (function (exports) {
             get(name) {
                 const item = $stores.get(name);
                 if (!item) {
-                    DebugManager$2.warn('Store', `Store.get('${name}') : store not found.`);
+                    DebugManager$1.warn('Store', `Store.get('${name}') : store not found.`);
                     return null;
                 }
                 return item.observer;
@@ -4232,7 +4302,7 @@ var NativeComponents = (function (exports) {
             delete(name) {
                 const item = $stores.get(name);
                 if (!item) {
-                    DebugManager$2.warn('Store', `Store.delete('${name}') : store not found, nothing to delete.`);
+                    DebugManager$1.warn('Store', `Store.delete('${name}') : store not found, nothing to delete.`);
                     return;
                 }
                 item.subscribers.forEach(follower => follower.destroy());
@@ -4334,7 +4404,7 @@ var NativeComponents = (function (exports) {
                 return undefined;
             },
             set(target, prop, value) {
-                DebugManager$2.error('Store', `Forbidden: You cannot overwrite the store key '${String(prop)}'. Use .use('${String(prop)}').set(value) instead.`);
+                DebugManager$1.error('Store', `Forbidden: You cannot overwrite the store key '${String(prop)}'. Use .use('${String(prop)}').set(value) instead.`);
                 throw new NativeDocumentError(`Store structure is immutable. Use .set() on the observable.`);
             },
             deleteProperty(target, prop) {
@@ -5524,7 +5594,7 @@ var NativeComponents = (function (exports) {
 
     Badge.preset = function(name, callback) {
         if (Badge.prototype[name] || Badge[name]) {
-            DebugManager$2.warn(`Warning: the ${name} method already exists in Badge.`);
+            DebugManager$1.warn(`Warning: the ${name} method already exists in Badge.`);
             return;
         }
         Badge[name] = (content, props) => callback(new Badge(content, props));
@@ -6293,7 +6363,7 @@ var NativeComponents = (function (exports) {
 
     Divider.preset = function(name, callback) {
         if (Divider.prototype[name] || Divider[name]) {
-            DebugManager$2.warn(`Warning: the ${name} method already exists in Divider.`);
+            DebugManager$1.warn(`Warning: the ${name} method already exists in Divider.`);
             return;
         }
         Divider[name] = (label, props) => callback(new Divider(label, props));
@@ -10281,7 +10351,7 @@ var NativeComponents = (function (exports) {
 
     Progress.preset = function(name, callback) {
         if (Progress.prototype[name] || Progress[name]) {
-            DebugManager$2.warn(`Warning: the ${name} method already exists in Progress.`);
+            DebugManager$1.warn(`Warning: the ${name} method already exists in Progress.`);
             return;
         }
         Progress[name] = (props) => callback(new Progress(props));
@@ -10513,7 +10583,7 @@ var NativeComponents = (function (exports) {
 
     Skeleton.preset = function(name, callback) {
         if (Skeleton.prototype[name] || Skeleton[name]) {
-            DebugManager$2.warn(`Warning: the ${name} method already exists in Skeleton.`);
+            DebugManager$1.warn(`Warning: the ${name} method already exists in Skeleton.`);
             return;
         }
         Skeleton[name] = (props) => callback(new Skeleton(props));
@@ -10829,7 +10899,7 @@ var NativeComponents = (function (exports) {
 
     Spinner.preset = function(name, callback) {
         if (Spinner.prototype[name] || Spinner[name]) {
-            DebugManager$2.warn(`Warning: the ${name} method already exists in Spinner.`);
+            DebugManager$1.warn(`Warning: the ${name} method already exists in Spinner.`);
             return;
         }
         Spinner[name] = (props) => callback(new Spinner(props));
@@ -12427,7 +12497,7 @@ var NativeComponents = (function (exports) {
 
     VStack.preset = function(name, callback) {
         if (VStack.prototype[name] || VStack[name]) {
-            DebugManager$2.warn(`Warning: the ${name} method already exists in VStack.`);
+            DebugManager$1.warn(`Warning: the ${name} method already exists in VStack.`);
             return;
         }
         VStack[name] = (content, props) => callback(new VStack(content, props));
@@ -12461,7 +12531,7 @@ var NativeComponents = (function (exports) {
 
     ZStack.preset = function(name, callback) {
         if (ZStack.prototype[name] || ZStack[name]) {
-            DebugManager$2.warn(`Warning: the ${name} method already exists in ZStack.`);
+            DebugManager$1.warn(`Warning: the ${name} method already exists in ZStack.`);
             return;
         }
         ZStack[name] = (content, props) => callback(new ZStack(content, props));
@@ -12496,7 +12566,7 @@ var NativeComponents = (function (exports) {
 
     HStack.preset = function(name, callback) {
         if (HStack.prototype[name] || HStack[name]) {
-            DebugManager$2.warn(`Warning: the ${name} method already exists in HStack.`);
+            DebugManager$1.warn(`Warning: the ${name} method already exists in HStack.`);
             return;
         }
         HStack[name] = (content, props) => callback(new HStack(content, props));