@lynx-js/web-core-server-canary 0.18.4-canary-20251120-e2c78043 → 0.18.4

package/dist/index.js

@@ -4,194 +4,427 @@ import node_path from "node:path";
 import node_vm from "node:vm";
 import node_fs from "node:fs";
 var __webpack_modules__ = {
-    "../web-style-transformer/dist/standard.js": function(__webpack_module__, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.a(__webpack_module__, async function(__webpack_handle_async_dependencies__, __webpack_async_result__) {
-            try {
-                __webpack_require__.d(__webpack_exports__, {
-                    H4: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.H4,
-                    RS: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.RS,
-                    aC: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.aC,
-                    bL: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.bL,
-                    f: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.f,
-                    iG: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.iG,
-                    lI: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.lI,
-                    pY: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.pY
-                });
-                var _standard_bg_wasm__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../web-style-transformer/dist/standard_bg.wasm");
-                var _standard_bg_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-style-transformer/dist/standard_bg.js");
-                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
-                    _standard_bg_wasm__WEBPACK_IMPORTED_MODULE_1__
-                ]);
-                _standard_bg_wasm__WEBPACK_IMPORTED_MODULE_1__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
-                (0, _standard_bg_js__WEBPACK_IMPORTED_MODULE_0__.lI)(_standard_bg_wasm__WEBPACK_IMPORTED_MODULE_1__);
-                _standard_bg_wasm__WEBPACK_IMPORTED_MODULE_1__.__wbindgen_start();
-                __webpack_async_result__();
-            } catch (e) {
-                __webpack_async_result__(e);
-            }
-        });
-    },
-    "../web-style-transformer/dist/standard_bg.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+    "../web-constants/dist/index.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            H4: ()=>__wbg___wbindgen_throw_b855445ff6a94295,
-            RS: ()=>__wbg_push_df81a39d04db858c,
-            aC: ()=>transform_raw_u16_inline_style_ptr,
-            bL: ()=>__wbindgen_init_externref_table,
-            f: ()=>__wbg_new_e17d9f43105b08be,
-            iG: ()=>transform_raw_u16_inline_style_ptr_parsed,
-            lI: ()=>__wbg_set_wasm,
-            pY: ()=>__wbindgen_cast_2241b6af4c4b2941
+            tf: ()=>LynxCrossThreadContext,
+            iH: ()=>callLepusMethodEndpoint,
+            Yx: ()=>generateTemplate,
+            Fw: ()=>getCustomSectionsEndpoint,
+            JA: ()=>lynxDisposedAttribute,
+            oZ: ()=>"l-part",
+            Ke: ()=>publicComponentEventEndpoint,
+            Ve: ()=>updateDataEndpoint,
+            $4: ()=>W3cEventNameToLynx,
+            mB: ()=>dispatchI18nResourceEndpoint,
+            SP: ()=>"l-uid",
+            er: ()=>parentComponentUniqueIdAttribute,
+            Gq: ()=>lynxTagAttribute,
+            im: ()=>LynxEventNameToW3cCommon,
+            js: ()=>cssIdAttribute,
+            Is: ()=>dispatchJSContextOnMainThreadEndpoint,
+            HO: ()=>getCacheI18nResourcesKey,
+            jK: ()=>dispatchCoreContextOnBackgroundEndpoint,
+            I7: ()=>__lynx_timing_flag,
+            vQ: ()=>LynxEventNameToW3cByTagName,
+            tl: ()=>lynxComponentConfigAttribute,
+            WS: ()=>updateBTSTemplateCacheEndpoint,
+            Pb: ()=>lynxEntryNameAttribute,
+            c1: ()=>systemInfo,
+            y: ()=>lynxElementTemplateMarkerAttribute,
+            a$: ()=>BackgroundThreadStartEndpoint,
+            F6: ()=>postTimingFlagsEndpoint,
+            gI: ()=>I18nResources,
+            C6: ()=>"l-dset",
+            pP: ()=>componentIdAttribute,
+            Gm: ()=>lynxDefaultDisplayLinearAttribute,
+            pd: ()=>postExposureEndpoint,
+            nk: ()=>queryComponentEndpoint,
+            eZ: ()=>switchExposureServiceEndpoint,
+            OE: ()=>inShadowRootStyles,
+            JW: ()=>publishEventEndpoint
         });
