{"version":3,"sources":["jsdelivr-header.js","/npm/lemonadejs@5.3.2/dist/lemonade.js"],"names":[],"mappings":"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","file":"/npm/lemonadejs@5.3.2/dist/lemonade.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/lemonadejs@5.3.2/dist/lemonade.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/**\r\n * LemonadeJS v5\r\n *\r\n * Website: https://lemonadejs.com\r\n * Description: Create amazing web based reusable components.\r\n *\r\n * This software is distributed under MIT License\r\n * @Roadmap\r\n * Accept interpolated values on properties `<div test=\"test: ${state}\"></div>\r\n */\r\n\r\n;(function (global, factory) {\r\n    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\r\n    typeof define === 'function' && define.amd ? define(factory) :\r\n    global.lemonade = factory();\r\n}(this, (function () {\r\n\r\n    'use strict';\r\n\r\n    /**\r\n     * Global control element\r\n     */\r\n    let R = {\r\n        queue: [],\r\n        container: {},\r\n        tracking: new Map,\r\n        components: {},\r\n        version: 5,\r\n    };\r\n\r\n    // Global LemonadeJS controllers\r\n    if (typeof(document) !== \"undefined\") {\r\n        if (! document.lemonadejs) {\r\n            document.lemonadejs = R;\r\n        } else {\r\n            R = document.lemonadejs;\r\n        }\r\n    }\r\n\r\n    // Get any conflict of versions\r\n    if (! R.version) {\r\n        console.error('This project seems to be using version 4 and version 5 causing a conflict of versions.');\r\n    }\r\n\r\n    // Script expression inside LemonadeJS templates\r\n    let isScript = /{{(.*?)}}/g;\r\n\r\n    /**\r\n     * Apply value in a object based on the address\r\n     */\r\n    const Path = function(str, val, remove) {\r\n        str = str.split('.');\r\n        if (str.length) {\r\n            let o = this;\r\n            let p = null;\r\n            while (str.length > 1) {\r\n                // Get the property\r\n                p = str.shift();\r\n                // Check if the property exists\r\n                if (o.hasOwnProperty(p)) {\r\n                    o = o[p];\r\n                } else {\r\n                    // Property does not exist\r\n                    if (typeof(val) === 'undefined') {\r\n                        return undefined;\r\n                    } else {\r\n                        // Create the property\r\n                        o[p] = {};\r\n                        // Next property\r\n                        o = o[p];\r\n                    }\r\n                }\r\n            }\r\n            // Get the property\r\n            p = str.shift();\r\n            // Set or get the value\r\n            if (typeof(val) !== 'undefined') {\r\n                if (remove === true) {\r\n                    delete o[p];\r\n                } else {\r\n                    o[p] = val;\r\n                }\r\n                // Success\r\n                return true;\r\n            } else {\r\n                // Return the value\r\n                if (o) {\r\n                    return o[p];\r\n                }\r\n            }\r\n        }\r\n        // Something went wrong\r\n        return false;\r\n    }\r\n\r\n    /**\r\n     * Show a better error developers\r\n     */\r\n    const createError = function() {\r\n        throw new Error('LemonadeJS ' + Array.from(arguments).join(' '));\r\n    }\r\n\r\n    /**\r\n     * Reference token is a string that define a token and not an expression\r\n     * @param {string} token\r\n     * @param {boolean?} topLevelOnly\r\n     * @returns {boolean}\r\n     */\r\n    function isReferenceToken(token, topLevelOnly) {\r\n        if (topLevelOnly) {\r\n            return /^(this|self)(\\.\\w+)$/gm.test(token);\r\n        } else {\r\n            return /^(this|self)(\\.\\w+|\\[\\d+])*$/gm.test(token);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Extract all valid tokens from a string\r\n     * @param {string} content\r\n     * @returns {string[]}\r\n     */\r\n    function extractTokens(content) {\r\n        // Input validation\r\n        if (typeof content !== 'string') {\r\n            throw new TypeError('Content must be a string');\r\n        }\r\n        // Single regex pattern to match both 'self.' and 'this.' prefixed identifiers Negative lookahead (?!\\.\\w) prevents matching nested properties\r\n        //const pattern =  /(?:self|this)\\.\\w+\\b(?!\\.\\w)/g;\r\n        const pattern = /(?<=(?:this|self)\\.)[a-zA-Z_]\\w*/gm\r\n\r\n        // If no matches found, return empty array early\r\n        const matches = content.match(pattern);\r\n        if (!matches) {\r\n            return [];\r\n        }\r\n        // Create Set directly from matches array with map transform This is more efficient than adding items one by one\r\n        return [...new Set(matches.map(match => match.slice(match.indexOf('.') + 1)))];\r\n    }\r\n\r\n    /**\r\n     * Bind a property to one action and start tracking\r\n     * @param {object} lemon\r\n     * @param {string} prop\r\n     */\r\n    const trackProperty = function(lemon, prop) {\r\n        // Lemon handler\r\n        let s = lemon.self;\r\n        if (typeof(s) === 'object') {\r\n            // Change\r\n            let change = lemon.change;\r\n            // Events\r\n            let events = lemon.events[prop];\r\n            // Current value\r\n            let value = s[prop];\r\n            // Do not allow undefined\r\n            if (typeof(value) === 'undefined') {\r\n                value = '';\r\n            }\r\n            // Create the observer\r\n            Object.defineProperty(s, prop, {\r\n                set: function(v) {\r\n                    // Old value\r\n                    let oldValue = value;\r\n                    // New value\r\n                    value = v;\r\n                    // Dispatch reactions\r\n                    if (events) {\r\n                        events.forEach((action) => {\r\n                            action();\r\n                        });\r\n                    }\r\n                    // Refresh bound elements\r\n                    if (change && change.length) {\r\n                        change.forEach((action) => {\r\n                            if (typeof (action) === 'function') {\r\n                                action.call(s, prop, oldValue, v);\r\n                            }\r\n                        })\r\n                    }\r\n                },\r\n                get: function () {\r\n                    // Get value\r\n                    return value;\r\n                },\r\n                configurable: true,\r\n                enumerable: true,\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Check if an element is appended to the DOM or a shadowRoot\r\n     * @param {HTMLElement} node\r\n     * @return {boolean}\r\n     */\r\n    const isAppended = function(node) {\r\n        while (node) {\r\n            if (node === document.body) {\r\n                return true; // Node is in main document\r\n            }\r\n\r\n            if (node.parentNode === null) {\r\n                if (node.host) {\r\n                    node = node.host; // Traverse up through ShadowRoot\r\n                } else {\r\n                    return false; // Detached node\r\n                }\r\n            } else {\r\n                node = node.parentNode; // Traverse up through parentNode\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n    const elementNotReady = new Set;\r\n\r\n    /**\r\n     * Execute all pending events from onload\r\n     * @param lemon\r\n     */\r\n    const executeOnload = function(lemon) {\r\n        let s = lemon.self;\r\n        // Ready event\r\n        while (lemon.ready.length) {\r\n            lemon.ready.shift()();\r\n        }\r\n        // Native onload\r\n        if (typeof(s.onload) === 'function') {\r\n            s.onload.call(s, s.el);\r\n        }\r\n        // Current self\r\n        if (typeof(lemon.load) === 'function') {\r\n            lemon.load.call(s, s.el);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Process the onload methods\r\n     */\r\n    const processOnload = function(lemon) {\r\n        let root = lemon.tree.element;\r\n        if (root.tagName === 'ROOT' && lemon.elements) {\r\n            root = lemon.elements[0];\r\n        }\r\n        // Add to the queue\r\n        elementNotReady.add(lemon);\r\n        // Check if the element is appended to the DOM\r\n        if (isAppended(root)) {\r\n            elementNotReady.forEach((item) => {\r\n                // Remove from the list\r\n                elementNotReady.delete(item);\r\n                // Run onload and ready events\r\n                executeOnload(item);\r\n            })\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Return the element based on the type\r\n     * @param item\r\n     * @returns {*}\r\n     */\r\n    const getElement = function(item) {\r\n        return typeof(item.type) === 'function' ? item.self : item.element;\r\n    }\r\n\r\n    const HTMLParser = function(html, values) {\r\n        /**\r\n         * process the scape chars\r\n         * @param char\r\n         * @returns {*|string}\r\n         */\r\n        function escape(char) {\r\n            const escapeMap = {\r\n                'n': String.fromCharCode(0x0A),\r\n                'r': String.fromCharCode(0x0D),\r\n                't': String.fromCharCode(0x09),\r\n                'b': String.fromCharCode(0x08),\r\n                'f': String.fromCharCode(0x0C),\r\n                'v': String.fromCharCode(0x0B),\r\n                '0': String.fromCharCode(0x00)\r\n            };\r\n\r\n            return escapeMap[char] || char;\r\n        }\r\n\r\n        /**\r\n         * Check if is a self-closing tag\r\n         * @param {string|function} type - Tag name or component function\r\n         * @returns {boolean}\r\n         */\r\n        function isSelfClosing(type) {\r\n            if (! type) {\r\n                return false;\r\n            } else {\r\n                // List of self-closing or void HTML elements\r\n                const selfClosingTags = [\r\n                    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr'\r\n                ];\r\n                // Convert tagName to lowercase to ensure case-insensitive comparison\r\n                return typeof(type) === 'function' || selfClosingTags.includes(type.toLowerCase());\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Create a text node and add it to current node's children\r\n         * @param {Object} tag - Text node properties\r\n         */\r\n        const createTextNode = function(tag) {\r\n            if (! this.current.children) {\r\n                this.current.children = [];\r\n            }\r\n\r\n            this.current.children.push({\r\n                type: '#text',\r\n                parent: this.current,\r\n                props: [tag],\r\n            });\r\n        }\r\n\r\n        /**\r\n         * Find the parent node by tag name\r\n         * @param {Object} node - Current node\r\n         * @param {string} type - Tag name to find\r\n         * @returns {Object|undefined}\r\n         */\r\n        const findParentByTagName = function(node, type) {\r\n            if (node && type) {\r\n                if (node.type === type) {\r\n                    return node;\r\n                } else {\r\n                    return findParentByTagName(node.parent, type);\r\n                }\r\n            }\r\n\r\n            return undefined;\r\n        }\r\n\r\n        /**\r\n         * Get expression value and update tag metadata\r\n         * @param {Object} tag - Tag to update\r\n         * @returns {*} Expression value\r\n         */\r\n        const getExpression = function(tag) {\r\n            // Get value\r\n            const v = values && values[this.index] !== undefined ? values[this.index] : '';\r\n            if (tag) {\r\n                // Keep the reference\r\n                tag.expression = this.reference;\r\n                // Keep the index\r\n                tag.index = this.index;\r\n            }\r\n            // Move the value index\r\n            this.index++;\r\n            // Delete reference\r\n            delete this.reference;\r\n            // Return value\r\n            return v;\r\n        }\r\n\r\n        /**\r\n         * Handle the text node creation\r\n         */\r\n        const commitText = function() {\r\n            if (typeof(this.text) !== 'undefined') {\r\n                const text = this.text.replace(/\\r?\\n\\s+/g, '');\r\n                if (text) {\r\n                    createTextNode.call(this, { name: 'textContent', value: text });\r\n                }\r\n                delete this.text;\r\n            }\r\n        }\r\n\r\n        const commitComments = function() {\r\n            if (typeof(this.comments) !== 'undefined') {\r\n                let comments = this.comments;\r\n                if (comments) {\r\n                    comments = comments\r\n                        .replace('<!--', '')\r\n                        .replace('-->', '')\r\n\r\n                    if (! this.current.children) {\r\n                        this.current.children = [];\r\n                    }\r\n\r\n                    this.current.children.push({\r\n                        type: '#comments',\r\n                        parent: this.current,\r\n                        props: [{ name: 'text', value: comments }],\r\n                    });\r\n                }\r\n                delete this.comments;\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Save the attribute to the tag\r\n         */\r\n        const commitAttribute = function() {\r\n            if (this.tag.attributeName) {\r\n                // Commit any current attribute\r\n                if (! this.tag.props) {\r\n                    this.tag.props = [];\r\n                }\r\n\r\n                let k = this.tag.attributeName;\r\n                let v = this.tag.attributeValue;\r\n\r\n                if (typeof(v) === 'undefined') {\r\n                    v = k;\r\n                }\r\n\r\n                let tag = {\r\n                    name: k,\r\n                    value: v,\r\n                };\r\n\r\n                if (typeof(this.tag.expression) !== 'undefined') {\r\n                    tag.index = this.tag.index;\r\n                    tag.expression = this.tag.expression;\r\n                }\r\n\r\n                this.tag.props.push(tag);\r\n\r\n                // Clean up temporary properties\r\n                delete this.tag.attributeName;\r\n                delete this.tag.attributeValue;\r\n                delete this.tag.index;\r\n                delete this.tag.expression;\r\n\r\n                if (this.tag.attributeIsReadyToClose) {\r\n                    delete this.tag.attributeIsReadyToClose;\r\n                }\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Actions controller\r\n         * @param {Object} control - Parser control object\r\n         * @param {string} char - Current character\r\n         */\r\n        const actions = function(control, char) {\r\n            const method = control.action || 'text';\r\n            if (typeof actions[method] === 'function') {\r\n                actions[method].call(control, char);\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Extract content between expression markers, handling quoted content\r\n         * @param {string} html - Full HTML string\r\n         * @param {number} startIndex - Starting index (position after ${})\r\n         * @returns {Object} Expression content and ending position\r\n         */\r\n        function extractExpressionContent(html, startIndex) {\r\n            let text = '';\r\n            let i = startIndex;\r\n            let insideQuotes = null;\r\n\r\n            while (i < html.length) {\r\n                const char = html[i];\r\n\r\n                // Handle quotes\r\n                if ((char === '\"' || char === \"'\" || char === '`')) {\r\n                    if (!insideQuotes) {\r\n                        insideQuotes = char;\r\n                    } else if (char === insideQuotes) {\r\n                        insideQuotes = null;\r\n                    }\r\n                }\r\n\r\n                // Found closing brace outside quotes\r\n                if (char === '}' && !insideQuotes) {\r\n                    return {\r\n                        content: text,\r\n                        position: i\r\n                    };\r\n                }\r\n\r\n                text += char;\r\n                i++;\r\n            }\r\n\r\n            return {\r\n                content: text,\r\n                position: i\r\n            };\r\n        }\r\n\r\n        /**\r\n         * Process a new tag\r\n         * @param char\r\n         */\r\n        actions.processTag = function(char) {\r\n            // Just to check if there are any text to commit\r\n            commitText.call(this);\r\n\r\n            // Process the tag\r\n            if (char === '<') {\r\n                // Create new tag\r\n                this.tag = {\r\n                    type: '',\r\n                    parent: this.current\r\n                };\r\n            } else if (char.match(/[a-zA-Z0-9-]/)) {\r\n                // Tag name\r\n                this.tag.type += char;\r\n            } else {\r\n                if (char === '$' && this.reference) {\r\n                    // Custom tags\r\n                    this.tag.type = getExpression.call(this);\r\n                }\r\n                // Finished with tag name, move to attribute handling\r\n                this.action = 'attributeName';\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Handle tag closing\r\n         * @param char\r\n         */\r\n        actions.closeTag = function(char) {\r\n            // Make sure to commit attribute\r\n            commitAttribute.call(this);\r\n            // Close the tag\r\n            if (char === '>') {\r\n                // Get the new parent\r\n                if (isSelfClosing(this.tag.type)) {\r\n                    // Push new tag to the parent\r\n                    if (! this.tag.parent.children) {\r\n                        this.tag.parent.children = [];\r\n                    }\r\n                    this.tag.parent.children.push(this.tag);\r\n                } else if (this.tag.closingTag) {\r\n                    // Need to find the parent on the chain\r\n                    const parentNode = findParentByTagName(this.tag.parent, this.tag.type);\r\n                    if (parentNode) {\r\n                        this.current = parentNode.parent;\r\n                    }\r\n                } else {\r\n                    if (this.tag.closing) {\r\n                        // Current is the parent\r\n                        this.current = this.tag.parent;\r\n                    } else {\r\n                        this.current = this.tag;\r\n                    }\r\n\r\n                    // Push new tag to the parent\r\n                    if (! this.tag.parent.children) {\r\n                        this.tag.parent.children = [];\r\n                    }\r\n                    this.tag.parent.children.push(this.tag);\r\n                }\r\n\r\n                // Remote temporary properties\r\n                delete this.tag.insideQuote;\r\n                delete this.tag.closingTag;\r\n                delete this.tag.closing;\r\n                // Finalize tag\r\n                this.tag = null;\r\n                // New action\r\n                this.action = 'text';\r\n            } else if (! this.tag.locked) {\r\n                if (char === '/') {\r\n                    if (! this.tag.type) {\r\n                        // This is a closing tag\r\n                        this.tag.closingTag = true;\r\n                    }\r\n                    // Closing character is found\r\n                    this.tag.closing = true;\r\n                } else if (char.match(/[a-zA-Z0-9-]/)) {\r\n                    // If is a closing tag, get the tag name\r\n                    if (this.tag.closingTag) {\r\n                        this.tag.type += char;\r\n                    }\r\n                } else {\r\n                    // Wait to the closing sign\r\n                    if (this.tag.type) {\r\n                        this.locked = true;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        actions.attributeName = function(char) {\r\n            // There is another attribute to commit\r\n            if (this.tag.attributeIsReadyToClose) {\r\n                commitAttribute.call(this);\r\n            }\r\n\r\n            // Build attribute name\r\n            if (char.match(/[a-zA-Z0-9-:]/)) {\r\n                if (! this.tag.attributeName) {\r\n                    this.tag.attributeName = '';\r\n                }\r\n                this.tag.attributeName += char;\r\n            } else if (char === '=') {\r\n                // Move to attribute value\r\n                if (this.tag.attributeName) {\r\n                    this.action = 'attributeValue';\r\n                    delete this.tag.attributeIsReadyToClose;\r\n                }\r\n            } else if (char.match(/\\s/)) {\r\n                if (this.tag.attributeName) {\r\n                    this.tag.attributeIsReadyToClose = true;\r\n                }\r\n            }\r\n        };\r\n\r\n        actions.attributeValue = function(char) {\r\n            if (! this.tag.attributeValue) {\r\n                this.tag.attributeValue = '';\r\n            }\r\n\r\n            if (char === '\"' || char === \"'\") {\r\n                if (this.tag.insideQuote) {\r\n                    if (this.tag.insideQuote === char) {\r\n                        this.tag.insideQuote = false;\r\n                    } else {\r\n                        this.tag.attributeValue += char;\r\n                    }\r\n                } else {\r\n                    this.tag.insideQuote = char;\r\n                }\r\n            } else {\r\n                if (char === '$' && this.reference) {\r\n                    // Custom tags\r\n                    char = getExpression.call(this, this.tag);\r\n                }\r\n                // Inside quotes, keep appending to the attribute value\r\n                if (this.tag.insideQuote) {\r\n                    if (this.tag.attributeValue) {\r\n                        this.tag.attributeValue += char;\r\n                    } else {\r\n                        this.tag.attributeValue = char;\r\n                    }\r\n                } else if (typeof(char) === 'string' && char.match(/\\s/)) {\r\n                    if (this.tag.attributeValue) {\r\n                        this.action = 'attributeName';\r\n                    }\r\n                    this.tag.attributeIsReadyToClose = true;\r\n                } else {\r\n                    if (this.tag.attributeIsReadyToClose) {\r\n                        this.action = 'attributeName';\r\n                        actions.attributeName.call(this, char);\r\n                    } else {\r\n                        if (this.tag.attributeValue) {\r\n                            this.tag.attributeValue += char;\r\n                        } else {\r\n                            this.tag.attributeValue = char;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        actions.text = function(char) {\r\n            if (char === '$' && this.reference) {\r\n                // Just to check if there are any text to commit\r\n                commitText.call(this);\r\n                // Custom tags\r\n                let tag = { name: 'textContent' }\r\n                tag.value = getExpression.call(this, tag);\r\n                // Add node tag\r\n                createTextNode.call(this, tag);\r\n            } else {\r\n                if (referenceControl === 1) {\r\n                    // Just to check if there are any text to commit\r\n                    commitText.call(this);\r\n                }\r\n\r\n                // Normal text processing\r\n                if (! this.text) {\r\n                    this.text = '';\r\n                }\r\n                this.text += char; // Keep appending to text content\r\n\r\n                if (referenceControl === 2) {\r\n                    // Just to check if there are any text to commit\r\n                    commitText.call(this);\r\n                }\r\n            }\r\n        }\r\n\r\n        actions.comments = function(char) {\r\n            if (! this.comments) {\r\n                this.comments = '';\r\n            }\r\n            this.comments += char;\r\n\r\n            if (this.comments.endsWith('-->')) {\r\n                commitComments.call(this);\r\n                this.action = 'text';\r\n            }\r\n        }\r\n\r\n        // Control the LemonadeJS native references\r\n        let referenceControl = null;\r\n\r\n        const result = { type: 'template' };\r\n        const control = {\r\n            current: result,\r\n            action: 'text',\r\n            index: 0,\r\n        };\r\n\r\n        // Input validation\r\n        if (typeof html !== 'string') {\r\n            throw new TypeError('HTML input must be a string');\r\n        }\r\n\r\n        // Main loop to process the HTML string\r\n        for (let i = 0; i < html.length; i++) {\r\n            // Current char\r\n            let char = html[i];\r\n\r\n            if (control.action === 'text' && char === '<' && html[i+1] === '!' && html[i+2] === '-' && html[i+3] === '-') {\r\n                control.action = 'comments';\r\n            }\r\n\r\n            if (control.action !== 'comments') {\r\n                let escaped = false;\r\n\r\n                if (values !== null) {\r\n                    // Handle scape\r\n                    if (char === '\\\\') {\r\n                        // This is a escaped char\r\n                        escaped = true;\r\n                        // Parse escape char\r\n                        char = escape(html[i+1]);\r\n                        // Move to the next char\r\n                        i++;\r\n                    }\r\n                }\r\n\r\n                // Global control logic\r\n                if (control.tag) {\r\n                    if (char === '>' || char === '/') {\r\n                        // End of tag, commit any attributes and go back to text parsing\r\n                        if (!control.tag.insideQuote) {\r\n                            control.action = 'closeTag';\r\n                        }\r\n                    }\r\n                } else {\r\n                    if (char === '<') {\r\n                        control.action = 'processTag';\r\n                    }\r\n                }\r\n\r\n                // Register references for a dynamic template\r\n                if (!escaped && char === '$' && html[i + 1] === '{') {\r\n                    const result = extractExpressionContent(html, i + 2);\r\n                    control.reference = result.content;\r\n                    i = result.position;\r\n                }\r\n\r\n                // Control node references\r\n                if (char === '{' && html[i + 1] === '{') {\r\n                    referenceControl = 1;\r\n                } else if (char === '}' && html[i - 1] === '}') {\r\n                    referenceControl = 2;\r\n                }\r\n            }\r\n\r\n            // Execute action\r\n            actions(control, char);\r\n\r\n            // Reference control\r\n            referenceControl = null;\r\n        }\r\n\r\n        // Handle any remaining text\r\n        commitText.call(control);\r\n\r\n        return result.children && result.children[0];\r\n    }\r\n\r\n    const generateHTML = function(lemon) {\r\n\r\n        const appendEvent = function(token, event, exec) {\r\n            if (! lemon.events[token]) {\r\n                lemon.events[token] = []\r\n            }\r\n            // Push the event\r\n            lemon.events[token].push(event);\r\n            // Execute\r\n            if (exec) {\r\n                event();\r\n            }\r\n        }\r\n\r\n        const createEventsFromExpression = function(expression, event, exec) {\r\n            // Get the tokens should be updated to populate this attribute\r\n            let tokens = extractTokens(expression);\r\n            if (tokens.length) {\r\n                // Process all the tokens\r\n                for (let i = 0; i < tokens.length; i++) {\r\n                    appendEvent(tokens[i], event);\r\n                }\r\n            }\r\n            // Execute method\r\n            if (exec) {\r\n                event();\r\n            }\r\n        }\r\n\r\n        const setDynamicValue = function(item, prop, attributeName) {\r\n            // Create a reference to the DOM element\r\n            let property = prop.expression || prop.value;\r\n\r\n            if (isReferenceToken(property)) {\r\n                // Event\r\n                let event = function() {\r\n                    // Reference\r\n                    let value = extractFromPath.call(lemon.self, property);\r\n                    // Update reference\r\n                    setAttribute(getElement(item), attributeName, value);\r\n                }\r\n                // Append event only for the top level properties in the self\r\n                if (isReferenceToken(property, true)) {\r\n                    let p = extractFromPath.call(lemon.self, property, true);\r\n                    if (p) {\r\n                        // Append event to the token change\r\n                        let token = p[1]\r\n                        // Append event\r\n                        appendEvent(token, event);\r\n                    }\r\n                }\r\n                // Execute the event in the first time\r\n                event();\r\n            } else {\r\n                setAttribute(getElement(item), attributeName, castProperty(prop.value));\r\n            }\r\n        }\r\n\r\n        const dynamicContent = function(text) {\r\n            try {\r\n                // Cast value\r\n                let cast = null;\r\n                // Replace the text\r\n                text = text.replace(isScript, function (a, b) {\r\n                    let s = lemon.self;\r\n                    // Try to find the property\r\n                    let result = extractFromPath.call(s, b);\r\n                    // Evaluation for legacy purposes\r\n                    if (typeof(result) === 'undefined') {\r\n                        // This is deprecated and will be dropped on LemonadeJS 6\r\n                        result = run.call(s, b);\r\n                        if (typeof (result) === 'undefined') {\r\n                            result = '';\r\n                        }\r\n                    } else if (result === null) {\r\n                        result = '';\r\n                    }\r\n                    // Parse correct type\r\n                    if (typeof(result) !== 'string' && a === text) {\r\n                        cast = result;\r\n                    }\r\n                    // Return\r\n                    return result;\r\n                });\r\n\r\n                if (cast !== null) {\r\n                    return cast;\r\n                }\r\n\r\n                return text;\r\n            } catch (e) {\r\n            }\r\n        }\r\n\r\n        const isHTML = function(str) {\r\n            return /<[^>]*>/.test(str);\r\n        }\r\n\r\n        const appendHTMLBeforeNode = function(item, value) {\r\n            // Remove previous elements\r\n            if (item.current) {\r\n                item.current.forEach(e => e?.remove());\r\n            }\r\n            item.current = [];\r\n            // Node container\r\n            let node = getElement(item);\r\n            // Append content\r\n            if (! isHTML(value)) {\r\n                node.textContent = value;\r\n            } else {\r\n                // TODO: improve that\r\n                queueMicrotask(() => {\r\n                    // Create a temporary container\r\n                    const t = document.createElement('div');\r\n                    t.innerHTML = value;\r\n                    // Insert elements and store references\r\n                    while (t.firstChild) {\r\n                        item.current.push(t.firstChild);\r\n                        node.parentNode.insertBefore(t.firstChild, node);\r\n                    }\r\n                });\r\n            }\r\n        }\r\n\r\n        const applyElementAttribute = function(item, prop) {\r\n            if (typeof(prop.expression) !== 'undefined') {\r\n                // Event to update the designed position\r\n                let event = function() {\r\n                    // Extra value from the template\r\n                    let value = lemon.view(parseTemplate)[prop.index];\r\n                    // Process the NODE\r\n                    if (item.type === '#text') {\r\n                        appendHTMLBeforeNode(item, value);\r\n                    } else {\r\n                        // Set attribute\r\n                        setAttribute(getElement(item), prop.name, value);\r\n                    }\r\n                }\r\n                // Bind event to any tokens change\r\n                createEventsFromExpression(prop.expression, event, true);\r\n                // Register event for state changes\r\n                lemon.events[prop.index] = event;\r\n            } else {\r\n                // Get the tokens should be updated to populate this attribute\r\n                let tokens = extractTokens(prop.value);\r\n                if (tokens.length) {\r\n                    // Dynamic\r\n                    createEventsFromExpression(prop.value, function() {\r\n                        // Dynamic text\r\n                        let value = dynamicContent(prop.value);\r\n                        // Get the dynamic value\r\n                        setAttribute(getElement(item), prop.name, value);\r\n                    }, true)\r\n                } else {\r\n                    let value = prop.value;\r\n                    if (value.match(isScript)) {\r\n                        value = dynamicContent(value);\r\n                    }\r\n\r\n                    setAttribute(getElement(item), prop.name, value, true);\r\n                }\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Create a LemonadeJS self bind\r\n         * @param item\r\n         * @param prop\r\n         */\r\n        const applyBindHandler = function(item, prop) {\r\n            // Create a reference to the DOM element\r\n            let property = prop.expression || prop.value;\r\n\r\n            if (isReferenceToken(property, true)) {\r\n                let prop = property.split('.')[1];\r\n\r\n                // Event from component to the property\r\n                let event = function () {\r\n                    let value = getAttribute(getElement(item), 'value');\r\n                    if (lemon.self[prop] !== value) {\r\n                        lemon.self[prop] = value;\r\n                    }\r\n                }\r\n\r\n                if (typeof (item.type) === 'function') {\r\n                    item.bind = event;\r\n                } else {\r\n                    item.element.addEventListener('input', event);\r\n                }\r\n\r\n                // Event property to the element\r\n                event = () => {\r\n                    let value = getAttribute(getElement(item), 'value');\r\n                    if (lemon.self[prop] !== value) {\r\n                        setAttribute(getElement(item), 'value', lemon.self[prop]);\r\n                    }\r\n                }\r\n                // Append event\r\n                appendEvent(prop, event, true);\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Create a LemonadeJS self render\r\n         * @param item\r\n         * @param prop\r\n         */\r\n        const applyRenderHandler = function(item, prop) {\r\n            // Create a reference to the DOM element\r\n            let property = prop.expression || prop.value;\r\n            let getValue = null;\r\n            let token = null;\r\n\r\n            if (isReferenceToken(property, true)) {\r\n                token = property.split('.')[1];\r\n                // Get value\r\n                getValue = () => {\r\n                    return lemon.self[token];\r\n                }\r\n            } else {\r\n                if (typeof(prop.expression) !== 'undefined') {\r\n                    getValue = () => {\r\n                        // Extra value from the template\r\n                        let data = lemon.view(parseTemplate)[prop.index];\r\n                        if (data instanceof state) {\r\n                            data = data.value;\r\n                        }\r\n                        return data;\r\n                    }\r\n                }\r\n            }\r\n\r\n            if (getValue) {\r\n                // Create container to keep the elements\r\n                item.container = [];\r\n\r\n                // Event property to the element\r\n                let event = () => {\r\n                    // Root element\r\n                    let root = typeof(item.type) === 'function' ? item.self.el : item.element;\r\n                    // Curren value\r\n                    let value = getValue();\r\n                    if (value) {\r\n                        item.container.forEach(e => {\r\n                            root.appendChild(e);\r\n                        });\r\n                    } else {\r\n                        while (root.firstChild) {\r\n                            item.container.push(root.firstChild);\r\n                            root.firstChild.remove();\r\n                        }\r\n                    }\r\n                }\r\n\r\n                if (token) {\r\n                    // Append event\r\n                    appendEvent(token, event);\r\n                } else {\r\n                    if (typeof(prop.expression) !== 'undefined') {\r\n                        lemon.events[prop.index] = event;\r\n                        createEventsFromExpression(prop.expression, event);\r\n                    }\r\n                }\r\n\r\n                // Execute event\r\n                let root = typeof(item.type) === 'function' ? item.self.el : item.element;\r\n                if (root) {\r\n                    event();\r\n                } else {\r\n                    lemon.ready.push(event);\r\n                }\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Create a dynamic reference\r\n         * @param item\r\n         * @param prop\r\n         */\r\n        const createReference = function(item, prop) {\r\n            let ref = getElement(item);\r\n            if (typeof(prop.value) === 'function') {\r\n                prop.value(ref);\r\n            } else {\r\n                // Create a reference to the DOM element\r\n                let property = prop.expression || prop.value;\r\n                // Reference\r\n                if (isReferenceToken(property)) {\r\n                    let p = extractFromPath.call(lemon.self, property, true);\r\n                    if (p) {\r\n                        lemon.self[p[1]] = ref;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        /**\r\n         * Process the :ready. Call when DOM is ready\r\n         * @param item\r\n         * @param prop\r\n         */\r\n        const whenIsReady = function(item, prop) {\r\n            let value = prop.value;\r\n            // If not a method, should be converted to a method\r\n            if (typeof(value) !== 'function') {\r\n                let t = extractFromPath.call(lemon.self, value);\r\n                if (t) {\r\n                    value = t;\r\n                }\r\n            }\r\n            // Must be a function\r\n            if (typeof(value) === 'function') {\r\n                lemon.ready.push(function() {\r\n                    value(getElement(item), lemon.self);\r\n                });\r\n            } else {\r\n                createError(`:ready ${value} is not a function`)\r\n            }\r\n        }\r\n\r\n        const getRoot = function(item) {\r\n            if (typeof(item.type) === 'function') {\r\n                if (item.parent.type === 'template') {\r\n                    return lemon.root;\r\n                } else {\r\n                    return item.parent.element;\r\n                }\r\n            }\r\n\r\n            return item.element;\r\n        }\r\n\r\n        const registerLoop = function(item, prop) {\r\n            // Create a reference to the DOM element\r\n            let property = prop.expression || prop.value;\r\n\r\n            // Append the template back to the correct position\r\n            if (lemon.self.settings?.loop) {\r\n                lemon.self.settings.loop(item)\r\n            }\r\n\r\n            // Event\r\n            let updateLoop = function(data) {\r\n                // Component\r\n                let method = typeof(item.type) === 'function' ? item.type : Basic;\r\n                // Remove all DOM\r\n                let root = getRoot(item);\r\n                if (root) {\r\n                    while (root.firstChild) {\r\n                        root.firstChild.remove();\r\n                    }\r\n                }\r\n                // Process the data\r\n                if (data && Array.isArray(data)) {\r\n                    // Process data\r\n                    data.forEach(function(self) {\r\n                        let el = self.el;\r\n                        if (el) {\r\n                            root.appendChild(el);\r\n                        } else {\r\n                            // Register parent\r\n                            register(self, 'parent', lemon.self);\r\n                            // Render\r\n                            L.render(method, root, self, item);\r\n                        }\r\n\r\n                        if (root?.getAttribute('unique') === 'false') {\r\n                            delete self.el;\r\n                        }\r\n                    })\r\n                }\r\n            }\r\n\r\n            // Event\r\n            let event;\r\n\r\n            // Type of property\r\n            if (isReferenceToken(property)) {\r\n                // Event\r\n                event = function() {\r\n                    // Reference\r\n                    let data = extractFromPath.call(lemon.self, property);\r\n                    // Update reference\r\n                    updateLoop(data);\r\n                }\r\n\r\n                // Append event only for the top level properties in the self\r\n                if (isReferenceToken(property, true)) {\r\n                    let p = extractFromPath.call(lemon.self, property, true);\r\n                    if (p) {\r\n                        // Append event to the token change\r\n                        appendEvent(p[1], event);\r\n                    }\r\n                }\r\n            } else {\r\n                if (typeof(prop.expression) !== 'undefined') {\r\n                    event = function() {\r\n                        // Extra value from the template\r\n                        let data = lemon.view(parseTemplate)[prop.index];\r\n                        if (data instanceof state) {\r\n                            data = data.value;\r\n                        }\r\n                        // Update the data\r\n                        updateLoop(data);\r\n                    }\r\n                    // Register event for state changes\r\n                    lemon.events[prop.index] = event;\r\n                }\r\n            }\r\n\r\n            // Defer event since the dom is not ready\r\n            if (event) {\r\n                if (getRoot(item)) {\r\n                    event();\r\n                } else {\r\n                    lemon.ready.push(event);\r\n                }\r\n            }\r\n        }\r\n\r\n        const isLoopAttribute = function(props) {\r\n            let test = false;\r\n            props.forEach(function(prop) {\r\n                if (prop.name === ':loop' || prop.name === 'lm-loop' || prop.name === '@loop') {\r\n                    test = true;\r\n                }\r\n            });\r\n            return test;\r\n        }\r\n\r\n        const registerPath = function(item, prop) {\r\n            if (! lemon.path.elements) {\r\n                lemon.path.elements = [];\r\n            }\r\n\r\n            let element = getElement(item);\r\n\r\n            lemon.path.elements.push({\r\n                element: element,\r\n                path: prop.value\r\n            });\r\n\r\n            // Event from component to the property\r\n            let event = function () {\r\n                // Get the current value of my HTML form element or component\r\n                let value = getAttribute(element, 'value');\r\n                // Apply the new value on the path on the object\r\n                if (lemon.path.value) {\r\n                    Path.call(lemon.path.value, prop.value, value);\r\n                    // Call the callback when exist\r\n                    if (typeof(lemon.path.change) === 'function') {\r\n                        lemon.path.change(value, prop.value, element);\r\n                    }\r\n                } else {\r\n                    console.log('Use setPath to define the form container before using lm-path');\r\n                }\r\n            }\r\n\r\n            if (typeof(item.type) === 'function') {\r\n                item.path = event;\r\n            } else {\r\n                item.element.addEventListener('input', event);\r\n            }\r\n        }\r\n\r\n        const appendChildren = function(container, children) {\r\n            if (container && children) {\r\n                for (let i = 0; i < children.length; i++) {\r\n                    let child = children[i];\r\n                    if (typeof(child) === 'string') {\r\n                        container.appendChild(document.createTextNode(child));\r\n                    } else if (child.element) {\r\n                        if (child.element.tagName === 'ROOT') {\r\n                            while (child.element.firstChild) {\r\n                                container.appendChild(child.element.firstChild);\r\n                            }\r\n                        } else {\r\n                            container.appendChild(child.element);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        const getAttributeName = function(prop) {\r\n            return prop[0] === ':' || prop[0] === '@' ? prop.substring(1) : prop.substring(3);\r\n        }\r\n\r\n        const getAttributeEvent = function(event) {\r\n            event = event.toLowerCase();\r\n            if (event.startsWith('on')) {\r\n                return event.toLowerCase();\r\n            } else if (event.startsWith(':on')) {\r\n                return getAttributeName(event);\r\n            }\r\n        }\r\n\r\n        /**\r\n         * CHeck if the event name is a valid DOM event name\r\n         * @param element\r\n         * @param eventName\r\n         * @returns {boolean}\r\n         */\r\n        const isValidEventName = function(element, eventName) {\r\n            const validEventPattern = /^on[a-z]+$/;\r\n            return validEventPattern.test(eventName);\r\n        }\r\n\r\n        /**\r\n         * Create element from the string tagname\r\n         * @param tagName\r\n         * @returns {*}\r\n         */\r\n        const createElementFromString = function(tagName) {\r\n            // List of SVG tags (you can expand this list if needed)\r\n            const svgTags = [\r\n                \"svg\", \"path\", \"circle\", \"rect\", \"line\", \"polygon\", \"polyline\", \"text\"\r\n            ];\r\n\r\n            if (svgTags.includes(tagName)) {\r\n                // For SVG elements, use createElementNS with the correct namespace\r\n                return document.createElementNS(\"http://www.w3.org/2000/svg\", tagName);\r\n            } else {\r\n                // For regular HTML elements, use createElement\r\n                return document.createElement(tagName);\r\n            }\r\n        }\r\n\r\n        const reorderProps = function(arr) {\r\n            // Define the desired order of names\r\n            const orderPriority = ['ref', 'bind', 'loop', 'ready'];\r\n\r\n            // Separate items into prioritized and non-prioritized\r\n            const prioritized = [];\r\n            const others = [];\r\n\r\n            // Sort items into respective arrays\r\n            arr.forEach(item => {\r\n                if (orderPriority.includes(item.name.substring(1)) || orderPriority.includes(item.name.substring(3))) {\r\n                    prioritized.push(item);\r\n                } else {\r\n                    others.push(item);\r\n                }\r\n            });\r\n\r\n            // Return combined array with prioritized items at the end\r\n            return [...others, ...prioritized];\r\n        }\r\n\r\n\r\n        const createElements = function(item) {\r\n            if (typeof(item) === 'object') {\r\n                // Create an element\r\n                if (item.type === '#comments') {\r\n                    item.element = document.createComment(item.props[0].value);\r\n                } else if (item.type === '#text') {\r\n                    // Text node\r\n                    item.element = document.createTextNode('');\r\n                    // Check for dynamic content\r\n                    applyElementAttribute(item, item.props[0]);\r\n                } else {\r\n                    // Apply attributes if they exist\r\n                    if (item.props && ! Array.isArray(item.props)) {\r\n                        let props = [];\r\n                        let keys = Object.keys(item.props);\r\n                        for (let i = 0; i < keys.length; i++) {\r\n                            props.push({ name: keys[i], value: item.props[keys[i]] });\r\n                        }\r\n                        item.props = props;\r\n                    } else if (! item.props) {\r\n                        item.props = [];\r\n                    }\r\n\r\n                    // This item is a parent for a loop\r\n                    if (isLoopAttribute(item.props)) {\r\n                        // Mark this item as a loop\r\n                        item.loop = true;\r\n                    }\r\n\r\n                    if (! item.type) {\r\n                        item.type = 'root';\r\n                    }\r\n\r\n                    if (typeof(item.type) === 'string') {\r\n                        if (item.type.match(/^[A-Z][a-zA-Z0-9\\-]*$/g)) {\r\n                            let controller = item.type.toUpperCase();\r\n                            if (typeof(R.components[controller]) === 'function') {\r\n                                item.type = R.components[controller];\r\n                            } else if (typeof (lemon.components[controller]) === 'function') {\r\n                                item.type = lemon.components[controller];\r\n                            } else {\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    if (typeof(item.type) === 'string') {\r\n                        item.element = createElementFromString(item.type);\r\n                    } else if (typeof(item.type) === 'function') {\r\n                        // Create instance without calling constructor\r\n                        if (isClass(item.type)) {\r\n                            item.self = new item.type;\r\n                        } else {\r\n                            item.self = {};\r\n                        }\r\n                    }\r\n\r\n                    // Create all children\r\n                    if (! item.loop) {\r\n                        if (item.children && Array.isArray(item.children)) {\r\n                            item.children.forEach(child => {\r\n                                createElements(child);\r\n                            });\r\n                        }\r\n                        if (item.element) {\r\n                            appendChildren(item.element, item.children);\r\n                        }\r\n                    }\r\n\r\n                    // Process attributes\r\n                    if (item.props.length) {\r\n                        // Reorder props\r\n                        item.props = reorderProps(item.props);\r\n                        // Order by priority\r\n                        item.props.forEach(function(prop) {\r\n                            // If the property is an event\r\n                            let event = getAttributeEvent(prop.name);\r\n                            // When event for a DOM\r\n                            if (event) {\r\n                                // Element\r\n                                let element = item.element;\r\n                                // Value\r\n                                let value = prop.value;\r\n                                if (value) {\r\n                                    let handler = null; // Reset handler for each iteration\r\n                                    if (typeof (value) === 'function') {\r\n                                        handler = value;\r\n                                    } else {\r\n                                        let t = extractFromPath.call(lemon.self, value);\r\n                                        if (t) {\r\n                                            if (typeof (t) === 'function') {\r\n                                                prop.value = handler = t;\r\n                                            }\r\n                                        }\r\n                                    }\r\n                                    // When the element is a DOM\r\n                                    if (isDOM(element)) {\r\n                                        // Create the event handler\r\n                                        let eventHandler;\r\n                                        // Bind event\r\n                                        if (typeof(handler) === 'function') {\r\n                                            eventHandler = function(e, a, b) {\r\n                                                return handler.call(element, e, lemon.self, a, b);\r\n                                            }\r\n                                        } else {\r\n                                            // Legacy compatibility. Inline scripting is non-Compliance with Content Security Policy (CSP).\r\n                                            eventHandler = function (e) {\r\n                                                return Function('e', 'self', value).call(element, e, lemon.self); // TODO, quebra tudo se mudar\r\n                                            }\r\n                                        }\r\n\r\n                                        if (isValidEventName(element, prop.name)) {\r\n                                            element.addEventListener(event.substring(2), eventHandler);\r\n                                        } else {\r\n                                            if (element.tagName?.includes('-')) {\r\n                                                element[event] = handler;\r\n                                            } else {\r\n                                                element[event] = eventHandler;\r\n                                            }\r\n                                        }\r\n                                    } else {\r\n                                        item.self[event] = handler || value;\r\n                                    }\r\n                                }\r\n                            } else if (prop.name.startsWith(':') || prop.name.startsWith('@') || prop.name.startsWith('lm-')) {\r\n                                // Special lemonade attribute name\r\n                                let attrName = getAttributeName(prop.name);\r\n                                // Special properties bound to the self\r\n                                if (attrName === 'ready') {\r\n                                    whenIsReady(item, prop);\r\n                                } else if (attrName === 'ref') {\r\n                                    createReference(item, prop);\r\n                                } else if (attrName === 'loop') {\r\n                                    registerLoop(item, prop);\r\n                                } else if (attrName === 'bind') {\r\n                                    applyBindHandler(item, prop);\r\n                                } else if (attrName === 'path') {\r\n                                    registerPath(item, prop);\r\n                                } else if (attrName === 'render') {\r\n                                    applyRenderHandler(item, prop);\r\n                                } else {\r\n                                    setDynamicValue(item, prop, attrName);\r\n                                }\r\n                            } else {\r\n                                applyElementAttribute(item, prop);\r\n                            }\r\n                        })\r\n                    }\r\n\r\n                    // Do not create elements at this state if this is a loop\r\n                    if (! item.loop) {\r\n                        if (typeof(item.type) === 'function') {\r\n                            // Execute component\r\n                            item.element = L.render(item.type, null, item.self, item);\r\n\r\n                            // Create all children\r\n                            if (item.children) {\r\n                                let root = item.element;\r\n                                if (typeof(item.self?.settings?.getRoot) === 'function') {\r\n                                    root = item.self.settings.getRoot();\r\n                                }\r\n                                appendChildren(root, item.children);\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        // Create DOM elements\r\n        createElements(lemon.tree);\r\n\r\n        return lemon.tree.element;\r\n    }\r\n\r\n    /**\r\n     * Extract a property from a nested object using a string address\r\n     * @param {string} str address inside the nested object\r\n     * @param {boolean} config get the configuration obj => property\r\n     */\r\n    const extractFromPath = function(str, config) {\r\n        try {\r\n            let t = str.toString().replace(/[\\[\\]]/g, '.').split('.');\r\n            if (t[0] === 'self' || t[0] === 'this') {\r\n                t.shift();\r\n            }\r\n            // Remove blanks\r\n            t = t.filter(item => item !== '');\r\n            // Object\r\n            let o = this;\r\n            let lastObject;\r\n            while (t.length) {\r\n                // Get the property\r\n                let p = t.shift();\r\n                // Process config\r\n                if (config) {\r\n                    if (typeof(o) === 'object' && ! Array.isArray(o)) {\r\n                        lastObject = [o,p];\r\n                    }\r\n                    if (t.length === 0) {\r\n                        return lastObject;\r\n                    }\r\n                }\r\n                // Check if the property exists\r\n                if (o.hasOwnProperty(p) || typeof(o[p]) !== 'undefined') {\r\n                    o = o[p];\r\n                } else {\r\n                    return undefined;\r\n                }\r\n            }\r\n\r\n            if (typeof(o) !== 'undefined') {\r\n                return o;\r\n            }\r\n        } catch (e) {}\r\n\r\n        // Something went wrong\r\n        return undefined;\r\n    }\r\n\r\n    /**\r\n     * Cast the value of an attribute\r\n     */\r\n    const castProperty = function(attr) {\r\n        // Parse type\r\n        try {\r\n            if (typeof(attr) === 'string' && attr) {\r\n                // Remove any white spaces\r\n                attr = attr.trim();\r\n                if (attr === 'true') {\r\n                    return true;\r\n                } else if (attr === 'false') {\r\n                    return false;\r\n                } else if (! isNaN(attr)) {\r\n                    return Number(attr);\r\n                } else {\r\n                    let firstChar = attr[0];\r\n                    if (firstChar === '{' || firstChar === '[') {\r\n                        if (attr.slice(-1) === '}' || attr.slice(-1) === ']') {\r\n                            return JSON.parse(attr);\r\n                        }\r\n                    } else if (attr.startsWith('self.') || attr.startsWith('this.')) {\r\n                        let v = extractFromPath.call(this, attr);\r\n                        if (typeof(v) !== 'undefined') {\r\n                            return v;\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        } catch (e) {}\r\n\r\n        return attr;\r\n    }\r\n\r\n    /**\r\n     * This allows to run inline script on LEGACY system. Inline script can lead to security issues so use carefully.\r\n     * @param {string} s string to function\r\n     */\r\n    const run = function(s) {\r\n        return Function('self', '\"use strict\";return (' + s + ')')(this);\r\n    }\r\n\r\n    /**\r\n     * Check if the content {o} is a valid DOM Element\r\n     * @param {HTMLElement|DocumentFragment|object} o - is this a valid dom?\r\n     * @return {boolean}\r\n     */\r\n    const isDOM = function(o) {\r\n        return (o instanceof HTMLElement || o instanceof Element || o instanceof DocumentFragment);\r\n    }\r\n\r\n    /**\r\n     * Check if the method is a method or a class\r\n     * @param {function} f\r\n     * @return {boolean}\r\n     */\r\n    const isClass = function(f) {\r\n        return typeof f === 'function' && /^class\\s/.test(Function.prototype.toString.call(f));\r\n    }\r\n\r\n    /**\r\n     * Basic handler\r\n     * @param {string|object} t - HTML template\r\n     * @return {string|object}\r\n     */\r\n    const Basic = function(t) {\r\n        return t;\r\n    }\r\n\r\n    /**\r\n     * Get the attribute helper\r\n     * @param {object} e Element\r\n     * @param {string} attribute\r\n     */\r\n    const getAttribute = function(e, attribute) {\r\n        let value;\r\n        if (attribute === 'value') {\r\n            if (typeof(e.val) === 'function') {\r\n                value = e.val();\r\n            } else {\r\n                if (e.getAttribute) {\r\n                    if (e.tagName === 'SELECT' && e.getAttribute('multiple') !== null) {\r\n                        value = [];\r\n                        for (let i = 0; i < e.options.length; i++) {\r\n                            if (e.options[i].selected) {\r\n                                value.push(e.options[i].value);\r\n                            }\r\n                        }\r\n                    } else if (e.type === 'checkbox') {\r\n                        value = e.checked && e.getAttribute('value') ? e.value : e.checked;\r\n                    } else if (e.getAttribute('contenteditable')) {\r\n                        value = e.innerHTML;\r\n                    } else {\r\n                        value = e.value;\r\n                    }\r\n                } else {\r\n                    value = e.value;\r\n                }\r\n            }\r\n        }\r\n        return value;\r\n    }\r\n\r\n    /**\r\n     * Set attribute value helper\r\n     * @param {object} e Element\r\n     * @param {string} attribute\r\n     * @param {any} value\r\n     * @param {boolean?} propertyValue\r\n     */\r\n    const setAttribute = function(e, attribute, value, propertyValue) {\r\n        // Handle state\r\n        if (value instanceof state) {\r\n            value = value.value;\r\n        } else if (typeof(value) === 'undefined') {\r\n            value = '';\r\n        }\r\n\r\n        if (attribute === 'value' && ! propertyValue) {\r\n            // Update HTML form element\r\n            if (typeof (e.val) === 'function') {\r\n                if (e.val() != value) {\r\n                    e.val(value);\r\n                }\r\n            } else if (e.tagName === 'SELECT' && e.getAttribute('multiple') !== null) {\r\n                for (let j = 0; j < e.children.length; j++) {\r\n                    e.children[j].selected = value.indexOf(e.children[j].value) >= 0;\r\n                }\r\n            } else if (e.type === 'checkbox') {\r\n                e.checked = !(!value || value === '0' || value === 'false');\r\n            } else if (e.type === 'radio') {\r\n                e.checked = e.value == value;\r\n            } else if (e.getAttribute && e.getAttribute('contenteditable')) {\r\n                if (e.innerHTML != value) {\r\n                    e.innerHTML = value;\r\n                }\r\n            } else {\r\n                // Make sure apply that to the value\r\n                e.value = value;\r\n                // Update attribute if exists\r\n                if (e.getAttribute && e.getAttribute('value') !== null) {\r\n                    e.setAttribute('value', value);\r\n                }\r\n            }\r\n        } else if (typeof(value) === 'object' || typeof(value) === 'function') {\r\n            e[attribute] = value;\r\n        } else {\r\n            if (isDOM(e)) {\r\n                if (typeof (e[attribute]) !== 'undefined' && !(e.namespaceURI && e.namespaceURI.includes('svg'))) {\r\n                    e[attribute] = value;\r\n                } else {\r\n                    if (value === '') {\r\n                        e.removeAttribute(attribute);\r\n                    } else {\r\n                        e.setAttribute(attribute, value);\r\n                    }\r\n                }\r\n            } else {\r\n                e[attribute] = value;\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Get attributes as an object\r\n     * @param {boolean} props - all attributes that are not undefined\r\n     * @return {object}\r\n     */\r\n    const getAttributes = function(props) {\r\n        let o = {};\r\n        let k = null;\r\n        let a = this.attributes;\r\n        if (a && a.length) {\r\n            for (let i = 0; i < a.length; i++) {\r\n                k = a[i].name;\r\n                if (props && typeof(this[k]) !== 'undefined') {\r\n                    o[k] = this[k];\r\n                } else {\r\n                    o[k] = a[i].value;\r\n                }\r\n            }\r\n        }\r\n        return o;\r\n    }\r\n\r\n    /**\r\n     * Register a getter without setter for a self object\r\n     * @param {object} s - self object\r\n     * @param {string} p - self property\r\n     * @param {string|object|number} v - value\r\n     */\r\n    const register = function(s, p, v) {\r\n        if (typeof(s) === 'object') {\r\n            Object.defineProperty(s, p, {\r\n                enumerable: false,\r\n                configurable: true,\r\n                get: function () {\r\n                    return v;\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Extract variables from the dynamic and append to the self\r\n     * @return {[string, array]} grab the literal injection\r\n     */\r\n    const parseTemplate = function() {\r\n        let args = Array.from(arguments);\r\n        // Remove first\r\n        args.shift()\r\n        // Return the final template\r\n        return args;\r\n    }\r\n\r\n    function cloneChildren(element) {\r\n        // Base case: if an element is null/undefined or not an object, return as is\r\n        if (!element || typeof element !== 'object') {\r\n            return element;\r\n        }\r\n\r\n        // Handle arrays\r\n        if (Array.isArray(element)) {\r\n            return element.map(item => cloneChildren(item));\r\n        }\r\n\r\n        // Create a new object\r\n        const cloned = {};\r\n\r\n        // Clone each property\r\n        for (const key in element) {\r\n            if (key === 'children') {\r\n                // Handle children especially as before\r\n                cloned.children = element.children ? cloneChildren(element.children) : undefined;\r\n            } else if (key === 'props') {\r\n                // Deep clone props array\r\n                cloned.props = element.props.map(prop => ({\r\n                    ...prop,\r\n                    value: prop.value // If value is a function, it will maintain the reference which is what we want\r\n                }));\r\n            } else {\r\n                // Clone other properties\r\n                cloned[key] = element[key];\r\n            }\r\n        }\r\n\r\n        return cloned;\r\n    }\r\n\r\n    // LemonadeJS object\r\n    const L = {};\r\n\r\n    /**\r\n     * Render a lemonade DOM element, method or class into a root DOM element\r\n     * @param {function} component - LemonadeJS component or DOM created\r\n     * @param {HTMLElement} root - root DOM element to receive the new HTML\r\n     * @param {object?} self - self to be used\r\n     * @param {object?} item - item\r\n     * @return {HTMLElement|boolean} o\r\n     */\r\n    L.render = function(component, root, self, item) {\r\n        if (typeof(component) !== 'function') {\r\n            console.error('Component is not a function');\r\n            return false;\r\n        }\r\n\r\n        // In case the self has not initial definition by the developer\r\n        if (typeof(self) === 'undefined') {\r\n            self = {};\r\n        }\r\n\r\n        // Web component\r\n        if (self.tagName && self.tagName.includes('-')) {\r\n            let props = getAttributes.call(self, true);\r\n            // Copy all values to the object\r\n            L.setProperties.call(self, props, true);\r\n        }\r\n\r\n        // Arguments\r\n        let args = Array.from(arguments);\r\n\r\n        // Lemonade component object\r\n        let lemon = {\r\n            self: self,\r\n            ready: [],\r\n            change: [],\r\n            events: [],\r\n            components: {},\r\n            elements: [],\r\n            root: root,\r\n            path: {},\r\n        }\r\n\r\n        // Current onchange\r\n        let externalOnchange = self.onchange;\r\n        let externalOnload = self.onload;\r\n\r\n        if (! item) {\r\n            item = {};\r\n        } else if (typeof(item) === 'string') {\r\n            item = {\r\n                children: item,\r\n            }\r\n        }\r\n\r\n        let view;\r\n        let result;\r\n\r\n        // New self\r\n        if (component === Basic) {\r\n            view = cloneChildren(item.children[0]);\r\n        } else {\r\n            R.currentLemon = lemon;\r\n\r\n            const tools = {\r\n                onload: (...args) => setOnload(lemon, ...args),\r\n                onchange: (...args) => setOnchange(lemon, ...args),\r\n                track: (...args) => setTrack(lemon, ...args),\r\n                state: (...args) => setState(lemon, ...args),\r\n                setPath: (...args) => setPath(lemon, ...args),\r\n            };\r\n\r\n            if (isClass(component)) {\r\n                if (! (self instanceof component)) {\r\n                    lemon.self = self = new component(self);\r\n                }\r\n                view = self.render(item.children, tools);\r\n            } else {\r\n                // Execute component\r\n                view = component.call(self, item.children, tools);\r\n            }\r\n\r\n            // Resolve onchange scope conflict\r\n            if (typeof(self.onchange) === 'function' && externalOnchange !== self.onchange) {\r\n                // Keep onchange event in the new onchange format\r\n                lemon.change.push(self.onchange);\r\n                // Keep the external onchange\r\n                self.onchange = externalOnchange;\r\n            }\r\n\r\n            R.currentLemon = null;\r\n        }\r\n\r\n        // Values\r\n        let values = null;\r\n        // Process return\r\n        if (typeof(view) === 'function') {\r\n            values = view(parseTemplate);\r\n            // Curren values\r\n            lemon.values = values;\r\n            // A render template to be executed\r\n            lemon.view = view;\r\n            // Template from the method\r\n            result = view.toString().split('`');\r\n            // Get the original template\r\n            if (result) {\r\n                // Remove the last element\r\n                result.shift();\r\n                result.pop();\r\n                // Join everything else\r\n                result = result.join('`').trim();\r\n            }\r\n        } else {\r\n            result = view;\r\n        }\r\n\r\n        // Virtual DOM tree\r\n        if (typeof(result) === 'string') {\r\n            result = HTMLParser(result.trim(), values);\r\n        }\r\n\r\n        let element;\r\n\r\n        // Process the result\r\n        if (result) {\r\n            // Get the HTML virtual DOM representation\r\n            lemon.tree = result;\r\n\r\n            // Create real DOM and append to the root\r\n            element = generateHTML(lemon);\r\n\r\n            if (element) {\r\n                // Parents\r\n                lemon.elements = [];\r\n                // Append parents\r\n                if (element.tagName === 'ROOT') {\r\n                    element.childNodes.forEach((e) => {\r\n                        lemon.elements.push(e);\r\n                    });\r\n                } else {\r\n                    lemon.elements.push(element);\r\n                }\r\n\r\n                // Register element when is not registered inside the component\r\n                register(lemon.self, 'el', element);\r\n\r\n                const destroy = () => {\r\n                    // Do not add in the same root\r\n                    let div = document.createElement('div');\r\n                    // Append temporary DIV to the same position\r\n                    lemon.elements[0].parentNode.insertBefore(div, lemon.elements[0]);\r\n                    // Remove the old elements\r\n                    lemon.elements.forEach((e) => {\r\n                        e.remove();\r\n                    });\r\n                    // Root element\r\n                    args[1] = div;\r\n                    // Create a new component\r\n                    L.render(...args);\r\n                    // Append elements in the same position in the DOM tree\r\n                    while (div.firstChild) {\r\n                        div.parentNode.insertBefore(div.firstChild, div);\r\n                    }\r\n                    // Remove DIV\r\n                    div.remove();\r\n                    // Object not in use\r\n                    lemon = null;\r\n                }\r\n\r\n                // Refresh\r\n                register(lemon.self, 'refresh', (prop) => {\r\n                    if (prop) {\r\n                        if (prop === true) {\r\n                            destroy();\r\n                        } else {\r\n                            lemon.self[prop] = lemon.self[prop];\r\n                        }\r\n                    } else {\r\n                        if (lemon.view) {\r\n                            runViewValues(lemon);\r\n                        } else {\r\n                            destroy();\r\n                        }\r\n                    }\r\n                });\r\n\r\n                // Append element to the DOM\r\n                if (root) {\r\n                    lemon.elements.forEach((e) => {\r\n                        root.appendChild(e);\r\n                    });\r\n                }\r\n            } else {\r\n                // Refresh\r\n                register(lemon.self, 'refresh', (prop) => {\r\n                    if (prop) {\r\n                        if (prop === true) {\r\n                            runViewValues(lemon);\r\n                        } else {\r\n                            lemon.self[prop] = lemon.self[prop];\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        }\r\n\r\n        // Bind to custom component\r\n        if (item.bind || item.path) {\r\n            let token = 'value';\r\n            if (! lemon.events[token]) {\r\n                lemon.events[token] = []\r\n            }\r\n            // Push the event\r\n            if (item.bind) {\r\n                lemon.events[token].push(item.bind);\r\n            }\r\n            if (item.path) {\r\n                lemon.events[token].push(item.path);\r\n            }\r\n        }\r\n\r\n        // In case initial exists\r\n        if (typeof(lemon.path.initial) === 'object') {\r\n            // Get the value of the draft\r\n            let newValue = lemon.path.initial;\r\n            // Delete draft\r\n            delete lemon.path.initial;\r\n            // Apply new values\r\n            lemon.path.setValue(newValue);\r\n\r\n        }\r\n\r\n        // Apply events\r\n        if (lemon.events) {\r\n            let props = Object.keys(lemon.events);\r\n            if (props.length) {\r\n                for (let i = 0; i <props.length; i++) {\r\n                    trackProperty(lemon, props[i]);\r\n                }\r\n            }\r\n        }\r\n\r\n        // Process the onload\r\n        if (element) {\r\n            processOnload(lemon);\r\n        }\r\n\r\n        return element;\r\n    }\r\n\r\n    const registerComponents = function(components) {\r\n        if (components && R.currentLemon) {\r\n            for (const key in components) {\r\n                R.currentLemon.components[key.toUpperCase()] = components[key];\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Deprecated\r\n     * @param {string} template\r\n     * @param {object?} s (self)\r\n     * @param {object?} components\r\n     */\r\n    L.element = function(template, s, components) {\r\n        if (R.currentLemon && s && typeof(s) === 'object') {\r\n            if (s !== R.currentLemon.self) {\r\n                R.currentLemon.self = s;\r\n            }\r\n        }\r\n        registerComponents(components);\r\n        return template;\r\n    }\r\n\r\n    /**\r\n     * Apply self to an existing appended DOM element\r\n     * @param {HTMLElement} el - element root\r\n     * @param {object} s - self to associate to the template\r\n     * @param {object?} components - object with component declarations\r\n     */\r\n    L.apply = function(el, s, components) {\r\n        let template = el.innerHTML;\r\n        el.textContent = '';\r\n        let Component = function() {\r\n            registerComponents(components);\r\n            return `<>${template}</>`;\r\n        }\r\n        return L.render(Component,el,s);\r\n    }\r\n\r\n    /**\r\n     * Get all properties existing in {o} and create a new object with the values from {this};\r\n     * @param {object} o - reference object with the properties relevant to the new object\r\n     * @return {object} n - the new object with all new values\r\n     */\r\n    L.getProperties = function(o) {\r\n        // The new object with all properties found in {o} with values from {this}\r\n        let n = {};\r\n        for (let p in o) {\r\n            n[p] = this[p];\r\n        }\r\n        return n;\r\n    }\r\n\r\n    /**\r\n     * Set the values from {o} to {this}\r\n     * @param {object} o set the values of {this} when the `this[property]` is found in {o}, or when flag force is true\r\n     * @param {boolean} f create a new property when that does not exist yet, but is found in {o}\r\n     * @return {object} this is redundant since object {this} is a reference and is already available in the caller\r\n     */\r\n    L.setProperties = function(o, f) {\r\n        for (let p in o) {\r\n            if (this.hasOwnProperty(p) || f) {\r\n                this[p] = o[p];\r\n            }\r\n        }\r\n        return this;\r\n    }\r\n\r\n    /**\r\n     * Reset the values of any common property name between this and a given object\r\n     * @param {object} o - all properties names in the object {o} found in {this} will be reset.\r\n     */\r\n    L.resetProperties = function(o) {\r\n        for (let p in o) {\r\n            this[p] = '';\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Lemonade CC (common container) helps you share a self or function through the whole application\r\n     * @param {string} name alias for your declared object(self) or function\r\n     * @returns {Object | Function} - registered element\r\n     */\r\n    L.get = function(name) {\r\n        return R.container[name];\r\n    }\r\n\r\n    /**\r\n     * Register something to the Lemonade CC (common container)\r\n     * @param {string} name - alias for your declared object(self) or function\r\n     * @param {object|function} e - the element to be added to the common container. Can be an object(self) or function.\r\n     * @param {boolean} persistence - optional the persistence flag. Only applicable for functions.\r\n     */\r\n    L.set = function(name, e, persistence) {\r\n        // Applicable only when the o is a function\r\n        if (typeof(e) === 'function' && persistence === true) {\r\n            // Keep the flag\r\n            e.storage = true;\r\n            // Any existing values\r\n            let t = window.localStorage.getItem(name);\r\n            if (t) {\r\n                // Parse JSON\r\n                t = JSON.parse(t);\r\n                // Execute method with the existing values\r\n                e(t);\r\n            }\r\n        }\r\n        // Save to the sugar container\r\n        R.container[name] = e;\r\n    }\r\n\r\n    /**\r\n     * Dispatch the new values to the function\r\n     * @param {string} name - alias to the element saved on the Lemonade CC (common container)\r\n     * @param {object?} data - data to be dispatched\r\n     */\r\n    L.dispatch = function(name, data) {\r\n        // Get from the container\r\n        let e = R.container[name];\r\n        // Confirm that the alias is a function\r\n        if (typeof(e) === 'function') {\r\n            // Save the data to the local storage\r\n            if (e.storage === true) {\r\n                window.localStorage.setItem(name, JSON.stringify(data));\r\n            }\r\n            // Dispatch the data to the function\r\n            return e(data);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Register components\r\n     * @param {object} components - register components\r\n     */\r\n    L.setComponents = function(components) {\r\n        if (typeof(components) === 'object') {\r\n            // Component names\r\n            let k = Object.keys(components);\r\n            // Make sure they follow the standard\r\n            for (let i = 0; i < k.length; i++) {\r\n                R.components[k[i].toUpperCase()] = components[k[i]];\r\n            }\r\n        }\r\n    }\r\n\r\n    L.component = class {}\r\n\r\n    /**\r\n     * Create a Web Component\r\n     * @param {string} name - web component name\r\n     * @param {function} handler - lemonadejs component\r\n     * @param {object} options - options to create the web components\r\n     */\r\n    L.createWebComponent = function(name, handler, options) {\r\n        if (typeof(window) === 'undefined') {\r\n            return;\r\n        }\r\n\r\n        if (typeof(handler) !== 'function') {\r\n            return 'Handler should be an function';\r\n        }\r\n        // Prefix\r\n        let prefix = options && options.prefix ? options.prefix : 'lm';\r\n\r\n        // Component name\r\n        const componentName = prefix + '-' + name;\r\n\r\n        // Check if the component is already defined\r\n        if (! window.customElements.get(componentName)) {\r\n            class Component extends HTMLElement {\r\n                constructor() {\r\n                    super();\r\n                }\r\n\r\n                connectedCallback() {\r\n                    // LemonadeJS self\r\n                    let self = this;\r\n                    // First call\r\n                    let state = typeof(this.el) === 'undefined';\r\n                    // LemonadeJS is already rendered\r\n                    if (state === true) {\r\n                        // Render\r\n                        if (options && options.applyOnly === true) {\r\n                            // Merge component\r\n                            handler.call(this);\r\n                            // Apply\r\n                            L.apply(this, self);\r\n                        } else {\r\n                            let root = this;\r\n                            if (options && options.shadowRoot === true) {\r\n                                this.attachShadow({ mode: 'open' });\r\n                                root = document.createElement('div');\r\n                                this.shadowRoot.appendChild(root);\r\n                            }\r\n                            // Give the browser time to calculate all width and heights\r\n                            L.render(handler, root, self);\r\n                        }\r\n                    }\r\n\r\n                    queueMicrotask(() => {\r\n                        // Event\r\n                        if (typeof(self.onconnect) === 'function') {\r\n                            self.onconnect(self, state);\r\n                        }\r\n                    });\r\n                }\r\n\r\n                disconnectedCallback() {\r\n                    if (typeof(this.ondisconnect) === 'function') {\r\n                        this.ondisconnect(this);\r\n                    }\r\n                }\r\n            }\r\n\r\n            if (! window.customElements.get(componentName)) {\r\n                window.customElements.define(componentName, Component);\r\n            }\r\n        }\r\n    }\r\n\r\n    L.h = function(type, props, ...children) {\r\n        return { type, props: props || {}, children };\r\n    }\r\n\r\n    L.Fragment = function(props) {\r\n        return props.children;\r\n    }\r\n\r\n    const wrongLevel = 'Hooks must be called at the top level of your component';\r\n\r\n    const setOnload = function(lemon, event) {\r\n        lemon.load = event;\r\n    }\r\n\r\n    const setOnchange = function(lemon, event) {\r\n        lemon.change.push(event);\r\n    }\r\n\r\n    const setTrack = function(lemon, prop) {\r\n        if (! lemon.events[prop]) {\r\n            lemon.events[prop] = [];\r\n        }\r\n    }\r\n\r\n    const setPath = function(lemon, initialValues, change) {\r\n        // My value object\r\n        let value = {};\r\n        // Create a method to update the state\r\n        const setValue = (newValue) => {\r\n            if (typeof(lemon.path.initial) === 'undefined') {\r\n                if (typeof (newValue) === 'object') {\r\n                    // If my has been declared\r\n                    let elements = lemon.path.elements;\r\n                    if (elements) {\r\n                        for (let i = 0; i < elements.length; i++) {\r\n                            let v = Path.call(newValue, elements[i].path)\r\n                            setAttribute(elements[i].element, 'value', v);\r\n                        }\r\n                    }\r\n                }\r\n            } else {\r\n                lemon.path.initial = newValue;\r\n            }\r\n        }\r\n\r\n        const getValue = () => {\r\n            let ret = {};\r\n            // If my has been declared\r\n            let elements = lemon.path.elements;\r\n            if (elements) {\r\n                for (let i = 0; i < elements.length; i++) {\r\n                    let v = getAttribute(elements[i].element, 'value');\r\n                    Path.call(ret, elements[i].path, v);\r\n                }\r\n            }\r\n            return ret;\r\n        }\r\n\r\n        lemon.path = {\r\n            setValue: setValue,\r\n            value: value,\r\n            change: change,\r\n            initial: initialValues || {}\r\n        };\r\n\r\n        return [value, setValue, getValue];\r\n    }\r\n\r\n    const setState = function(lemon, value, callback) {\r\n        // Create a state container\r\n        const s = new state();\r\n        // Create a method to update the state\r\n        const setValue = (newValue) => {\r\n            let oldValue = value;\r\n            // Update original value\r\n            value = typeof newValue === 'function' ? newValue(value) : newValue;\r\n            // Values from the view\r\n            runViewValues(lemon, s);\r\n            // Call back\r\n            callback?.(value, oldValue);\r\n        }\r\n        // Make the value attribute dynamic\r\n        Object.defineProperty(s, 'value', {\r\n            set: setValue,\r\n            get: () => value\r\n        });\r\n\r\n        return s;\r\n    }\r\n\r\n    L.onload = function(event) {\r\n        if (! R.currentLemon) {\r\n            createError(wrongLevel);\r\n        }\r\n        return setOnload(R.currentLemon, event);\r\n    }\r\n\r\n    L.onchange = function(event) {\r\n        if (! R.currentLemon) {\r\n            createError(wrongLevel);\r\n        }\r\n        return setOnchange(R.currentLemon, event);\r\n    }\r\n\r\n    L.track = function(prop) {\r\n        if (! R.currentLemon) {\r\n            createError(wrongLevel);\r\n        }\r\n        return setTrack(R.currentLemon, prop);\r\n    }\r\n\r\n    L.setPath = function(initialValues, change) {\r\n        if (! R.currentLemon) {\r\n            createError(wrongLevel);\r\n        }\r\n        return setPath(R.currentLemon, initialValues, change);\r\n    }\r\n\r\n    /**\r\n     * Run view values\r\n     * @param lemon\r\n     * @param s - refresh from state\r\n     */\r\n    const runViewValues = function(lemon, s) {\r\n        let values = lemon.view(parseTemplate);\r\n        if (values && values.length) {\r\n            values.forEach((v, k) => {\r\n                let current = lemon.values[k];\r\n                // Compare if the previous value\r\n                if (s && s === v || v !== current) {\r\n                    // Update current value\r\n                    lemon.values[k] = v;\r\n                    // Trigger state events\r\n                    if (typeof(lemon.events[k]) === 'function') {\r\n                        lemon.events[k]();\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    }\r\n\r\n    const state = function() {}\r\n\r\n    state.prototype.toString = function() {\r\n        return this.value.toString();\r\n    }\r\n\r\n    state.prototype.valueOf = function() {\r\n        return this.value;\r\n    }\r\n\r\n    state.prototype[Symbol.toPrimitive] = function(hint) {\r\n        if (hint === 'string') {\r\n            return this.value.toString();\r\n        }\r\n        return this.value;\r\n    }\r\n\r\n    // TODO: Proxy for Objects and Arrays\r\n    L.state = function(value, callback) {\r\n        if (! R.currentLemon) {\r\n            createError(wrongLevel);\r\n        }\r\n\r\n        return setState(R.currentLemon, value, callback);\r\n    }\r\n\r\n    L.helpers = {\r\n        path: extractFromPath,\r\n        properties: {\r\n            get: L.getProperties,\r\n            set: L.setProperties,\r\n            reset: L.resetProperties,\r\n        }\r\n    }\r\n\r\n    L.events = (function() {\r\n        class CustomEvents extends Event {\r\n            constructor(type, props, options) {\r\n                super(type, {\r\n                    bubbles: true,\r\n                    composed: true,\r\n                    ...options,\r\n                });\r\n\r\n                if (props) {\r\n                    for (const key in props) {\r\n                        // Avoid assigning if property already exists anywhere on `this`\r\n                        if (! (key in this)) {\r\n                            this[key] = props[key];\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        const create = function(type, props, options) {\r\n            return new CustomEvents(type, props, options);\r\n        };\r\n\r\n        return {\r\n            create: create,\r\n            dispatch(element, event, options) {\r\n                if (typeof event === 'string') {\r\n                    event = create(event, options);\r\n                }\r\n                element.dispatchEvent(event);\r\n            }\r\n        };\r\n    })();\r\n\r\n    return L;\r\n})));"]}