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

package/dist/27.js

@@ -0,0 +1,1822 @@
+export const __webpack_id__ = "27";
+export const __webpack_ids__ = [
+    "27"
+];
+export const __webpack_modules__ = {
+    "../../../node_modules/.pnpm/hyphenate-style-name@1.1.0/node_modules/hyphenate-style-name/index.js": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>__WEBPACK_DEFAULT_EXPORT__
+        });
+        var uppercasePattern = /[A-Z]/g;
+        var msPattern = /^ms-/;
+        var cache = {};
+        function toHyphenLower(match) {
+            return '-' + match.toLowerCase();
+        }
+        function hyphenateStyleName(name) {
+            if (cache.hasOwnProperty(name)) return cache[name];
+            var hName = name.replace(uppercasePattern, toHyphenLower);
+            return cache[name] = msPattern.test(hName) ? '-' + hName : hName;
+        }
+        const __WEBPACK_DEFAULT_EXPORT__ = hyphenateStyleName;
+    },
+    "../../../node_modules/.pnpm/wasm-feature-detect@1.8.0/node_modules/wasm-feature-detect/dist/esm/index.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            rO: ()=>referenceTypes
+        });
+        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
+            ]));
+    },
+    "../web-mainthread-apis/binary/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_1__.H4,
+                    RS: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_1__.RS,
+                    aC: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_1__.aC,
+                    bL: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_1__.bL,
+                    f: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_1__.f,
+                    iG: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_1__.iG,
+                    lI: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_1__.lI,
+                    pY: ()=>_standard_bg_js__WEBPACK_IMPORTED_MODULE_1__.pY
+                });
+                var _standard_bg_wasm__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-mainthread-apis/binary/standard_bg.wasm");
+                var _standard_bg_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../web-mainthread-apis/binary/standard_bg.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _standard_bg_wasm__WEBPACK_IMPORTED_MODULE_0__
+                ]);
+                _standard_bg_wasm__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
+                (0, _standard_bg_js__WEBPACK_IMPORTED_MODULE_1__.lI)(_standard_bg_wasm__WEBPACK_IMPORTED_MODULE_0__);
+                _standard_bg_wasm__WEBPACK_IMPORTED_MODULE_0__.__wbindgen_start();
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        });
+    },
+    "../web-mainthread-apis/binary/standard_bg.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
+        });
+        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;
+        }
+        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
+                });
+                cachedTextDecoder.decode();
+                numBytesDecoded = len;
+            }
+            return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+        }
+        function getStringFromWasm0(ptr, len) {
+            ptr >>>= 0;
+            return decodeText(ptr, len);
+        }
+        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);
+            return {
+                read: arg.length,
+                written: buf.length
+            };
+        };
+        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;
+            }
+            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;
+            }
+            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;
+            }
+            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);
+            }
+            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-mainthread-apis/dist/createMainThreadGlobalThis.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__, {
+                    D: ()=>createMainThreadGlobalThis
+                });
+                var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+                var _createMainThreadLynx_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../web-mainthread-apis/dist/createMainThreadLynx.js");
+                var _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../web-mainthread-apis/dist/pureElementPAPIs.js");
+                var _utils_createCrossThreadEvent_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("../web-mainthread-apis/dist/utils/createCrossThreadEvent.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__,
+                    _createMainThreadLynx_js__WEBPACK_IMPORTED_MODULE_1__
+                ]);
+                [_pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__, _createMainThreadLynx_js__WEBPACK_IMPORTED_MODULE_1__] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;
+                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 = _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.$4[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 = (0, _utils_createCrossThreadEvent_js__WEBPACK_IMPORTED_MODULE_3__.X)(event, lynxEventName);
+                            if ('string' == typeof hname) {
+                                const parentComponentUniqueId = Number(currentTarget.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.er));
+                                const parentComponent = lynxUniqueIdToElement[parentComponentUniqueId].deref();
+                                const componentId = parentComponent?.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Gq) !== 'page' ? parentComponent?.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.pP) ?? 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 = _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.vQ[element.tagName]?.[eventName] ?? _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.im[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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js);
+                        parentComponentCssID && '0' !== parentComponentCssID && element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js, parentComponentCssID);
+                        element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Gq, tag);
+                        element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP, uniqueId + '');
+                        element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.er, parentComponentUniqueId + '');
+                        return element;
+                    };
+                    const __CreateView = (parentComponentUniqueId)=>__CreateElement('view', parentComponentUniqueId);
+                    const __CreateText = (parentComponentUniqueId)=>__CreateElement('text', parentComponentUniqueId);
+                    const __CreateRawText = (text)=>{
+                        const element = __CreateElement('raw-text', -1);
+                        element.setAttribute('text', text);
+                        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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js, cssID + '');
+                        page.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.er, '0');
+                        page.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.pP, componentID);
+                        (0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.uY)(page);
+                        if (false === pageConfig.defaultDisplayLinear) page.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Gm, '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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js, cssID + '');
+                        component.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.pP, componentID);
+                        component.setAttribute('name', name);
+                        return component;
+                    };
+                    const __SetAttribute = (element, key, value)=>{
+                        const tag = element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Gq);
+                        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 = (0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Tj)(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_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.I7 && 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: (0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Tj)(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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js, cssId + '');
+                            entryName && element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Pb, 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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js);
+                        const uniqueId = Number(element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP));
+                        const entryName = element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Pb);
+                        callbacks.updateCssOGStyle(uniqueId, newClassName, cssId, entryName);
+                    };
+                    const __SetClassesForCSSOG = (element, classNames)=>{
+                        (0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.R5)(element, classNames);
+                        const cssId = element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js);
+                        const uniqueId = Number(element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP));
+                        const entryName = element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Pb);
+                        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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.JA)) 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);
+                        (0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.wr)(element, data.id);
+                        data.class && (0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.R5)(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) (0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.ZW)(element, value);
+                            __SetAttribute(element, key, value);
+                        }
+                        for (const childData of data.children || [])(0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.vh)(element, createElementForElementTemplateData(childData, parentComponentUniId));
+                        void 0 !== data.dataset && (0, _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.bw)(element, data.dataset);
+                        return element;
+                    };
+                    const applyEventsForElementTemplate = (data, element)=>{
+                        const uniqueId = uniqueIdInc++;
+                        element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP, 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(_pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.uY);
+                            return clonedElements;
+                        }
+                        return [];
+                    };
+                    let release = '';
+                    const isCSSOG = !pageConfig.enableCSSSelector;
+                    const SystemInfo = {
+                        ..._lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.c1,
+                        ...config.browserConfig
+                    };
+                    const mtsGlobalThis = {
+                        __ElementFromBinary,
+                        __GetTemplateParts: rootDom.querySelectorAll ? _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.$G : void 0,
+                        __MarkTemplateElement: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.uY,
+                        __MarkPartElement: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.ZW,
+                        __AddEvent: ssrHooks?.__AddEvent ?? __AddEvent,
+                        __GetEvent,
+                        __GetEvents,
+                        __SetEvents,
+                        __AppendElement: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.vh,
+                        __ElementIsEqual: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.pn,
+                        __FirstElement: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.vH,
+                        __GetChildren: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.yj,
+                        __GetParent: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.d6,
+                        __InsertElementBefore: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.pi,
+                        __LastElement: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Nu,
+                        __NextElement: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.cw,
+                        __RemoveElement: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.z3,
+                        __ReplaceElement: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Xk,
+                        __ReplaceElements: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.yE,
+                        __AddConfig: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Ud,
+                        __AddDataset: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Kz,
+                        __GetAttributes: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.GE,
+                        __GetComponentID: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.zP,
+                        __GetDataByKey: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.NV,
+                        __GetDataset: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Fl,
+                        __GetElementConfig: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.pe,
+                        __GetElementUniqueID: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Tj,
+                        __GetID: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.cb,
+                        __GetTag: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.zm,
+                        __SetConfig: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.l9,
+                        __SetDataset: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.bw,
+                        __SetID: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.wr,
+                        __UpdateComponentID: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.A7,
+                        __UpdateComponentInfo: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.$r,
+                        __CreateElement,
+                        __CreateView,
+                        __CreateText,
+                        __CreateComponent,
+                        __CreatePage,
+                        __CreateRawText,
+                        __CreateImage,
+                        __CreateScrollView,
+                        __CreateWrapperElement,
+                        __CreateList,
+                        __SetAttribute,
+                        __SwapElement,
+                        __UpdateListCallbacks,
+                        __GetConfig: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.pe,
+                        __GetAttributeByName: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.li,
+                        __GetClasses: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.Tq,
+                        __AddClass: isCSSOG ? __AddClassForCSSOG : _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.gA,
+                        __SetClasses: isCSSOG ? __SetClassesForCSSOG : _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.R5,
+                        __AddInlineStyle: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.kB,
+                        __SetCSSId: isCSSOG ? __SetCSSIdForCSSOG : _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.D1,
+                        __SetInlineStyles: _pureElementPAPIs_js__WEBPACK_IMPORTED_MODULE_2__.c2,
+                        __LoadLepusChunk,
+                        __GetPageElement,
+                        __globalProps: globalProps,
+                        __QueryComponent: callbacks.__QueryComponent,
+                        SystemInfo,
+                        lynx: (0, _createMainThreadLynx_js__WEBPACK_IMPORTED_MODULE_1__.B)(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;
+                }
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        });
+    },
+    "../web-mainthread-apis/dist/createMainThreadLynx.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__, {
+                    B: ()=>createMainThreadLynx
+                });
+                var _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-mainthread-apis/dist/createMainThreadGlobalThis.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_0__
+                ]);
+                _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
+                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
+                    };
+                }
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        });
+    },
+    "../web-mainthread-apis/dist/crossThreadHandlers/createQueryComponent.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            k: ()=>createQueryComponent
+        });
+        var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+        function createQueryComponent(loadTemplate, updateLazyComponentStyle, backgroundThreadRpc, mtsGlobalThisRef, jsContext, mtsRealm) {
+            const updateBTSTemplateCache = backgroundThreadRpc.createCall(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.WS);
+            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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.nk, (url)=>{
+                const ret = new Promise((resolve)=>{
+                    __QueryComponentImpl(url, (result)=>{
+                        resolve({
+                            code: result.code,
+                            detail: {
+                                schema: url
+                            }
+                        });
+                    });
+                });
+                return ret;
+            });
+            return __QueryComponentImpl;
+        }
+    },
+    "../web-mainthread-apis/dist/crossThreadHandlers/registerCallLepusMethodHandler.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            A: ()=>registerCallLepusMethodHandler
+        });
+        var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+        function registerCallLepusMethodHandler(rpc, runtime) {
+            rpc.registerHandler(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.iH, (methodName, data)=>{
+                runtime[methodName](data);
+            });
+        }
+    },
+    "../web-mainthread-apis/dist/crossThreadHandlers/registerGetCustomSectionHandler.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            m: ()=>registerGetCustomSectionHandler
+        });
+        var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+        function registerGetCustomSectionHandler(rpc, customSections) {
+            rpc.registerHandler(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Fw, (key)=>customSections[key]?.content);
+        }
+    },
+    "../web-mainthread-apis/dist/index.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__, {
+                    prepareMainThreadAPIs: ()=>_prepareMainThreadAPIs_js__WEBPACK_IMPORTED_MODULE_0__.m
+                });
+                var _prepareMainThreadAPIs_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-mainthread-apis/dist/prepareMainThreadAPIs.js");
+                var _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../web-mainthread-apis/dist/createMainThreadGlobalThis.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _prepareMainThreadAPIs_js__WEBPACK_IMPORTED_MODULE_0__,
+                    _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_1__
+                ]);
+                [_prepareMainThreadAPIs_js__WEBPACK_IMPORTED_MODULE_0__, _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_1__] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        });
+    },
+    "../web-mainthread-apis/dist/prepareMainThreadAPIs.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__, {
+                    m: ()=>prepareMainThreadAPIs
+                });
+                var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+                var _crossThreadHandlers_registerCallLepusMethodHandler_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../web-mainthread-apis/dist/crossThreadHandlers/registerCallLepusMethodHandler.js");
+                var _crossThreadHandlers_registerGetCustomSectionHandler_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../web-mainthread-apis/dist/crossThreadHandlers/registerGetCustomSectionHandler.js");
+                var _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("../web-mainthread-apis/dist/createMainThreadGlobalThis.js");
+                var _utils_createExposureService_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("../web-mainthread-apis/dist/utils/createExposureService.js");
+                var _utils_processStyleInfo_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("../web-mainthread-apis/dist/utils/processStyleInfo.js");
+                var _crossThreadHandlers_createQueryComponent_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("../web-mainthread-apis/dist/crossThreadHandlers/createQueryComponent.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _utils_processStyleInfo_js__WEBPACK_IMPORTED_MODULE_5__,
+                    _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_3__
+                ]);
+                [_utils_processStyleInfo_js__WEBPACK_IMPORTED_MODULE_5__, _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_3__] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__;
+                function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, document, mtsRealmPromise, commitDocument, markTimingInternal, flushMarkTimingInternal, reportError, triggerI18nResourceFallback, initialI18nResources, loadTemplate, ssrHooks) {
+                    const postTimingFlags = backgroundThreadRpc.createCall(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.F6);
+                    const backgroundStart = backgroundThreadRpc.createCall(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.a$);
+                    const publishEvent = backgroundThreadRpc.createCall(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.JW);
+                    const publicComponentEvent = backgroundThreadRpc.createCall(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Ke);
+                    const postExposure = backgroundThreadRpc.createCall(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.pd);
+                    const dispatchI18nResource = backgroundThreadRpc.createCall(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.mB);
+                    const updateDataBackground = backgroundThreadRpc.createCall(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Ve);
+                    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');
+                        const jsContext = new _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.tf({
+                            rpc: backgroundThreadRpc,
+                            receiveEventEndpoint: _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Is,
+                            sendEventEndpoint: _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.jK
+                        });
+                        const i18nResources = initialI18nResources(initI18nResources);
+                        const { updateCssOGStyle, updateLazyComponentStyle } = (0, _utils_processStyleInfo_js__WEBPACK_IMPORTED_MODULE_5__.c6)(styleInfo, pageConfig, rootDom, document, ssrHydrateInfo);
+                        const mtsGlobalThisRef = {
+                            mtsGlobalThis: void 0
+                        };
+                        const __QueryComponent = (0, _crossThreadHandlers_createQueryComponent_js__WEBPACK_IMPORTED_MODULE_6__.k)(loadTemplate, updateLazyComponentStyle, backgroundThreadRpc, mtsGlobalThisRef, jsContext, mtsRealm);
+                        const mtsGlobalThis = (0, _createMainThreadGlobalThis_js__WEBPACK_IMPORTED_MODULE_3__.D)({
+                            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');
+                                    (0, _crossThreadHandlers_registerCallLepusMethodHandler_js__WEBPACK_IMPORTED_MODULE_1__.A)(backgroundThreadRpc, mtsGlobalThis);
+                                    (0, _crossThreadHandlers_registerGetCustomSectionHandler_js__WEBPACK_IMPORTED_MODULE_2__.m)(backgroundThreadRpc, customSections);
+                                    const { switchExposureService } = (0, _utils_createExposureService_js__WEBPACK_IMPORTED_MODULE_4__.b)(rootDom, postExposure);
+                                    backgroundThreadRpc.registerHandler(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.eZ, 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)=>(0, _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.HO)(i.options) === (0, _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.HO)(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
+                    };
+                }
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        });
+    },
+    "../web-mainthread-apis/dist/pureElementPAPIs.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__, {
+                    $G: ()=>__GetTemplateParts,
+                    $r: ()=>__UpdateComponentInfo,
+                    A7: ()=>__UpdateComponentID,
+                    D1: ()=>__SetCSSId,
+                    Fl: ()=>__GetDataset,
+                    GE: ()=>__GetAttributes,
+                    Kz: ()=>__AddDataset,
+                    NV: ()=>__GetDataByKey,
+                    Nu: ()=>__LastElement,
+                    R5: ()=>__SetClasses,
+                    Tj: ()=>__GetElementUniqueID,
+                    Tq: ()=>__GetClasses,
+                    Ud: ()=>__AddConfig,
+                    Xk: ()=>__ReplaceElement,
+                    ZW: ()=>__MarkPartElement,
+                    bw: ()=>__SetDataset,
+                    c2: ()=>__SetInlineStyles,
+                    cb: ()=>__GetID,
+                    cw: ()=>__NextElement,
+                    d6: ()=>__GetParent,
+                    gA: ()=>__AddClass,
+                    kB: ()=>__AddInlineStyle,
+                    l9: ()=>__SetConfig,
+                    li: ()=>__GetAttributeByName,
+                    pe: ()=>__GetElementConfig,
+                    pi: ()=>__InsertElementBefore,
+                    pn: ()=>__ElementIsEqual,
+                    uY: ()=>__MarkTemplateElement,
+                    vH: ()=>__FirstElement,
+                    vh: ()=>__AppendElement,
+                    wr: ()=>__SetID,
+                    yE: ()=>__ReplaceElements,
+                    yj: ()=>__GetChildren,
+                    z3: ()=>__RemoveElement,
+                    zP: ()=>__GetComponentID,
+                    zm: ()=>__GetTag
+                });
+                var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+                var _style_cssPropertyMap_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../web-mainthread-apis/dist/style/cssPropertyMap.js");
+                var _style_transformInlineStyle_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../web-mainthread-apis/dist/style/transformInlineStyle.js");
+                var hyphenate_style_name__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("../../../node_modules/.pnpm/hyphenate-style-name@1.1.0/node_modules/hyphenate-style-name/index.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _style_transformInlineStyle_js__WEBPACK_IMPORTED_MODULE_2__
+                ]);
+                _style_transformInlineStyle_js__WEBPACK_IMPORTED_MODULE_2__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
+                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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.tl);
+                    let currentComponentConfig = currentComponentConfigString ? JSON.parse(decodeURIComponent(currentComponentConfigString)) : {};
+                    currentComponentConfig[type] = value;
+                    element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.tl, encodeURIComponent(JSON.stringify(currentComponentConfig)));
+                };
+                const __AddDataset = /*#__PURE__*/ (element, key, value)=>{
+                    const currentDataset = __GetDataset(element);
+                    currentDataset[key] = value;
+                    element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.C6, encodeURIComponent(JSON.stringify(currentDataset)));
+                    value ? element.setAttribute('data-' + key, value.toString()) : element.removeAttribute('data-' + key);
+                };
+                const __GetDataset = /*#__PURE__*/ (element)=>{
+                    const datasetString = element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.C6);
+                    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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.pP);
+                const __GetElementConfig = /*#__PURE__*/ (element)=>{
+                    const currentComponentConfigString = element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.tl);
+                    return currentComponentConfigString ? JSON.parse(decodeURIComponent(currentComponentConfigString)) : {};
+                };
+                const __GetAttributeByName = /*#__PURE__*/ (element, name)=>element.getAttribute(name);
+                const __GetElementUniqueID = /*#__PURE__*/ (element)=>element && element.getAttribute ? Number(element.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP)) : -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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Gq);
+                const __SetConfig = /*#__PURE__*/ (element, config)=>{
+                    element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.tl, encodeURIComponent(JSON.stringify(config)));
+                };
+                const __SetDataset = /*#__PURE__*/ (element, dataset)=>{
+                    element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.C6, 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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.pP, 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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js, params.cssID + '');
+                    void 0 !== params.name && element.setAttribute('name', params.name);
+                };
+                const __SetCSSId = /*#__PURE__*/ (elements, cssId, entryName)=>{
+                    for (const element of elements){
+                        element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js, cssId + '');
+                        entryName && element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Pb, 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 = (0, _style_cssPropertyMap_js__WEBPACK_IMPORTED_MODULE_1__.BH)(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 } = (0, _style_transformInlineStyle_js__WEBPACK_IMPORTED_MODULE_2__.x)([
+                            [
+                                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', (0, _style_transformInlineStyle_js__WEBPACK_IMPORTED_MODULE_2__.Q)(value));
+                    else {
+                        const { transformedStyle } = (0, _style_transformInlineStyle_js__WEBPACK_IMPORTED_MODULE_2__.x)(Object.entries(value).map(([k, value])=>[
+                                (0, hyphenate_style_name__WEBPACK_IMPORTED_MODULE_3__.A)(k),
+                                value?.toString?.() ?? ''
+                            ]));
+                        const transformedStyleStr = transformedStyle.map(([property, value])=>`${property}:${value};`).join('');
+                        element.setAttribute('style', transformedStyleStr);
+                    }
+                };
+                const __GetTemplateParts = (templateElement)=>{
+                    const isTemplate = null !== templateElement.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.y);
+                    if (!isTemplate) return {};
+                    const templateUniqueId = __GetElementUniqueID(templateElement);
+                    const parts = {};
+                    const partElements = templateElement.querySelectorAll(`[${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP}="${templateUniqueId}"] [${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.oZ}]:not([${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP}="${templateUniqueId}"] [${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.y}] [${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.oZ}])`);
+                    for (const partElement of partElements){
+                        const partId = partElement.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.oZ);
+                        if (partId) parts[partId] = partElement;
+                    }
+                    return parts;
+                };
+                const __MarkTemplateElement = (element)=>{
+                    element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.y, '');
+                };
+                const __MarkPartElement = (element, partId)=>{
+                    element.setAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.oZ, partId);
+                };
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        });
+    },
+    "../web-mainthread-apis/dist/style/cssPropertyMap.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            BH: ()=>queryCSSProperty
+        });
+        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 index = 1;
+        const cssPropertyMap = {};
+        const cssPropertyReverseMap = {};
+        const V = (name)=>{
+            const k = 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];
+        }
+    },
+    "../web-mainthread-apis/dist/style/transformInlineStyle.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__, {
+                    Q: ()=>_utils_tokenizer_js__WEBPACK_IMPORTED_MODULE_0__.Q,
+                    x: ()=>_utils_tokenizer_js__WEBPACK_IMPORTED_MODULE_0__.x
+                });
+                var _utils_tokenizer_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-mainthread-apis/dist/utils/tokenizer.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _utils_tokenizer_js__WEBPACK_IMPORTED_MODULE_0__
+                ]);
+                _utils_tokenizer_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);
+            }
+        });
+    },
+    "../web-mainthread-apis/dist/utils/createCrossThreadEvent.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            X: ()=>createCrossThreadEvent
+        });
+        var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+        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(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.C6);
+            const currentTargetDataset = currentTargetDatasetString ? JSON.parse(decodeURIComponent(currentTargetDatasetString)) : {};
+            const targetDatasetString = targetElement.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.C6);
+            const targetDataset = targetDatasetString ? JSON.parse(decodeURIComponent(targetDatasetString)) : {};
+            return {
+                type: eventName,
+                timestamp: domEvent.timeStamp,
+                target: {
+                    id: targetElement.getAttribute('id'),
+                    dataset: targetDataset,
+                    uniqueId: Number(targetElement.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP))
+                },
+                currentTarget: currentTargetElement ? {
+                    id: currentTargetElement.getAttribute('id'),
+                    dataset: currentTargetDataset,
+                    uniqueId: Number(currentTargetElement.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP))
+                } : null,
+                detail,
+                params,
+                ...otherProperties
+            };
+        }
+    },
+    "../web-mainthread-apis/dist/utils/createExposureService.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            b: ()=>createExposureService
+        });
+        var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+        var _createCrossThreadEvent_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../web-mainthread-apis/dist/utils/createCrossThreadEvent.js");
+        function createExposureService(rootDom, postExposure) {
+            let working = true;
+            let exposureCache = [];
+            let disexposureCache = [];
+            let delayCallback = null;
+            const onScreen = new Map();
+            function exposureEventHandler(ev) {
+                const exposureEvent = (0, _createCrossThreadEvent_js__WEBPACK_IMPORTED_MODULE_1__.X)(ev, ev.type);
+                exposureEvent.detail['unique-id'] = parseFloat(ev.target.getAttribute(_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP));
+                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
+            };
+        }
+    },
+    "../web-mainthread-apis/dist/utils/decodeCssOG.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            y: ()=>decodeCssOG
+        });
+        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('');
+        }
+    },
+    "../web-mainthread-apis/dist/utils/processStyleInfo.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__, {
+                    c6: ()=>appendStyleElement
+                });
+                var _lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-constants/dist/index.js");
+                var _tokenizer_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("../web-mainthread-apis/dist/utils/tokenizer.js");
+                var _decodeCssOG_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("../web-mainthread-apis/dist/utils/decodeCssOG.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _tokenizer_js__WEBPACK_IMPORTED_MODULE_1__
+                ]);
+                _tokenizer_js__WEBPACK_IMPORTED_MODULE_1__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
+                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 } = (0, _tokenizer_js__WEBPACK_IMPORTED_MODULE_1__.x)(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 ? `[${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Gq}]` : `[${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.js}="${cssId}"]`;
+                        suffix = entryName ? `${suffix}[${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Pb}=${JSON.stringify(entryName)}]` : `${suffix}:not([${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.Pb}])`;
+                        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 = (0, _decodeCssOG_js__WEBPACK_IMPORTED_MODULE_2__.y)(newClassName, styleMap, cssID);
+                        if (void 0 !== lynxUniqueIdToStyleRulesIndex[uniqueId]) {
+                            const rule = cardStyleElementSheet.cssRules[lynxUniqueIdToStyleRulesIndex[uniqueId]];
+                            rule.style.cssText = newStyles;
+                        } else {
+                            const index = cardStyleElementSheet.insertRule(`[${_lynx_js_web_constants__WEBPACK_IMPORTED_MODULE_0__.SP}="${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
+                    };
+                }
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        });
+    },
+    "../web-mainthread-apis/dist/utils/tokenizer.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__, {
+                    Q: ()=>transformInlineStyleString,
+                    x: ()=>transformParsedStyles
+                });
+                var _wasm_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-mainthread-apis/wasm/index.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _wasm_index_js__WEBPACK_IMPORTED_MODULE_0__
+                ]);
+                _wasm_index_js__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
+                function transformInlineStyleString(str) {
+                    return _wasm_index_js__WEBPACK_IMPORTED_MODULE_0__.v.transform_raw_u16_inline_style_ptr(str) ?? str;
+                }
+                function transformParsedStyles(styles) {
+                    let childStyle = [];
+                    let transformedStyle = [];
+                    for (const [property, value] of styles){
+                        const transformedResult = _wasm_index_js__WEBPACK_IMPORTED_MODULE_0__.v.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
+                    };
+                }
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        });
+    },
+    "../web-mainthread-apis/wasm/index.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__, {
+                    v: ()=>wasm
+                });
+                var wasm_feature_detect__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../../../node_modules/.pnpm/wasm-feature-detect@1.8.0/node_modules/wasm-feature-detect/dist/esm/index.js");
+                let wasm;
+                async function initWasm() {
+                    const supportsReferenceTypes = await (0, wasm_feature_detect__WEBPACK_IMPORTED_MODULE_0__.rO)();
+                    wasm = supportsReferenceTypes ? await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../web-mainthread-apis/wasm/standard.js")) : await __webpack_require__.e("8").then(__webpack_require__.bind(__webpack_require__, "../web-mainthread-apis/wasm/legacy.js"));
+                }
+                await initWasm();
+                __webpack_async_result__();
+            } catch (e) {
+                __webpack_async_result__(e);
+            }
+        }, 1);
+    },
+    "../web-mainthread-apis/wasm/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: ()=>_binary_standard_js__WEBPACK_IMPORTED_MODULE_0__.H4,
+                    __wbg_new_e17d9f43105b08be: ()=>_binary_standard_js__WEBPACK_IMPORTED_MODULE_0__.f,
+                    __wbg_push_df81a39d04db858c: ()=>_binary_standard_js__WEBPACK_IMPORTED_MODULE_0__.RS,
+                    __wbg_set_wasm: ()=>_binary_standard_js__WEBPACK_IMPORTED_MODULE_0__.lI,
+                    __wbindgen_cast_2241b6af4c4b2941: ()=>_binary_standard_js__WEBPACK_IMPORTED_MODULE_0__.pY,
+                    __wbindgen_init_externref_table: ()=>_binary_standard_js__WEBPACK_IMPORTED_MODULE_0__.bL,
+                    transform_raw_u16_inline_style_ptr: ()=>_binary_standard_js__WEBPACK_IMPORTED_MODULE_0__.aC,
+                    transform_raw_u16_inline_style_ptr_parsed: ()=>_binary_standard_js__WEBPACK_IMPORTED_MODULE_0__.iG
+                });
+                var _binary_standard_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("../web-mainthread-apis/binary/standard.js");
+                var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([
+                    _binary_standard_js__WEBPACK_IMPORTED_MODULE_0__
+                ]);
+                _binary_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);
+            }
+        });
+    },
+    "../web-mainthread-apis/binary/standard_bg.wasm": function(module, exports, __webpack_require__) {
+        var WEBPACK_IMPORTED_MODULE_0 = __webpack_require__("../web-mainthread-apis/binary/standard_bg.js");
+        module.exports = __webpack_require__.v(exports, module.id, "7f8d048731bd644f", {
+            "./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
+            }
+        });
+    }
+};
+
+//# sourceMappingURL=27.js.map