-        let wasm;
-        function __wbg_set_wasm(val) {
-            wasm = val;
-        }
-        let cachedUint8ArrayMemory0 = null;
-        function getUint8ArrayMemory0() {
-            if (null === cachedUint8ArrayMemory0 || 0 === cachedUint8ArrayMemory0.byteLength) cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-            return cachedUint8ArrayMemory0;
+        const cssIdAttribute = 'l-css-id';
+        const componentIdAttribute = 'l-comp-id';
+        const parentComponentUniqueIdAttribute = 'l-p-comp-uid';
+        const lynxEntryNameAttribute = 'l-e-name';
+        const lynxTagAttribute = 'lynx-tag';
+        const lynxComponentConfigAttribute = 'l-comp-cfg';
+        const lynxDisposedAttribute = 'l-disposed';
+        const lynxElementTemplateMarkerAttribute = 'l-template';
+        const lynxDefaultDisplayLinearAttribute = 'lynx-default-display-linear';
+        const __lynx_timing_flag = '__lynx_timing_flag';
+        const systemInfo = {
+            platform: 'web',
+            lynxSdkVersion: '3.0'
+        };
+        const inShadowRootStyles = [
+            ` [lynx-default-display-linear="false"] * {
+    --lynx-display: flex;
+    --lynx-display-toggle: var(--lynx-display-flex);
+  }`,
+            `[lynx-default-overflow-visible="true"] x-view{
+    overflow: visible;
+  }`
+        ];
+        const W3cEventNameToLynx = {
+            click: 'tap',
+            lynxscroll: 'scroll',
+            lynxscrollend: 'scrollend',
+            overlaytouch: 'touch',
+            lynxfocus: 'focus',
+            lynxblur: 'blur',
+            lynxinput: 'input'
+        };
+        const LynxEventNameToW3cByTagName = {
+            'X-INPUT': {
+                blur: 'lynxblur',
+                focus: 'lynxfocus',
+                input: 'lynxinput'
+            },
+            'X-TEXTAREA': {
+                blur: 'lynxblur',
+                focus: 'lynxfocus',
+                input: 'lynxinput'
+            }
+        };
+        const LynxEventNameToW3cCommon = {
+            tap: 'click',
+            scroll: 'lynxscroll',
+            scrollend: 'lynxscrollend',
+            touch: 'overlaytouch'
+        };
+        var dist = __webpack_require__("../web-worker-rpc/dist/index.js");
+        const postExposureEndpoint = (0, dist.H)('__postExposure', false, false);
+        const publicComponentEventEndpoint = (0, dist.H)('publicComponentEvent', false, false);
+        const publishEventEndpoint = (0, dist.H)('publishEvent', false, false);
+        (0, dist.H)('postOffscreenEventEndpoint', false, false);
+        const switchExposureServiceEndpoint = (0, dist.H)('switchExposureServiceEndpoint', false, false);
+        (0, dist.H)('mainThreadStart', false, false);
+        const updateDataEndpoint = (0, dist.H)('updateData', false, true);
+        (0, dist.H)('sendGlobalEventEndpoint', false, false);
+        (0, dist.H)('dispose', false, true);
+        const BackgroundThreadStartEndpoint = (0, dist.H)('start', false, true);
+        (0, dist.H)('reportError', false, false);
+        (0, dist.H)('flushElementTree', false, true);
+        const callLepusMethodEndpoint = (0, dist.H)('callLepusMethod', false, true);
+        (0, dist.H)('multiThreadExposureChangedEndpoint', false, false);
+        (0, dist.H)('__invokeUIMethod', false, true);
+        (0, dist.H)('__setNativeProps', false, true);
+        (0, dist.H)('__getPathInfo', false, true);
+        (0, dist.H)('nativeModulesCall', false, true);
+        (0, dist.H)('napiModulesCall', false, true, true);
+        const getCustomSectionsEndpoint = (0, dist.H)('getCustomSections', false, true);
+        (0, dist.H)('markTiming', false, false);
+        const postTimingFlagsEndpoint = (0, dist.H)('postTimingFlags', false, false);
+        (0, dist.H)('__triggerComponentEvent', false, false);
+        (0, dist.H)('__selectComponent', false, true);
+        (0, dist.H)('dispatchLynxViewEvent', false, false);
+        (0, dist.H)('dispatchNapiModule', false, false);
+        const dispatchCoreContextOnBackgroundEndpoint = (0, dist.H)('dispatchCoreContextOnBackground', false, false);
+        const dispatchJSContextOnMainThreadEndpoint = (0, dist.H)('dispatchJSContextOnMainThread', false, false);
+        (0, dist.H)('__triggerElementMethod', false, false);
+        (0, dist.H)('updateGlobalProps', false, false);
+        (0, dist.H)('updateI18nResources', false, false);
+        (0, dist.H)('updateI18nResource', false, false);
+        const dispatchI18nResourceEndpoint = (0, dist.H)('dispatchI18nResource', false, false);
+        const queryComponentEndpoint = (0, dist.H)('queryComponent', false, true);
+        const updateBTSTemplateCacheEndpoint = (0, dist.H)('updateBTSTemplateCacheEndpoint', false, true);
+        (0, dist.H)('loadTemplateMultiThread', false, true);
+        var NativeApp_IdentifierType;
+        (function(IdentifierType) {
+            IdentifierType[IdentifierType["ID_SELECTOR"] = 0] = "ID_SELECTOR";
+            IdentifierType[IdentifierType["REF_ID"] = 1] = "REF_ID";
+            IdentifierType[IdentifierType["UNIQUE_ID"] = 2] = "UNIQUE_ID";
+        })(NativeApp_IdentifierType || (NativeApp_IdentifierType = {}));
+        var NativeApp_ErrorCode;
+        (function(ErrorCode) {
+            ErrorCode[ErrorCode["SUCCESS"] = 0] = "SUCCESS";
+            ErrorCode[ErrorCode["UNKNOWN"] = 1] = "UNKNOWN";
+            ErrorCode[ErrorCode["NODE_NOT_FOUND"] = 2] = "NODE_NOT_FOUND";
+            ErrorCode[ErrorCode["METHOD_NOT_FOUND"] = 3] = "METHOD_NOT_FOUND";
+            ErrorCode[ErrorCode["PARAM_INVALID"] = 4] = "PARAM_INVALID";
+            ErrorCode[ErrorCode["SELECTOR_NOT_SUPPORTED"] = 5] = "SELECTOR_NOT_SUPPORTED";
+            ErrorCode[ErrorCode["NO_UI_FOR_NODE"] = 6] = "NO_UI_FOR_NODE";
+        })(NativeApp_ErrorCode || (NativeApp_ErrorCode = {}));
+        var UpdateDataOptions_NativeUpdateDataType;
+        (function(NativeUpdateDataType) {
+            NativeUpdateDataType[NativeUpdateDataType["UPDATE"] = 0] = "UPDATE";
+            NativeUpdateDataType[NativeUpdateDataType["RESET"] = 1] = "RESET";
+        })(UpdateDataOptions_NativeUpdateDataType || (UpdateDataOptions_NativeUpdateDataType = {}));
+        const DispatchEventResult = {
+            NotCanceled: 0,
+            CanceledByEventHandler: 1,
+            CanceledByDefaultEventHandler: 2,
+            CanceledBeforeDispatch: 3
+        };
+        var Element_AnimationOperation;
+        (function(AnimationOperation) {
+            AnimationOperation[AnimationOperation["START"] = 0] = "START";
+            AnimationOperation[AnimationOperation["PLAY"] = 1] = "PLAY";
+            AnimationOperation[AnimationOperation["PAUSE"] = 2] = "PAUSE";
+            AnimationOperation[AnimationOperation["CANCEL"] = 3] = "CANCEL";
+            AnimationOperation[AnimationOperation["FINISH"] = 4] = "FINISH";
+        })(Element_AnimationOperation || (Element_AnimationOperation = {}));
+        const getCacheI18nResourcesKey = (options)=>`${options.locale}_${options.channel}_${options.fallback_url}`;
+        class I18nResources {
+            data;
+            constructor(data){
+                this.data = data;
+            }
+            setData(data) {
+                this.data = data;
+            }
         }
-        let cachedTextDecoder = new TextDecoder('utf-8', {
-            ignoreBOM: true,
-            fatal: true
-        });
-        cachedTextDecoder.decode();
-        const MAX_SAFARI_DECODE_BYTES = 2146435072;
-        let numBytesDecoded = 0;
-        function decodeText(ptr, len) {
-            numBytesDecoded += len;
-            if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-                cachedTextDecoder = new TextDecoder('utf-8', {
-                    ignoreBOM: true,
-                    fatal: true
+        class LynxCrossThreadContext extends EventTarget {
+            _config;
+            constructor(_config){
+                super();
+                this._config = _config;
+            }
+            postMessage(...args) {
+                console.error('[lynx-web] postMessage not implemented, args:', ...args);
+            }
+            dispatchEvent(event) {
+                const { rpc, sendEventEndpoint } = this._config;
+                rpc.invoke(sendEventEndpoint, [
+                    event
+                ]);
+                return DispatchEventResult.CanceledBeforeDispatch;
+            }
+            __start() {
+                const { rpc, receiveEventEndpoint } = this._config;
+                rpc.registerHandler(receiveEventEndpoint, ({ type, data })=>{
+                    super.dispatchEvent(new MessageEvent(type, {
+                        data: data ?? {}
+                    }));
                 });
-                cachedTextDecoder.decode();
-                numBytesDecoded = len;
             }
-            return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
         }
-        function getStringFromWasm0(ptr, len) {
-            ptr >>>= 0;
-            return decodeText(ptr, len);
+        const currentSupportedTemplateVersion = 2;
+        const globalDisallowedVars = [
+            'navigator',
+            'postMessage',
+            'window'
+        ];
+        const templateUpgraders = [
+            (template)=>{
+                template.appType = template.appType ?? (template.lepusCode.root.startsWith('(function (globDynamicComponentEntry') ? 'lazy' : 'card');
+                template.version = 2;
+                template.lepusCode = Object.fromEntries(Object.entries(template.lepusCode).filter(([_, content])=>'string' == typeof content));
+                return template;
+            }
+        ];
+        const generateModuleContent = (fileName, content, eager, appType)=>[
+                eager ? '//# allFunctionsCalledOnLoad' : '',
+                '\n(function() { "use strict"; const ',
+                globalDisallowedVars.join('=void 0,'),
+                '=void 0;\n',
+                'card' !== appType ? 'module.exports=\n' : '',
+                content,
+                '\n})()',
+                '\n//# sourceURL=',
+                fileName
+            ].join('');
+        async function generateJavascriptUrl(obj, createJsModuleUrl, eager, appType, templateName) {
+            return Promise.all(Object.entries(obj).filter(([_, content])=>'string' == typeof content).map(async ([name, content])=>[
+                    name,
+                    await createJsModuleUrl(generateModuleContent(`${templateName}/${name.replaceAll('/', '_')}.js`, content, eager, appType), `${templateName}-${name.replaceAll('/', '_')}.js`)
+                ])).then(Object.fromEntries);
         }
-        let WASM_VECTOR_LEN = 0;
-        const cachedTextEncoder = new TextEncoder();
-        if (!('encodeInto' in cachedTextEncoder)) cachedTextEncoder.encodeInto = function(arg, view) {
-            const buf = cachedTextEncoder.encode(arg);
-            view.set(buf);
+        async function generateTemplate(template, createJsModuleUrl, templateName) {
+            template.version = template.version ?? 1;
+            if (template.version > currentSupportedTemplateVersion) throw new Error("Unsupported template, please upgrade your web-platform dependencies");
+            let upgrader;
+            while(template.version < currentSupportedTemplateVersion && (upgrader = templateUpgraders[template.version - 1]))template = upgrader(template);
             return {
-                read: arg.length,
-                written: buf.length
+                ...template,
+                lepusCode: await generateJavascriptUrl(template.lepusCode, createJsModuleUrl, true, template.appType, templateName)
             };
-        };
-        function passStringToWasm0(arg, malloc, realloc) {
-            if (void 0 === realloc) {
-                const buf = cachedTextEncoder.encode(arg);
-                const ptr = malloc(buf.length, 1) >>> 0;
-                getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-                WASM_VECTOR_LEN = buf.length;
-                return ptr;
+        }
+    },
+    "../web-worker-rpc/dist/index.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            C: ()=>Rpc,
+            H: ()=>createRpcEndpoint
+        });
+        class Rpc {
+            port;
+            name;
+            incId = 0;
+            #messageCache = {};
+            #textEncoder = new TextEncoder();
+            #textDecoder = new TextDecoder();
+            #handlerMap = new Map();
+            constructor(port, name){
+                this.port = port;
+                this.name = name;
+                port.onmessage = (ev)=>this.#onMessage(ev.data);
             }
-            let len = arg.length;
-            let ptr = malloc(len, 1) >>> 0;
-            const mem = getUint8ArrayMemory0();
-            let offset = 0;
-            for(; offset < len; offset++){
-                const code = arg.charCodeAt(offset);
-                if (code > 0x7F) break;
-                mem[ptr + offset] = code;
+            get nextRetId() {
+                return `ret_${this.name}_${this.incId++}`;
             }
-            if (offset !== len) {
-                if (0 !== offset) arg = arg.slice(offset);
-                ptr = realloc(ptr, len, len = offset + 3 * arg.length, 1) >>> 0;
-                const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-                const ret = cachedTextEncoder.encodeInto(arg, view);
-                offset += ret.written;
-                ptr = realloc(ptr, len, offset, 1) >>> 0;
+            static createRetEndpoint(retId) {
+                return {
+                    name: retId,
+                    hasReturn: false,
+                    isSync: false
+                };
             }
-            WASM_VECTOR_LEN = offset;
-            return ptr;
-        }
-        function transform_raw_u16_inline_style_ptr(str) {
-            const ptr0 = passStringToWasm0(str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.transform_raw_u16_inline_style_ptr(ptr0, len0);
-            let v2;
-            if (0 !== ret[0]) {
-                v2 = getStringFromWasm0(ret[0], ret[1]).slice();
-                wasm.__wbindgen_free(ret[0], +ret[1], 1);
+            #onMessage = async (message)=>{
+                const handler = this.#handlerMap.get(message.name);
+                if (handler) {
+                    const lockViewer = message.sync ? new Int32Array(message.lock) : void 0;
+                    const replyTempEndpoint = !message.sync && message.retId ? Rpc.createRetEndpoint(message.retId) : void 0;
+                    try {
+                        const result = await handler(...message.data);
+                        let retData, transfer = [];
+                        if (message.sync) retData = result;
+                        else if (message.hasTransfer) ({ data: retData, transfer } = result || {});
+                        else retData = result;
+                        if (message.sync) {
+                            if (message.buf) {
+                                const retStr = JSON.stringify(retData);
+                                const lengthViewer = new Uint32Array(message.buf, 0, 1);
+                                const bufViewer = new Uint8Array(message.buf, 4);
+                                const retCache = new Uint8Array(message.buf.byteLength - 4);
+                                const { written: byteLength } = this.#textEncoder.encodeInto(retStr, retCache);
+                                lengthViewer[0] = byteLength;
+                                bufViewer.set(retCache, 0);
+                            }
+                            Atomics.store(lockViewer, 0, 1);
+                            Atomics.notify(lockViewer, 0);
+                        } else if (message.retId) this.invoke(replyTempEndpoint, [
+                            retData,
+                            false
+                        ], transfer || []);
+                    } catch (e) {
+                        console.error(e);
+                        if (message.sync) {
+                            Atomics.store(lockViewer, 0, 2);
+                            Atomics.notify(lockViewer, 0);
+                            lockViewer[1] = 2;
+                        } else this.invoke(replyTempEndpoint, [
+                            void 0,
+                            true
+                        ]);
+                    }
+                } else {
+                    const cache = this.#messageCache[message.name];
+                    if (cache) cache.push(message);
+                    else this.#messageCache[message.name] = [
+                        message
+                    ];
+                }
+            };
+            createCall(endpoint) {
+                return (...args)=>this.invoke(endpoint, args);
             }
-            return v2;
-        }
-        function transform_raw_u16_inline_style_ptr_parsed(name, value) {
-            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            const ret = wasm.transform_raw_u16_inline_style_ptr_parsed(ptr0, len0, ptr1, len1);
-            return ret;
-        }
-        function __wbg___wbindgen_throw_b855445ff6a94295(arg0, arg1) {
-            throw new Error(getStringFromWasm0(arg0, arg1));
-        }
-        function __wbg_new_e17d9f43105b08be() {
-            const ret = new Array();
-            return ret;
-        }
-        function __wbg_push_df81a39d04db858c(arg0, arg1) {
-            const ret = arg0.push(arg1);
-            return ret;
-        }
-        function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
-            const ret = getStringFromWasm0(arg0, arg1);
-            return ret;
-        }
-        function __wbindgen_init_externref_table() {
-            const table = wasm.__wbindgen_externrefs;
-            const offset = table.grow(4);
-            table.set(0, void 0);
-            table.set(offset + 0, void 0);
-            table.set(offset + 1, null);
-            table.set(offset + 2, true);
-            table.set(offset + 3, false);
-        }
-    },
-    "../web-style-transformer/standard.js": function(__webpack_module__, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.a(__webpack_module__, async function(__webpack_handle_async_dependencies__, __webpack_async_result__) {
-            try {
-                __webpack_require__.r(__webpack_exports__);
-                __webpack_require__.d(__webpack_exports__, {
-                    __wbg___wbindgen_throw_b855445ff6a94295: ()=>_dist_standard_js__WEBPACK_IMPORTED_MODULE_0__.H4,
-                    __wbg_new_e17d9f43105b08be: ()=>_dist_standard_js__WEBPACK_IMPORTED_MODULE_0__.f,
-                    __wbg_push_df81a39d04db858c: ()=>_dist_standard_js__WEBPACK_IMPORTED_MODULE_0__.RS,
-                    __wbg_set_wasm: ()=>_dist_standard_js__WEBPACK_IMPORTED_MODULE_0__.lI,
-                    __wbindgen_cast_2241b6af4c4b2941: ()=>_dist_standard_js__WEBPACK_IMPORTED_MODULE_0__.pY,
-                    __wbindgen_init_externref_table: ()=>_dist_standard_js__WEBPACK_IMPORTED_MODULE_0__.bL,
-                    transform_raw_u16_inline_style_ptr: ()=>_dist_standard_js__WEBPACK_IMPORTED_MODULE_0__.aC,
-                    transform_raw_u16_inline_style_ptr_parsed: ()=>_dist_standard_js__WEBPACK_IMPORTED_MODULE_0__.iG
-                });
-                var _dist_standard_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-style-transformer/dist/standard.js");
-                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
-                    _dist_standard_js__WEBPACK_IMPORTED_MODULE_0__
-                ]);
-                _dist_standard_js__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
-                __webpack_async_result__();
-            } catch (e) {
-                __webpack_async_result__(e);
+            registerHandler(endpoint, handler) {
+                this.#handlerMap.set(endpoint.name, handler);
+                const currentCache = this.#messageCache[endpoint.name];
+                if (currentCache?.length) {
+                    this.#messageCache[endpoint.name] = void 0;
+                    for (const message of currentCache)this.#onMessage(message);
+                }
             }
-        });
-    },
-    "../web-style-transformer/dist/standard_bg.wasm": function(module, exports, __webpack_require__) {
-        var WEBPACK_IMPORTED_MODULE_0 = __webpack_require__("../web-style-transformer/dist/standard_bg.js");
-        module.exports = __webpack_require__.v(exports, module.id, "75dda3584a4e8253", {
-            "./standard_bg.js": {
-                __wbg_new_e17d9f43105b08be: WEBPACK_IMPORTED_MODULE_0.f,
-                __wbg_push_df81a39d04db858c: WEBPACK_IMPORTED_MODULE_0.RS,
-                __wbg___wbindgen_throw_b855445ff6a94295: WEBPACK_IMPORTED_MODULE_0.H4,
-                __wbindgen_init_externref_table: WEBPACK_IMPORTED_MODULE_0.bL,
-                __wbindgen_cast_2241b6af4c4b2941: WEBPACK_IMPORTED_MODULE_0.pY
+            registerHandlerRef(endpoint, target, propertyName) {
+                this.registerHandler(endpoint, (...args)=>target[propertyName]?.call(target, ...args));
             }
-        });
+            registerHandlerLazy(endpoint, target, propertyName) {
+                if (target[propertyName]) this.registerHandlerRef(endpoint, target, propertyName);
+                else {
+                    let property;
+                    const rpc = this;
+                    Object.defineProperty(target, propertyName, {
+                        get () {
+                            return property;
+                        },
+                        set (v) {
+                            property = v;
+                            if (v) rpc.registerHandlerRef(endpoint, target, propertyName);
+                        }
+                    });
+                }
+            }
+            removeHandler(rpc) {
+                this.#handlerMap.delete(rpc.name);
+            }
+            invoke(endpoint, parameters, transfer = []) {
+                if (endpoint.isSync) {
+                    const sharedBuffer = endpoint.bufferSize ? new SharedArrayBuffer(endpoint.bufferSize + 4) : void 0;
+                    const lock = new SharedArrayBuffer(4);
+                    const lockViewer = new Int32Array(lock);
+                    lockViewer[0] = 0;
+                    const message = {
+                        name: endpoint.name,
+                        data: parameters,
+                        sync: true,
+                        lock: lock,
+                        buf: sharedBuffer
+                    };
+                    this.port.postMessage(message, {
+                        transfer
+                    });
+                    Atomics.wait(lockViewer, 0, 0);
+                    if (2 === lockViewer[0]) throw null;
+                    if (!sharedBuffer) return;
+                    {
+                        const byteLength = new Uint32Array(sharedBuffer, 0, 4)[0];
+                        const sharedBufferView = new Uint8Array(sharedBuffer, 4, byteLength);
+                        const localBuf = new Uint8Array(byteLength);
+                        localBuf.set(sharedBufferView, 0);
+                        const ret = localBuf ? JSON.parse(this.#textDecoder.decode(localBuf)) : void 0;
+                        return ret;
+                    }
+                }
+                if (endpoint.hasReturn) {
+                    const { promise, resolve, reject } = Promise.withResolvers();
+                    const retHandler = Rpc.createRetEndpoint(this.nextRetId);
+                    this.registerHandler(retHandler, (returnValue, error)=>{
+                        if (error) reject();
+                        resolve(returnValue);
+                    });
+                    const message = {
+                        name: endpoint.name,
+                        data: parameters,
+                        sync: false,
+                        retId: retHandler?.name,
+                        hasTransfer: endpoint.hasReturnTransfer
+                    };
+                    this.port.postMessage(message, {
+                        transfer
+                    });
+                    return promise;
+                }
+                {
+                    const message = {
+                        name: endpoint.name,
+                        data: parameters,
+                        sync: false
+                    };
+                    this.port.postMessage(message, {
+                        transfer
+                    });
+                }
+            }
+            createCallbackify(endpoint, callbackAt) {
+                const call = this.createCall(endpoint);
+                return (...params)=>{
+                    const callback = params.at(callbackAt);
+                    params.splice(callbackAt, 1);
+                    call(...params).then(callback);
+                };
+            }
+        }
+        function createRpcEndpoint(name, isSync, hasReturn = true, hasReturnTransfer = false, bufferSize) {
+            return {
+                name,
+                isSync,
+                hasReturn,
+                hasReturnTransfer,
+                bufferSize
+            };
+        }
     }
 };
 var __webpack_module_cache__ = {};
@@ -312,7 +545,10 @@ __webpack_require__.m = __webpack_modules__;
         }, []));
 })();
 (()=>{
-    __webpack_require__.u = (chunkId)=>"legacy-wasm-chunk.js";
+    __webpack_require__.k = (chunkId)=>"" + chunkId + ".css";
+})();
+(()=>{
+    __webpack_require__.u = (chunkId)=>"" + ("8" === chunkId ? "legacy-wasm-chunk" : chunkId) + ".js";
 })();
 (()=>{
     __webpack_require__.g = (()=>{
@@ -404,1756 +640,12 @@ __webpack_require__.m = __webpack_modules__;
         }
     };
 })();
