@love-sqjm/magic 2026.4.15

package/template/runtime/runtime.js

@@ -0,0 +1,895 @@
+window[ "magic" ] = ( function () {
+    "use strict";
+
+    window[ "__MAGIC__" ] = {
+        M : {},
+        CREATE_ELEMENT_LIST : new Map()
+    };
+
+    function idGenerate() {
+        const timestamp = `${ new Date().getTime() }`.substring( 2 );
+
+        function getRandomLetter() {
+            const letters = 'abcdefghijklmnopqrstuvwxyz';
+            return letters[ Math.floor( Math.random() * letters.length ) ];
+        }
+
+        let result = '';
+        for ( let i = 0; i < timestamp.length; i++ ) {
+            result += timestamp[ i ];
+            if ( i < timestamp.length - 1 ) {
+                result += getRandomLetter();
+            }
+        }
+
+        return "m-id-" + result;
+    }
+
+    const call = function ( scope ) {
+        return {
+            interface : new Proxy( scope, {
+                get( target, prop, receiver ) {
+                    return Reflect.get( scope[ "__magic_interface" ], prop, receiver );
+                },
+                set( target, prop, value, receiver ) {
+                    return false;
+                }
+            } ),
+            event : new Proxy( scope, {
+                get( target, prop, receiver ) {
+                    return Reflect.get( scope[ "__magic_event" ], prop, receiver );
+                },
+                set( target, prop, value, receiver ) {
+                    return false;
+                }
+            } ),
+            listen : new Proxy( scope, {
+                get( target, prop, receiver ) {
+                    return scope[ `__magic_listen_${ prop }` ];
+                },
+                set( target, prop, value, receiver ) {
+                    return false;
+                }
+            } )
+        }
+    };
+
+    const emit = {
+        event : function ( listen ) {
+            return ( name, ...args ) => {
+                if ( listen.hasOwnProperty( name ) )
+                    return listen[ name ]( ...args );
+                else
+                    return undefined;
+            }
+        }
+    };
+
+    const dom = ( () => {
+        function element( tag ) {
+            const r = document.createElement( tag );
+            r.__MAGIC_CREATE_ELEMENT__ = true;
+            return r;
+        }
+
+        function text( content ) {
+            return document.createTextNode( content );
+        }
+
+        function append( p, ...childs ) {
+            const bool = p.templateArgs && p.templateArgs.inline && p.childNodes.length > 0;
+            if ( bool && p.interface._inline ) {
+                p.interface._inline( ...childs );
+                return;
+            }
+            for ( const c of childs ) {
+                const child = ( () => {
+                    if ( c.fragment ) return c.fragment;
+                    else return c;
+                } )();
+                if ( bool ) {
+                    p.childNodes.item( 0 ).appendChild( child );
+                } else {
+                    p.appendChild( child );
+                }
+            }
+        }
+
+        function attribute( e, atts ) {
+            for ( const key in atts ) {
+                if ( key === "class" ) {
+                    atts[ key ].split( " " ).forEach( s => {
+                        e.classList.add( s );
+                    } );
+                } else {
+                    if ( e[ "__fragment" ] && e[ "mid" ] ) {
+                        e.childNodes[ 0 ].setAttribute( key, atts[ key ] || "" );
+                    } else {
+                        e.setAttribute( key, atts[ key ] || "" );
+                    }
+                }
+            }
+        }
+
+        function event( e, eventName, _this, fnName, opt ) {
+            e.addEventListener( eventName, _this.__magic_event[ fnName ], opt );
+        }
+
+        return {
+            element,
+            text,
+            attribute,
+            event,
+            append
+        }
+    } )();
+
+    function importElementInit( ...args ) {
+        args.forEach( i => {
+            if ( i.interface.hasOwnProperty( "_render" ) ) i.interface[ "_render" ]();
+        } );
+    }
+
+    function importM( name, args = {}, listen = {} ) {
+        name = name.replace( /[^a-zA-Z]/g, '' ).toLowerCase();
+        if ( window[ "__MAGIC__" ][ "M" ].hasOwnProperty( name ) ) {
+            return new window[ "__MAGIC__" ][ "M" ][ name ]( args, listen );
+        } else {
+            throw `未知的 ${ name }`;
+        }
+    }
+
+    function $id( _$id ) {
+        const createNameFinder = ( element ) => ( name ) => {
+            const findChildByName = ( parent ) => {
+                for ( const child of parent.childNodes ) {
+                    if ( child.nodeType !== 1 ) continue;
+                    if ( child._$name === name ) return child;
+                    if ( child._$id ) return null;
+
+                    const found = findChildByName( child );
+                    if ( found ) return found;
+                }
+                return null;
+            };
+            return findChildByName( element );
+        };
+
+        const convertIdMapToObject = ( map ) => {
+            const result = {};
+            map.forEach( ( value, key ) => {
+                const formattedKey = `$${ key.replace( /-(\w)/g, ( _, c ) => c.toUpperCase() ) }`;
+                value.$name = createNameFinder( value );
+                result[ formattedKey ] = value;
+            } );
+            return result;
+        };
+
+        return ( id ) => {
+            if ( id === undefined ) {
+                return convertIdMapToObject( _$id );
+            }
+
+            const target = _$id.get( id );
+            if ( !target ) throw new Error( `没有 id 为 ${ id } 的元素` );
+
+            target.$name = createNameFinder( target );
+            return target;
+        };
+    }
+
+    function $( id, root = document.body ) {
+        if ( !id || typeof id !== 'string' || !root || root.nodeType !== 1 ) {
+            return null;
+        }
+
+        const stack = [ root ];
+
+        while ( stack.length > 0 ) {
+            const element = stack.pop();
+
+            // 检查当前元素
+            if ( element.mid === id ) {
+                return element;
+            }
+
+            // 将子元素推入栈（从后往前推，保持搜索顺序）
+            const children = element.children;
+            for ( let i = children.length - 1; i >= 0; i-- ) {
+                stack.push( children[ i ] );
+            }
+        }
+
+        return null;
+    }
+
+    function parserArgs( args ) {
+        if ( typeof args === "string" )
+            return JSON.parse( args );
+
+        function transformObject( obj ) {
+            const result = {};
+            for ( const key in obj ) {
+                if ( obj.hasOwnProperty( key ) ) {
+                    const value = obj[ key ];
+                    if ( typeof value === 'object' && value !== null ) {
+                        result[ key ] = transformObject( value );
+                    } else {
+                        result[ key ] = value;
+                    }
+                }
+            }
+            return result;
+        }
+
+        function splitKeys( obj ) {
+            const result = {};
+            for ( const key in obj ) {
+                if ( obj.hasOwnProperty( key ) ) {
+                    const value = obj[ key ];
+                    if ( key.includes( ':' ) ) {
+                        const keys = key.split( ':' );
+                        let current = result;
+                        for ( let i = 0; i < keys.length; i++ ) {
+                            const k = keys[ i ];
+                            if ( i === keys.length - 1 ) {
+                                current[ k ] = value;
+                            } else {
+                                if ( !current[ k ] ) {
+                                    current[ k ] = {};
+                                }
+                                current = current[ k ];
+                            }
+                        }
+                    } else {
+                        result[ key ] = value;
+                    }
+                }
+            }
+            return result;
+        }
+
+        const transformed = transformObject( args );
+        return splitKeys( transformed );
+    }
+
+    function createArgs( obj ) {
+        return JSON.stringify( obj );
+    }
+
+    function createUiData( target = {}, source = {} ) {
+        function _getType( val ) {
+            return Object.prototype.toString.call( val ).slice( 8, -1 );
+        }
+
+        function _convertType( t, s = "", k ) {
+            const type = _getType( t );
+            let result = s;
+            switch ( type ) {
+                case "Boolean": {
+                    if ( s === "true" ) result = true;
+                    else if ( s === "false" ) result = false;
+                    else throw new Error();
+                    break;
+                }
+                case "Number": {
+                    if ( s.includes( "." ) ) result = parseFloat( s );
+                    else result = parseInt( s );
+                    break;
+                }
+                case "Array": {
+                    result = JSON.parse( s );
+                    break;
+                }
+                case "RegExp": {
+                    const parts = s.match( /^\/(.+)\/([gimuy]*)$/ );
+                    result = new RegExp( parts[ 1 ], parts[ 2 ] );
+                    break;
+                }
+            }
+            return result;
+        }
+
+        for ( const key in source ) {
+            if ( source.hasOwnProperty( key ) ) {
+                const sourceValue = source[ key ];
+                const targetValue = target[ key ];
+
+                if ( typeof sourceValue === 'object' && sourceValue !== null && typeof targetValue === 'object' && targetValue !== null ) {
+                    createUiData( targetValue, sourceValue );
+                } else {
+                    try {
+                        target[ key ] = _convertType( targetValue, sourceValue, key );
+                    } catch ( e ) {
+                        throw `[UiData] 给 ${ key } 传入的键值类型与目标键类型不符合`;
+                    }
+                }
+            }
+        }
+
+        const bindings = {};
+
+        function createDeepProxy( t, path = [] ) {
+            if ( !t || typeof t !== 'object' ) {
+                return t;
+            }
+
+            const handler = {
+                get( t, prop, receiver ) {
+                    const value = Reflect.get( t, prop, receiver );
+                    const currentPath = [ ...path, prop ];
+
+                    // 如果值是对象，递归创建代理
+                    if ( value && typeof value === 'object' ) {
+                        return createDeepProxy( value, currentPath );
+                    }
+
+                    return value;
+                },
+
+                set( t, prop, newValue, receiver ) {
+                    const currentPath = [ ...path, prop ];
+
+                    const p = currentPath.join( '.' );
+                    if ( bindings.hasOwnProperty( p ) ) {
+                        bindings[ p ].forEach( n => {
+                            n.textContent = newValue;
+                        } );
+                    }
+
+                    // 如果新值是对象，确保它也被代理
+                    if ( newValue && typeof newValue === 'object' ) {
+                        newValue = createDeepProxy( newValue, currentPath );
+                    }
+
+                    return Reflect.set( t, prop, newValue, receiver );
+                }
+            };
+
+            return new Proxy( t, handler );
+        }
+
+        /**
+         * 动态值绑定初始化函数
+         */
+        target.__DynamicValueBind = function ( bindingMap ) {
+            if ( !bindingMap || typeof bindingMap !== 'object' ) {
+                console.warn( '[UiData] __DynamicValueBind 需要接收一个对象参数' );
+                return this;
+            }
+
+            for ( const key in bindingMap ) {
+                if ( bindingMap.hasOwnProperty( key ) ) {
+                    const textNodes = bindingMap[ key ];
+
+                    if ( !Array.isArray( textNodes ) ) {
+                        console.warn( `[UiData] 键 "${ key }" 的值必须是数组` );
+                        continue;
+                    }
+
+                    const validTextNodes = textNodes.filter( node =>
+                        node && node.nodeType === 3
+                    );
+
+                    if ( validTextNodes.length === 0 ) {
+                        console.warn( `[UiData] 键 "${ key }" 没有有效的文本节点` );
+                        continue;
+                    }
+
+                    if ( !bindings[ key ] ) {
+                        bindings[ key ] = [];
+                    }
+                    bindings[ key ].push( ...validTextNodes );
+
+                    const value = this._getValueByPath( key );
+                    if ( value !== undefined ) {
+                        validTextNodes.forEach( node => {
+                            node.textContent = value;
+                        } );
+                    }
+                }
+            }
+
+            return this;
+        };
+
+        /**
+         * 辅助方法：通过路径获取值
+         * @param {string} path - 属性路径，如 "user.name"
+         * @returns {*} - 路径对应的值
+         */
+        target._getValueByPath = function ( path ) {
+            const parts = path.split( '.' );
+            let current = target;
+
+            for ( const part of parts ) {
+                if ( current === null || current === undefined ) {
+                    return undefined;
+                }
+                current = current[ part ];
+            }
+
+            return current;
+        };
+        return createDeepProxy( target );
+    }
+
+    function parserListen( listen ) {
+        return listen || {};
+    }
+
+    function on_event( event, listen ) {
+        if ( !event || !listen || !listen.hasOwnProperty( event.type ) ) return;
+        event.runState = "on";
+        return listen[ event.type ]( event );
+    }
+
+    function end_event( event, listen ) {
+        if ( !event || !listen || !listen.hasOwnProperty( event.type ) ) return;
+        event.runState = "end";
+        return listen[ event.type ]( event );
+    }
+
+    function mapIdElement() {
+        const map = new Map;
+        map.s = ( id, e, s = false ) => {
+            e._$id = id;
+            if ( s && e.__fragment ) {
+                e.childNodes.item( 0 ).classList.add( s );
+            } else if ( s ) {
+                e.classList.add( s );
+            }
+            map.set( id, e );
+        };
+        return map;
+    }
+
+    function exportInterface( scope, target, parcel ) {
+        function fn( si ) {
+            for ( const pKey in parcel ) {
+                if ( scope[ si ].hasOwnProperty( pKey ) ) {
+                    throw new Error( "导出的接口存在: " + pKey );
+                }
+                if ( parcel[ pKey ] === nop ) {
+                    scope[ si ][ pKey ] = target.interface[ pKey ];
+                } else if ( typeof parcel[ pKey ] === "function" ) {
+                    scope[ si ][ pKey ] = ( ...args ) => {
+                        target.interface[ pKey ]( parcel[ pKey ]( ...args ) );
+                    };
+                }
+            }
+        }
+
+        if ( scope.__magic_interface ) {
+            fn( "__magic_interface" );
+        } else if ( scope.interface ) {
+            fn( "interface" );
+        }
+    }
+
+    function GetInterface( ele ) {
+        if ( ele.__SCOPE__ ) {
+            return ele.__SCOPE__.__magic_interface;
+        }
+        return null;
+    }
+
+    function BindScope( arr, ths, id ) {
+        const bindScope = ( element ) => {
+            Object.defineProperty( element, '__SCOPE__', {
+                value : ths,
+                writable : false,
+                configurable : true
+            } );
+            element.__MAGIC_MODULE_ID = id;
+            return element;
+        };
+
+        if ( arr.length === 0 ) {
+            arr.push( {} );
+        }
+
+        return arr.map( bindScope );
+    }
+
+    {
+
+        const originalRemove = Element.prototype.remove;
+        Element.prototype.remove = function () {
+            function t_e( e ) {
+                if ( e.__MAGIC_CREATE_ELEMENT__ && e.mid ) {
+                }
+            }
+
+            this.querySelectorAll( "*" ).forEach( e => {
+                t_e( e );
+            } );
+            t_e( this );
+            originalRemove.call( this );
+        };
+    }
+
+    const replaceMagicComments = ( () => {
+        // 缓存正则表达式（模块级常量）
+        const MAGIC_PATTERN = /(\\)?\$(\{([^}]*)\}|)/g;
+        const COMMENT_PATTERN = /<!--MAGIC:DV\[(.*?)\]-->/g;
+
+        /**
+         * 处理单个文本节点
+         * @param {Text} textNode - 要处理的文本节点
+         * @param {Object} resultMap - 结果收集对象
+         * @returns {boolean} - 是否处理成功
+         */
+        function processTextNode( textNode, resultMap ) {
+            const content = textNode.textContent;
+            let processed = '';
+            let lastIndex = 0;
+            let match;
+
+            MAGIC_PATTERN.lastIndex = 0;
+
+            while ( ( match = MAGIC_PATTERN.exec( content ) ) !== null ) {
+                if ( match.index > lastIndex ) {
+                    processed += content.substring( lastIndex, match.index );
+                }
+
+                if ( match[ 1 ] ) {
+                    // 转义的\$
+                    processed += '$';
+                    if ( match[ 2 ]?.startsWith( '{' ) ) {
+                        processed += match[ 2 ];
+                    }
+                } else if ( match[ 3 ] !== undefined ) {
+                    // ${xxx} 模式
+                    processed += `<!--MAGIC:DV[${ match[ 3 ] }]-->`;
+                } else {
+                    // 单独的$
+                    processed += '$';
+                }
+
+                lastIndex = match.index + match[ 0 ].length;
+            }
+
+            if ( lastIndex < content.length ) {
+                processed += content.substring( lastIndex );
+            }
+
+            // 如果没有变化，返回false
+            if ( processed === content ) return false;
+
+            // 构建新内容
+            const fragment = document.createDocumentFragment();
+            let textStart = 0;
+
+            COMMENT_PATTERN.lastIndex = 0;
+            while ( ( match = COMMENT_PATTERN.exec( processed ) ) !== null ) {
+                if ( match.index > textStart ) {
+                    fragment.appendChild(
+                        document.createTextNode( processed.substring( textStart, match.index ) )
+                    );
+                }
+
+                // 创建注释节点
+                const comment = document.createComment( `MAGIC:DV[${ match[ 1 ] }]` );
+                fragment.appendChild( comment );
+
+                // 在注释后面创建一个空的文本节点
+                const emptyTextNode = document.createTextNode( `{${ match[ 1 ] }}` );
+                fragment.appendChild( emptyTextNode );
+
+                // 将空文本节点添加到结果映射中
+                const key = match[ 1 ];
+                if ( !resultMap[ key ] ) {
+                    resultMap[ key ] = [];
+                }
+                resultMap[ key ].push( emptyTextNode );
+
+                textStart = match.index + match[ 0 ].length;
+            }
+
+            if ( textStart < processed.length ) {
+                fragment.appendChild(
+                    document.createTextNode( processed.substring( textStart ) )
+                );
+            }
+
+            // 执行替换
+            try {
+                textNode.parentNode.replaceChild( fragment, textNode );
+                return true;
+            } catch ( e ) {
+                console.warn( '替换文本节点失败:', e );
+                return false;
+            }
+        }
+
+        /**
+         * 收集需要处理的文本节点
+         * @param {Element} element - 根元素
+         * @returns {Text[]} - 文本节点数组
+         */
+        function collectTextNodes( element ) {
+            const walker = document.createTreeWalker(
+                element,
+                NodeFilter.SHOW_TEXT,
+                {
+                    acceptNode : ( node ) => {
+                        // 只处理包含$符号且非空的文本节点
+                        return node.textContent.trim() !== '' && node.textContent.includes( '$' )
+                            ? NodeFilter.FILTER_ACCEPT
+                            : NodeFilter.FILTER_REJECT;
+                    }
+                }
+            );
+
+            const textNodes = [];
+            let currentNode;
+
+            while ( ( currentNode = walker.nextNode() ) ) {
+                textNodes.push( currentNode );
+            }
+
+            return textNodes;
+        }
+
+        /**
+         * 处理所有文本节点
+         * @param {Element} element - 根元素
+         * @returns {Object} - 结果对象
+         */
+        function processAllNodes( element ) {
+            const result = {};
+            const textNodes = collectTextNodes( element );
+
+            textNodes.forEach( node => {
+                processTextNode( node, result );
+            } );
+
+            return result;
+        }
+
+        /**
+         * Promise 版本的主函数
+         * @param {Element} element - 要处理的根元素
+         * @returns {Promise<Object>} - 返回 Promise，解析为结果对象
+         */
+        return function ( element ) {
+
+            return new Promise( ( resolve, reject ) => {
+                // 快速失败检查
+                if ( !element ) {
+                    reject( new Error( '元素不能为空' ) );
+                    return;
+                }
+
+                if ( element.nodeType !== 1 ) {
+                    reject( new Error( '元素必须是 Element 类型' ) );
+                    return;
+                }
+
+                // 处理函数
+                const process = () => {
+                    try {
+                        const result = processAllNodes( element );
+                        resolve( result );
+                    } catch ( error ) {
+                        reject( error );
+                    }
+                };
+
+                // 使用 requestIdleCallback 或 setTimeout 来避免阻塞主线程
+                if ( window.requestIdleCallback ) {
+                    requestIdleCallback( process, { timeout : 100 } );
+                } else {
+                    setTimeout( process, 0 );
+                }
+            } );
+        };
+    } )();
+
+    function DynamicValueBind( ...ele ) {
+        const o = ele.pop();
+        ele.forEach( node => {
+            replaceMagicComments( node ).then( r => {
+                o.__DynamicValueBind( r )
+            } );
+        } )
+    }
+
+    const router = ( () => {
+        const routes = [];
+        const routeComponents = {};
+        let currentRoute = null;
+        let rootContainer = null;
+        const guards = [];
+
+        function pathToRegex( path ) {
+            const paramNames = [];
+            const regexStr = path.replace( /:([^/]+)/g, ( _, name ) => {
+                paramNames.push( name );
+                return '([^/]+)';
+            } );
+            return {
+                regex: new RegExp( `^${ regexStr }$` ),
+                params: paramNames
+            };
+        }
+
+        function matchRoute( path ) {
+            for ( const route of routes ) {
+                const { regex, params } = pathToRegex( route.path );
+                const match = path.match( regex );
+                if ( match ) {
+                    const paramValues = {};
+                    params.forEach( ( name, i ) => {
+                        paramValues[ name ] = match[ i + 1 ];
+                    } );
+                    return {
+                        ...route,
+                        params: paramValues,
+                        query: parseQuery( path )
+                    };
+                }
+            }
+            return null;
+        }
+
+        function parseQuery( path ) {
+            const queryIndex = path.indexOf( '?' );
+            if ( queryIndex === -1 ) return {};
+            const queryStr = path.slice( queryIndex + 1 );
+            const result = {};
+            queryStr.split( '&' ).forEach( pair => {
+                const [ key, value ] = pair.split( '=' );
+                result[ decodeURIComponent( key ) ] = decodeURIComponent( value || '' );
+            } );
+            return result;
+        }
+
+        function extractPath( pathname ) {
+            const queryIndex = pathname.indexOf( '?' );
+            return queryIndex === -1 ? pathname : pathname.slice( 0, queryIndex );
+        }
+
+        async function executeGuards( to, from ) {
+            for ( const guard of guards ) {
+                const result = await guard( to, from );
+                if ( result === false ) return false;
+                if ( typeof result === 'string' ) {
+                    navigate( result, true );
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        function renderRoute( route ) {
+            if ( !rootContainer ) return;
+
+            const component = routeComponents[ route.component ];
+            if ( !component ) {
+                console.error( `Route component "${ route.component }" not found` );
+                return;
+            }
+
+            const element = magic.importM( component, {
+                ...route.params,
+                ...route.query
+            } );
+
+            rootContainer.innerHTML = '';
+            if ( element.fragment ) {
+                rootContainer.appendChild( element.fragment );
+            } else {
+                rootContainer.appendChild( element );
+            }
+
+            currentRoute = route;
+        }
+
+        function handleNavigation( path, replace = false ) {
+            const pathname = extractPath( path );
+            const route = matchRoute( pathname );
+
+            if ( !route ) {
+                console.error( `No route matched for path: ${ path }` );
+                return;
+            }
+
+            const from = currentRoute;
+            executeGuards( route, from ).then( ( canContinue ) => {
+                if ( canContinue === false ) return;
+
+                if ( replace ) {
+                    history.replaceState( null, '', path );
+                } else {
+                    history.pushState( null, '', path );
+                }
+                renderRoute( route );
+            } );
+        }
+
+        return {
+            getCurrentRoute() {
+                return currentRoute;
+            },
+
+            addRoute( path, component ) {
+                routes.push( { path, component } );
+                routeComponents[ component ] = component;
+            },
+
+            addRoutes( routeList ) {
+                routeList.forEach( r => this.addRoute( r.path, r.component ) );
+            },
+
+            init( containerId ) {
+                rootContainer = document.getElementById( containerId );
+                if ( !rootContainer ) {
+                    throw new Error( `Router container element "${ containerId }" not found` );
+                }
+
+                window.addEventListener( 'popstate', () => {
+                    const path = extractPath( location.pathname );
+                    const route = matchRoute( path );
+                    if ( route ) renderRoute( route );
+                } );
+
+                this.navigate( extractPath( location.pathname ), true );
+            },
+
+            navigate( path, replace = false ) {
+                handleNavigation( path, replace );
+            },
+
+            push( path ) {
+                handleNavigation( path, false );
+            },
+
+            replace( path ) {
+                handleNavigation( path, true );
+            },
+
+            beforeEach( guard ) {
+                guards.push( guard );
+            }
+        };
+    } )();
+
+    function init( main ) {
+        Object.freeze( window[ "magic_version" ] );
+        Object.freeze( window[ "magic" ] );
+
+        console.log( "%cMagic ヾ(๑╹◡╹)ﾉ",
+            "color:#f8faff;font-weight:bold;font-size:6em;padding:10px 30px;background: linear-gradient(to right top, #FFC0CB, #ADD8E6);" );
+        console.log( "magic v" + magic_version );
+
+        const app = document.getElementById( "app" );
+
+        app.appendChild( importM( main ).fragment );
+    }
+
+    return {
+        init,
+        dom,
+        importM,
+        call,
+        emit,
+        $id,
+        idGenerate,
+        $,
+        parserArgs,
+        createArgs,
+        parserListen,
+        on_event,
+        end_event,
+        mapIdElement,
+        createUiData,
+        importElementInit,
+        exportInterface,
+        GetInterface,
+        BindScope,
+        DynamicValueBind,
+        router
+    };
+} )();