@lynx-js/web-core-server-canary 0.19.4-canary-20260104-f4b90f3a → 0.19.5-canary-20260107-78c21890

package/dist/131.js

@@ -0,0 +1,1389 @@
+import { __webpack_require__ } from "./rslib-runtime.js";
+import node_os from "node:os";
+import promises from "node:fs/promises";
+import node_path from "node:path";
+import node_vm from "node:vm";
+import node_fs from "node:fs";
+__webpack_require__.add({
+    "../web-constants/dist/constants.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Gm: ()=>lynxDefaultDisplayLinearAttribute,
+            Gq: ()=>lynxTagAttribute,
+            I7: ()=>__lynx_timing_flag,
+            JA: ()=>lynxDisposedAttribute,
+            OE: ()=>inShadowRootStyles,
+            Pb: ()=>lynxEntryNameAttribute,
+            c1: ()=>systemInfo,
+            er: ()=>parentComponentUniqueIdAttribute,
+            js: ()=>cssIdAttribute,
+            pP: ()=>componentIdAttribute,
+            tl: ()=>lynxComponentConfigAttribute,
+            y: ()=>lynxElementTemplateMarkerAttribute
+        });
+        const cssIdAttribute = 'l-css-id';
+        const componentIdAttribute = 'l-comp-id';
+        const parentComponentUniqueIdAttribute = 'l-p-comp-uid';
+        const lynxEntryNameAttribute = 'l-e-name';
+        const lynxTagAttribute = 'lynx-tag';
+        const lynxComponentConfigAttribute = 'l-comp-cfg';
+        const lynxDisposedAttribute = 'l-disposed';
+        const lynxElementTemplateMarkerAttribute = 'l-template';
+        const lynxDefaultDisplayLinearAttribute = 'lynx-default-display-linear';
+        const __lynx_timing_flag = '__lynx_timing_flag';
+        const systemInfo = {
+            platform: 'web',
+            lynxSdkVersion: '3.0'
+        };
+        const inShadowRootStyles = [
+            ` [lynx-default-display-linear="false"] * {
+    --lynx-display: flex;
+    --lynx-display-toggle: var(--lynx-display-flex);
+  }`,
+            `[lynx-default-overflow-visible="true"] x-view{
+    overflow: visible;
+  }`
+        ];
+    },
+    "../web-constants/dist/endpoints.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            F6: ()=>postTimingFlagsEndpoint,
+            Fw: ()=>getCustomSectionsEndpoint,
+            Is: ()=>dispatchJSContextOnMainThreadEndpoint,
+            JW: ()=>publishEventEndpoint,
+            Ke: ()=>publicComponentEventEndpoint,
+            Ve: ()=>updateDataEndpoint,
+            WS: ()=>updateBTSTemplateCacheEndpoint,
+            a$: ()=>BackgroundThreadStartEndpoint,
+            eZ: ()=>switchExposureServiceEndpoint,
+            iH: ()=>callLepusMethodEndpoint,
+            jK: ()=>dispatchCoreContextOnBackgroundEndpoint,
+            mB: ()=>dispatchI18nResourceEndpoint,
+            nk: ()=>queryComponentEndpoint,
+            pd: ()=>postExposureEndpoint
+        });
+        var _lynx_js_web_worker_rpc__rspack_import_0 = __webpack_require__("../web-worker-rpc/dist/RpcEndpoint.js");
+        const postExposureEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('__postExposure', false, false);
+        const publicComponentEventEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('publicComponentEvent', false, false);
+        const publishEventEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('publishEvent', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('postOffscreenEventEndpoint', false, false);
+        const switchExposureServiceEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('switchExposureServiceEndpoint', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('mainThreadStart', false, false);
+        const updateDataEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('updateData', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('sendGlobalEventEndpoint', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('dispose', false, true);
+        const BackgroundThreadStartEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('start', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('reportError', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('flushElementTree', false, true);
+        const callLepusMethodEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('callLepusMethod', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('multiThreadExposureChangedEndpoint', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('__invokeUIMethod', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('__setNativeProps', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('__getPathInfo', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('nativeModulesCall', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('napiModulesCall', false, true, true);
+        const getCustomSectionsEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('getCustomSections', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('markTiming', false, false);
+        const postTimingFlagsEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('postTimingFlags', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('__triggerComponentEvent', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('__selectComponent', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('dispatchLynxViewEvent', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('dispatchNapiModule', false, false);
+        const dispatchCoreContextOnBackgroundEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('dispatchCoreContextOnBackground', false, false);
+        const dispatchJSContextOnMainThreadEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('dispatchJSContextOnMainThread', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('__triggerElementMethod', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('updateGlobalProps', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('updateI18nResources', false, false);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('updateI18nResource', false, false);
+        const dispatchI18nResourceEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('dispatchI18nResource', false, false);
+        const queryComponentEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('queryComponent', false, true);
+        const updateBTSTemplateCacheEndpoint = (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('updateBTSTemplateCacheEndpoint', false, true);
+        (0, _lynx_js_web_worker_rpc__rspack_import_0.H)('loadTemplateMultiThread', false, true);
+    },
+    "../web-constants/dist/eventName.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            $4: ()=>W3cEventNameToLynx,
+            im: ()=>LynxEventNameToW3cCommon,
+            vQ: ()=>LynxEventNameToW3cByTagName
+        });
+        const W3cEventNameToLynx = {
+            click: 'tap',
+            lynxscroll: 'scroll',
+            lynxscrollend: 'scrollend',
+            overlaytouch: 'touch',
+            lynxfocus: 'focus',
+            lynxblur: 'blur',
+            lynxinput: 'input'
+        };
+        const LynxEventNameToW3cByTagName = {
+            'X-INPUT': {
+                blur: 'lynxblur',
+                focus: 'lynxfocus',
+                input: 'lynxinput'
+            },
+            'X-TEXTAREA': {
+                blur: 'lynxblur',
+                focus: 'lynxfocus',
+                input: 'lynxinput'
+            }
+        };
+        const LynxEventNameToW3cCommon = {
+            tap: 'click',
+            scroll: 'lynxscroll',
+            scrollend: 'lynxscrollend',
+            touch: 'overlaytouch'
+        };
+    },
+    "../web-constants/dist/index.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            $4: ()=>_eventName_js__rspack_import_1.$4,
+            C6: ()=>"l-dset",
+            F6: ()=>_endpoints_js__rspack_import_2.F6,
+            Fw: ()=>_endpoints_js__rspack_import_2.Fw,
+            Gm: ()=>_constants_js__rspack_import_0.Gm,
+            Gq: ()=>_constants_js__rspack_import_0.Gq,
+            HO: ()=>_types_index_js__rspack_import_3.HO,
+            I7: ()=>_constants_js__rspack_import_0.I7,
+            Is: ()=>_endpoints_js__rspack_import_2.Is,
+            JA: ()=>_constants_js__rspack_import_0.JA,
+            JW: ()=>_endpoints_js__rspack_import_2.JW,
+            Ke: ()=>_endpoints_js__rspack_import_2.Ke,
+            OE: ()=>_constants_js__rspack_import_0.OE,
+            Pb: ()=>_constants_js__rspack_import_0.Pb,
+            SP: ()=>"l-uid",
+            Ve: ()=>_endpoints_js__rspack_import_2.Ve,
+            WS: ()=>_endpoints_js__rspack_import_2.WS,
+            Yx: ()=>_utils_index_js__rspack_import_4.Yx,
+            a$: ()=>_endpoints_js__rspack_import_2.a$,
+            c1: ()=>_constants_js__rspack_import_0.c1,
+            eZ: ()=>_endpoints_js__rspack_import_2.eZ,
+            er: ()=>_constants_js__rspack_import_0.er,
+            gI: ()=>_types_index_js__rspack_import_3.gI,
+            iH: ()=>_endpoints_js__rspack_import_2.iH,
+            im: ()=>_eventName_js__rspack_import_1.im,
+            jK: ()=>_endpoints_js__rspack_import_2.jK,
+            js: ()=>_constants_js__rspack_import_0.js,
+            mB: ()=>_endpoints_js__rspack_import_2.mB,
+            nk: ()=>_endpoints_js__rspack_import_2.nk,
+            oZ: ()=>"l-part",
+            pP: ()=>_constants_js__rspack_import_0.pP,
+            pd: ()=>_endpoints_js__rspack_import_2.pd,
+            tf: ()=>_utils_index_js__rspack_import_4.tf,
+            tl: ()=>_constants_js__rspack_import_0.tl,
+            vQ: ()=>_eventName_js__rspack_import_1.vQ,
+            y: ()=>_constants_js__rspack_import_0.y
+        });
+        var _constants_js__rspack_import_0 = __webpack_require__("../web-constants/dist/constants.js");
+        var _eventName_js__rspack_import_1 = __webpack_require__("../web-constants/dist/eventName.js");
+        var _endpoints_js__rspack_import_2 = __webpack_require__("../web-constants/dist/endpoints.js");
+        var _types_index_js__rspack_import_3 = __webpack_require__("../web-constants/dist/types/index.js");
+        var _utils_index_js__rspack_import_4 = __webpack_require__("../web-constants/dist/utils/index.js");
+    },
+    "../web-constants/dist/types/Element.js" () {
+        var AnimationOperation;
+        (function(AnimationOperation) {
+            AnimationOperation[AnimationOperation["START"] = 0] = "START";
+            AnimationOperation[AnimationOperation["PLAY"] = 1] = "PLAY";
+            AnimationOperation[AnimationOperation["PAUSE"] = 2] = "PAUSE";
+            AnimationOperation[AnimationOperation["CANCEL"] = 3] = "CANCEL";
+            AnimationOperation[AnimationOperation["FINISH"] = 4] = "FINISH";
+        })(AnimationOperation || (AnimationOperation = {}));
+    },
+    "../web-constants/dist/types/I18n.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            HO: ()=>getCacheI18nResourcesKey,
+            gI: ()=>I18nResources
+        });
+        const getCacheI18nResourcesKey = (options)=>`${options.locale}_${options.channel}_${options.fallback_url}`;
+        class I18nResources {
+            data;
+            constructor(data){
+                this.data = data;
+            }
+            setData(data) {
+                this.data = data;
+            }
+        }
+    },
+    "../web-constants/dist/types/LynxContextEventTarget.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            U: ()=>DispatchEventResult
+        });
+        const DispatchEventResult = {
+            NotCanceled: 0,
+            CanceledByEventHandler: 1,
+            CanceledByDefaultEventHandler: 2,
+            CanceledBeforeDispatch: 3
+        };
+    },
+    "../web-constants/dist/types/NativeApp.js" () {
+        var IdentifierType;
+        (function(IdentifierType) {
+            IdentifierType[IdentifierType["ID_SELECTOR"] = 0] = "ID_SELECTOR";
+            IdentifierType[IdentifierType["REF_ID"] = 1] = "REF_ID";
+            IdentifierType[IdentifierType["UNIQUE_ID"] = 2] = "UNIQUE_ID";
+        })(IdentifierType || (IdentifierType = {}));
+        var ErrorCode;
+        (function(ErrorCode) {
+            ErrorCode[ErrorCode["SUCCESS"] = 0] = "SUCCESS";
+            ErrorCode[ErrorCode["UNKNOWN"] = 1] = "UNKNOWN";
+            ErrorCode[ErrorCode["NODE_NOT_FOUND"] = 2] = "NODE_NOT_FOUND";
+            ErrorCode[ErrorCode["METHOD_NOT_FOUND"] = 3] = "METHOD_NOT_FOUND";
+            ErrorCode[ErrorCode["PARAM_INVALID"] = 4] = "PARAM_INVALID";
+            ErrorCode[ErrorCode["SELECTOR_NOT_SUPPORTED"] = 5] = "SELECTOR_NOT_SUPPORTED";
+            ErrorCode[ErrorCode["NO_UI_FOR_NODE"] = 6] = "NO_UI_FOR_NODE";
+        })(ErrorCode || (ErrorCode = {}));
+    },
+    "../web-constants/dist/types/UpdateDataOptions.js" () {
+        var NativeUpdateDataType;
+        (function(NativeUpdateDataType) {
+            NativeUpdateDataType[NativeUpdateDataType["UPDATE"] = 0] = "UPDATE";
+            NativeUpdateDataType[NativeUpdateDataType["RESET"] = 1] = "RESET";
+        })(NativeUpdateDataType || (NativeUpdateDataType = {}));
+    },
+    "../web-constants/dist/types/index.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            HO: ()=>_I18n_js__rspack_import_3.HO,
+            gI: ()=>_I18n_js__rspack_import_3.gI
+        });
+        __webpack_require__("../web-constants/dist/types/NativeApp.js");
+        __webpack_require__("../web-constants/dist/types/UpdateDataOptions.js");
+        __webpack_require__("../web-constants/dist/types/Element.js");
+        var _I18n_js__rspack_import_3 = __webpack_require__("../web-constants/dist/types/I18n.js");
+    },
+    "../web-constants/dist/utils/LynxCrossThreadContext.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            t: ()=>LynxCrossThreadContext
+        });
+        var _types_LynxContextEventTarget_js__rspack_import_0 = __webpack_require__("../web-constants/dist/types/LynxContextEventTarget.js");
+        class LynxCrossThreadContext extends EventTarget {
+            _config;
+            constructor(_config){
+                super();
+                this._config = _config;
+            }
+            postMessage(...args) {
+                console.error('[lynx-web] postMessage not implemented, args:', ...args);
+            }
+            dispatchEvent(event) {
+                const { rpc, sendEventEndpoint } = this._config;
+                rpc.invoke(sendEventEndpoint, [
+                    event
+                ]);
+                return _types_LynxContextEventTarget_js__rspack_import_0.U.CanceledBeforeDispatch;
+            }
+            __start() {
+                const { rpc, receiveEventEndpoint } = this._config;
+                rpc.registerHandler(receiveEventEndpoint, ({ type, data })=>{
+                    super.dispatchEvent(new MessageEvent(type, {
+                        data: data ?? {}
+                    }));
+                });
+            }
+        }
+    },
+    "../web-constants/dist/utils/generateTemplate.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Y: ()=>generateTemplate
+        });
+        const currentSupportedTemplateVersion = 2;
+        const globalDisallowedVars = [
+            'navigator',
+            'postMessage',
+            'window'
+        ];
+        const templateUpgraders = [
+            (template)=>{
+                template.appType = template.appType ?? (template.lepusCode.root.startsWith('(function (globDynamicComponentEntry') ? 'lazy' : 'card');
+                template.version = 2;
+                template.lepusCode = Object.fromEntries(Object.entries(template.lepusCode).filter(([_, content])=>'string' == typeof content));
+                return template;
+            }
+        ];
+        const generateModuleContent = (fileName, content, eager, appType)=>[
+                eager ? '//# allFunctionsCalledOnLoad' : '',
+                '\n(function() { "use strict"; const ',
+                globalDisallowedVars.join('=void 0,'),
+                '=void 0;\n',
+                'card' !== appType ? 'module.exports=\n' : '',
+                content,
+                '\n})()',
+                '\n//# sourceURL=',
+                fileName
+            ].join('');
+        async function generateJavascriptUrl(obj, createJsModuleUrl, eager, appType, templateName) {
+            return Promise.all(Object.entries(obj).filter(([_, content])=>'string' == typeof content).map(async ([name, content])=>[
+                    name,
+                    await createJsModuleUrl(generateModuleContent(`${templateName}/${name.replaceAll('/', '_')}.js`, content, eager, appType), `${templateName}-${name.replaceAll('/', '_')}.js`)
+                ])).then(Object.fromEntries);
+        }
+        async function generateTemplate(template, createJsModuleUrl, templateName) {
+            template.version = template.version ?? 1;
+            if (template.version > currentSupportedTemplateVersion) throw new Error("Unsupported template, please upgrade your web-platform dependencies");
+            let upgrader;
+            while(template.version < currentSupportedTemplateVersion && (upgrader = templateUpgraders[template.version - 1]))template = upgrader(template);
+            return {
+                ...template,
+                lepusCode: await generateJavascriptUrl(template.lepusCode, createJsModuleUrl, true, template.appType, templateName)
+            };
+        }
+    },
+    "../web-constants/dist/utils/index.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Yx: ()=>_generateTemplate_js__rspack_import_1.Y,
+            tf: ()=>_LynxCrossThreadContext_js__rspack_import_0.t
+        });
+        var _LynxCrossThreadContext_js__rspack_import_0 = __webpack_require__("../web-constants/dist/utils/LynxCrossThreadContext.js");
+        var _generateTemplate_js__rspack_import_1 = __webpack_require__("../web-constants/dist/utils/generateTemplate.js");
+    },
+    "../web-worker-rpc/dist/Rpc.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            C: ()=>Rpc
+        });
+        class Rpc {
+            port;
+            name;
+            incId = 0;
+            #messageQueue = [];
+            #messageCache = {};
+            #textEncoder = new TextEncoder();
+            #textDecoder = new TextDecoder();
+            #handlerMap = new Map();
+            constructor(port, name){
+                this.port = port;
+                this.name = name;
+                if (port) port.onmessage = (ev)=>this.#onMessage(ev.data);
+            }
+            setMessagePort(port) {
+                if (this.port) throw new Error('Rpc port already set');
+                this.port = port;
+                for (const item of this.#messageQueue)this.postMessage(item.message, item.detail);
+                this.#messageQueue = [];
+                port.onmessage = (ev)=>this.#onMessage(ev.data);
+            }
+            postMessage(message, detail) {
+                if (this.port) this.port.postMessage(message, detail);
+                else this.#messageQueue.push({
+                    message: message,
+                    detail
+                });
+            }
+            get nextRetId() {
+                return `ret_${this.name}_${this.incId++}`;
+            }
+            static createRetEndpoint(retId) {
+                return {
+                    name: retId,
+                    hasReturn: false,
+                    isSync: false
+                };
+            }
+            #onMessage = async (message)=>{
+                const handler = this.#handlerMap.get(message.name);
+                if (handler) {
+                    const lockViewer = message.sync ? new Int32Array(message.lock) : void 0;
+                    const replyTempEndpoint = !message.sync && message.retId ? Rpc.createRetEndpoint(message.retId) : void 0;
+                    try {
+                        const result = await handler(...message.data);
+                        let retData, transfer = [];
+                        if (message.sync) retData = result;
+                        else if (message.hasTransfer) ({ data: retData, transfer } = result || {});
+                        else retData = result;
+                        if (message.sync) {
+                            if (message.buf) {
+                                const retStr = JSON.stringify(retData);
+                                const lengthViewer = new Uint32Array(message.buf, 0, 1);
+                                const bufViewer = new Uint8Array(message.buf, 4);
+                                const retCache = new Uint8Array(message.buf.byteLength - 4);
+                                const { written: byteLength } = this.#textEncoder.encodeInto(retStr, retCache);
+                                lengthViewer[0] = byteLength;
+                                bufViewer.set(retCache, 0);
+                            }
+                            Atomics.store(lockViewer, 0, 1);
+                            Atomics.notify(lockViewer, 0);
+                        } else if (message.retId) this.invoke(replyTempEndpoint, [
+                            retData,
+                            false
+                        ], transfer || []);
+                    } catch (e) {
+                        console.error(e);
+                        if (message.sync) {
+                            Atomics.store(lockViewer, 0, 2);
+                            Atomics.notify(lockViewer, 0);
+                            lockViewer[1] = 2;
+                        } else this.invoke(replyTempEndpoint, [
+                            void 0,
+                            true
+                        ]);
+                    }
+                } else {
+                    const cache = this.#messageCache[message.name];
+                    if (cache) cache.push(message);
+                    else this.#messageCache[message.name] = [
+                        message
+                    ];
+                }
+            };
+            createCall(endpoint) {
+                return (...args)=>this.invoke(endpoint, args);
+            }
+            registerHandler(endpoint, handler) {
+                this.#handlerMap.set(endpoint.name, handler);
+                const currentCache = this.#messageCache[endpoint.name];
+                if (currentCache?.length) {
+                    this.#messageCache[endpoint.name] = void 0;
+                    for (const message of currentCache)this.#onMessage(message);
+                }
+            }
+            registerHandlerRef(endpoint, target, propertyName) {
+                this.registerHandler(endpoint, (...args)=>target[propertyName]?.call(target, ...args));
+            }
+            registerHandlerLazy(endpoint, target, propertyName) {
+                if (target[propertyName]) this.registerHandlerRef(endpoint, target, propertyName);
+                else {
+                    let property;
+                    const rpc = this;
+                    Object.defineProperty(target, propertyName, {
+                        get () {
+                            return property;
+                        },
+                        set (v) {
+                            property = v;
+                            if (v) rpc.registerHandlerRef(endpoint, target, propertyName);
+                        }
+                    });
+                }
+            }
+            removeHandler(rpc) {
+                this.#handlerMap.delete(rpc.name);
+            }
+            invoke(endpoint, parameters, transfer = []) {
+                if (endpoint.isSync) {
+                    const sharedBuffer = endpoint.bufferSize ? new SharedArrayBuffer(endpoint.bufferSize + 4) : void 0;
+                    const lock = new SharedArrayBuffer(4);
+                    const lockViewer = new Int32Array(lock);
+                    lockViewer[0] = 0;
+                    const message = {
+                        name: endpoint.name,
+                        data: parameters,
+                        sync: true,
+                        lock: lock,
+                        buf: sharedBuffer
+                    };
+                    this.postMessage(message, {
+                        transfer
+                    });
+                    Atomics.wait(lockViewer, 0, 0);
+                    if (2 === lockViewer[0]) throw null;
+                    if (!sharedBuffer) return;
+                    {
+                        const byteLength = new Uint32Array(sharedBuffer, 0, 4)[0];
+                        const sharedBufferView = new Uint8Array(sharedBuffer, 4, byteLength);
+                        const localBuf = new Uint8Array(byteLength);
+                        localBuf.set(sharedBufferView, 0);
+                        const ret = localBuf ? JSON.parse(this.#textDecoder.decode(localBuf)) : void 0;
+                        return ret;
+                    }
+                }
+                if (endpoint.hasReturn) {
+                    let promise, resolve, reject;
+                    promise = new Promise((res, rej)=>{
+                        resolve = res;
+                        reject = rej;
+                    });
+                    const retHandler = Rpc.createRetEndpoint(this.nextRetId);
+                    this.registerHandler(retHandler, (returnValue, error)=>{
+                        if (error) reject();
+                        resolve(returnValue);
+                    });
+                    const message = {
+                        name: endpoint.name,
+                        data: parameters,
+                        sync: false,
+                        retId: retHandler?.name,
+                        hasTransfer: endpoint.hasReturnTransfer
+                    };
+                    this.postMessage(message, {
+                        transfer
+                    });
+                    return promise;
+                }
+                {
+                    const message = {
+                        name: endpoint.name,
+                        data: parameters,
+                        sync: false
+                    };
+                    this.postMessage(message, {
+                        transfer
+                    });
+                }
+            }
+            createCallbackify(endpoint, callbackAt) {
+                const call = this.createCall(endpoint);
+                return (...params)=>{
+                    const callback = params.at(callbackAt);
+                    params.splice(callbackAt, 1);
+                    call(...params).then(callback);
+                };
+            }
+        }
+    },
+    "../web-worker-rpc/dist/RpcEndpoint.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            H: ()=>createRpcEndpoint
+        });
+        function createRpcEndpoint(name, isSync, hasReturn = true, hasReturnTransfer = false, bufferSize) {
+            return {
+                name,
+                isSync,
+                hasReturn,
+                hasReturnTransfer,
+                bufferSize
+            };
+        }
+    }
+});
+const dist = __webpack_require__("../web-constants/dist/index.js");
+const templateCache = new Map();
+let tmpDir;
+const tmpDirPromise = promises.mkdtemp(node_path.join(node_os.tmpdir(), 'lynx'));
+async function createJsModuleUrl(content, filename) {
+    if (!tmpDir) tmpDir = await tmpDirPromise;
+    const fileUrl = node_path.join(tmpDir, filename);
+    await promises.writeFile(fileUrl, content, {
+        flag: 'w+'
+    });
+    return fileUrl;
+}
+async function loadTemplate(rawTemplate, templateName = Math.random().toString(36).substring(2, 7)) {
+    if (templateCache.has(rawTemplate)) return templateCache.get(rawTemplate);
+    templateName += Math.random().toString(36).substring(2, 7);
+    const decodedTemplate = templateCache.get(rawTemplate) ?? await (0, dist.Yx)(rawTemplate, createJsModuleUrl, templateName + '-lepusCode');
+    templateCache.set(rawTemplate, decodedTemplate);
+    return decodedTemplate;
+}
+const OperationType = {
+    CreateElement: 1,
+    SetAttribute: 2,
+    RemoveAttribute: 3,
+    Append: 4,
+    Remove: 5,
+    ReplaceWith: 6,
+    InsertBefore: 7,
+    EnableEvent: 8,
+    RemoveChild: 9,
+    StyleDeclarationSetProperty: 10,
+    StyleDeclarationRemoveProperty: 11,
+    SetTextContent: 12,
+    sheetInsertRule: 13,
+    sheetRuleUpdateCssText: 14
+};
+class OffscreenCSSStyleDeclaration {
+    _parent;
+    constructor(parent){
+        this._parent = parent;
+    }
+    setProperty(property, value, priority) {
+        this._parent[ancestorDocument][operations].push(OperationType.StyleDeclarationSetProperty, this._parent[OffscreenElement_uniqueId], property, value, priority ?? '');
+        const currentStyle = this._parent.getAttribute('style') ?? '';
+        this._parent[_attributes].set('style', currentStyle + `${property}:${value}${priority ? ` !${priority}` : ''};`);
+    }
+    removeProperty(property) {
+        this._parent[ancestorDocument][operations].push(OperationType.StyleDeclarationRemoveProperty, this._parent[OffscreenElement_uniqueId], property);
+        const currentStyle = this._parent.getAttribute('style') ?? '';
+        this._parent[_attributes].set('style', currentStyle + `${property}:inital;`);
+    }
+}
+const ancestorDocument = Symbol('ancestorDocument');
+const _attributes = Symbol('_attributes');
+const _children = Symbol('_children');
+const textContent = Symbol('textContent');
+const _cssRuleContents = Symbol('_cssRuleContents');
+const OffscreenElement_uniqueId = Symbol('uniqueId');
+const _style = Symbol('_style');
+class OffscreenElement extends EventTarget {
+    [textContent] = '';
+    [_style];
+    [_attributes] = new Map();
+    _parentElement = null;
+    [_children] = [];
+    [_cssRuleContents];
+    #sheet;
+    [OffscreenElement_uniqueId];
+    [ancestorDocument];
+    localName;
+    constructor(localName, elementUniqueId){
+        super();
+        this.localName = localName;
+        this[OffscreenElement_uniqueId] = elementUniqueId;
+    }
+    get sheet() {
+        if (!this.#sheet) {
+            const uid = this[OffscreenElement_uniqueId];
+            const ancestor = this[ancestorDocument];
+            const cssRules = [];
+            this.#sheet = {
+                cssRules,
+                insertRule: (rule, index)=>{
+                    cssRules.splice(index, 0, {
+                        style: {
+                            set cssText (text){
+                                ancestor[operations].push(OperationType.sheetRuleUpdateCssText, uid, index, text);
+                            }
+                        }
+                    });
+                    if (!this[_cssRuleContents]) this[_cssRuleContents] = [];
+                    this[_cssRuleContents].splice(index, 0, rule);
+                    this[ancestorDocument][operations].push(OperationType.sheetInsertRule, uid, index, rule);
+                    return index;
+                }
+            };
+        }
+        return this.#sheet;
+    }
+    get tagName() {
+        return this.localName.toUpperCase();
+    }
+    get style() {
+        if (!this[_style]) this[_style] = new OffscreenCSSStyleDeclaration(this);
+        return this[_style];
+    }
+    get children() {
+        return this[_children].slice();
+    }
+    get parentElement() {
+        return this._parentElement;
+    }
+    get parentNode() {
+        return this._parentElement;
+    }
+    get firstElementChild() {
+        return this[_children][0] ?? null;
+    }
+    get lastElementChild() {
+        return this[_children][this[_children].length - 1] ?? null;
+    }
+    get nextElementSibling() {
+        const parent = this._parentElement;
+        if (parent) {
+            const nextElementSiblingIndex = parent[_children].indexOf(this);
+            if (nextElementSiblingIndex >= 0) return parent[_children][nextElementSiblingIndex + 1] || null;
+        }
+        return null;
+    }
+    _remove() {
+        if (this._parentElement) {
+            const currentIdx = this._parentElement[_children].indexOf(this);
+            this._parentElement[_children].splice(currentIdx, 1);
+            this._parentElement = null;
+        }
+    }
+    setAttribute(qualifiedName, value) {
+        this[_attributes].set(qualifiedName, value);
+        this[ancestorDocument][operations].push(OperationType.SetAttribute, this[OffscreenElement_uniqueId], qualifiedName, value);
+    }
+    getAttribute(qualifiedName) {
+        return this[_attributes].get(qualifiedName) ?? null;
+    }
+    removeAttribute(qualifiedName) {
+        this[_attributes].delete(qualifiedName);
+        this[ancestorDocument][operations].push(OperationType.RemoveAttribute, this[OffscreenElement_uniqueId], qualifiedName);
+    }
+    append(...nodes) {
+        this[ancestorDocument][operations].push(OperationType.Append, this[OffscreenElement_uniqueId], nodes.length, ...nodes.map((node)=>node[OffscreenElement_uniqueId]));
+        for (const node of nodes){
+            node._remove();
+            node._parentElement = this;
+        }
+        this[_children].push(...nodes);
+    }
+    appendChild(node) {
+        this[ancestorDocument][operations].push(OperationType.Append, this[OffscreenElement_uniqueId], 1, node[OffscreenElement_uniqueId]);
+        node._remove();
+        node._parentElement = this;
+        this[_children].push(node);
+        return node;
+    }
+    replaceWith(...nodes) {
+        this[ancestorDocument][operations].push(OperationType.ReplaceWith, this[OffscreenElement_uniqueId], nodes.length, ...nodes.map((node)=>node[OffscreenElement_uniqueId]));
+        if (this._parentElement) {
+            const parent = this._parentElement;
+            this._parentElement = null;
+            const currentIdx = parent[_children].indexOf(this);
+            parent[_children].splice(currentIdx, 1, ...nodes);
+            for (const node of nodes)node._parentElement = parent;
+        }
+    }
+    getAttributeNames() {
+        return [
+            ...this[_attributes].keys()
+        ];
+    }
+    remove() {
+        this[ancestorDocument][operations].push(OperationType.Remove, this[OffscreenElement_uniqueId]);
+        this._remove();
+    }
+    insertBefore(newNode, refNode) {
+        newNode._remove();
+        if (refNode) {
+            const refNodeIndex = this[_children].indexOf(refNode);
+            if (refNodeIndex >= 0) {
+                newNode._parentElement = this;
+                this[_children].splice(refNodeIndex, 0, newNode);
+            }
+        } else {
+            newNode._parentElement = this;
+            this[_children].push(newNode);
+        }
+        this[ancestorDocument][operations].push(OperationType.InsertBefore, this[OffscreenElement_uniqueId], newNode[OffscreenElement_uniqueId], refNode?.[OffscreenElement_uniqueId] ?? 0);
+        return newNode;
+    }
+    removeChild(child) {
+        if (!child) throw new DOMException('The node to be removed is not a child of this node.', 'NotFoundError');
+        if (child._parentElement !== this) throw new DOMException('The node to be removed is not a child of this node.', 'NotFoundError');
+        this[ancestorDocument][operations].push(OperationType.RemoveChild, this[OffscreenElement_uniqueId], child[OffscreenElement_uniqueId]);
+        child._remove();
+        return child;
+    }
+    addEventListener(type, callback, options) {
+        this[ancestorDocument][enableEvent](type, this[OffscreenElement_uniqueId]);
+        super.addEventListener(type, callback, options);
+    }
+    get textContent() {
+        return this[textContent];
+    }
+    set textContent(text1) {
+        this[ancestorDocument][operations].push(OperationType.SetTextContent, this[OffscreenElement_uniqueId], text1);
+        for (const child of this.children)child.remove();
+        this[textContent] = text1;
+        if (this[_cssRuleContents]) this[_cssRuleContents] = [];
+    }
+}
+const propagationStopped = Symbol('propagationStopped');
+const eventPhase = Symbol('eventPhase');
+class OffscreenEvent extends Event {
+    _target;
+    [eventPhase] = Event.CAPTURING_PHASE;
+    constructor(type, _target){
+        super(type);
+        this._target = _target;
+    }
+    get target() {
+        return this._target;
+    }
+    [propagationStopped] = false;
+    stopImmediatePropagation() {
+        this[propagationStopped] = true;
+        super.stopImmediatePropagation();
+    }
+    stopPropagation() {
+        this[propagationStopped] = true;
+        super.stopPropagation();
+    }
+    get eventPhase() {
+        return this[eventPhase];
+    }
+}
+const operations = Symbol('operations');
+const enableEvent = Symbol('enableEvent');
+const getElementByUniqueId = Symbol('getElementByUniqueId');
+const _onEvent = Symbol('_onEvent');
+const _uniqueIdInc = Symbol('uniqueIdInc');
+const _uniqueIdToElement = Symbol('_uniqueIdToElement');
+class OffscreenDocument extends OffscreenElement {
+    _callbacks;
+    [_uniqueIdInc] = 1;
+    [_uniqueIdToElement] = [];
+    [operations] = [];
+    [getElementByUniqueId](uniqueId) {
+        return this[_uniqueIdToElement][uniqueId]?.deref();
+    }
+    [enableEvent];
+    constructor(_callbacks){
+        const enableEventImpl = (eventType, uid)=>{
+            this[operations].push(OperationType.EnableEvent, uid, eventType);
+        };
+        super('', 0);
+        this._callbacks = _callbacks;
+        this[ancestorDocument] = this;
+        this[enableEvent] = enableEventImpl;
+    }
+    commit() {
+        const currentOperations = this[operations];
+        this[operations] = [];
+        this._callbacks.onCommit(currentOperations);
+    }
+    createElement(tagName) {
+        const uniqueId = this[_uniqueIdInc]++;
+        const element = new OffscreenElement(tagName, uniqueId);
+        element[ancestorDocument] = this;
+        this[_uniqueIdToElement][uniqueId] = new WeakRef(element);
+        this[operations].push(OperationType.CreateElement, uniqueId, tagName);
+        return element;
+    }
+    [_onEvent] = (eventType, targetUniqueId, bubbles, otherProperties)=>{
+        const target = this[getElementByUniqueId](targetUniqueId);
+        if (target) {
+            const bubblePath = [];
+            let tempTarget = target;
+            while(tempTarget.parentElement){
+                bubblePath.push(tempTarget.parentElement);
+                tempTarget = tempTarget.parentElement;
+            }
+            const event = new OffscreenEvent(eventType, target);
+            Object.assign(event, otherProperties);
+            event[eventPhase] = Event.CAPTURING_PHASE;
+            for(let ii = bubblePath.length - 1; ii >= 0; ii--){
+                const currentPhaseTarget = bubblePath[ii];
+                currentPhaseTarget.dispatchEvent(event);
+                if (event[propagationStopped]) return;
+            }
+            event[eventPhase] = Event.AT_TARGET;
+            target.dispatchEvent(event);
+            if (bubbles) {
+                event[eventPhase] = Event.BUBBLING_PHASE;
+                for (const currentPhaseTarget of bubblePath){
+                    currentPhaseTarget.dispatchEvent(event);
+                    if (event[propagationStopped]) return;
+                }
+            }
+        }
+    };
+}
+const templateScrollView = `<style>
+  .placeholder-dom {
+    display: none;
+    flex: 0 0 0;
+    align-self: stretch;
+    min-height: 0;
+    min-width: 0;
+  }
+  .mask {
+    z-index: 1;
+    position: sticky;
+  }
+  .observer-container {
+    flex-direction: inherit;
+    overflow: visible;
+  }
+  .observer {
+    display: flex;
+  }
+  ::-webkit-scrollbar {
+    display: none;
+  }
+
+  @keyframes topFading {
+    0% {
+      box-shadow: transparent 0px 0px 0px 0px;
+    }
+    5% {
+      box-shadow: var(--scroll-view-bg-color) 0px 0px
+        var(--scroll-view-fading-edge-length)
+        var(--scroll-view-fading-edge-length);
+    }
+    100% {
+      box-shadow: var(--scroll-view-bg-color) 0px 0px
+        var(--scroll-view-fading-edge-length)
+        var(--scroll-view-fading-edge-length);
+    }
+  }
+  @keyframes botFading {
+    0% {
+      box-shadow: var(--scroll-view-bg-color) 0px 0px
+        var(--scroll-view-fading-edge-length)
+        var(--scroll-view-fading-edge-length);
+    }
+    95% {
+      box-shadow: var(--scroll-view-bg-color) 0px 0px
+        var(--scroll-view-fading-edge-length)
+        var(--scroll-view-fading-edge-length);
+    }
+    100% {
+      box-shadow: transparent 0px 0px 0px 0px;
+    }
+  }
+</style>
+  <div
+    class="mask placeholder-dom"
+    id="top-fade-mask"
+    part="top-fade-mask"
+  ></div>
+  <div
+    class="observer-container placeholder-dom"
+    part="upper-threshold-observer"
+  >
+    <div
+      class="observer placeholder-dom"
+      id="upper-threshold-observer"
+    ></div>
+  </div>
+  <slot></slot>
+  <div
+    class="observer-container placeholder-dom"
+    part="lower-threshold-observer"
+  >
+    <div
+      class="observer placeholder-dom"
+      id="lower-threshold-observer"
+    ></div>
+  </div>
+  <div
+    class="mask placeholder-dom"
+    id="bot-fade-mask"
+    part="bot-fade-mask"
+  ></div>`;
+const templateXAudioTT = '<audio id="audio"></audio>';
+const XSSDetector = /<\s*script/g;
+const templateXImage = (attributes)=>{
+    const { src } = attributes;
+    if (src && XSSDetector.test(src)) throw new Error("detected <script, this is a potential XSS attack, please check your src");
+    return `<img part="img" alt="" loading="lazy" id="img" ${src ? `src="${src}"` : ''}/> `;
+};
+const templateFilterImage = templateXImage;
+const templateXInput = `<style>
+  #input:focus {
+    outline: none;
+  }
+  #form {
+    display: none;
+  }
+</style>
+<form id="form" part="form" method="dialog">
+  <input
+    id="input"
+    part="input"
+    step="any"
+    type="text"
+    inputmode="text"
+    spell-check="true"
+  />
+</form>`;
+const templateXList = `<style>
+  .placeholder-dom {
+    display: none;
+    flex: 0 0 0;
+    align-self: stretch;
+    min-height: 0;
+    min-width: 0;
+  }
+  .observer-container {
+    flex-direction: inherit;
+    overflow: visible;
+  }
+  .observer {
+    display: flex;
+  }
+</style>
+<div id="content" part="content">
+  <div
+    class="observer-container placeholder-dom"
+    part="upper-threshold-observer"
+  >
+    <div
+      class="observer placeholder-dom"
+      id="upper-threshold-observer"
+    ></div>
+  </div>
+  <slot part="slot"></slot>
+  <div
+    class="observer-container placeholder-dom"
+    part="lower-threshold-observer"
+  >
+    <div
+      class="observer placeholder-dom"
+      id="lower-threshold-observer"
+    ></div>
+  </div>
+</div>`;
+const templateXOverlayNg = `<style>
+  #dialog[open] {
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    position: fixed;
+    overscroll-behavior: contain;
+    scrollbar-width: none;
+  }
+  #dialog[open]::-webkit-scrollbar {
+    display: none;
+  }
+  #dialog::backdrop {
+    background-color: transparent;
+  }
+  .overlay-inner {
+    position: sticky;
+    top: 0;
+    width: 100%;
+    height: 100%;
+    pointer-events: none;
+  }
+  .overlay-inner > * {
+    pointer-events: auto;
+  }
+  .overlay-placeholder {
+    width: 100%;
+    height: 1px;
+  }
+</style>
+<dialog id="dialog" part="dialog">
+  <div class="overlay-inner">
+    <slot></slot>
+  </div>
+  <div class="overlay-placeholder"></div>
+</dialog>`;
+const templateXRefreshView = `<style>
+  .bounce-container {
+    overflow: scroll;
+    overscroll-behavior: contain;
+    scroll-snap-type: y mandatory;
+    scroll-behavior: smooth;
+    scrollbar-width: none;
+  }
+  .overflow-placeholder {
+    min-height: 30%;
+    min-width: 100%;
+    flex-shrink: 0;
+    scroll-snap-align: none;
+  }
+  .not-shrink {
+    height: 100%;
+    width: 100%;
+    min-height: 100%;
+    min-width: 100%;
+    flex-shrink: 0;
+  }
+  .vertical {
+    display: flex;
+    flex-direction: column;
+  }
+  #content {
+    scroll-snap-align: center;
+  }
+</style>
+<div id="container" part="container" class="bounce-container not-shrink vertical">
+  <div
+    id="placeholder-top"
+    class="overflow-placeholder bounce-item"
+    part="placeholder-top"
+  ></div>
+  <slot name="header"></slot>
+  <div id="content" part="content" class="not-shrink vertical">
+    <slot part="slot"></slot>
+  </div>
+  <slot name="footer"></slot>
+  <div
+    id="placeholder-bot"
+    class="overflow-placeholder bounce-item"
+    part="placeholder-bot"
+  ></div>
+</div>`;
+const templateXSwiper = `<style>
+  #bounce-padding {
+    display: none;
+    flex: 0 0 0;
+    align-self: stretch;
+    scroll-snap-align: none;
+    flex-basis: 100%;
+  }
+  #content {
+    position: relative;
+    display: flex;
+    flex: 0 0 100%;
+    flex-direction: inherit;
+    flex-wrap: inherit;
+    align-self: stretch;
+    justify-content: inherit;
+    align-items: inherit;
+    overflow: inherit;
+    scrollbar-width: none;
+    scroll-snap-align: start;
+    scroll-snap-type: inherit;
+  }
+  div::-webkit-scrollbar {
+    display: none;
+  }
+  #indicator-container {
+    display: none;
+  }
+  #indicator-container > div {
+    animation-name: indicator-dot;
+    animation-duration: 100ms;
+  }
+  @keyframes indicator-dot {
+    30%,
+    70% {
+      background-color: var(--indicator-color);
+    }
+    31%,
+    69% {
+      background-color: var(--indicator-active-color);
+    }
+  }
+</style>
+<style id="indicator-style"></style>
+<div id="bounce-padding" part="bounce-padding"></div>
+<div id="indicator-container" part="indicator-container"></div>
+<div id="content" part="content">
+  <slot part="slot-start" name="circular-start" id="circular-start"></slot>
+  <slot part="slot"></slot>
+  <slot part="slot-end" name="circular-end" id="circular-end"></slot>
+</div>`;
+const templateXText = '<div id="inner-box" part="inner-box"><slot part="slot"></slot><slot name="inline-truncation"></slot></div>';
+const templateInlineImage = templateXImage;
+const templateXTextarea = `<style>
+  #textarea:focus,
+  #textarea:focus-visible {
+    border: inherit;
+    outline: inherit;
+  }
+</style>
+<form id="form" part="form" method="dialog">
+  <textarea id="textarea" part="textarea"></textarea>
+</form>`;
+const templateXViewpageNg = `<style>
+  #bounce-padding {
+    display: none;
+    flex: 0 0 0;
+    align-self: stretch;
+    scroll-snap-align: none;
+    flex-basis: 100%;
+  }
+  #content {
+    flex: 0 0 100%;
+    flex-direction: row;
+    align-self: stretch;
+    display: inherit;
+    justify-content: inherit;
+    align-items: inherit;
+    overflow: inherit;
+    scrollbar-width: none;
+    scroll-snap-type: inherit;
+  }
+  #content::-webkit-scrollbar {
+    display: none;
+  }
+</style>
+<div id="bounce-padding" part="bounce-padding"></div>
+<div id="content" part="content">
+  <slot></slot>
+</div>`;
+const matchHtmlRegExp = /["'&<>]/;
+function escapeHtml(string) {
+    const str = '' + string;
+    const match = matchHtmlRegExp.exec(str);
+    if (!match) return str;
+    let escape;
+    let html = '';
+    let index;
+    let lastIndex = 0;
+    for(index = match.index; index < str.length; index++){
+        switch(str.charCodeAt(index)){
+            case 34:
+                escape = '&quot;';
+                break;
+            case 38:
+                escape = '&amp;';
+                break;
+            case 39:
+                escape = '&#x27;';
+                break;
+            case 60:
+                escape = '&lt;';
+                break;
+            case 62:
+                escape = '&gt;';
+                break;
+            default:
+                continue;
+        }
+        if (lastIndex !== index) html += str.substring(lastIndex, index);
+        lastIndex = index + 1;
+        html += escape;
+    }
+    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+function getTextContentImpl(buffer, element, shadowrootTemplates) {
+    const localName = element.localName;
+    buffer.push('<');
+    buffer.push(localName);
+    for (const [key, value] of element[_attributes]){
+        buffer.push(' ');
+        buffer.push(key);
+        if (value.length > 0) {
+            buffer.push('="');
+            buffer.push(escapeHtml(value));
+            buffer.push('"');
+        }
+    }
+    const partId = element[_attributes].get(dist.oZ) ?? element[_attributes].get(dist.SP);
+    buffer.push(' ', dist.oZ, '="', partId, '"');
+    buffer.push('>');
+    const templateImpl = shadowrootTemplates[localName];
+    if (templateImpl) {
+        const template = 'function' == typeof templateImpl ? templateImpl(Object.fromEntries(element[_attributes].entries())) : templateImpl;
+        buffer.push('<template shadowrootmode="open">', template, '</template>');
+    }
+    if (element[_cssRuleContents]?.length) buffer.push(...element[_cssRuleContents]);
+    if (element[textContent]) buffer.push(element[textContent]);
+    else for (const child of element[_children])getTextContentImpl(buffer, child, shadowrootTemplates);
+    buffer.push('</');
+    buffer.push(localName);
+    buffer.push('>');
+}
+function dumpHTMLString(buffer, element, shadowrootTemplates) {
+    for (const child of element[_children])getTextContentImpl(buffer, child, shadowrootTemplates);
+}
+const Rpc = __webpack_require__("../web-worker-rpc/dist/Rpc.js");
+const builtinElementTemplates = {
+    'scroll-view': templateScrollView,
+    'x-audio-tt': templateXAudioTT,
+    'x-image': templateXImage,
+    'filter-image': templateFilterImage,
+    'x-input': templateXInput,
+    'x-list': templateXList,
+    'x-overlay-ng': templateXOverlayNg,
+    'x-refresh-view': templateXRefreshView,
+    'x-swiper': templateXSwiper,
+    'x-text': templateXText,
+    'inline-image': templateInlineImage,
+    'x-textarea': templateXTextarea,
+    'x-viewpage-ng': templateXViewpageNg
+};
+const builtinTagTransformMap = {
+    page: 'div',
+    view: 'x-view',
+    text: 'x-text',
+    image: 'x-image',
+    list: 'x-list',
+    svg: 'x-svg',
+    input: 'x-input',
+    'x-input-ng': 'x-input'
+};
+OffscreenElement.prototype.toJSON = function() {
+    return {
+        ssrID: this[_attributes].get(dist.oZ) ?? this[_attributes].get(dist.SP)
+    };
+};
+async function createLynxView(config) {
+    const { template: rawTemplate, browserConfig, tagMap, initData, globalProps, overrideElementTemplates = {}, hydrateUrl, autoSize, injectStyles, lynxViewStyle, threadStrategy = 'all-on-ui', initI18nResources } = config;
+    const template = await loadTemplate(rawTemplate, config.templateName);
+    const { promise: firstPaintReadyPromise, resolve: firstPaintReady } = Promise.withResolvers();
+    const mainWithBackgroundChannel = new MessageChannel();
+    const backgroundThreadRpc = new Rpc.C(mainWithBackgroundChannel.port1, 'background-thread');
+    const offscreenDocument = new OffscreenDocument({
+        onCommit: ()=>{}
+    });
+    const i18nResources = new dist.gI();
+    const events = [];
+    const mtsVMContext = node_vm.createContext(node_vm.constants.DONT_CONTEXTIFY);
+    Object.assign(mtsVMContext, {
+        document: offscreenDocument,
+        module: {
+            exports: null
+        }
+    });
+    const loadScriptSync = (url)=>{
+        const scriptContent = node_fs.readFileSync(url);
+        const script = new node_vm.Script(scriptContent.toString(), {
+            filename: url
+        });
+        mtsVMContext.module = {
+            exports: null
+        };
+        script.runInContext(mtsVMContext);
+        const ret = mtsVMContext.module.exports;
+        mtsVMContext.module = {
+            exports: null
+        };
+        return ret;
+    };
+    const loadScript = async (url)=>new Promise((resolve, reject)=>{
+            node_fs.readFile(url, (err, data)=>{
+                if (err) return void reject(err);
+                try {
+                    const script = new node_vm.Script(data.toString(), {
+                        filename: url
+                    });
+                    mtsVMContext.module = {
+                        exports: null
+                    };
+                    script.runInContext(mtsVMContext);
+                    const ret = mtsVMContext.module.exports;
+                    mtsVMContext.module = {
+                        exports: null
+                    };
+                    resolve(ret);
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    const { prepareMainThreadAPIs } = await import("./27.js").then(__webpack_require__.bind(__webpack_require__, "../web-mainthread-apis/dist/index.js"));
+    const { startMainThread } = prepareMainThreadAPIs(backgroundThreadRpc, offscreenDocument, offscreenDocument, {
+        globalWindow: mtsVMContext,
+        loadScript,
+        loadScriptSync
+    }, ()=>{
+        firstPaintReady();
+    }, ()=>{}, ()=>{}, ()=>{}, ()=>{}, (initI18nResources)=>{
+        i18nResources.setData(initI18nResources);
+        return i18nResources;
+    }, ()=>{}, {
+        __AddEvent (element, eventName, eventData, eventOptions) {
+            events.push([
+                Number(element.getAttribute(dist.SP)),
+                eventName,
+                eventData,
+                eventOptions
+            ]);
+        }
+    }, 'all-on-ui' === threadStrategy);
+    await startMainThread({
+        template,
+        initData,
+        globalProps,
+        browserConfig,
+        nativeModulesMap: {},
+        napiModulesMap: {},
+        tagMap: {
+            ...builtinTagTransformMap,
+            ...tagMap
+        },
+        initI18nResources
+    });
+    const elementTemplates = {
+        ...builtinElementTemplates,
+        ...overrideElementTemplates
+    };
+    async function renderToString() {
+        await firstPaintReadyPromise;
+        const ssrEncodeData = mtsVMContext?.ssrEncode?.();
+        const ssrDumpInfo = {
+            ssrEncodeData,
+            events
+        };
+        const buffer = [];
+        buffer.push('<lynx-view url="', hydrateUrl, '" ssr ="', encodeURI(JSON.stringify(ssrDumpInfo)), '" ', 'thread-strategy="', threadStrategy, '"');
+        if (autoSize) buffer.push(' height="auto" width="auto"');
+        if (lynxViewStyle) buffer.push(' style="', lynxViewStyle, '"');
+        buffer.push('><template shadowrootmode="open">', '<style>', injectStyles, '\n', dist.OE.join('\n'), '</style>');
+        dumpHTMLString(buffer, offscreenDocument, elementTemplates);
+        buffer.push('</template>');
+        buffer.push('</lynx-view>');
+        return buffer.join('');
+    }
+    return {
+        renderToString
+    };
+}
+if (!globalThis.requestAnimationFrame) {
+    globalThis.requestAnimationFrame = (cb)=>setTimeout(cb, 0);
+    globalThis.cancelAnimationFrame = (id)=>{
+        clearTimeout(id);
+    };
+}
+export { createLynxView };
+
+//# sourceMappingURL=131.js.map