-const cssIdAttribute = 'l-css-id';
-const componentIdAttribute = 'l-comp-id';
-const parentComponentUniqueIdAttribute = 'l-p-comp-uid';
-const lynxEntryNameAttribute = 'l-e-name';
-const lynxTagAttribute = 'lynx-tag';
-const lynxComponentConfigAttribute = 'l-comp-cfg';
-const lynxDisposedAttribute = 'l-disposed';
-const lynxElementTemplateMarkerAttribute = 'l-template';
-const lynxDefaultDisplayLinearAttribute = 'lynx-default-display-linear';
-const __lynx_timing_flag = '__lynx_timing_flag';
-const systemInfo = {
-    platform: 'web',
-    lynxSdkVersion: '3.0'
-};
-const inShadowRootStyles = [
-    ` [lynx-default-display-linear="false"] * {
-    --lynx-display: flex;
-    --lynx-display-toggle: var(--lynx-display-flex);
-  }`,
-    `[lynx-default-overflow-visible="true"] x-view{
-    overflow: visible;
-  }`
-];
-const W3cEventNameToLynx = {
-    click: 'tap',
-    lynxscroll: 'scroll',
-    lynxscrollend: 'scrollend',
-    overlaytouch: 'touch',
-    lynxfocus: 'focus',
-    lynxblur: 'blur',
-    lynxinput: 'input'
-};
-const LynxEventNameToW3cByTagName = {
-    'X-INPUT': {
-        blur: 'lynxblur',
-        focus: 'lynxfocus',
-        input: 'lynxinput'
-    },
-    'X-TEXTAREA': {
-        blur: 'lynxblur',
-        focus: 'lynxfocus',
-        input: 'lynxinput'
-    }
-};
-const LynxEventNameToW3cCommon = {
-    tap: 'click',
-    scroll: 'lynxscroll',
-    scrollend: 'lynxscrollend',
-    touch: 'overlaytouch'
-};
-class Rpc {
-    port;
-    name;
-    incId = 0;
-    #messageCache = {};
-    #textEncoder = new TextEncoder();
-    #textDecoder = new TextDecoder();
-    #handlerMap = new Map();
-    constructor(port, name){
-        this.port = port;
-        this.name = name;
-        port.onmessage = (ev)=>this.#onMessage(ev.data);
-    }
-    get nextRetId() {
-        return `ret_${this.name}_${this.incId++}`;
-    }
-    static createRetEndpoint(retId) {
-        return {
-            name: retId,
-            hasReturn: false,
-            isSync: false
-        };
-    }
-    #onMessage = async (message)=>{
-        const handler = this.#handlerMap.get(message.name);
-        if (handler) {
-            const lockViewer = message.sync ? new Int32Array(message.lock) : void 0;
-            const replyTempEndpoint = !message.sync && message.retId ? Rpc.createRetEndpoint(message.retId) : void 0;
-            try {
-                const result = await handler(...message.data);
-                let retData, transfer = [];
-                if (message.sync) retData = result;
-                else if (message.hasTransfer) ({ data: retData, transfer } = result || {});
-                else retData = result;
-                if (message.sync) {
-                    if (message.buf) {
-                        const retStr = JSON.stringify(retData);
-                        const lengthViewer = new Uint32Array(message.buf, 0, 1);
-                        const bufViewer = new Uint8Array(message.buf, 4);
-                        const retCache = new Uint8Array(message.buf.byteLength - 4);
-                        const { written: byteLength } = this.#textEncoder.encodeInto(retStr, retCache);
-                        lengthViewer[0] = byteLength;
-                        bufViewer.set(retCache, 0);
-                    }
-                    Atomics.store(lockViewer, 0, 1);
-                    Atomics.notify(lockViewer, 0);
-                } else if (message.retId) this.invoke(replyTempEndpoint, [
-                    retData,
-                    false
-                ], transfer || []);
-            } catch (e) {
-                console.error(e);
-                if (message.sync) {
-                    Atomics.store(lockViewer, 0, 2);
-                    Atomics.notify(lockViewer, 0);
-                    lockViewer[1] = 2;
-                } else this.invoke(replyTempEndpoint, [
-                    void 0,
-                    true
-                ]);
-            }
-        } else {
-            const cache = this.#messageCache[message.name];
-            if (cache) cache.push(message);
-            else this.#messageCache[message.name] = [
-                message
-            ];
-        }
-    };
-    createCall(endpoint) {
-        return (...args)=>this.invoke(endpoint, args);
-    }
-    registerHandler(endpoint, handler) {
-        this.#handlerMap.set(endpoint.name, handler);
-        const currentCache = this.#messageCache[endpoint.name];
-        if (currentCache?.length) {
-            this.#messageCache[endpoint.name] = void 0;
-            for (const message of currentCache)this.#onMessage(message);
-        }
-    }
-    registerHandlerRef(endpoint, target, propertyName) {
-        this.registerHandler(endpoint, (...args)=>target[propertyName]?.call(target, ...args));
-    }
-    registerHandlerLazy(endpoint, target, propertyName) {
-        if (target[propertyName]) this.registerHandlerRef(endpoint, target, propertyName);
-        else {
-            let property;
-            const rpc = this;
-            Object.defineProperty(target, propertyName, {
-                get () {
-                    return property;
-                },
-                set (v) {
-                    property = v;
-                    if (v) rpc.registerHandlerRef(endpoint, target, propertyName);
-                }
-            });
-        }
-    }
-    removeHandler(rpc) {
-        this.#handlerMap.delete(rpc.name);
-    }
-    invoke(endpoint, parameters, transfer = []) {
-        if (endpoint.isSync) {
-            const sharedBuffer = endpoint.bufferSize ? new SharedArrayBuffer(endpoint.bufferSize + 4) : void 0;
-            const lock = new SharedArrayBuffer(4);
-            const lockViewer = new Int32Array(lock);
-            lockViewer[0] = 0;
-            const message = {
-                name: endpoint.name,
-                data: parameters,
-                sync: true,
-                lock: lock,
-                buf: sharedBuffer
-            };
-            this.port.postMessage(message, {
-                transfer
-            });
-            Atomics.wait(lockViewer, 0, 0);
-            if (2 === lockViewer[0]) throw null;
-            if (!sharedBuffer) return;
-            {
-                const byteLength = new Uint32Array(sharedBuffer, 0, 4)[0];
-                const sharedBufferView = new Uint8Array(sharedBuffer, 4, byteLength);
-                const localBuf = new Uint8Array(byteLength);
-                localBuf.set(sharedBufferView, 0);
-                const ret = localBuf ? JSON.parse(this.#textDecoder.decode(localBuf)) : void 0;
-                return ret;
-            }
-        }
-        if (endpoint.hasReturn) {
-            const { promise, resolve, reject } = Promise.withResolvers();
-            const retHandler = Rpc.createRetEndpoint(this.nextRetId);
-            this.registerHandler(retHandler, (returnValue, error)=>{
-                if (error) reject();
-                resolve(returnValue);
-            });
-            const message = {
-                name: endpoint.name,
-                data: parameters,
-                sync: false,
-                retId: retHandler?.name,
-                hasTransfer: endpoint.hasReturnTransfer
-            };
-            this.port.postMessage(message, {
-                transfer
-            });
-            return promise;
-        }
-        {
-            const message = {
-                name: endpoint.name,
-                data: parameters,
-                sync: false
-            };
-            this.port.postMessage(message, {
-                transfer
-            });
-        }
-    }
-    createCallbackify(endpoint, callbackAt) {
-        const call = this.createCall(endpoint);
-        return (...params)=>{
-            const callback = params.at(callbackAt);
-            params.splice(callbackAt, 1);
-            call(...params).then(callback);
-        };
-    }
-}
-function createRpcEndpoint(name, isSync, hasReturn = true, hasReturnTransfer = false, bufferSize) {
-    return {
-        name,
-        isSync,
-        hasReturn,
-        hasReturnTransfer,
-        bufferSize
-    };
-}
-const postExposureEndpoint = createRpcEndpoint('__postExposure', false, false);
-const publicComponentEventEndpoint = createRpcEndpoint('publicComponentEvent', false, false);
-const publishEventEndpoint = createRpcEndpoint('publishEvent', false, false);
-createRpcEndpoint('postOffscreenEventEndpoint', false, false);
-const switchExposureServiceEndpoint = createRpcEndpoint('switchExposureServiceEndpoint', false, false);
-createRpcEndpoint('mainThreadStart', false, false);
-const updateDataEndpoint = createRpcEndpoint('updateData', false, true);
-createRpcEndpoint('sendGlobalEventEndpoint', false, false);
-createRpcEndpoint('dispose', false, true);
-const BackgroundThreadStartEndpoint = createRpcEndpoint('start', false, true);
-createRpcEndpoint('reportError', false, false);
-createRpcEndpoint('flushElementTree', false, true);
-const callLepusMethodEndpoint = createRpcEndpoint('callLepusMethod', false, true);
-createRpcEndpoint('multiThreadExposureChangedEndpoint', false, false);
-createRpcEndpoint('__invokeUIMethod', false, true);
-createRpcEndpoint('__setNativeProps', false, true);
-createRpcEndpoint('__getPathInfo', false, true);
-createRpcEndpoint('nativeModulesCall', false, true);
-createRpcEndpoint('napiModulesCall', false, true, true);
-const getCustomSectionsEndpoint = createRpcEndpoint('getCustomSections', false, true);
-createRpcEndpoint('markTiming', false, false);
-const postTimingFlagsEndpoint = createRpcEndpoint('postTimingFlags', false, false);
-createRpcEndpoint('__triggerComponentEvent', false, false);
-createRpcEndpoint('__selectComponent', false, true);
-createRpcEndpoint('dispatchLynxViewEvent', false, false);
-createRpcEndpoint('dispatchNapiModule', false, false);
-const dispatchCoreContextOnBackgroundEndpoint = createRpcEndpoint('dispatchCoreContextOnBackground', false, false);
-const dispatchJSContextOnMainThreadEndpoint = createRpcEndpoint('dispatchJSContextOnMainThread', false, false);
-createRpcEndpoint('__triggerElementMethod', false, false);
-createRpcEndpoint('updateGlobalProps', false, false);
-createRpcEndpoint('updateI18nResources', false, false);
-createRpcEndpoint('updateI18nResource', false, false);
-const dispatchI18nResourceEndpoint = createRpcEndpoint('dispatchI18nResource', false, false);
-const queryComponentEndpoint = createRpcEndpoint('queryComponent', false, true);
-const updateBTSTemplateCacheEndpoint = createRpcEndpoint('updateBTSTemplateCacheEndpoint', false, true);
-createRpcEndpoint('loadTemplateMultiThread', false, true);
-var NativeApp_IdentifierType;
-(function(IdentifierType) {
-    IdentifierType[IdentifierType["ID_SELECTOR"] = 0] = "ID_SELECTOR";
-    IdentifierType[IdentifierType["REF_ID"] = 1] = "REF_ID";
-    IdentifierType[IdentifierType["UNIQUE_ID"] = 2] = "UNIQUE_ID";
-})(NativeApp_IdentifierType || (NativeApp_IdentifierType = {}));
-var NativeApp_ErrorCode;
-(function(ErrorCode) {
-    ErrorCode[ErrorCode["SUCCESS"] = 0] = "SUCCESS";
-    ErrorCode[ErrorCode["UNKNOWN"] = 1] = "UNKNOWN";
-    ErrorCode[ErrorCode["NODE_NOT_FOUND"] = 2] = "NODE_NOT_FOUND";
-    ErrorCode[ErrorCode["METHOD_NOT_FOUND"] = 3] = "METHOD_NOT_FOUND";
-    ErrorCode[ErrorCode["PARAM_INVALID"] = 4] = "PARAM_INVALID";
-    ErrorCode[ErrorCode["SELECTOR_NOT_SUPPORTED"] = 5] = "SELECTOR_NOT_SUPPORTED";
-    ErrorCode[ErrorCode["NO_UI_FOR_NODE"] = 6] = "NO_UI_FOR_NODE";
-})(NativeApp_ErrorCode || (NativeApp_ErrorCode = {}));
-var UpdateDataOptions_NativeUpdateDataType;
-(function(NativeUpdateDataType) {
-    NativeUpdateDataType[NativeUpdateDataType["UPDATE"] = 0] = "UPDATE";
-    NativeUpdateDataType[NativeUpdateDataType["RESET"] = 1] = "RESET";
-})(UpdateDataOptions_NativeUpdateDataType || (UpdateDataOptions_NativeUpdateDataType = {}));
-const DispatchEventResult = {
-    NotCanceled: 0,
-    CanceledByEventHandler: 1,
-    CanceledByDefaultEventHandler: 2,
-    CanceledBeforeDispatch: 3
-};
-var Element_AnimationOperation;
-(function(AnimationOperation) {
-    AnimationOperation[AnimationOperation["START"] = 0] = "START";
-    AnimationOperation[AnimationOperation["PLAY"] = 1] = "PLAY";
-    AnimationOperation[AnimationOperation["PAUSE"] = 2] = "PAUSE";
-    AnimationOperation[AnimationOperation["CANCEL"] = 3] = "CANCEL";
-    AnimationOperation[AnimationOperation["FINISH"] = 4] = "FINISH";
-})(Element_AnimationOperation || (Element_AnimationOperation = {}));
-const getCacheI18nResourcesKey = (options)=>`${options.locale}_${options.channel}_${options.fallback_url}`;
-class I18nResources {
-    data;
-    constructor(data){
-        this.data = data;
-    }
-    setData(data) {
-        this.data = data;
-    }
-}
-class LynxCrossThreadContext extends EventTarget {
-    _config;
-    constructor(_config){
-        super();
-        this._config = _config;
-    }
-    postMessage(...args) {
-        console.error('[lynx-web] postMessage not implemented, args:', ...args);
-    }
-    dispatchEvent(event) {
-        const { rpc, sendEventEndpoint } = this._config;
-        rpc.invoke(sendEventEndpoint, [
-            event
-        ]);
-        return DispatchEventResult.CanceledBeforeDispatch;
-    }
-    __start() {
-        const { rpc, receiveEventEndpoint } = this._config;
-        rpc.registerHandler(receiveEventEndpoint, ({ type, data })=>{
-            super.dispatchEvent(new MessageEvent(type, {
-                data: data ?? {}
-            }));
-        });
-    }
-}
-const currentSupportedTemplateVersion = 2;
-const globalDisallowedVars = [
-    'navigator',
-    'postMessage',
-    'window'
-];
-const templateUpgraders = [
-    (template)=>{
-        template.appType = template.appType ?? (template.lepusCode.root.startsWith('(function (globDynamicComponentEntry') ? 'lazy' : 'card');
-        template.version = 2;
-        template.lepusCode = Object.fromEntries(Object.entries(template.lepusCode).filter(([_, content])=>'string' == typeof content));
-        return template;
-    }
-];
-const generateModuleContent = (fileName, content, eager, appType)=>[
-        eager ? '//# allFunctionsCalledOnLoad' : '',
-        '\n(function() { "use strict"; const ',
-        globalDisallowedVars.join('=void 0,'),
-        '=void 0;\n',
-        'card' !== appType ? 'module.exports=\n' : '',
-        content,
-        '\n})()',
-        '\n//# sourceURL=',
-        fileName
-    ].join('');
-async function generateJavascriptUrl(obj, createJsModuleUrl, eager, appType, templateName) {
-    return Promise.all(Object.entries(obj).filter(([_, content])=>'string' == typeof content).map(async ([name, content])=>[
-            name,
-            await createJsModuleUrl(generateModuleContent(`${templateName}/${name.replaceAll('/', '_')}.js`, content, eager, appType), `${templateName}-${name.replaceAll('/', '_')}.js`)
-        ])).then(Object.fromEntries);
-}
-async function generateTemplate(template, createJsModuleUrl, templateName) {
-    template.version = template.version ?? 1;
-    if (template.version > currentSupportedTemplateVersion) throw new Error("Unsupported template, please upgrade your web-platform dependencies");
-    let upgrader;
-    while(template.version < currentSupportedTemplateVersion && (upgrader = templateUpgraders[template.version - 1]))template = upgrader(template);
-    return {
-        ...template,
-        lepusCode: await generateJavascriptUrl(template.lepusCode, createJsModuleUrl, true, template.appType, templateName)
-    };
-}
-function registerCallLepusMethodHandler(rpc, runtime) {
-    rpc.registerHandler(callLepusMethodEndpoint, (methodName, data)=>{
-        runtime[methodName](data);
-    });
-}
-function registerGetCustomSectionHandler(rpc, customSections) {
-    rpc.registerHandler(getCustomSectionsEndpoint, (key)=>customSections[key]?.content);
-}
-function createMainThreadLynx(config, SystemInfo) {
-    const requestAnimationFrameBrowserImpl = requestAnimationFrame;
-    const cancelAnimationFrameBrowserImpl = cancelAnimationFrame;
-    const setTimeoutBrowserImpl = setTimeout;
-    const clearTimeoutBrowserImpl = clearTimeout;
-    const setIntervalBrowserImpl = setInterval;
-    const clearIntervalBrowserImpl = clearInterval;
-    return {
-        getJSContext () {
-            return config.jsContext;
-        },
-        requestAnimationFrame (cb) {
-            return requestAnimationFrameBrowserImpl(cb);
-        },
-        cancelAnimationFrame (handler) {
-            return cancelAnimationFrameBrowserImpl(handler);
-        },
-        __globalProps: config.globalProps,
-        getCustomSectionSync (key) {
-            return config.lynxTemplate.customSections[key]?.content;
-        },
-        markPipelineTiming: config.callbacks.markTiming,
-        SystemInfo,
-        setTimeout: setTimeoutBrowserImpl,
-        clearTimeout: clearTimeoutBrowserImpl,
-        setInterval: setIntervalBrowserImpl,
-        clearInterval: clearIntervalBrowserImpl
-    };
-}
-const cacheForCamelize = {};
-function camelize(str) {
-    if (cacheForCamelize[str]) return cacheForCamelize[str];
-    const result = (str + '').replace(/-\D/g, function(match) {
-        return match.charAt(1).toUpperCase();
-    });
-    cacheForCamelize[str] = result;
-    return result;
-}
-let cssPropertyMap_index = 1;
-const cssPropertyMap = {};
-const cssPropertyReverseMap = {};
-const V = (name)=>{
-    const k = cssPropertyMap_index++;
-    const isX = name.startsWith('-x-');
-    cssPropertyMap[k] = {
-        name: camelize(name),
-        dashName: name,
-        isX
-    };
-    cssPropertyReverseMap[name] = k;
-};
-V('top');
-V('left');
-V('right');
-V('bottom');
-V('position');
-V('box-sizing');
-V('background-color');
-V('border-left-color');
-V('border-right-color');
-V('border-top-color');
-V('border-bottom-color');
-V('border-radius');
-V('border-top-left-radius');
-V('border-bottom-left-radius');
-V('border-top-right-radius');
-V('border-bottom-right-radius');
-V('border-width');
-V('border-left-width');
-V('border-right-width');
-V('border-top-width');
-V('border-bottom-width');
-V('color');
-V('opacity');
-V('display');
-V('overflow');
-V('height');
-V('width');
-V('max-width');
-V('min-width');
-V('max-height');
-V('min-height');
-V('padding');
-V('padding-left');
-V('padding-right');
-V('padding-top');
-V('padding-bottom');
-V('margin');
-V('margin-left');
-V('margin-right');
-V('margin-top');
-V('margin-bottom');
-V('white-space');
-V('letter-spacing');
-V('text-align');
-V('line-height');
-V('text-overflow');
-V('font-size');
-V('font-weight');
-V('flex');
-V('flex-grow');
-V('flex-shrink');
-V('flex-basis');
-V('flex-direction');
-V('flex-wrap');
-V('align-items');
-V('align-self');
-V('align-content');
-V('justify-content');
-V('background');
-V('border-color');
-V('font-family');
-V('font-style');
-V('transform');
-V('animation');
-V('animation-name');
-V('animation-duration');
-V('animation-timing-function');
-V('animation-delay');
-V('animation-iteration-count');
-V('animation-direction');
-V('animation-fill-mode');
-V('animation-play-state');
-V('line-spacing');
-V('border-style');
-V('order');
-V('box-shadow');
-V('transform-origin');
-V('linear-orientation');
-V('linear-weight-sum');
-V('linear-weight');
-V('linear-gravity');
-V('linear-layout-gravity');
-V('layout-animation-create-duration');
-V('layout-animation-create-timing-function');
-V('layout-animation-create-delay');
-V('layout-animation-create-property');
-V('layout-animation-delete-duration');
-V('layout-animation-delete-timing-function');
-V('layout-animation-delete-delay');
-V('layout-animation-delete-property');
-V('layout-animation-update-duration');
-V('layout-animation-update-timing-function');
-V('layout-animation-update-delay');
-V('adapt-font-size');
-V('aspect-ratio');
-V('text-decoration');
-V('text-shadow');
-V('background-image');
-V('background-position');
-V('background-origin');
-V('background-repeat');
-V('background-size');
-V('border');
-V('visibility');
-V('border-right');
-V('border-left');
-V('border-top');
-V('border-bottom');
-V('transition');
-V('transition-property');
-V('transition-duration');
-V('transition-delay');
-V('transition-timing-function');
-V('content');
-V('border-left-style');
-V('border-right-style');
-V('border-top-style');
-V('border-bottom-style');
-V('implicit-animation');
-V('overflow-x');
-V('overflow-y');
-V('word-break');
-V('background-clip');
-V('outline');
-V('outline-color');
-V('outline-style');
-V('outline-width');
-V('vertical-align');
-V('caret-color');
-V('direction');
-V('relative-id');
-V('relative-align-top');
-V('relative-align-right');
-V('relative-align-bottom');
-V('relative-align-left');
-V('relative-top-of');
-V('relative-right-of');
-V('relative-bottom-of');
-V('relative-left-of');
-V('relative-layout-once');
-V('relative-center');
-V('enter-transition-name');
-V('exit-transition-name');
-V('pause-transition-name');
-V('resume-transition-name');
-V('flex-flow');
-V('z-index');
-V('text-decoration-color');
-V('linear-cross-gravity');
-V('margin-inline-start');
-V('margin-inline-end');
-V('padding-inline-start');
-V('padding-inline-end');
-V('border-inline-start-color');
-V('border-inline-end-color');
-V('border-inline-start-width');
-V('border-inline-end-width');
-V('border-inline-start-style');
-V('border-inline-end-style');
-V('border-start-start-radius');
-V('border-end-start-radius');
-V('border-start-end-radius');
-V('border-end-end-radius');
-V('relative-align-inline-start');
-V('relative-align-inline-end');
-V('relative-inline-start-of');
-V('relative-inline-end-of');
-V('inset-inline-start');
-V('inset-inline-end');
-V('mask-image');
-V('grid-template-columns');
-V('grid-template-rows');
-V('grid-auto-columns');
-V('grid-auto-rows');
-V('grid-column-span');
-V('grid-row-span');
-V('grid-column-start');
-V('grid-column-end');
-V('grid-row-start');
-V('grid-row-end');
-V('grid-column-gap');
-V('grid-row-gap');
-V('justify-items');
-V('justify-self');
-V('grid-auto-flow');
-V('filter');
-V('list-main-axis-gap');
-V('list-cross-axis-gap');
-V('linear-direction');
-V('perspective');
-V('cursor');
-V('text-indent');
-V('clip-path');
-V('text-stroke');
-V('text-stroke-width');
-V('text-stroke-color');
-V('-x-auto-font-size');
-V('-x-auto-font-size-preset-sizes');
-V('mask');
-V('mask-repeat');
-V('mask-position');
-V('mask-clip');
-V('mask-origin');
-V('mask-size');
-V('gap');
-V('column-gap');
-V('row-gap');
-V('image-rendering');
-V('hyphens');
-V('-x-app-region');
-V('-x-animation-color-interpolation');
-V('-x-handle-color');
-V('-x-handle-size');
-V('offset-path');
-V('offset-distance');
-function queryCSSProperty(index) {
-    return cssPropertyMap[index];
-}
-const referenceTypes = async ()=>WebAssembly.validate(new Uint8Array([
-        0,
-        97,
-        115,
-        109,
-        1,
-        0,
-        0,
-        0,
-        1,
-        4,
-        1,
-        96,
-        0,
-        0,
-        3,
-        2,
-        1,
-        0,
-        10,
-        7,
-        1,
-        5,
-        0,
-        208,
-        112,
-        26,
-        11
-    ]));
-let wasm;
-async function initWasm() {
-    const supportsReferenceTypes = await referenceTypes();
-    wasm = supportsReferenceTypes ? await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../web-style-transformer/standard.js")) : await __webpack_require__.e("8").then(__webpack_require__.bind(__webpack_require__, "../web-style-transformer/legacy.js"));
-}
-function transformInlineStyleString(str) {
-    return wasm.transform_raw_u16_inline_style_ptr(str) ?? str;
-}
-function transformParsedStyles(styles) {
-    let childStyle = [];
-    let transformedStyle = [];
-    for (const [property, value] of styles){
-        const transformedResult = wasm.transform_raw_u16_inline_style_ptr_parsed(property, value);
-        if (transformedResult) {
-            const [transformedStyleForCurrent, childStyleForCurrent] = transformedResult;
-            transformedStyle = transformedStyle.concat(transformedStyleForCurrent);
-            if (childStyleForCurrent) childStyle = childStyle.concat(childStyleForCurrent);
-        } else transformedStyle.push([
-            property,
-            value
-        ]);
-    }
-    return {
-        childStyle,
-        transformedStyle
-    };
-}
-var uppercasePattern = /[A-Z]/g;
-var msPattern = /^ms-/;
-var hyphenate_style_name_cache = {};
-function toHyphenLower(match) {
-    return '-' + match.toLowerCase();
-}
-function hyphenateStyleName(name) {
-    if (hyphenate_style_name_cache.hasOwnProperty(name)) return hyphenate_style_name_cache[name];
-    var hName = name.replace(uppercasePattern, toHyphenLower);
-    return hyphenate_style_name_cache[name] = msPattern.test(hName) ? '-' + hName : hName;
-}
-const hyphenate_style_name = hyphenateStyleName;
-const __AppendElement = /*#__PURE__*/ (parent, child)=>parent.appendChild(child);
-const __ElementIsEqual = /*#__PURE__*/ (left, right)=>left === right;
-const __FirstElement = /*#__PURE__*/ (element)=>element.firstElementChild;
-const __GetChildren = /*#__PURE__*/ (element)=>element.children ? [
-        ...element.children
-    ] : null;
-const __GetParent = /*#__PURE__*/ (element)=>element.parentElement;
-const __InsertElementBefore = /*#__PURE__*/ (parent, child, ref)=>parent.insertBefore(child, ref);
-const __LastElement = /*#__PURE__*/ (element)=>element.lastElementChild;
-const __NextElement = /*#__PURE__*/ (element)=>element.nextElementSibling;
-const __RemoveElement = /*#__PURE__*/ (parent, child)=>parent.removeChild(child);
-const __ReplaceElement = /*#__PURE__*/ (newElement, oldElement)=>oldElement.replaceWith(newElement);
-const __ReplaceElements = /*#__PURE__*/ (parent, newChildren, oldChildren)=>{
-    newChildren = Array.isArray(newChildren) ? newChildren : [
-        newChildren
-    ];
-    if (!oldChildren || Array.isArray(oldChildren) && oldChildren?.length === 0) parent.append(...newChildren);
-    else {
-        oldChildren = Array.isArray(oldChildren) ? oldChildren : [
-            oldChildren
-        ];
-        for(let ii = 1; ii < oldChildren.length; ii++)__RemoveElement(parent, oldChildren[ii]);
-        const firstOldChildren = oldChildren[0];
-        firstOldChildren.replaceWith(...newChildren);
-    }
-};
-const __AddConfig = /*#__PURE__*/ (element, type, value)=>{
-    const currentComponentConfigString = element.getAttribute(lynxComponentConfigAttribute);
-    let currentComponentConfig = currentComponentConfigString ? JSON.parse(decodeURIComponent(currentComponentConfigString)) : {};
-    currentComponentConfig[type] = value;
-    element.setAttribute(lynxComponentConfigAttribute, encodeURIComponent(JSON.stringify(currentComponentConfig)));
-};
-const __AddDataset = /*#__PURE__*/ (element, key, value)=>{
-    const currentDataset = __GetDataset(element);
-    currentDataset[key] = value;
-    element.setAttribute("l-dset", encodeURIComponent(JSON.stringify(currentDataset)));
-    value ? element.setAttribute('data-' + key, value.toString()) : element.removeAttribute('data-' + key);
-};
-const __GetDataset = /*#__PURE__*/ (element)=>{
-    const datasetString = element.getAttribute("l-dset");
-    const currentDataset = datasetString ? JSON.parse(decodeURIComponent(datasetString)) : {};
-    return currentDataset;
-};
-const __GetDataByKey = /*#__PURE__*/ (element, key)=>{
-    const dataset = __GetDataset(element);
-    return dataset[key];
-};
-const __GetAttributes = /*#__PURE__*/ (element)=>Object.fromEntries(element.getAttributeNames().map((attributeName)=>[
-            attributeName,
-            element.getAttribute(attributeName)
-        ]).filter(([, value])=>value));
-const __GetComponentID = /*#__PURE__*/ (element)=>element.getAttribute(componentIdAttribute);
-const __GetElementConfig = /*#__PURE__*/ (element)=>{
-    const currentComponentConfigString = element.getAttribute(lynxComponentConfigAttribute);
-    return currentComponentConfigString ? JSON.parse(decodeURIComponent(currentComponentConfigString)) : {};
-};
-const __GetAttributeByName = /*#__PURE__*/ (element, name)=>element.getAttribute(name);
-const __GetElementUniqueID = /*#__PURE__*/ (element)=>element && element.getAttribute ? Number(element.getAttribute("l-uid")) : -1;
-const __GetID = /*#__PURE__*/ (element)=>element.getAttribute('id');
-const __SetID = /*#__PURE__*/ (element, id)=>id ? element.setAttribute('id', id) : element.removeAttribute('id');
-const __GetTag = /*#__PURE__*/ (element)=>element.getAttribute(lynxTagAttribute);
-const __SetConfig = /*#__PURE__*/ (element, config)=>{
-    element.setAttribute(lynxComponentConfigAttribute, encodeURIComponent(JSON.stringify(config)));
-};
-const __SetDataset = /*#__PURE__*/ (element, dataset)=>{
-    element.setAttribute("l-dset", encodeURIComponent(JSON.stringify(dataset)));
-    for (const [key, value] of Object.entries(dataset))element.setAttribute('data-' + key, value.toString());
-};
-const __UpdateComponentID = /*#__PURE__*/ (element, componentID)=>element.setAttribute(componentIdAttribute, componentID);
-const __GetClasses = /*#__PURE__*/ (element)=>(element.getAttribute('class') ?? '').split(' ').filter((e)=>e);
-const __UpdateComponentInfo = /*#__PURE__*/ (element, params)=>{
-    void 0 !== params.componentID && __UpdateComponentID(element, params.componentID);
-    void 0 !== params.cssID && element.setAttribute(cssIdAttribute, params.cssID + '');
-    void 0 !== params.name && element.setAttribute('name', params.name);
-};
-const __SetCSSId = /*#__PURE__*/ (elements, cssId, entryName)=>{
-    for (const element of elements){
-        element.setAttribute(cssIdAttribute, cssId + '');
-        entryName && element.setAttribute(lynxEntryNameAttribute, entryName);
-    }
-};
-const __SetClasses = /*#__PURE__*/ (element, classname)=>{
-    classname ? element.setAttribute('class', classname) : element.removeAttribute('class');
-};
-const __AddInlineStyle = /*#__PURE__*/ (element, key, value)=>{
-    let dashName;
-    if ('number' == typeof key) {
-        const queryResult = queryCSSProperty(key);
-        dashName = queryResult.dashName;
-        if (queryResult.isX) console.error(`[lynx-web] css property: ${dashName} is not supported.`);
-    } else dashName = key;
-    const valueStr = 'number' == typeof value ? value.toString() : value;
-    if (valueStr) {
-        const { transformedStyle } = transformParsedStyles([
-            [
-                dashName,
-                valueStr
-            ]
-        ]);
-        for (const [property, value] of transformedStyle)element.style.setProperty(property, value);
-    } else element.style.removeProperty(dashName);
-};
-const __AddClass = /*#__PURE__*/ (element, className)=>{
-    const newClassName = ((element.getAttribute('class') ?? '') + ' ' + className).trim();
-    element.setAttribute('class', newClassName);
-};
-const __SetInlineStyles = /*#__PURE__*/ (element, value)=>{
-    if (!value) return;
-    if ('string' == typeof value) element.setAttribute('style', transformInlineStyleString(value));
-    else {
-        const { transformedStyle } = transformParsedStyles(Object.entries(value).map(([k, value])=>[
-                hyphenate_style_name(k),
-                value?.toString?.() ?? ''
-            ]));
-        const transformedStyleStr = transformedStyle.map(([property, value])=>`${property}:${value};`).join('');
-        element.setAttribute('style', transformedStyleStr);
-    }
-};
-const __GetTemplateParts = (templateElement)=>{
-    const isTemplate = null !== templateElement.getAttribute(lynxElementTemplateMarkerAttribute);
-    if (!isTemplate) return {};
-    const templateUniqueId = __GetElementUniqueID(templateElement);
-    const parts = {};
-    const partElements = templateElement.querySelectorAll(`[l-uid="${templateUniqueId}"] [l-part]:not([l-uid="${templateUniqueId}"] [${lynxElementTemplateMarkerAttribute}] [l-part])`);
-    for (const partElement of partElements){
-        const partId = partElement.getAttribute("l-part");
-        if (partId) parts[partId] = partElement;
-    }
-    return parts;
-};
-const __MarkTemplateElement = (element)=>{
-    element.setAttribute(lynxElementTemplateMarkerAttribute, '');
-};
-const __MarkPartElement = (element, partId)=>{
-    element.setAttribute("l-part", partId);
-};
-function toCloneableObject(obj) {
-    const cloneableObj = {};
-    for(const key in obj){
-        const value = obj[key];
-        if ('boolean' == typeof value || 'number' == typeof value || 'string' == typeof value || null === value) cloneableObj[key] = value;
-    }
-    return cloneableObj;
-}
-function createCrossThreadEvent(domEvent, eventName) {
-    const targetElement = domEvent.target;
-    const currentTargetElement = domEvent.currentTarget.getAttribute ? domEvent.currentTarget : void 0;
-    const type = domEvent.type;
-    const params = {};
-    const isTrusted = domEvent.isTrusted;
-    const otherProperties = {};
-    let detail = domEvent.detail ?? {};
-    if (type.match(/^transition/)) Object.assign(params, {
-        animation_type: 'keyframe-animation',
-        animation_name: domEvent.propertyName,
-        new_animator: true
-    });
-    else if (type.match(/animation/)) Object.assign(params, {
-        animation_type: 'keyframe-animation',
-        animation_name: domEvent.animationName,
-        new_animator: true
-    });
-    else if (type.startsWith('touch')) {
-        const touchEvent = domEvent;
-        const touch = [
-            ...touchEvent.touches
-        ];
-        const targetTouches = [
-            ...touchEvent.targetTouches
-        ];
-        const changedTouches = [
-            ...touchEvent.changedTouches
-        ];
-        Object.assign(otherProperties, {
-            touches: isTrusted ? touch.map(toCloneableObject) : touch,
-            targetTouches: isTrusted ? targetTouches.map(toCloneableObject) : targetTouches,
-            changedTouches: isTrusted ? changedTouches.map(toCloneableObject) : changedTouches
-        });
-    } else if (type.startsWith('mouse')) {
-        const mouseEvent = domEvent;
-        Object.assign(otherProperties, {
-            button: mouseEvent.button,
-            buttons: mouseEvent.buttons,
-            x: mouseEvent.x,
-            y: mouseEvent.y,
-            pageX: mouseEvent.pageX,
-            pageY: mouseEvent.pageY,
-            clientX: mouseEvent.clientX,
-            clientY: mouseEvent.clientY
-        });
-    } else if ('click' === type) detail = {
-        x: domEvent.x,
-        y: domEvent.y
-    };
-    const currentTargetDatasetString = currentTargetElement?.getAttribute("l-dset");
-    const currentTargetDataset = currentTargetDatasetString ? JSON.parse(decodeURIComponent(currentTargetDatasetString)) : {};
-    const targetDatasetString = targetElement.getAttribute("l-dset");
-    const targetDataset = targetDatasetString ? JSON.parse(decodeURIComponent(targetDatasetString)) : {};
-    return {
-        type: eventName,
-        timestamp: domEvent.timeStamp,
-        target: {
-            id: targetElement.getAttribute('id'),
-            dataset: targetDataset,
-            uniqueId: Number(targetElement.getAttribute("l-uid"))
-        },
-        currentTarget: currentTargetElement ? {
-            id: currentTargetElement.getAttribute('id'),
-            dataset: currentTargetDataset,
-            uniqueId: Number(currentTargetElement.getAttribute("l-uid"))
-        } : null,
-        detail,
-        params,
-        ...otherProperties
-    };
-}
-const exposureRelatedAttributes = new Set([
-    'exposure-id',
-    'exposure-area',
-    'exposure-screen-margin-top',
-    'exposure-screen-margin-right',
-    'exposure-screen-margin-bottom',
-    'exposure-screen-margin-left',
-    'exposure-ui-margin-top',
-    'exposure-ui-margin-right',
-    'exposure-ui-margin-bottom',
-    'exposure-ui-margin-left'
-]);
-function createMainThreadGlobalThis(config) {
-    let timingFlags = [];
-    const { callbacks, tagMap, pageConfig, lynxTemplate, rootDom, globalProps, ssrHydrateInfo, ssrHooks, mtsRealm, document } = config;
-    const { elementTemplate, lepusCode } = lynxTemplate;
-    const lynxUniqueIdToElement = ssrHydrateInfo?.lynxUniqueIdToElement ?? [];
-    const elementToRuntimeInfoMap = new WeakMap();
-    let pageElement = lynxUniqueIdToElement[1]?.deref();
-    let uniqueIdInc = lynxUniqueIdToElement.length || 1;
-    const exposureChangedElements = new Set();
-    const commonHandler = (event)=>{
-        if (!event.currentTarget) return;
-        const currentTarget = event.currentTarget;
-        const isCapture = event.eventPhase === Event.CAPTURING_PHASE;
-        const lynxEventName = W3cEventNameToLynx[event.type] ?? event.type;
-        const runtimeInfo = elementToRuntimeInfoMap.get(currentTarget);
-        if (runtimeInfo) {
-            const hname = isCapture ? runtimeInfo.eventHandlerMap[lynxEventName]?.capture?.handler : runtimeInfo.eventHandlerMap[lynxEventName]?.bind?.handler;
-            const crossThreadEvent = createCrossThreadEvent(event, lynxEventName);
-            if ('string' == typeof hname) {
-                const parentComponentUniqueId = Number(currentTarget.getAttribute(parentComponentUniqueIdAttribute));
-                const parentComponent = lynxUniqueIdToElement[parentComponentUniqueId].deref();
-                const componentId = parentComponent?.getAttribute(lynxTagAttribute) !== 'page' ? parentComponent?.getAttribute(componentIdAttribute) ?? void 0 : void 0;
-                if (componentId) callbacks.publicComponentEvent(componentId, hname, crossThreadEvent);
-                else callbacks.publishEvent(hname, crossThreadEvent);
-                return true;
-            }
-            if (hname) {
-                crossThreadEvent.target.elementRefptr = event.target;
-                if (crossThreadEvent.currentTarget) crossThreadEvent.currentTarget.elementRefptr = event.currentTarget;
-                mtsRealm.globalWindow.runWorklet?.(hname.value, [
-                    crossThreadEvent
-                ]);
-            }
-        }
-        return false;
-    };
-    const commonCatchHandler = (event)=>{
-        const handlerTriggered = commonHandler(event);
-        if (handlerTriggered) event.stopPropagation();
-    };
-    const __AddEvent = (element, eventType, eventName, newEventHandler)=>{
-        eventName = eventName.toLowerCase();
-        const isCatch = 'catchEvent' === eventType || 'capture-catch' === eventType;
-        const isCapture = eventType.startsWith('capture');
-        const runtimeInfo = elementToRuntimeInfoMap.get(element) ?? {
-            eventHandlerMap: {},
-            componentAtIndex: void 0,
-            enqueueComponent: void 0
-        };
-        const currentHandler = isCapture ? runtimeInfo.eventHandlerMap[eventName]?.capture : runtimeInfo.eventHandlerMap[eventName]?.bind;
-        const currentRegisteredHandler = isCatch ? commonCatchHandler : commonHandler;
-        if (currentHandler) {
-            if (!newEventHandler) {
-                element.removeEventListener(eventName, currentRegisteredHandler, {
-                    capture: isCapture
-                });
-                const isExposure = 'uiappear' === eventName || 'uidisappear' === eventName;
-                if (isExposure && '-1' === element.getAttribute('exposure-id')) mtsGlobalThis.__SetAttribute(element, 'exposure-id', null);
-            }
-        } else if (newEventHandler) {
-            const htmlEventName = LynxEventNameToW3cByTagName[element.tagName]?.[eventName] ?? LynxEventNameToW3cCommon[eventName] ?? eventName;
-            element.addEventListener(htmlEventName, currentRegisteredHandler, {
-                capture: isCapture
-            });
-            const isExposure = 'uiappear' === eventName || 'uidisappear' === eventName;
-            if (isExposure && null === element.getAttribute('exposure-id')) mtsGlobalThis.__SetAttribute(element, 'exposure-id', '-1');
-        }
-        if (newEventHandler) {
-            const info = {
-                type: eventType,
-                handler: newEventHandler
-            };
-            if (!runtimeInfo.eventHandlerMap[eventName]) runtimeInfo.eventHandlerMap[eventName] = {
-                capture: void 0,
-                bind: void 0
-            };
-            if (isCapture) runtimeInfo.eventHandlerMap[eventName].capture = info;
-            else runtimeInfo.eventHandlerMap[eventName].bind = info;
-        }
-        elementToRuntimeInfoMap.set(element, runtimeInfo);
-    };
-    const __GetEvent = (element, eventName, eventType)=>{
-        const runtimeInfo = elementToRuntimeInfoMap.get(element);
-        if (!runtimeInfo) return;
-        {
-            eventName = eventName.toLowerCase();
-            const isCapture = eventType.startsWith('capture');
-            const handler = isCapture ? runtimeInfo.eventHandlerMap[eventName]?.capture : runtimeInfo.eventHandlerMap[eventName]?.bind;
-            return handler?.handler;
-        }
-    };
-    const __GetEvents = (element)=>{
-        const eventHandlerMap = elementToRuntimeInfoMap.get(element)?.eventHandlerMap ?? {};
-        const eventInfos = [];
-        for (const [lynxEventName, info] of Object.entries(eventHandlerMap))for (const atomInfo of [
-            info.bind,
-            info.capture
-        ])if (atomInfo) {
-            const { type, handler } = atomInfo;
-            if (handler) eventInfos.push({
-                type: type,
-                name: lynxEventName,
-                function: handler
-            });
-        }
-        return eventInfos;
-    };
-    const __SetEvents = (element, listeners)=>{
-        for (const { type: eventType, name: lynxEventName, function: eventHandler } of listeners)__AddEvent(element, eventType, lynxEventName, eventHandler);
-    };
-    const __CreateElement = (tag, parentComponentUniqueId)=>{
-        const uniqueId = uniqueIdInc++;
-        const htmlTag = tagMap[tag] ?? tag;
-        const element = document.createElement(htmlTag);
-        lynxUniqueIdToElement[uniqueId] = new WeakRef(element);
-        const parentComponentCssID = lynxUniqueIdToElement[parentComponentUniqueId]?.deref()?.getAttribute(cssIdAttribute);
-        parentComponentCssID && '0' !== parentComponentCssID && element.setAttribute(cssIdAttribute, parentComponentCssID);
-        element.setAttribute(lynxTagAttribute, tag);
-        element.setAttribute("l-uid", uniqueId + '');
-        element.setAttribute(parentComponentUniqueIdAttribute, parentComponentUniqueId + '');
-        return element;
-    };
-    const __CreateView = (parentComponentUniqueId)=>__CreateElement('view', parentComponentUniqueId);
-    const __CreateText = (parentComponentUniqueId)=>__CreateElement('text', parentComponentUniqueId);
-    const __CreateRawText = (text1)=>{
-        const element = __CreateElement('raw-text', -1);
-        element.setAttribute('text', text1);
-        return element;
-    };
-    const __CreateImage = (parentComponentUniqueId)=>__CreateElement('image', parentComponentUniqueId);
-    const __CreateScrollView = (parentComponentUniqueId)=>__CreateElement('scroll-view', parentComponentUniqueId);
-    const __CreateWrapperElement = (parentComponentUniqueId)=>__CreateElement('lynx-wrapper', parentComponentUniqueId);
-    const __CreatePage = (componentID, cssID)=>{
-        const page = __CreateElement('page', 0);
-        page.setAttribute('part', 'page');
-        page.setAttribute(cssIdAttribute, cssID + '');
-        page.setAttribute(parentComponentUniqueIdAttribute, '0');
-        page.setAttribute(componentIdAttribute, componentID);
-        __MarkTemplateElement(page);
-        if (false === pageConfig.defaultDisplayLinear) page.setAttribute(lynxDefaultDisplayLinearAttribute, 'false');
-        if (true === pageConfig.defaultOverflowVisible) page.setAttribute('lynx-default-overflow-visible', 'true');
-        pageElement = page;
-        return page;
-    };
-    const __CreateList = (parentComponentUniqueId, componentAtIndex, enqueueComponent)=>{
-        const list = __CreateElement('list', parentComponentUniqueId);
-        const runtimeInfo = {
-            eventHandlerMap: {},
-            componentAtIndex: componentAtIndex,
-            enqueueComponent: enqueueComponent
-        };
-        elementToRuntimeInfoMap.set(list, runtimeInfo);
-        return list;
-    };
-    const __CreateComponent = (componentParentUniqueID, componentID, cssID, _, name)=>{
-        const component = __CreateElement('view', componentParentUniqueID);
-        component.setAttribute(cssIdAttribute, cssID + '');
-        component.setAttribute(componentIdAttribute, componentID);
-        component.setAttribute('name', name);
-        return component;
-    };
-    const __SetAttribute = (element, key, value)=>{
-        const tag = element.getAttribute(lynxTagAttribute);
-        if ('list' === tag && 'update-list-info' === key) {
-            const listInfo = value;
-            const { insertAction, removeAction } = listInfo;
-            queueMicrotask(()=>{
-                const runtimeInfo = elementToRuntimeInfoMap.get(element);
-                if (runtimeInfo) {
-                    const componentAtIndex = runtimeInfo.componentAtIndex;
-                    const enqueueComponent = runtimeInfo.enqueueComponent;
-                    const uniqueId = __GetElementUniqueID(element);
-                    for (const action of insertAction)componentAtIndex?.(element, uniqueId, action.position, 0, false);
-                    for (const action of removeAction)enqueueComponent?.(element, uniqueId, action.position);
-                }
-            });
-        } else {
-            null == value ? element.removeAttribute(key) : element.setAttribute(key, value + '');
-            if (key === __lynx_timing_flag && value) timingFlags.push(value);
-            if (exposureRelatedAttributes.has(key)) exposureChangedElements.add(element);
-        }
-    };
-    const __UpdateListCallbacks = (element, componentAtIndex, enqueueComponent)=>{
-        const runtimeInfo = elementToRuntimeInfoMap.get(element) ?? {
-            eventHandlerMap: {},
-            componentAtIndex: componentAtIndex,
-            enqueueComponent: enqueueComponent,
-            uniqueId: __GetElementUniqueID(element)
-        };
-        runtimeInfo.componentAtIndex = componentAtIndex;
-        runtimeInfo.enqueueComponent = enqueueComponent;
-        elementToRuntimeInfoMap.set(element, runtimeInfo);
-    };
-    const __SwapElement = (childA, childB)=>{
-        const temp = document.createElement('div');
-        childA.replaceWith(temp);
-        childB.replaceWith(childA);
-        temp.replaceWith(childB);
-    };
-    const __SetCSSIdForCSSOG = (elements, cssId, entryName)=>{
-        for (const element of elements){
-            element.setAttribute(cssIdAttribute, cssId + '');
-            entryName && element.setAttribute(lynxEntryNameAttribute, entryName);
-            const cls = element.getAttribute('class');
-            cls && __SetClassesForCSSOG(element, cls);
-        }
-    };
-    const __AddClassForCSSOG = (element, className)=>{
-        const newClassName = ((element.getAttribute('class') ?? '') + ' ' + className).trim();
-        element.setAttribute('class', newClassName);
-        const cssId = element.getAttribute(cssIdAttribute);
-        const uniqueId = Number(element.getAttribute("l-uid"));
-        const entryName = element.getAttribute(lynxEntryNameAttribute);
-        callbacks.updateCssOGStyle(uniqueId, newClassName, cssId, entryName);
-    };
-    const __SetClassesForCSSOG = (element, classNames)=>{
-        __SetClasses(element, classNames);
-        const cssId = element.getAttribute(cssIdAttribute);
-        const uniqueId = Number(element.getAttribute("l-uid"));
-        const entryName = element.getAttribute(lynxEntryNameAttribute);
-        callbacks.updateCssOGStyle(uniqueId, classNames ?? '', cssId, entryName);
-    };
-    const __LoadLepusChunk = (path)=>{
-        try {
-            path = lepusCode?.[path] ?? path;
-            mtsRealm.loadScriptSync(path);
-            return true;
-        } catch (e) {
-            console.error(`failed to load lepus chunk ${path}`, e);
-            return false;
-        }
-    };
-    const __FlushElementTree = (_subTree, options)=>{
-        const timingFlagsCopied = timingFlags;
-        timingFlags = [];
-        if (pageElement && !pageElement.parentNode && '' !== pageElement.getAttribute(lynxDisposedAttribute)) rootDom.append(pageElement);
-        const exposureChangedElementsArray = Array.from(exposureChangedElements);
-        exposureChangedElements.clear();
-        callbacks.flushElementTree(options, timingFlagsCopied, exposureChangedElementsArray);
-    };
-    const __GetPageElement = ()=>pageElement;
-    const templateIdToTemplate = {};
-    const createElementForElementTemplateData = (data, parentComponentUniId)=>{
-        const element = __CreateElement(data.type, parentComponentUniId);
-        __SetID(element, data.id);
-        data.class && __SetClasses(element, data.class.join(' '));
-        for (const [key, value] of Object.entries(data.attributes || {}))__SetAttribute(element, key, value);
-        for (const [key, value] of Object.entries(data.builtinAttributes || {})){
-            if ('dirtyID' === key && value === data.id) __MarkPartElement(element, value);
-            __SetAttribute(element, key, value);
-        }
-        for (const childData of data.children || [])__AppendElement(element, createElementForElementTemplateData(childData, parentComponentUniId));
-        void 0 !== data.dataset && __SetDataset(element, data.dataset);
-        return element;
-    };
-    const applyEventsForElementTemplate = (data, element)=>{
-        const uniqueId = uniqueIdInc++;
-        element.setAttribute("l-uid", uniqueId + '');
-        for (const event of data.events || []){
-            const { type, name, value } = event;
-            __AddEvent(element, type, name, value);
-        }
-        for(let ii = 0; ii < (data.children || []).length; ii++){
-            const childData = (data.children || [])[ii];
-            const childElement = element.children[ii];
-            if (childData && childElement) applyEventsForElementTemplate(childData, childElement);
-        }
-    };
-    const __ElementFromBinary = (templateId, parentComponentUniId)=>{
-        const elementTemplateData = elementTemplate[templateId];
-        if (elementTemplateData) {
-            let clonedElements;
-            if (templateIdToTemplate[templateId]) clonedElements = Array.from(templateIdToTemplate[templateId].content.cloneNode(true).children);
-            else {
-                clonedElements = elementTemplateData.map((data)=>createElementForElementTemplateData(data, parentComponentUniId));
-                if (rootDom.cloneNode) {
-                    const template = document.createElement('template');
-                    template.content.append(...clonedElements);
-                    templateIdToTemplate[templateId] = template;
-                    rootDom.append(template);
-                    return __ElementFromBinary(templateId, parentComponentUniId);
-                }
-            }
-            for(let ii = 0; ii < clonedElements.length; ii++){
-                const data = elementTemplateData[ii];
-                const element = clonedElements[ii];
-                if (data && element) applyEventsForElementTemplate(data, element);
-            }
-            clonedElements.forEach(__MarkTemplateElement);
-            return clonedElements;
-        }
-        return [];
-    };
-    let release = '';
-    const isCSSOG = !pageConfig.enableCSSSelector;
-    const SystemInfo = {
-        ...systemInfo,
-        ...config.browserConfig
-    };
-    const mtsGlobalThis = {
-        __ElementFromBinary,
-        __GetTemplateParts: rootDom.querySelectorAll ? __GetTemplateParts : void 0,
-        __MarkTemplateElement: __MarkTemplateElement,
-        __MarkPartElement: __MarkPartElement,
-        __AddEvent: ssrHooks?.__AddEvent ?? __AddEvent,
-        __GetEvent,
-        __GetEvents,
-        __SetEvents,
-        __AppendElement: __AppendElement,
-        __ElementIsEqual: __ElementIsEqual,
-        __FirstElement: __FirstElement,
-        __GetChildren: __GetChildren,
-        __GetParent: __GetParent,
-        __InsertElementBefore: __InsertElementBefore,
-        __LastElement: __LastElement,
-        __NextElement: __NextElement,
-        __RemoveElement: __RemoveElement,
-        __ReplaceElement: __ReplaceElement,
-        __ReplaceElements: __ReplaceElements,
-        __AddConfig: __AddConfig,
-        __AddDataset: __AddDataset,
-        __GetAttributes: __GetAttributes,
-        __GetComponentID: __GetComponentID,
-        __GetDataByKey: __GetDataByKey,
-        __GetDataset: __GetDataset,
-        __GetElementConfig: __GetElementConfig,
-        __GetElementUniqueID: __GetElementUniqueID,
-        __GetID: __GetID,
-        __GetTag: __GetTag,
-        __SetConfig: __SetConfig,
-        __SetDataset: __SetDataset,
-        __SetID: __SetID,
-        __UpdateComponentID: __UpdateComponentID,
-        __UpdateComponentInfo: __UpdateComponentInfo,
-        __CreateElement,
-        __CreateView,
-        __CreateText,
-        __CreateComponent,
-        __CreatePage,
-        __CreateRawText,
-        __CreateImage,
-        __CreateScrollView,
-        __CreateWrapperElement,
-        __CreateList,
-        __SetAttribute,
-        __SwapElement,
-        __UpdateListCallbacks,
-        __GetConfig: __GetElementConfig,
-        __GetAttributeByName: __GetAttributeByName,
-        __GetClasses: __GetClasses,
-        __AddClass: isCSSOG ? __AddClassForCSSOG : __AddClass,
-        __SetClasses: isCSSOG ? __SetClassesForCSSOG : __SetClasses,
-        __AddInlineStyle: __AddInlineStyle,
-        __SetCSSId: isCSSOG ? __SetCSSIdForCSSOG : __SetCSSId,
-        __SetInlineStyles: __SetInlineStyles,
-        __LoadLepusChunk,
-        __GetPageElement,
-        __globalProps: globalProps,
-        __QueryComponent: callbacks.__QueryComponent,
-        SystemInfo,
-        lynx: createMainThreadLynx(config, SystemInfo),
-        _ReportError: (err, _)=>callbacks._ReportError(err, _, release),
-        _SetSourceMapRelease: (errInfo)=>release = errInfo?.release,
-        __OnLifecycleEvent: callbacks.__OnLifecycleEvent,
-        __FlushElementTree,
-        _I18nResourceTranslation: callbacks._I18nResourceTranslation,
-        _AddEventListener: ()=>{},
-        renderPage: void 0
-    };
-    Object.assign(mtsRealm.globalWindow, mtsGlobalThis);
-    Object.defineProperty(mtsRealm.globalWindow, 'renderPage', {
-        get () {
-            return mtsGlobalThis.renderPage;
-        },
-        set (v) {
-            mtsGlobalThis.renderPage = v;
-            queueMicrotask(callbacks.mainChunkReady);
-        },
-        configurable: true,
-        enumerable: true
-    });
-    return mtsRealm.globalWindow;
-}
-function createExposureService(rootDom, postExposure) {
-    let working = true;
-    let exposureCache = [];
-    let disexposureCache = [];
-    let delayCallback = null;
-    const onScreen = new Map();
-    function exposureEventHandler(ev) {
-        const exposureEvent = createCrossThreadEvent(ev, ev.type);
-        exposureEvent.detail['unique-id'] = parseFloat(ev.target.getAttribute("l-uid"));
-        const exposureID = exposureEvent.detail.exposureID;
-        if ('exposure' === ev.type) {
-            exposureCache.push(exposureEvent);
-            onScreen.set(exposureID, exposureEvent);
-        } else {
-            disexposureCache.push(exposureEvent);
-            onScreen.delete(exposureID);
-        }
-        if (!delayCallback) delayCallback = setTimeout(()=>{
-            if (exposureCache.length > 0 || disexposureCache.length > 0) {
-                const currentExposure = exposureCache;
-                const currentDisexposure = disexposureCache;
-                exposureCache = [];
-                disexposureCache = [];
-                postExposure({
-                    exposures: currentExposure,
-                    disExposures: currentDisexposure
-                });
-            }
-            delayCallback = null;
-        }, 50);
-    }
-    rootDom.addEventListener('exposure', exposureEventHandler, {
-        passive: true
-    });
-    rootDom.addEventListener('disexposure', exposureEventHandler, {
-        passive: true
-    });
-    function switchExposureService(enable, sendEvent) {
-        if (enable && !working) postExposure({
-            exposures: [
-                ...onScreen.values()
-            ],
-            disExposures: []
-        });
-        else if (!enable && working) {
-            if (sendEvent) postExposure({
-                exposures: [],
-                disExposures: [
-                    ...onScreen.values()
-                ]
-            });
-        }
-        working = enable;
-    }
-    return {
-        switchExposureService
-    };
-}
-function decodeCssOG(classes, styleInfo, cssId) {
-    const classList = classes.split(' ').filter((e)=>e);
-    let declarations = [];
-    const currentStyleInfo = styleInfo[cssId ?? '0'];
-    if (currentStyleInfo) for (const oneClassName of classList){
-        const oneRule = currentStyleInfo[oneClassName];
-        if (oneRule) declarations.push(...oneRule);
-    }
-    else console.warn(`[lynx-web] cannot find styleinfo for cssid ${cssId}`);
-    return declarations.map(([property, value])=>`${property}:${value};`).join('');
-}
-function topologicalSort(styleInfo) {
-    const queue = [];
-    const inDegreeMap = new Map();
-    for (const [cssId, oneStyleInfo] of Object.entries(styleInfo)){
-        inDegreeMap.has(cssId) || inDegreeMap.set(cssId, 0);
-        for (const importCssId of oneStyleInfo.imports ?? []){
-            const currentInDegree = inDegreeMap.get(importCssId) ?? 0;
-            inDegreeMap.set(importCssId, currentInDegree + 1);
-        }
-    }
-    for (const [cssId, inDegree] of inDegreeMap.entries())if (0 === inDegree) queue.push(cssId);
-    const sortedCssIds = [];
-    while(queue.length > 0){
-        const currentCssId = queue.shift();
-        sortedCssIds.push(currentCssId);
-        const currentAdjunction = styleInfo[currentCssId]?.imports;
-        if (currentAdjunction) for (const importCssId of currentAdjunction){
-            const importInDegree = inDegreeMap.get(importCssId) - 1;
-            inDegreeMap.set(importCssId, importInDegree);
-            if (0 === importInDegree) queue.push(importCssId);
-        }
-    }
-    return sortedCssIds;
-}
-function generateImportByMap(styleInfo, sortedCssIds) {
-    const cssIdToImportBy = new Map();
-    for (const cssId of sortedCssIds){
-        const currentAdjunction = styleInfo[cssId]?.imports;
-        if (currentAdjunction) {
-            const currentImportBy = cssIdToImportBy.get(cssId) ?? new Set([
-                cssId
-            ]);
-            for (const importCssId of currentAdjunction){
-                const importDeps = cssIdToImportBy.get(importCssId) ?? new Set([
-                    importCssId
-                ]);
-                importDeps.add(cssId);
-                cssIdToImportBy.set(importCssId, currentImportBy.union(importDeps));
-            }
-            cssIdToImportBy.set(cssId, currentImportBy);
-        }
-    }
-    return cssIdToImportBy;
-}
-function flattenStyleInfo(styleInfo) {
-    const sortedCssIds = topologicalSort(styleInfo);
-    const cssIdToImportBy = generateImportByMap(styleInfo, sortedCssIds);
-    sortedCssIds.reverse();
-    return sortedCssIds.map((cssId)=>{
-        const oneInfo = styleInfo[cssId];
-        const flattenedInfo = oneInfo ? {
-            content: oneInfo.content,
-            rules: oneInfo.rules,
-            importBy: Array.from(cssIdToImportBy.get(cssId) ?? [
-                cssId
-            ])
-        } : {
-            content: [],
-            rules: [],
-            importBy: [
-                cssId
-            ]
-        };
-        return flattenedInfo;
-    });
-}
-function transformToWebCss(styleInfo) {
-    for (const cssInfos of styleInfo)for (const rule of cssInfos.rules){
-        const { sel: selectors, decl: declarations } = rule;
-        const { transformedStyle, childStyle } = transformParsedStyles(declarations);
-        rule.decl = transformedStyle;
-        if (childStyle.length > 0) cssInfos.rules.push({
-            sel: selectors.map((selector)=>selector.toSpliced(-2, 1, [
-                    '>'
-                ], [
-                    '*'
-                ], [], [], [])),
-            decl: childStyle
-        });
-    }
-}
-function genCssContent(styleInfo, pageConfig, entryName) {
-    function getExtraSelectors(cssId) {
-        let suffix;
-        suffix = pageConfig.enableRemoveCSSScope ? `[${lynxTagAttribute}]` : `[${cssIdAttribute}="${cssId}"]`;
-        suffix = entryName ? `${suffix}[${lynxEntryNameAttribute}=${JSON.stringify(entryName)}]` : `${suffix}:not([${lynxEntryNameAttribute}])`;
-        return suffix;
-    }
-    const finalCssContent = [];
-    for (const cssInfos of styleInfo){
-        const declarationContent = cssInfos.rules.map((rule)=>{
-            const { sel: selectorList, decl: declarations } = rule;
-            const selectorString = cssInfos.importBy.map((cssId)=>{
-                const suffix = getExtraSelectors(cssId);
-                return selectorList.map((selectors)=>selectors.toSpliced(-4, 0, [
-                        suffix
-                    ]).flat().join('')).join(',');
-            }).join(',');
-            const declarationString = declarations.map(([k, v])=>`${k}:${v};`).join('');
-            return `${selectorString}{${declarationString}}`;
-        }).join('');
-        finalCssContent.push(...cssInfos.content, declarationContent);
-    }
-    return finalCssContent.join('\n');
-}
-function genCssOGInfo(styleInfo) {
-    const cssOGInfo = {};
-    for (const oneInfo of styleInfo)oneInfo.rules = oneInfo.rules.filter((oneRule)=>{
-        oneRule.sel = oneRule.sel.filter((selectorList)=>{
-            const [classSelectors, pseudoClassSelectors, pseudoElementSelectors, combinator] = selectorList;
-            if (1 === classSelectors.length && '.' === classSelectors[0][0] && 0 === pseudoClassSelectors.length && 0 === pseudoElementSelectors.length && 0 === combinator.length) {
-                const selectorName = classSelectors[0].substring(1);
-                for (const cssId of oneInfo.importBy){
-                    if (!cssOGInfo[cssId]) cssOGInfo[cssId] = {};
-                    const currentDeclarations = cssOGInfo[cssId][selectorName];
-                    if (currentDeclarations) currentDeclarations.push(...oneRule.decl);
-                    else cssOGInfo[cssId][selectorName] = oneRule.decl;
-                }
-                return false;
-            }
-            return true;
-        });
-        return oneRule.sel.length > 0;
-    });
-    return cssOGInfo;
-}
-function appendStyleElement(styleInfo, pageConfig, rootDom, document, ssrHydrateInfo) {
-    const lynxUniqueIdToStyleRulesIndex = ssrHydrateInfo?.lynxUniqueIdToStyleRulesIndex ?? [];
-    const flattenedStyleInfo = flattenStyleInfo(styleInfo);
-    transformToWebCss(flattenedStyleInfo);
-    const cssOGInfo = pageConfig.enableCSSSelector ? {} : genCssOGInfo(flattenedStyleInfo);
-    const lazyCSSOGInfo = {};
-    let cardStyleElement;
-    if (ssrHydrateInfo?.cardStyleElement) cardStyleElement = ssrHydrateInfo.cardStyleElement;
-    else {
-        cardStyleElement = document.createElement('style');
-        cardStyleElement.textContent = genCssContent(flattenedStyleInfo, pageConfig, void 0);
-        rootDom.appendChild(cardStyleElement);
-    }
-    const updateCssOGStyle = (uniqueId, newClassName, cssID, entryName)=>{
-        const cardStyleElementSheet = cardStyleElement.sheet;
-        const styleMap = entryName && lazyCSSOGInfo[entryName] ? lazyCSSOGInfo[entryName] : cssOGInfo;
-        const newStyles = decodeCssOG(newClassName, styleMap, cssID);
-        if (void 0 !== lynxUniqueIdToStyleRulesIndex[uniqueId]) {
-            const rule = cardStyleElementSheet.cssRules[lynxUniqueIdToStyleRulesIndex[uniqueId]];
-            rule.style.cssText = newStyles;
-        } else {
-            const index = cardStyleElementSheet.insertRule(`[l-uid="${uniqueId}"]{${newStyles}}`, cardStyleElementSheet.cssRules.length);
-            lynxUniqueIdToStyleRulesIndex[uniqueId] = index;
-        }
-    };
-    const updateLazyComponentStyle = (styleInfo, entryName)=>{
-        const flattenedStyleInfo = flattenStyleInfo(styleInfo);
-        transformToWebCss(flattenedStyleInfo);
-        if (!pageConfig.enableCSSSelector) lazyCSSOGInfo[entryName] = genCssOGInfo(flattenedStyleInfo);
-        const newStyleSheet = genCssContent(flattenedStyleInfo, pageConfig, entryName);
-        cardStyleElement.textContent += newStyleSheet;
-    };
-    return {
-        updateCssOGStyle,
-        updateLazyComponentStyle
-    };
-}
-function createQueryComponent(loadTemplate, updateLazyComponentStyle, backgroundThreadRpc, mtsGlobalThisRef, jsContext, mtsRealm) {
-    const updateBTSTemplateCache = backgroundThreadRpc.createCall(updateBTSTemplateCacheEndpoint);
-    const lazyCache = new Map();
-    const __QueryComponentImpl = (url, callback)=>{
-        const cacheLazy = lazyCache.get(url);
-        const loadPromise = cacheLazy ?? loadTemplate(url).then(async (template)=>{
-            const updateBTSCachePromise = updateBTSTemplateCache(url, template);
-            let lepusRootChunkExport = await mtsRealm.loadScript(template.lepusCode.root);
-            if (mtsGlobalThisRef.mtsGlobalThis.processEvalResult) lepusRootChunkExport = mtsGlobalThisRef.mtsGlobalThis.processEvalResult(lepusRootChunkExport, url);
-            updateLazyComponentStyle(template.styleInfo, url);
-            await updateBTSCachePromise;
-            jsContext.dispatchEvent({
-                type: '__OnDynamicJSSourcePrepared',
-                data: url
-            });
-            return lepusRootChunkExport;
-        });
-        cacheLazy || lazyCache.set(url, loadPromise);
-        loadPromise.then((lepusRootChunkExport)=>{
-            callback?.({
-                code: 0,
-                data: {
-                    url,
-                    evalResult: lepusRootChunkExport
-                }
-            });
-        }).catch((error)=>{
-            console.error("lynx web: lazy bundle load failed:", error);
-            lazyCache.delete(url);
-            callback?.({
-                code: -1,
-                data: void 0
-            });
-        });
-        return null;
-    };
-    backgroundThreadRpc.registerHandler(queryComponentEndpoint, (url)=>{
-        const ret = new Promise((resolve)=>{
-            __QueryComponentImpl(url, (result)=>{
-                resolve({
-                    code: result.code,
-                    detail: {
-                        schema: url
-                    }
-                });
-            });
-        });
-        return ret;
-    });
-    return __QueryComponentImpl;
-}
-const initWasmPromise = initWasm();
-function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, document, mtsRealmPromise, commitDocument, markTimingInternal, flushMarkTimingInternal, reportError, triggerI18nResourceFallback, initialI18nResources, loadTemplate, ssrHooks) {
-    const postTimingFlags = backgroundThreadRpc.createCall(postTimingFlagsEndpoint);
-    const backgroundStart = backgroundThreadRpc.createCall(BackgroundThreadStartEndpoint);
-    const publishEvent = backgroundThreadRpc.createCall(publishEventEndpoint);
-    const publicComponentEvent = backgroundThreadRpc.createCall(publicComponentEventEndpoint);
-    const postExposure = backgroundThreadRpc.createCall(postExposureEndpoint);
-    const dispatchI18nResource = backgroundThreadRpc.createCall(dispatchI18nResourceEndpoint);
-    const updateDataBackground = backgroundThreadRpc.createCall(updateDataEndpoint);
-    markTimingInternal('lepus_execute_start');
-    async function startMainThread(config, ssrHydrateInfo) {
-        let isFp = true;
-        const { globalProps, template, browserConfig, nativeModulesMap, napiModulesMap, tagMap, initI18nResources } = config;
-        const { styleInfo, pageConfig, customSections, cardType } = template;
-        const mtsRealm = await mtsRealmPromise;
-        markTimingInternal('decode_start');
-        await initWasmPromise;
-        const jsContext = new LynxCrossThreadContext({
-            rpc: backgroundThreadRpc,
-            receiveEventEndpoint: dispatchJSContextOnMainThreadEndpoint,
-            sendEventEndpoint: dispatchCoreContextOnBackgroundEndpoint
-        });
-        const i18nResources = initialI18nResources(initI18nResources);
-        const { updateCssOGStyle, updateLazyComponentStyle } = appendStyleElement(styleInfo, pageConfig, rootDom, document, ssrHydrateInfo);
-        const mtsGlobalThisRef = {
-            mtsGlobalThis: void 0
-        };
-        const __QueryComponent = createQueryComponent(loadTemplate, updateLazyComponentStyle, backgroundThreadRpc, mtsGlobalThisRef, jsContext, mtsRealm);
-        const mtsGlobalThis = createMainThreadGlobalThis({
-            lynxTemplate: template,
-            mtsRealm,
-            jsContext,
-            tagMap,
-            browserConfig,
-            globalProps,
-            pageConfig,
-            rootDom,
-            ssrHydrateInfo,
-            ssrHooks,
-            document,
-            callbacks: {
-                updateCssOGStyle,
-                mainChunkReady: ()=>{
-                    markTimingInternal('data_processor_start');
-                    let initData = config.initData;
-                    if (true !== pageConfig.enableJSDataProcessor && mtsGlobalThis.processData) initData = mtsGlobalThis.processData(config.initData);
-                    markTimingInternal('data_processor_end');
-                    registerCallLepusMethodHandler(backgroundThreadRpc, mtsGlobalThis);
-                    registerGetCustomSectionHandler(backgroundThreadRpc, customSections);
-                    const { switchExposureService } = createExposureService(rootDom, postExposure);
-                    backgroundThreadRpc.registerHandler(switchExposureServiceEndpoint, switchExposureService);
-                    backgroundStart({
-                        initData,
-                        globalProps,
-                        template,
-                        cardType: cardType ?? 'react',
-                        customSections: Object.fromEntries(Object.entries(customSections).filter(([, value])=>'lazy' !== value.type).map(([k, v])=>[
-                                k,
-                                v.content
-                            ])),
-                        nativeModulesMap,
-                        napiModulesMap
-                    });
-                    if (ssrHydrateInfo) {
-                        for (const event of ssrHydrateInfo.events){
-                            const uniqueId = event[0];
-                            const element = ssrHydrateInfo.lynxUniqueIdToElement[uniqueId]?.deref();
-                            if (element) mtsGlobalThis.__AddEvent(element, event[1], event[2], event[3]);
-                        }
-                        mtsGlobalThis.ssrHydrate?.(ssrHydrateInfo.ssrEncodeData);
-                    } else {
-                        mtsGlobalThis.renderPage(initData);
-                        mtsGlobalThis.__FlushElementTree(void 0, {});
-                    }
-                },
-                flushElementTree: async (options, timingFlags, exposureChangedElements)=>{
-                    const pipelineId = options?.pipelineOptions?.pipelineID;
-                    markTimingInternal('dispatch_start', pipelineId);
-                    if (isFp) {
-                        isFp = false;
-                        jsContext.dispatchEvent({
-                            type: '__OnNativeAppReady',
-                            data: void 0
-                        });
-                    }
-                    markTimingInternal('layout_start', pipelineId);
-                    markTimingInternal('ui_operation_flush_start', pipelineId);
-                    await commitDocument(exposureChangedElements);
-                    markTimingInternal('ui_operation_flush_end', pipelineId);
-                    markTimingInternal('layout_end', pipelineId);
-                    markTimingInternal('dispatch_end', pipelineId);
-                    flushMarkTimingInternal();
-                    requestAnimationFrame(()=>{
-                        postTimingFlags(timingFlags, pipelineId);
-                    });
-                },
-                _ReportError: reportError,
-                __OnLifecycleEvent: (data)=>{
-                    jsContext.dispatchEvent({
-                        type: '__OnLifecycleEvent',
-                        data
-                    });
-                },
-                markTiming: (a, b)=>markTimingInternal(b, a),
-                publishEvent,
-                publicComponentEvent,
-                _I18nResourceTranslation: (options)=>{
-                    const matchedInitI18nResources = i18nResources.data?.find((i)=>getCacheI18nResourcesKey(i.options) === getCacheI18nResourcesKey(options));
-                    dispatchI18nResource(matchedInitI18nResources?.resource);
-                    if (matchedInitI18nResources) return matchedInitI18nResources.resource;
-                    return triggerI18nResourceFallback(options);
-                },
-                __QueryComponent
-            }
-        });
-        mtsGlobalThisRef.mtsGlobalThis = mtsGlobalThis;
-        markTimingInternal('decode_end');
-        await mtsRealm.loadScript(template.lepusCode.root);
-        jsContext.__start();
-    }
-    async function handleUpdatedData(newData, options) {
-        const mtsRealm = await mtsRealmPromise;
-        const runtime = mtsRealm.globalWindow;
-        const processedData = runtime.processData ? runtime.processData(newData, options?.processorName) : newData;
-        runtime.updatePage?.(processedData, options);
-        return updateDataBackground(processedData, options);
-    }
-    return {
-        startMainThread,
-        handleUpdatedData
-    };
-}
+var dist = __webpack_require__("../web-constants/dist/index.js");
+var web_worker_rpc_dist = __webpack_require__("../web-worker-rpc/dist/index.js");
 const templateCache = new Map();
 let tmpDir;
 const tmpDirPromise = promises.mkdtemp(node_path.join(node_os.tmpdir(), 'lynx'));
-async function loadTemplate_createJsModuleUrl(content, filename) {
+async function createJsModuleUrl(content, filename) {
     if (!tmpDir) tmpDir = await tmpDirPromise;
     const fileUrl = node_path.join(tmpDir, filename);
     await promises.writeFile(fileUrl, content, {
@@ -2161,10 +653,10 @@ async function loadTemplate_createJsModuleUrl(content, filename) {
     });
     return fileUrl;
 }
-async function loadTemplate_loadTemplate(rawTemplate, templateName = Math.random().toString(36).substring(2, 7)) {
+async function loadTemplate(rawTemplate, templateName = Math.random().toString(36).substring(2, 7)) {
     if (templateCache.has(rawTemplate)) return templateCache.get(rawTemplate);
     templateName += Math.random().toString(36).substring(2, 7);
-    const decodedTemplate = templateCache.get(rawTemplate) ?? await generateTemplate(rawTemplate, loadTemplate_createJsModuleUrl, templateName + '-lepusCode');
+    const decodedTemplate = templateCache.get(rawTemplate) ?? await (0, dist.Yx)(rawTemplate, createJsModuleUrl, templateName + '-lepusCode');
     templateCache.set(rawTemplate, decodedTemplate);
     return decodedTemplate;
 }
@@ -2823,8 +1315,8 @@ function getTextContentImpl(buffer, element, shadowrootTemplates) {
             buffer.push('"');
         }
     }
-    const partId = element[_attributes].get("l-part") ?? element[_attributes].get("l-uid");
-    buffer.push(' ', "l-part", '="', partId, '"');
+    const partId = element[_attributes].get(dist.oZ) ?? element[_attributes].get(dist.SP);
+    buffer.push(' ', dist.oZ, '="', partId, '"');
     buffer.push('>');
     const templateImpl = shadowrootTemplates[localName];
     if (templateImpl) {
@@ -2868,19 +1360,19 @@ const builtinTagTransformMap = {
 };
 OffscreenElement.prototype.toJSON = function() {
     return {
-        ssrID: this[_attributes].get("l-part") ?? this[_attributes].get("l-uid")
+        ssrID: this[_attributes].get(dist.oZ) ?? this[_attributes].get(dist.SP)
     };
 };
 async function createLynxView(config) {
     const { template: rawTemplate, browserConfig, tagMap, initData, globalProps, overrideElementTemplates = {}, hydrateUrl, autoSize, injectStyles, lynxViewStyle, threadStrategy = 'all-on-ui', initI18nResources } = config;
-    const template = await loadTemplate_loadTemplate(rawTemplate, config.templateName);
+    const template = await loadTemplate(rawTemplate, config.templateName);
     const { promise: firstPaintReadyPromise, resolve: firstPaintReady } = Promise.withResolvers();
     const mainWithBackgroundChannel = new MessageChannel();
-    const backgroundThreadRpc = new Rpc(mainWithBackgroundChannel.port1, 'background-thread');
+    const backgroundThreadRpc = new web_worker_rpc_dist.C(mainWithBackgroundChannel.port1, 'background-thread');
     const offscreenDocument = new OffscreenDocument({
         onCommit: ()=>{}
     });
-    const i18nResources = new I18nResources();
+    const i18nResources = new dist.gI();
     const events = [];
     const mtsVMContext = node_vm.createContext(node_vm.constants.DONT_CONTEXTIFY);
     Object.assign(mtsVMContext, {
@@ -2925,6 +1417,7 @@ async function createLynxView(config) {
                 }
             });
         });
+    const { prepareMainThreadAPIs } = await __webpack_require__.e("27").then(__webpack_require__.bind(__webpack_require__, "../web-mainthread-apis/dist/index.js"));
     const { startMainThread } = prepareMainThreadAPIs(backgroundThreadRpc, offscreenDocument, offscreenDocument, {
         globalWindow: mtsVMContext,
         loadScript,
@@ -2937,7 +1430,7 @@ async function createLynxView(config) {
     }, ()=>{}, {
         __AddEvent (element, eventName, eventData, eventOptions) {
             events.push([
-                Number(element.getAttribute("l-uid")),
+                Number(element.getAttribute(dist.SP)),
                 eventName,
                 eventData,
                 eventOptions
@@ -2972,7 +1465,7 @@ async function createLynxView(config) {
         buffer.push('<lynx-view url="', hydrateUrl, '" ssr ="', encodeURI(JSON.stringify(ssrDumpInfo)), '" ', 'thread-strategy="', threadStrategy, '"');
         if (autoSize) buffer.push(' height="auto" width="auto"');
         if (lynxViewStyle) buffer.push(' style="', lynxViewStyle, '"');
-        buffer.push('><template shadowrootmode="open">', '<style>', injectStyles, '\n', inShadowRootStyles.join('\n'), '</style>');
+        buffer.push('><template shadowrootmode="open">', '<style>', injectStyles, '\n', dist.OE.join('\n'), '</style>');
         dumpHTMLString(buffer, offscreenDocument, elementTemplates);
         buffer.push('</template>');
         buffer.push('</lynx-view>');