@lynx-js/react 0.117.0 → 0.118.0

package/runtime/worklet-runtime/dev.js

@@ -0,0 +1,629 @@
+(()=>{
+    "use strict";
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    class Animation {
+        cancel() {
+            return __ElementAnimate(this.effect.target.element, [
+                3,
+                this.id
+            ]);
+        }
+        pause() {
+            return __ElementAnimate(this.effect.target.element, [
+                2,
+                this.id
+            ]);
+        }
+        play() {
+            return __ElementAnimate(this.effect.target.element, [
+                1,
+                this.id
+            ]);
+        }
+        start() {
+            return __ElementAnimate(this.effect.target.element, [
+                0,
+                this.id,
+                this.effect.keyframes,
+                this.effect.options
+            ]);
+        }
+        constructor(effect){
+            _define_property(this, "effect", void 0);
+            _define_property(this, "id", void 0);
+            this.effect = effect;
+            this.id = '__lynx-inner-js-animation-' + Animation.count++;
+            this.start();
+        }
+    }
+    _define_property(Animation, "count", 0);
+    function effect_define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    class KeyframeEffect {
+        constructor(target, keyframes, options){
+            effect_define_property(this, "target", void 0);
+            effect_define_property(this, "keyframes", void 0);
+            effect_define_property(this, "options", void 0);
+            this.target = target;
+            this.keyframes = keyframes;
+            this.options = options;
+        }
+    }
+    const TRACE_LIMIT = 256;
+    const DEFAULT_FLUSH_LIMIT = 256;
+    let trace = [];
+    let flushCountInWindow = 0;
+    let resetScheduled = false;
+    let trippedError = null;
+    function pushTrace(marker) {
+        trace.push(marker);
+        if (trace.length > TRACE_LIMIT) trace = trace.slice(trace.length - TRACE_LIMIT);
+    }
+    function compressTrace(markers) {
+        if (0 === markers.length) return '';
+        const out = [];
+        let prev = markers[markers.length - 1];
+        let count = 1;
+        for(let i = markers.length - 2; i >= 0; i--){
+            const cur = markers[i];
+            if (cur === prev) {
+                count++;
+                continue;
+            }
+            out.push(1 === count ? prev : `${prev} x${count}`);
+            prev = cur;
+            count = 1;
+        }
+        out.push(1 === count ? prev : `${prev} x${count}`);
+        return out.join(' <- ');
+    }
+    function mainThreadFlushLoopMark(marker) {
+        pushTrace(marker);
+    }
+    function mainThreadFlushLoopOnFlushMicrotask() {
+        if (trippedError) return trippedError;
+        if (!resetScheduled) {
+            resetScheduled = true;
+            setTimeout(()=>{
+                mainThreadFlushLoopReset();
+            }, 0);
+        }
+        flushCountInWindow++;
+        const limit = DEFAULT_FLUSH_LIMIT;
+        if (flushCountInWindow > limit) {
+            const traceText = compressTrace(trace);
+            trippedError = new Error(`[ReactLynx][DEV] MainThread flush loop detected: render executed ${flushCountInWindow} times without yielding (limit=${limit}). Trace: ${traceText}`);
+            return trippedError;
+        }
+        return null;
+    }
+    function mainThreadFlushLoopReport(error) {
+        setTimeout(()=>{
+            throw error;
+        }, 0);
+    }
+    function mainThreadFlushLoopReset() {
+        trace = [];
+        flushCountInWindow = 0;
+        resetScheduled = false;
+        trippedError = null;
+    }
+    function isSdkVersionGt(major, minor) {
+        var _SystemInfo_lynxSdkVersion;
+        const lynxSdkVersion = null != (_SystemInfo_lynxSdkVersion = SystemInfo.lynxSdkVersion) ? _SystemInfo_lynxSdkVersion : '1.0';
+        const version = lynxSdkVersion.split('.');
+        return Number(version[0]) > major || Number(version[0]) == major && Number(version[1]) > minor;
+    }
+    function element_define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    let willFlush = false;
+    let shouldFlush = true;
+    function setShouldFlush(value) {
+        shouldFlush = value;
+    }
+    class Element {
+        setAttribute(name, value) {
+            mainThreadFlushLoopMark(`element:setAttribute ${name}`);
+            __SetAttribute(this.element, name, value);
+            this.flushElementTree();
+        }
+        setStyleProperty(name, value) {
+            mainThreadFlushLoopMark(`element:setStyleProperty ${name}`);
+            __AddInlineStyle(this.element, name, value);
+            this.flushElementTree();
+        }
+        setStyleProperties(styles) {
+            mainThreadFlushLoopMark(`element:setStyleProperties keys=${Object.keys(styles).length}`);
+            for(const key in styles)__AddInlineStyle(this.element, key, styles[key]);
+            this.flushElementTree();
+        }
+        getAttribute(attributeName) {
+            return __GetAttributeByName(this.element, attributeName);
+        }
+        getAttributeNames() {
+            return __GetAttributeNames(this.element);
+        }
+        querySelector(selector) {
+            const ref = __QuerySelector(this.element, selector, {});
+            return ref ? new Element(ref) : null;
+        }
+        querySelectorAll(selector) {
+            return __QuerySelectorAll(this.element, selector, {}).map((element)=>new Element(element));
+        }
+        getComputedStyleProperty(key) {
+            if (!isSdkVersionGt(3, 4)) throw new Error('getComputedStyleProperty requires Lynx sdk version 3.5');
+            if (!key) throw new Error('getComputedStyleProperty: key is required');
+            return __GetComputedStyleByKey(this.element, key);
+        }
+        animate(keyframes, options) {
+            const normalizedOptions = 'number' == typeof options ? {
+                duration: options
+            } : null != options ? options : {};
+            return new Animation(new KeyframeEffect(this, keyframes, normalizedOptions));
+        }
+        invoke(methodName, params) {
+            mainThreadFlushLoopMark(`element:invoke ${methodName}`);
+            return new Promise((resolve, reject)=>{
+                __InvokeUIMethod(this.element, methodName, null != params ? params : {}, (res)=>{
+                    if (0 === res.code) resolve(res.data);
+                    else reject(new Error('UI method invoke: ' + JSON.stringify(res)));
+                });
+                this.flushElementTree();
+            });
+        }
+        flushElementTree() {
+            if (willFlush || !shouldFlush) return;
+            willFlush = true;
+            Promise.resolve().then(()=>{
+                willFlush = false;
+                {
+                    mainThreadFlushLoopMark('render');
+                    const error = mainThreadFlushLoopOnFlushMicrotask();
+                    if (error) {
+                        shouldFlush = false;
+                        mainThreadFlushLoopReport(error);
+                        return;
+                    }
+                }
+                __FlushElementTree();
+            });
+        }
+        constructor(element){
+            element_define_property(this, "element", void 0);
+            Object.defineProperty(this, 'element', {
+                get () {
+                    return element;
+                }
+            });
+        }
+    }
+    function lepusQuerySelector_define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    class PageElement {
+        static get() {
+            var _PageElement;
+            null != (_PageElement = PageElement).pageElement || (_PageElement.pageElement = __GetPageElement());
+            return PageElement.pageElement;
+        }
+    }
+    lepusQuerySelector_define_property(PageElement, "pageElement", void 0);
+    function querySelector(cssSelector) {
+        const pageElement = PageElement.get();
+        if (!pageElement) return null;
+        const element = __QuerySelector(pageElement, cssSelector, {});
+        return element ? new Element(element) : null;
+    }
+    function querySelectorAll(cssSelector) {
+        const pageElement = PageElement.get();
+        if (!pageElement) return [];
+        return __QuerySelectorAll(pageElement, cssSelector, {}).map((element)=>new Element(element));
+    }
+    function initApiEnv() {
+        var _lynx_clearInterval;
+        lynx.querySelector = querySelector;
+        lynx.querySelectorAll = querySelectorAll;
+        globalThis.setTimeout = lynx.setTimeout;
+        globalThis.setInterval = lynx.setInterval;
+        globalThis.clearTimeout = lynx.clearTimeout;
+        globalThis.clearInterval = null != (_lynx_clearInterval = lynx.clearInterval) ? _lynx_clearInterval : lynx.clearTimeInterval;
+        {
+            const requestAnimationFrame = lynx.requestAnimationFrame;
+            lynx.requestAnimationFrame = globalThis.requestAnimationFrame = (callback)=>{
+                if (!isSdkVersionGt(2, 15)) throw new Error("requestAnimationFrame in main thread script requires Lynx sdk version 2.16");
+                return requestAnimationFrame(callback);
+            };
+        }
+        globalThis.cancelAnimationFrame = lynx.cancelAnimationFrame;
+    }
+    function runRunOnMainThreadTask(task, params, resolveId) {
+        let returnValue;
+        try {
+            returnValue = runWorklet(task, params);
+        } finally{
+            lynx.getJSContext().dispatchEvent({
+                type: "Lynx.Worklet.FunctionCallRet",
+                data: JSON.stringify({
+                    resolveId,
+                    returnValue
+                })
+            });
+        }
+    }
+    function profile(sliceName, f) {
+        var _console_profile, _console;
+        null == (_console_profile = (_console = console).profile) || _console_profile.call(_console, sliceName);
+        try {
+            return f();
+        } finally{
+            var _console_profileEnd, _console1;
+            null == (_console_profileEnd = (_console1 = console).profileEnd) || _console_profileEnd.call(_console1);
+        }
+    }
+    let impl;
+    function initWorkletRef() {
+        return impl = {
+            _workletRefMap: {},
+            _firstScreenWorkletRefMap: {},
+            updateWorkletRef,
+            updateWorkletRefInitValueChanges,
+            clearFirstScreenWorkletRefMap
+        };
+    }
+    const createWorkletRef = (id, value)=>({
+            current: value,
+            _wvid: id
+        });
+    const getFromWorkletRefMap = (refImpl)=>{
+        const id = refImpl._wvid;
+        mainThreadFlushLoopMark(`MainThreadRef:get id=${id}`);
+        let value;
+        if (id < 0) {
+            value = impl._firstScreenWorkletRefMap[id];
+            if (!value) value = impl._firstScreenWorkletRefMap[id] = createWorkletRef(id, refImpl._initValue);
+        } else value = impl._workletRefMap[id];
+        if (void 0 === value) throw new Error('MainThreadRef is not initialized: ' + id);
+        return value;
+    };
+    function removeValueFromWorkletRefMap(id) {
+        delete impl._workletRefMap[id];
+    }
+    function updateWorkletRef(handle, element) {
+        getFromWorkletRefMap(handle).current = element ? new Element(element) : null;
+    }
+    function updateWorkletRefInitValueChanges(patch) {
+        profile('updateWorkletRefInitValueChanges', ()=>{
+            patch.forEach(([id, value])=>{
+                if (!impl._workletRefMap[id]) impl._workletRefMap[id] = createWorkletRef(id, value);
+            });
+        });
+    }
+    function clearFirstScreenWorkletRefMap() {
+        impl._firstScreenWorkletRefMap = {};
+    }
+    function initEventListeners() {
+        const jsContext = lynx.getJSContext();
+        jsContext.addEventListener("Lynx.Worklet.runWorkletCtx", (event)=>{
+            const data = JSON.parse(event.data);
+            runRunOnMainThreadTask(data.worklet, data.params, data.resolveId);
+        });
+        jsContext.addEventListener("Lynx.Worklet.releaseWorkletRef", (event)=>{
+            removeValueFromWorkletRefMap(event.data.id);
+        });
+    }
+    let delayRunOnBackground_impl;
+    function initRunOnBackgroundDelay() {
+        return delayRunOnBackground_impl = {
+            delayedBackgroundFunctionArray: [],
+            delayRunOnBackground,
+            runDelayedBackgroundFunctions
+        };
+    }
+    function delayRunOnBackground(fnObj, task) {
+        var _fnObj, __delayIndices;
+        delayRunOnBackground_impl.delayedBackgroundFunctionArray.push({
+            task
+        });
+        const delayIndices = null != (__delayIndices = (_fnObj = fnObj)._delayIndices) ? __delayIndices : _fnObj._delayIndices = [];
+        delayIndices.push(delayRunOnBackground_impl.delayedBackgroundFunctionArray.length - 1);
+    }
+    function runDelayedBackgroundFunctions() {
+        for (const details of delayRunOnBackground_impl.delayedBackgroundFunctionArray)if (details.jsFnHandle) details.task(details.jsFnHandle._jsFnId, details.jsFnHandle._execId);
+        delayRunOnBackground_impl.delayedBackgroundFunctionArray.length = 0;
+    }
+    let delayWorkletEvent_impl;
+    function initEventDelay() {
+        return delayWorkletEvent_impl = {
+            _delayedWorkletParamsMap: new Map(),
+            runDelayedWorklet,
+            clearDelayedWorklets
+        };
+    }
+    function delayExecUntilJsReady(hash, params) {
+        profile('delayExecUntilJsReady: ' + hash, ()=>{
+            const map = delayWorkletEvent_impl._delayedWorkletParamsMap;
+            const paramVec = map.get(hash);
+            if (paramVec) paramVec.push(params);
+            else map.set(hash, [
+                params
+            ]);
+        });
+    }
+    function runDelayedWorklet(worklet, element) {
+        profile('commitDelayedWorklet', ()=>{
+            const paramsVec = delayWorkletEvent_impl._delayedWorkletParamsMap.get(worklet._wkltId);
+            if (void 0 === paramsVec) return;
+            const leftParamsVec = [];
+            paramsVec.forEach((params)=>{
+                var _firstParam_currentTarget;
+                const firstParam = params[0];
+                if ((null == firstParam ? void 0 : null == (_firstParam_currentTarget = firstParam.currentTarget) ? void 0 : _firstParam_currentTarget.elementRefptr) === element) setTimeout(()=>{
+                    profile('runDelayedWorklet', ()=>{
+                        runWorklet(worklet, params);
+                    });
+                }, 0);
+                else leftParamsVec.push(params);
+            });
+            delayWorkletEvent_impl._delayedWorkletParamsMap.set(worklet._wkltId, leftParamsVec);
+        });
+    }
+    function clearDelayedWorklets() {
+        delayWorkletEvent_impl._delayedWorkletParamsMap.clear();
+    }
+    function initEomImpl() {
+        return {
+            setShouldFlush: setShouldFlush
+        };
+    }
+    const EventResult = {
+        kDefault: 0x0,
+        kStopPropagationMask: 0x1,
+        kStopImmediatePropagationMask: 0x2
+    };
+    function isEventObject(ctx, options) {
+        if (!Array.isArray(ctx) || 'object' != typeof ctx[0] || null === ctx[0]) return false;
+        if (options && 1 === options.source) return true;
+        return false;
+    }
+    function addEventMethodsIfNeeded(ctx, options) {
+        if (!isEventObject(ctx, options)) return [
+            false,
+            {}
+        ];
+        const eventCtx = {};
+        const eventObj = ctx[0];
+        eventObj['stopPropagation'] = function() {
+            var _eventCtx__eventReturnResult;
+            eventCtx._eventReturnResult = (null != (_eventCtx__eventReturnResult = eventCtx._eventReturnResult) ? _eventCtx__eventReturnResult : EventResult.kDefault) | EventResult.kStopPropagationMask;
+        };
+        eventObj['stopImmediatePropagation'] = function() {
+            var _eventCtx__eventReturnResult;
+            eventCtx._eventReturnResult = (null != (_eventCtx__eventReturnResult = eventCtx._eventReturnResult) ? _eventCtx__eventReturnResult : EventResult.kDefault) | EventResult.kStopImmediatePropagationMask;
+        };
+        return [
+            true,
+            eventCtx
+        ];
+    }
+    function hydrateCtx(ctx, firstScreenCtx) {
+        profile('hydrateCtx', ()=>{
+            hydrateCtxImpl(ctx, firstScreenCtx, ctx._execId);
+        });
+    }
+    function hydrateCtxImpl(ctx, firstScreenCtx, execId) {
+        if (!ctx || 'object' != typeof ctx || !firstScreenCtx || 'object' != typeof firstScreenCtx) return;
+        const ctxObj = ctx;
+        const firstScreenCtxObj = firstScreenCtx;
+        if (ctxObj['_wkltId'] && ctxObj['_wkltId'] !== firstScreenCtxObj['_wkltId']) return;
+        for(const key in ctx)if ('_wvid' === key) hydrateMainThreadRef(ctxObj[key], firstScreenCtxObj);
+        else if ('_jsFn' === key) hydrateDelayRunOnBackgroundTasks(ctxObj[key], firstScreenCtxObj[key], execId);
+        else {
+            const firstScreenValue = 'function' == typeof firstScreenCtxObj[key] ? firstScreenCtxObj[key].ctx : firstScreenCtxObj[key];
+            hydrateCtxImpl(ctxObj[key], firstScreenValue, execId);
+        }
+    }
+    function hydrateMainThreadRef(refId, value) {
+        if ('_initValue' in value) return;
+        lynxWorkletImpl._refImpl._workletRefMap[refId] = value;
+    }
+    function hydrateDelayRunOnBackgroundTasks(fnObjs, firstScreenFnObjs, execId) {
+        for(const fnName in fnObjs){
+            const fnObj = fnObjs[fnName];
+            const firstScreenFnObj = firstScreenFnObjs[fnName];
+            if (!(null == firstScreenFnObj ? void 0 : firstScreenFnObj._delayIndices)) {
+                if (firstScreenFnObj) {
+                    firstScreenFnObj._isFirstScreen = false;
+                    firstScreenFnObj._execId = execId;
+                    Object.assign(firstScreenFnObj, fnObj);
+                }
+                continue;
+            }
+            for (const index of firstScreenFnObj._delayIndices){
+                const details = lynxWorkletImpl._runOnBackgroundDelayImpl.delayedBackgroundFunctionArray[index];
+                fnObj._execId = execId;
+                details.jsFnHandle = fnObj;
+            }
+        }
+    }
+    function jsFunctionLifecycle_define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    class JsFunctionLifecycleManager {
+        addRef(execId, objToRef) {
+            var _this_execIdRefCount_get;
+            this.execIdRefCount.set(execId, (null != (_this_execIdRefCount_get = this.execIdRefCount.get(execId)) ? _this_execIdRefCount_get : 0) + 1);
+            this.registry.register(objToRef, execId);
+        }
+        removeRef(execId) {
+            const rc = this.execIdRefCount.get(execId);
+            if (rc > 1) return void this.execIdRefCount.set(execId, rc - 1);
+            this.execIdRefCount.delete(execId);
+            this.execIdSetToFire.add(execId);
+            if (!this.willFire) {
+                this.willFire = true;
+                Promise.resolve().then(()=>{
+                    this.fire();
+                });
+            }
+        }
+        fire() {
+            profile('JsFunctionLifecycleManager.fire', ()=>{
+                lynx.getJSContext().dispatchEvent({
+                    type: "Lynx.Worklet.releaseBackgroundWorkletCtx",
+                    data: Array.from(this.execIdSetToFire)
+                });
+                this.execIdSetToFire.clear();
+                this.willFire = false;
+            });
+        }
+        constructor(){
+            jsFunctionLifecycle_define_property(this, "execIdRefCount", new Map());
+            jsFunctionLifecycle_define_property(this, "execIdSetToFire", new Set());
+            jsFunctionLifecycle_define_property(this, "willFire", false);
+            jsFunctionLifecycle_define_property(this, "registry", void 0);
+            this.registry = new FinalizationRegistry(this.removeRef.bind(this));
+        }
+    }
+    function isRunOnBackgroundEnabled() {
+        return isSdkVersionGt(2, 15);
+    }
+    function initWorklet() {
+        globalThis.lynxWorkletImpl = {
+            _workletMap: {},
+            _refImpl: initWorkletRef(),
+            _runOnBackgroundDelayImpl: initRunOnBackgroundDelay(),
+            _hydrateCtx: hydrateCtx,
+            _eventDelayImpl: initEventDelay(),
+            _eomImpl: initEomImpl(),
+            _runRunOnMainThreadTask: runRunOnMainThreadTask
+        };
+        if (isRunOnBackgroundEnabled()) globalThis.lynxWorkletImpl._jsFunctionLifecycleManager = new JsFunctionLifecycleManager();
+        globalThis.registerWorklet = registerWorklet;
+        globalThis.registerWorkletInternal = registerWorklet;
+        globalThis.runWorklet = workletRuntime_runWorklet;
+    }
+    function registerWorklet(_type, id, worklet) {
+        lynxWorkletImpl._workletMap[id] = worklet;
+    }
+    function workletRuntime_runWorklet(ctx, params, options) {
+        if (!validateWorklet(ctx)) return void console.warn('MainThreadFunction: Invalid function object: ' + JSON.stringify(ctx));
+        if ((null == options ? void 0 : options.source) === 1 && Array.isArray(params)) {
+            const first = params[0];
+            const t = first.type;
+            if ('string' == typeof t) mainThreadFlushLoopMark(`event:${t}`);
+        }
+        mainThreadFlushLoopMark(`MainThreadFunction id=${String(ctx._wkltId)}`);
+        if ('_lepusWorkletHash' in ctx) return void delayExecUntilJsReady(ctx._lepusWorkletHash, params);
+        return runWorkletImpl(ctx, params, options);
+    }
+    function runWorkletImpl(ctx, params, options) {
+        const worklet = profile('transformWorkletCtx ' + ctx._wkltId, ()=>transformWorklet(ctx, true));
+        const params_ = profile('transformWorkletParams', ()=>transformWorklet(params || [], false));
+        const [hasEventMethods, eventCtx] = addEventMethodsIfNeeded(params_, options);
+        const result = profile('runWorklet', ()=>worklet(...params_));
+        if (hasEventMethods) return {
+            returnValue: result,
+            eventReturnResult: eventCtx._eventReturnResult
+        };
+        return result;
+    }
+    function validateWorklet(ctx) {
+        return 'object' == typeof ctx && null !== ctx && ('_wkltId' in ctx || '_lepusWorkletHash' in ctx);
+    }
+    const workletCache = new WeakMap();
+    function transformWorklet(ctx, isWorklet) {
+        if ('object' != typeof ctx || null === ctx) return ctx;
+        if (isWorklet) {
+            const res = workletCache.get(ctx);
+            if (res) return res;
+        }
+        const worklet = {
+            main: ctx
+        };
+        transformWorkletInner(worklet, 0, ctx);
+        if (isWorklet) workletCache.set(ctx, worklet.main);
+        return worklet.main;
+    }
+    const transformWorkletInner = (value, depth, ctx)=>{
+        const limit = 1000;
+        if (++depth >= limit) throw new Error('Depth of value exceeds limit of ' + limit + '.');
+        if ('object' != typeof value || null === value) return;
+        const obj = value;
+        for(const key in obj){
+            const subObj = obj[key];
+            if ('object' != typeof subObj || null === subObj) continue;
+            if ('elementRefptr' in subObj) {
+                obj[key] = new Element(subObj['elementRefptr']);
+                continue;
+            }
+            if (subObj instanceof Element) continue;
+            transformWorkletInner(subObj, depth, ctx);
+            const isWorkletRef = '_wvid' in subObj;
+            if (isWorkletRef) {
+                obj[key] = getFromWorkletRefMap(subObj);
+                continue;
+            }
+            const isWorklet = '_wkltId' in subObj;
+            if (isWorklet) {
+                obj[key] = lynxWorkletImpl._workletMap[subObj._wkltId].bind({
+                    ...subObj
+                });
+                obj[key].ctx = subObj;
+                continue;
+            }
+            const isJsFn = '_jsFnId' in subObj;
+            if (isJsFn) {
+                var _lynxWorkletImpl__jsFunctionLifecycleManager;
+                subObj['_execId'] = ctx._execId;
+                null == (_lynxWorkletImpl__jsFunctionLifecycleManager = lynxWorkletImpl._jsFunctionLifecycleManager) || _lynxWorkletImpl__jsFunctionLifecycleManager.addRef(ctx._execId, subObj);
+                continue;
+            }
+        }
+    };
+    if (void 0 === globalThis.lynxWorkletImpl) {
+        initWorklet();
+        initApiEnv();
+        initEventListeners();
+    }
+})();
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"dev.js","sources":["webpack://@lynx-js/react/./runtime/src/worklet-runtime/api/animation/animation.ts?c644","webpack://@lynx-js/react/./runtime/src/worklet-runtime/api/animation/effect.ts?cd48","webpack://@lynx-js/react/./runtime/src/worklet-runtime/utils/mainThreadFlushLoopGuard.ts?387f","webpack://@lynx-js/react/./runtime/src/worklet-runtime/utils/version.ts?6111","webpack://@lynx-js/react/./runtime/src/worklet-runtime/api/element.ts?8b32","webpack://@lynx-js/react/./runtime/src/worklet-runtime/api/lepusQuerySelector.ts?c9a4","webpack://@lynx-js/react/./runtime/src/worklet-runtime/api/lynxApi.ts?e059","webpack://@lynx-js/react/./runtime/src/worklet-runtime/runOnMainThread.ts?7374","webpack://@lynx-js/react/./runtime/src/worklet-runtime/utils/profile.ts?9ecb","webpack://@lynx-js/react/./runtime/src/worklet-runtime/workletRef.ts?7b9b","webpack://@lynx-js/react/./runtime/src/worklet-runtime/listeners.ts?77d4","webpack://@lynx-js/react/./runtime/src/worklet-runtime/delayRunOnBackground.ts?7bfb","webpack://@lynx-js/react/./runtime/src/worklet-runtime/delayWorkletEvent.ts?dc08","webpack://@lynx-js/react/./runtime/src/worklet-runtime/eomImpl.ts?a039","webpack://@lynx-js/react/./runtime/src/worklet-runtime/eventPropagation.ts?f55f","webpack://@lynx-js/react/./runtime/src/worklet-runtime/hydrate.ts?855b","webpack://@lynx-js/react/./runtime/src/worklet-runtime/jsFunctionLifecycle.ts?1dc8","webpack://@lynx-js/react/./runtime/src/worklet-runtime/workletRuntime.ts?cb01","[relative-resource-path]"],"sourcesContent":["// Copyright 2025 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport type { KeyframeEffect } from './effect.js';\n\nexport enum AnimationOperation {\n  START = 0, // Start a new animation\n  PLAY = 1, // Play/resume a paused animation\n  PAUSE = 2, // Pause an existing animation\n  CANCEL = 3, // Cancel an animation\n}\n\nexport class Animation {\n  static count = 0;\n  public readonly effect: KeyframeEffect;\n  public readonly id: string;\n\n  constructor(effect: KeyframeEffect) {\n    this.effect = effect;\n    this.id = '__lynx-inner-js-animation-' + Animation.count++;\n    this.start();\n  }\n\n  public cancel(): void {\n    // @ts-expect-error accessing private member 'element'\n    return __ElementAnimate(this.effect.target.element, [AnimationOperation.CANCEL, this.id]);\n  }\n\n  public pause(): void {\n    // @ts-expect-error accessing private member 'element'\n    return __ElementAnimate(this.effect.target.element, [AnimationOperation.PAUSE, this.id]);\n  }\n\n  public play(): void {\n    // @ts-expect-error accessing private member 'element'\n    return __ElementAnimate(this.effect.target.element, [AnimationOperation.PLAY, this.id]);\n  }\n\n  private start(): void {\n    // @ts-expect-error accessing private member 'element'\n    return __ElementAnimate(this.effect.target.element, [\n      AnimationOperation.START,\n      this.id,\n      this.effect.keyframes,\n      this.effect.options,\n    ]);\n  }\n}\n","// Copyright 2025 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport type { Element } from '../element.js';\n\nexport class KeyframeEffect {\n  public readonly target: Element;\n  public readonly keyframes: Record<string, number | string>[];\n  public readonly options: Record<string, number | string>;\n\n  constructor(\n    target: Element,\n    keyframes: Record<string, number | string>[],\n    options: Record<string, number | string>,\n  ) {\n    this.target = target;\n    this.keyframes = keyframes;\n    this.options = options;\n  }\n}\n","// Copyright 2026 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\n\nconst TRACE_LIMIT = 256;\nconst DEFAULT_FLUSH_LIMIT = 256;\n\nlet trace: string[] = [];\n\nlet flushCountInWindow = 0;\nlet resetScheduled = false;\nlet trippedError: Error | null = null;\n\nfunction pushTrace(marker: string): void {\n  trace.push(marker);\n  if (trace.length > TRACE_LIMIT) {\n    trace = trace.slice(trace.length - TRACE_LIMIT);\n  }\n}\n\nfunction compressTrace(markers: string[]): string {\n  if (markers.length === 0) return '';\n  const out: string[] = [];\n  // Display most-recent-first to make loops easier to read.\n  let prev = markers[markers.length - 1]!;\n  let count = 1;\n\n  for (let i = markers.length - 2; i >= 0; i--) {\n    const cur = markers[i]!;\n    if (cur === prev) {\n      count++;\n      continue;\n    }\n    out.push(count === 1 ? prev : `${prev} x${count}`);\n    prev = cur;\n    count = 1;\n  }\n  out.push(count === 1 ? prev : `${prev} x${count}`);\n  return out.join(' <- ');\n}\n\nexport function mainThreadFlushLoopMark(marker: string): void {\n  if (__DEV__) {\n    pushTrace(marker);\n  }\n}\n\nexport function mainThreadFlushLoopOnFlushMicrotask(): Error | null {\n  /* v8 ignore next 1 */\n  if (!__DEV__) return null;\n  if (trippedError) return trippedError;\n\n  if (!resetScheduled) {\n    resetScheduled = true;\n    setTimeout(() => {\n      mainThreadFlushLoopReset();\n    }, 0);\n  }\n\n  flushCountInWindow++;\n  const limit = DEFAULT_FLUSH_LIMIT;\n  if (flushCountInWindow > limit) {\n    const traceText = compressTrace(trace);\n    trippedError = new Error(\n      `[ReactLynx][DEV] MainThread flush loop detected: render executed ${flushCountInWindow} times without yielding (limit=${limit}). Trace: ${traceText}`,\n    );\n    return trippedError;\n  }\n\n  return null;\n}\n\nexport function mainThreadFlushLoopReport(error: Error): void {\n  if (__DEV__) {\n    // Throw on macrotask to avoid Promise-unhandled-rejection noise.\n    setTimeout(() => {\n      throw error;\n    }, 0);\n  }\n}\n\nexport function mainThreadFlushLoopReset(): void {\n  trace = [];\n  flushCountInWindow = 0;\n  resetScheduled = false;\n  trippedError = null;\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nexport function isSdkVersionGt(major: number, minor: number): boolean {\n  const lynxSdkVersion: string = SystemInfo.lynxSdkVersion ?? '1.0';\n  const version = lynxSdkVersion.split('.');\n  return (\n    Number(version[0]) > major\n    || (Number(version[0]) == major && Number(version[1]) > minor)\n  );\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { Animation } from './animation/animation.js';\nimport { KeyframeEffect } from './animation/effect.js';\nimport {\n  mainThreadFlushLoopMark,\n  mainThreadFlushLoopOnFlushMicrotask,\n  mainThreadFlushLoopReport,\n} from '../utils/mainThreadFlushLoopGuard.js';\nimport { isSdkVersionGt } from '../utils/version.js';\n\nlet willFlush = false;\nlet shouldFlush = true;\n\nexport function setShouldFlush(value: boolean): void {\n  shouldFlush = value;\n}\n\nexport class Element {\n  // @ts-expect-error set in constructor\n  private readonly element: ElementNode;\n\n  constructor(element: ElementNode) {\n    // In Lynx versions prior to and including 2.15,\n    // a crash occurs when printing or transferring refCounted across threads.\n    // Bypass this problem by hiding the element object.\n    Object.defineProperty(this, 'element', {\n      get() {\n        return element;\n      },\n    });\n  }\n\n  public setAttribute(name: string, value: unknown): void {\n    /* v8 ignore next 3 */\n    if (__DEV__) {\n      mainThreadFlushLoopMark(`element:setAttribute ${name}`);\n    }\n    __SetAttribute(this.element, name, value);\n    this.flushElementTree();\n  }\n\n  public setStyleProperty(name: string, value: string): void {\n    /* v8 ignore next 3 */\n    if (__DEV__) {\n      mainThreadFlushLoopMark(`element:setStyleProperty ${name}`);\n    }\n    __AddInlineStyle(this.element, name, value);\n    this.flushElementTree();\n  }\n\n  public setStyleProperties(styles: Record<string, string>): void {\n    /* v8 ignore next 5 */\n    if (__DEV__) {\n      mainThreadFlushLoopMark(\n        `element:setStyleProperties keys=${Object.keys(styles).length}`,\n      );\n    }\n    for (const key in styles) {\n      __AddInlineStyle(this.element, key, styles[key]!);\n    }\n    this.flushElementTree();\n  }\n\n  public getAttribute(attributeName: string): unknown {\n    return __GetAttributeByName(this.element, attributeName);\n  }\n\n  public getAttributeNames(): string[] {\n    return __GetAttributeNames(this.element);\n  }\n\n  public querySelector(selector: string): Element | null {\n    const ref = __QuerySelector(this.element, selector, {});\n    return ref ? new Element(ref) : null;\n  }\n\n  public querySelectorAll(selector: string): Element[] {\n    return __QuerySelectorAll(this.element, selector, {}).map((element) => {\n      return new Element(element);\n    });\n  }\n\n  public getComputedStyleProperty(key: string): string {\n    if (!isSdkVersionGt(3, 4)) {\n      throw new Error(\n        'getComputedStyleProperty requires Lynx sdk version 3.5',\n      );\n    }\n\n    if (!key) {\n      throw new Error('getComputedStyleProperty: key is required');\n    }\n    return __GetComputedStyleByKey(this.element, key);\n  }\n\n  public animate(\n    keyframes: Record<string, number | string>[],\n    options?: number | Record<string, number | string>,\n  ): Animation {\n    const normalizedOptions = typeof options === 'number' ? { duration: options } : options ?? {};\n    return new Animation(new KeyframeEffect(this, keyframes, normalizedOptions));\n  }\n\n  public invoke(\n    methodName: string,\n    params?: Record<string, unknown>,\n  ): Promise<unknown> {\n    /* v8 ignore next 3 */\n    if (__DEV__) {\n      mainThreadFlushLoopMark(`element:invoke ${methodName}`);\n    }\n    return new Promise((resolve, reject) => {\n      __InvokeUIMethod(\n        this.element,\n        methodName,\n        params ?? {},\n        (res: { code: number; data: unknown }) => {\n          if (res.code === 0) {\n            resolve(res.data);\n          } else {\n            reject(new Error('UI method invoke: ' + JSON.stringify(res)));\n          }\n        },\n      );\n      this.flushElementTree();\n    });\n  }\n\n  private flushElementTree() {\n    if (willFlush || !shouldFlush) {\n      return;\n    }\n    willFlush = true;\n    void Promise.resolve().then(() => {\n      willFlush = false;\n      if (__DEV__) {\n        mainThreadFlushLoopMark('render');\n        const error = mainThreadFlushLoopOnFlushMicrotask();\n        if (error) {\n          // Stop scheduling further flushes so we can surface the error.\n          // This is DEV-only behavior guarded internally by the dev guard.\n          shouldFlush = false;\n          mainThreadFlushLoopReport(error);\n          return;\n        }\n      }\n      __FlushElementTree();\n    });\n  }\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { Element } from './element.js';\n\nclass PageElement {\n  private static pageElement: ElementNode | undefined;\n\n  static get() {\n    PageElement.pageElement ??= __GetPageElement();\n    return PageElement.pageElement;\n  }\n}\n\nexport function querySelector(cssSelector: string): Element | null {\n  const pageElement = PageElement.get();\n  if (!pageElement) {\n    return null;\n  }\n  const element = __QuerySelector(pageElement, cssSelector, {});\n  return element ? new Element(element) : null;\n}\n\nexport function querySelectorAll(cssSelector: string): Element[] {\n  const pageElement = PageElement.get();\n  if (!pageElement) {\n    return [];\n  }\n  return __QuerySelectorAll(pageElement, cssSelector, {}).map(\n    (element) => {\n      return new Element(element);\n    },\n  );\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { querySelector, querySelectorAll } from './lepusQuerySelector.js';\nimport { isSdkVersionGt } from '../utils/version.js';\n\nfunction initApiEnv(): void {\n  // @ts-expect-error type\n  lynx.querySelector = querySelector;\n  // @ts-expect-error type\n  lynx.querySelectorAll = querySelectorAll;\n  // @ts-expect-error type\n  globalThis.setTimeout = lynx.setTimeout as (cb: () => void, timeout: number) => number;\n  // @ts-expect-error type\n  globalThis.setInterval = lynx.setInterval as (cb: () => void, timeout: number) => number;\n  // @ts-expect-error type\n  globalThis.clearTimeout = lynx.clearTimeout as (timeout: number) => void;\n  // In lynx 2.14 `clearInterval` is mistakenly spelled as `clearTimeInterval`. This is fixed in lynx 2.15.\n  // @ts-expect-error type\n  globalThis.clearInterval = (lynx.clearInterval ?? lynx.clearTimeInterval) as (timeout: number) => void;\n\n  {\n    // @ts-expect-error type\n    const requestAnimationFrame = lynx.requestAnimationFrame as (callback: () => void) => number;\n    // @ts-expect-error type\n    lynx.requestAnimationFrame = globalThis.requestAnimationFrame = (\n      callback: () => void,\n    ) => {\n      if (!isSdkVersionGt(2, 15)) {\n        throw new Error(\n          'requestAnimationFrame in main thread script requires Lynx sdk version 2.16',\n        );\n      }\n      return requestAnimationFrame(callback);\n    };\n  }\n\n  // @ts-expect-error type\n  globalThis.cancelAnimationFrame = lynx.cancelAnimationFrame as (requestId: number) => void;\n}\n\nexport { initApiEnv };\n","// Copyright 2025 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { WorkletEvents } from './bindings/index.js';\nimport type { ClosureValueType, RunWorkletCtxRetData, Worklet } from './bindings/index.js';\n\nexport function runRunOnMainThreadTask(task: Worklet, params: ClosureValueType[], resolveId: number): void {\n  let returnValue;\n  try {\n    returnValue = runWorklet(task, params);\n  } finally {\n    // TODO: Should be more proper to reject the promise if there is an error.\n    lynx.getJSContext().dispatchEvent({\n      type: WorkletEvents.FunctionCallRet,\n      data: JSON.stringify({\n        resolveId,\n        returnValue,\n      } as RunWorkletCtxRetData),\n    });\n  }\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nexport function profile<Ret, Fn extends (...args: unknown[]) => Ret>(\n  sliceName: string,\n  f: Fn,\n): Ret {\n  /* v8 ignore next 9 */\n  // TODO: change it to __PROFILE__\n  if (__DEV__) {\n    console.profile?.(sliceName);\n    try {\n      return f();\n    } finally {\n      console.profileEnd?.();\n    }\n  } else {\n    return f();\n  }\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { Element } from './api/element.js';\nimport type { WorkletRef, WorkletRefId, WorkletRefImpl } from './bindings/types.js';\nimport { mainThreadFlushLoopMark } from './utils/mainThreadFlushLoopGuard.js';\nimport { profile } from './utils/profile.js';\n\ninterface RefImpl {\n  _workletRefMap: Record<WorkletRefId, WorkletRef<unknown>>;\n  _firstScreenWorkletRefMap: Record<WorkletRefId, WorkletRef<unknown>>;\n  updateWorkletRef(\n    refImpl: WorkletRefImpl<Element | null>,\n    element: ElementNode | null,\n  ): void;\n  updateWorkletRefInitValueChanges(patch: [number, unknown][]): void;\n  clearFirstScreenWorkletRefMap(): void;\n}\n\nlet impl: RefImpl | undefined;\n\nfunction initWorkletRef(): RefImpl {\n  return (impl = {\n    _workletRefMap: {},\n    /**\n     * Map of worklet refs that are created during first screen rendering.\n     * These refs are created with negative IDs and need to be hydrated\n     * when the app starts. The map is cleared after hydration is complete\n     * to free up memory.\n     */\n    _firstScreenWorkletRefMap: {},\n    updateWorkletRef,\n    updateWorkletRefInitValueChanges,\n    clearFirstScreenWorkletRefMap,\n  });\n}\n\nconst createWorkletRef = <T>(\n  id: WorkletRefId,\n  value: T,\n): WorkletRef<T> => {\n  return {\n    current: value,\n    _wvid: id,\n  };\n};\n\nconst getFromWorkletRefMap = <T>(\n  refImpl: WorkletRefImpl<T>,\n): WorkletRef<T> => {\n  const id = refImpl._wvid;\n  /* v8 ignore next 3 */\n  if (__DEV__) {\n    mainThreadFlushLoopMark(`MainThreadRef:get id=${id}`);\n  }\n  let value;\n  if (id < 0) {\n    // At the first screen rendering, the worklet ref is created with a negative ID.\n    // Might be called in two scenarios:\n    // 1. In MTS events\n    // 2. In `main-thread:ref`\n    value = impl!._firstScreenWorkletRefMap[id] as WorkletRef<T>;\n    if (!value) {\n      value = impl!._firstScreenWorkletRefMap[id] = createWorkletRef(id, refImpl._initValue);\n    }\n  } else {\n    value = impl!._workletRefMap[id] as WorkletRef<T>;\n  }\n\n  /* v8 ignore next 3 */\n  if (__DEV__ && value === undefined) {\n    throw new Error('MainThreadRef is not initialized: ' + id);\n  }\n  return value;\n};\n\nfunction removeValueFromWorkletRefMap(id: WorkletRefId): void {\n  delete impl!._workletRefMap[id];\n}\n\n/**\n * Create an element instance of the given element node, then set the worklet value to it.\n * This is called in `snapshotContextUpdateWorkletRef`.\n * @param handle handle of the worklet value.\n * @param element the element node.\n */\nfunction updateWorkletRef(\n  handle: WorkletRefImpl<Element | null>,\n  element: ElementNode | null,\n): void {\n  getFromWorkletRefMap(handle).current = element\n    ? new Element(element)\n    : null;\n}\n\nfunction updateWorkletRefInitValueChanges(\n  patch: [WorkletRefId, unknown][],\n): void {\n  profile('updateWorkletRefInitValueChanges', () => {\n    patch.forEach(([id, value]) => {\n      if (!impl!._workletRefMap[id]) {\n        impl!._workletRefMap[id] = createWorkletRef(id, value);\n      }\n    });\n  });\n}\n\nfunction clearFirstScreenWorkletRefMap(): void {\n  impl!._firstScreenWorkletRefMap = {};\n}\n\nexport {\n  type RefImpl,\n  createWorkletRef,\n  initWorkletRef,\n  getFromWorkletRefMap,\n  removeValueFromWorkletRefMap,\n  updateWorkletRefInitValueChanges,\n};\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { WorkletEvents } from './bindings/events.js';\nimport type { ReleaseWorkletRefData, RunWorkletCtxData } from './bindings/events.js';\nimport type { ClosureValueType } from './bindings/types.js';\nimport { runRunOnMainThreadTask } from './runOnMainThread.js';\nimport type { Event } from './types/runtimeProxy.js';\nimport { removeValueFromWorkletRefMap } from './workletRef.js';\n\nfunction initEventListeners(): void {\n  const jsContext = lynx.getJSContext();\n  jsContext.addEventListener(\n    WorkletEvents.runWorkletCtx,\n    (event: Event) => {\n      const data = JSON.parse(event.data as string) as RunWorkletCtxData;\n      runRunOnMainThreadTask(data.worklet, data.params as ClosureValueType[], data.resolveId);\n    },\n  );\n  jsContext.addEventListener(\n    WorkletEvents.releaseWorkletRef,\n    (event: Event) => {\n      removeValueFromWorkletRefMap((event.data as ReleaseWorkletRefData).id);\n    },\n  );\n}\n\nexport { initEventListeners };\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport type { JsFnHandle } from './bindings/types.js';\n\ninterface Details {\n  task: (fnId: number, execId: number) => void;\n\n  // This comes from the background thread, inserted here during ctx hydration.\n  jsFnHandle?: JsFnHandle;\n}\n\ninterface RunOnBackgroundDelayImpl {\n  // Elements should keep the order being called by the user.\n  delayedBackgroundFunctionArray: Details[];\n  delayRunOnBackground(fnObj: JsFnHandle, fn: (fnId: number, execId: number) => void): void;\n  runDelayedBackgroundFunctions(): void;\n}\n\nlet impl: RunOnBackgroundDelayImpl | undefined;\n\nfunction initRunOnBackgroundDelay(): RunOnBackgroundDelayImpl {\n  return (impl = {\n    delayedBackgroundFunctionArray: [],\n    delayRunOnBackground,\n    runDelayedBackgroundFunctions,\n  });\n}\n\nfunction delayRunOnBackground(fnObj: JsFnHandle, task: (fnId: number, execId: number) => void) {\n  impl!.delayedBackgroundFunctionArray.push({ task });\n  const delayIndices = fnObj._delayIndices ??= [];\n  delayIndices.push(impl!.delayedBackgroundFunctionArray.length - 1);\n}\n\nfunction runDelayedBackgroundFunctions(): void {\n  for (const details of impl!.delayedBackgroundFunctionArray) {\n    if (details.jsFnHandle) {\n      details.task(details.jsFnHandle._jsFnId!, details.jsFnHandle._execId!);\n    }\n  }\n  impl!.delayedBackgroundFunctionArray.length = 0;\n}\n\nexport { type RunOnBackgroundDelayImpl, initRunOnBackgroundDelay };\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport type { ClosureValueType, Worklet } from './bindings/types.js';\nimport { profile } from './utils/profile.js';\n\ninterface EventDelayImpl {\n  _delayedWorkletParamsMap: Map<string, ClosureValueType[][]>;\n  runDelayedWorklet(worklet: Worklet, element: ElementNode): void;\n  clearDelayedWorklets(): void;\n}\n\nlet impl: EventDelayImpl | undefined;\n\nfunction initEventDelay(): EventDelayImpl {\n  return (impl = {\n    _delayedWorkletParamsMap: new Map(),\n    runDelayedWorklet,\n    clearDelayedWorklets,\n  });\n}\n\nfunction delayExecUntilJsReady(\n  hash: string,\n  params: ClosureValueType[],\n): void {\n  profile('delayExecUntilJsReady: ' + hash, () => {\n    const map = impl!._delayedWorkletParamsMap;\n    const paramVec = map.get(hash);\n    if (paramVec) {\n      paramVec.push(params);\n    } else {\n      map.set(hash, [params]);\n    }\n  });\n}\n\nfunction runDelayedWorklet(worklet: Worklet, element: ElementNode): void {\n  profile('commitDelayedWorklet', () => {\n    const paramsVec = impl!._delayedWorkletParamsMap.get(\n      worklet._wkltId,\n    );\n    if (paramsVec === undefined) {\n      return;\n    }\n    const leftParamsVec: ClosureValueType[][] = [];\n    paramsVec.forEach((params) => {\n      const firstParam = params[0] as { currentTarget?: { elementRefptr?: ElementNode } } | undefined;\n      if (firstParam?.currentTarget?.elementRefptr === element) {\n        setTimeout(() => {\n          profile('runDelayedWorklet', () => {\n            runWorklet(worklet, params);\n          });\n        }, 0);\n      } else {\n        leftParamsVec.push(params);\n      }\n    });\n    impl!._delayedWorkletParamsMap.set(\n      worklet._wkltId,\n      leftParamsVec,\n    );\n  });\n}\n\nfunction clearDelayedWorklets(): void {\n  impl!._delayedWorkletParamsMap.clear();\n}\n\nexport { type EventDelayImpl, initEventDelay, delayExecUntilJsReady, runDelayedWorklet, clearDelayedWorklets };\n","// Copyright 2025 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { setShouldFlush } from './api/element.js';\n\nexport interface EomImpl {\n  setShouldFlush(value: boolean): void;\n}\n\nexport function initEomImpl(): EomImpl {\n  return {\n    setShouldFlush,\n  };\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\n\nimport type { ClosureValueType, EventCtx, RunWorkletOptions } from './bindings/types.js';\nimport { RunWorkletSource } from './bindings/types.js';\n\n// EventResult enum values\nexport const EventResult = {\n  kDefault: 0x0,\n  kStopPropagationMask: 0x1,\n  kStopImmediatePropagationMask: 0x2,\n} as const;\n\ntype EventLike = Record<string, ClosureValueType>;\n\nexport function isEventObject(\n  ctx: ClosureValueType[],\n  options?: RunWorkletOptions,\n): ctx is [EventLike, ...ClosureValueType[]] {\n  if (!Array.isArray(ctx) || typeof ctx[0] !== 'object' || ctx[0] === null) {\n    return false;\n  }\n  if (options && options.source === RunWorkletSource.EVENT) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Add event methods to an event object if needed\n * @param ctx The event object to enhance\n * @param options The run worklet options\n * @returns A tuple of boolean and the event return result\n */\nexport function addEventMethodsIfNeeded(ctx: ClosureValueType[], options?: RunWorkletOptions): [boolean, EventCtx] {\n  if (!isEventObject(ctx, options)) {\n    return [false, {}];\n  }\n  const eventCtx: EventCtx = {};\n  const eventObj = ctx[0];\n\n  // Add stopPropagation method\n  eventObj['stopPropagation'] = function() {\n    eventCtx._eventReturnResult = (eventCtx._eventReturnResult ?? EventResult.kDefault)\n      | EventResult.kStopPropagationMask;\n  };\n\n  // Add stopImmediatePropagation method\n  eventObj['stopImmediatePropagation'] = function() {\n    eventCtx._eventReturnResult = (eventCtx._eventReturnResult ?? EventResult.kDefault)\n      | EventResult.kStopImmediatePropagationMask;\n  };\n\n  return [true, eventCtx];\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\n\nimport type { ClosureValueType, JsFnHandle, Worklet, WorkletRefId, WorkletRefImpl } from './bindings/index.js';\nimport { profile } from './utils/profile.js';\n\n/**\n * Hydrates a Worklet context with data from a first-screen Worklet context.\n * This process is typically used to run all delayed `runOnBackground` functions\n * and initialize `WorkletRef` values modified before hydration.\n *\n * @param ctx The target Worklet context to be hydrated.\n * @param firstScreenCtx The Worklet context from the first screen rendering,\n *                       containing the data to hydrate with.\n */\nexport function hydrateCtx(ctx: Worklet, firstScreenCtx: Worklet): void {\n  profile('hydrateCtx', () => {\n    hydrateCtxImpl(ctx, firstScreenCtx, ctx._execId!);\n  });\n}\n\nfunction hydrateCtxImpl(\n  ctx: ClosureValueType,\n  firstScreenCtx: ClosureValueType,\n  execId: number,\n): void {\n  if (\n    !ctx || typeof ctx !== 'object' || !firstScreenCtx\n    || typeof firstScreenCtx !== 'object'\n  ) return;\n\n  const ctxObj = ctx as Record<string, ClosureValueType>;\n  const firstScreenCtxObj = firstScreenCtx as Record<string, ClosureValueType>;\n\n  if (ctxObj['_wkltId'] && ctxObj['_wkltId'] !== firstScreenCtxObj['_wkltId']) {\n    return;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-for-in-array\n  for (const key in ctx) {\n    if (key === '_wvid') {\n      hydrateMainThreadRef(\n        ctxObj[key] as WorkletRefId,\n        firstScreenCtxObj as unknown as WorkletRefImpl<unknown>,\n      );\n    } else if (key === '_jsFn') {\n      hydrateDelayRunOnBackgroundTasks(\n        ctxObj[key] as Record<string, JsFnHandle>,\n        firstScreenCtxObj[key] as Record<string, JsFnHandle>,\n        execId,\n      );\n    } else {\n      const firstScreenValue = typeof firstScreenCtxObj[key] === 'function'\n        ? (firstScreenCtxObj[key] as { ctx: ClosureValueType }).ctx\n        : firstScreenCtxObj[key];\n      hydrateCtxImpl(ctxObj[key], firstScreenValue, execId);\n    }\n  }\n}\n\n/**\n * Hydrates a WorkletRef on the main thread.\n * This is used to update the WorkletRef's background initial value based on changes\n * that occurred in the first-screen Worklet context before hydration.\n *\n * @param refId The ID of the WorkletRef to hydrate.\n * @param value The new value for the WorkletRef.\n */\nfunction hydrateMainThreadRef(\n  refId: WorkletRefId,\n  value: WorkletRefImpl<unknown>,\n) {\n  if ('_initValue' in value) {\n    // The ref has not been accessed yet.\n    return;\n  }\n  lynxWorkletImpl!._refImpl._workletRefMap[refId] = value;\n}\n\n/**\n * Hydrates delayed `runOnBackground` tasks.\n * This function ensures that any `runOnBackground` calls that were delayed\n * during the first-screen rendering are correctly associated with their\n * respective JavaScript function handles in the hydrated Worklet context.\n */\nfunction hydrateDelayRunOnBackgroundTasks(\n  fnObjs: Record<string, JsFnHandle>, // example: {\"_jsFn1\":{\"_jsFnId\":1}}\n  firstScreenFnObjs: Record<string, JsFnHandle>, // example: {\"_jsFn1\":{\"_isFirstScreen\":true,\"_delayIndices\":[0]}}\n  execId: number,\n) {\n  for (const fnName in fnObjs) {\n    const fnObj = fnObjs[fnName]!;\n    const firstScreenFnObj: JsFnHandle | undefined = firstScreenFnObjs[fnName];\n    if (!firstScreenFnObj?._delayIndices) {\n      if (firstScreenFnObj) {\n        firstScreenFnObj._isFirstScreen = false;\n        firstScreenFnObj._execId = execId;\n        Object.assign(firstScreenFnObj, fnObj);\n      }\n      continue;\n    }\n    for (const index of firstScreenFnObj._delayIndices) {\n      const details = lynxWorkletImpl!._runOnBackgroundDelayImpl\n        .delayedBackgroundFunctionArray[index]!;\n      fnObj._execId = execId;\n      details.jsFnHandle = fnObj;\n    }\n  }\n}\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { WorkletEvents } from './bindings/events.js';\nimport { profile } from './utils/profile.js';\nimport { isSdkVersionGt } from './utils/version.js';\n\n/**\n * `JsFunctionLifecycleManager` monitors references to JS function handles to be called by `runOnBackground()`.\n * In JS context, functions to be called by `runOnBackground()` is referenced by `JsFnHandle`s and finally by `execId`.\n * When all `JsFnHandle`s in lepus are released, an event will be sent to JS context to de-ref the `execId`,\n * resulting a de-ref to the js function in JS context.\n */\nclass JsFunctionLifecycleManager {\n  private execIdRefCount = new Map<number, number>();\n  private execIdSetToFire = new Set<number>();\n  private willFire = false;\n  private registry?: FinalizationRegistry<number> = undefined;\n\n  constructor() {\n    this.registry = new FinalizationRegistry<number>(this.removeRef.bind(this));\n  }\n\n  addRef(execId: number, objToRef: object): void {\n    this.execIdRefCount.set(\n      execId,\n      (this.execIdRefCount.get(execId) ?? 0) + 1,\n    );\n    this.registry!.register(objToRef, execId);\n  }\n\n  removeRef(execId: number): void {\n    const rc = this.execIdRefCount.get(execId)!;\n    if (rc > 1) {\n      this.execIdRefCount.set(execId, rc - 1);\n      return;\n    }\n    this.execIdRefCount.delete(execId);\n    this.execIdSetToFire.add(execId);\n    if (!this.willFire) {\n      this.willFire = true;\n      void Promise.resolve().then(() => {\n        this.fire();\n      });\n    }\n  }\n\n  fire(): void {\n    profile('JsFunctionLifecycleManager.fire', () => {\n      lynx.getJSContext().dispatchEvent({\n        type: WorkletEvents.releaseBackgroundWorkletCtx,\n        data: Array.from(this.execIdSetToFire),\n      });\n      this.execIdSetToFire.clear();\n      this.willFire = false;\n    });\n  }\n}\n\nfunction isRunOnBackgroundEnabled(): boolean {\n  return isSdkVersionGt(2, 15);\n}\n\nexport { JsFunctionLifecycleManager, isRunOnBackgroundEnabled };\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { Element } from './api/element.js';\nimport type { ClosureValueType, RunWorkletOptions, Worklet, WorkletRefImpl } from './bindings/types.js';\nimport { RunWorkletSource } from './bindings/types.js';\nimport { initRunOnBackgroundDelay } from './delayRunOnBackground.js';\nimport { delayExecUntilJsReady, initEventDelay } from './delayWorkletEvent.js';\nimport { initEomImpl } from './eomImpl.js';\nimport { addEventMethodsIfNeeded } from './eventPropagation.js';\nimport { hydrateCtx } from './hydrate.js';\nimport { JsFunctionLifecycleManager, isRunOnBackgroundEnabled } from './jsFunctionLifecycle.js';\nimport { runRunOnMainThreadTask } from './runOnMainThread.js';\nimport { mainThreadFlushLoopMark } from './utils/mainThreadFlushLoopGuard.js';\nimport { profile } from './utils/profile.js';\nimport { getFromWorkletRefMap, initWorkletRef } from './workletRef.js';\n\nfunction initWorklet(): void {\n  globalThis.lynxWorkletImpl = {\n    _workletMap: {},\n    _refImpl: initWorkletRef(),\n    _runOnBackgroundDelayImpl: initRunOnBackgroundDelay(),\n    _hydrateCtx: hydrateCtx,\n    _eventDelayImpl: initEventDelay(),\n    _eomImpl: initEomImpl(),\n    _runRunOnMainThreadTask: runRunOnMainThreadTask,\n  };\n\n  if (isRunOnBackgroundEnabled()) {\n    globalThis.lynxWorkletImpl._jsFunctionLifecycleManager = new JsFunctionLifecycleManager();\n  }\n\n  globalThis.registerWorklet = registerWorklet;\n  globalThis.registerWorkletInternal = registerWorklet;\n  globalThis.runWorklet = runWorklet;\n}\n\n/**\n * Register a worklet function, allowing it to be executed by `runWorklet()`.\n * This is called in lepus.js.\n * @param _type worklet type, 'main-thread' or 'ui'\n * @param id worklet hash\n * @param worklet worklet function\n */\nfunction registerWorklet(_type: string, id: string, worklet: (...args: unknown[]) => unknown): void {\n  lynxWorkletImpl._workletMap[id] = worklet;\n}\n\n/**\n * Entrance of all worklet calls.\n * Native event touch handler will call this function.\n * @param ctx worklet object.\n * @param params worklet params.\n * @param options run worklet options.\n */\nfunction runWorklet(ctx: Worklet, params: ClosureValueType[], options?: RunWorkletOptions): unknown {\n  if (!validateWorklet(ctx)) {\n    console.warn('MainThreadFunction: Invalid function object: ' + JSON.stringify(ctx));\n    return;\n  }\n\n  if (__DEV__) {\n    if (options?.source === RunWorkletSource.EVENT && Array.isArray(params)) {\n      const first = params[0];\n      const t = (first as { type?: unknown }).type;\n      if (typeof t === 'string') {\n        mainThreadFlushLoopMark(`event:${t}`);\n      }\n    }\n\n    mainThreadFlushLoopMark(`MainThreadFunction id=${String(ctx._wkltId)}`);\n  }\n\n  if ('_lepusWorkletHash' in ctx) {\n    delayExecUntilJsReady(ctx._lepusWorkletHash, params);\n    return;\n  }\n  return runWorkletImpl(ctx, params, options);\n}\n\nfunction runWorkletImpl(ctx: Worklet, params: ClosureValueType[], options?: RunWorkletOptions): unknown {\n  const worklet: (...args: unknown[]) => unknown = profile(\n    'transformWorkletCtx ' + ctx._wkltId,\n    () => transformWorklet(ctx, true),\n  );\n  const params_: ClosureValueType[] = profile(\n    'transformWorkletParams',\n    () => transformWorklet(params || [], false),\n  );\n\n  const [hasEventMethods, eventCtx] = addEventMethodsIfNeeded(params_, options);\n\n  const result = profile('runWorklet', () => worklet(...params_));\n\n  if (hasEventMethods) {\n    return {\n      returnValue: result,\n      eventReturnResult: eventCtx._eventReturnResult,\n    };\n  }\n\n  return result;\n}\n\nfunction validateWorklet(ctx: unknown): ctx is Worklet {\n  return typeof ctx === 'object' && ctx !== null && ('_wkltId' in ctx || '_lepusWorkletHash' in ctx);\n}\n\nconst workletCache = new WeakMap<object, ClosureValueType | ((...args: unknown[]) => unknown)>();\n\nfunction transformWorklet(ctx: Worklet, isWorklet: true): (...args: unknown[]) => unknown;\nfunction transformWorklet(\n  ctx: ClosureValueType[],\n  isWorklet: false,\n): ClosureValueType[];\n\nfunction transformWorklet(\n  ctx: ClosureValueType,\n  isWorklet: boolean,\n): ClosureValueType | ((...args: unknown[]) => unknown) {\n  /* v8 ignore next 3 */\n  if (typeof ctx !== 'object' || ctx === null) {\n    return ctx;\n  }\n\n  if (isWorklet) {\n    const res = workletCache.get(ctx);\n    if (res) {\n      return res;\n    }\n  }\n\n  const worklet = { main: ctx };\n  transformWorkletInner(worklet, 0, ctx);\n\n  if (isWorklet) {\n    workletCache.set(ctx, worklet.main);\n  }\n\n  return worklet.main;\n}\n\nconst transformWorkletInner = (\n  value: ClosureValueType,\n  depth: number,\n  ctx: unknown,\n) => {\n  const limit = 1000;\n  if (++depth >= limit) {\n    throw new Error('Depth of value exceeds limit of ' + limit + '.');\n  }\n  /* v8 ignore next 3 */\n  if (typeof value !== 'object' || value === null) {\n    return;\n  }\n  const obj = value as Record<string, ClosureValueType>;\n\n  for (const key in obj) {\n    const subObj: ClosureValueType = obj[key];\n    if (typeof subObj !== 'object' || subObj === null) {\n      continue;\n    }\n\n    if (/** isEventTarget */ 'elementRefptr' in subObj) {\n      obj[key] = new Element(subObj['elementRefptr'] as ElementNode);\n      continue;\n    } else if (subObj instanceof Element) {\n      continue;\n    }\n\n    transformWorkletInner(subObj, depth, ctx);\n\n    const isWorkletRef = '_wvid' in (subObj as object);\n    if (isWorkletRef) {\n      obj[key] = getFromWorkletRefMap(\n        subObj as unknown as WorkletRefImpl<unknown>,\n      );\n      continue;\n    }\n    const isWorklet = '_wkltId' in subObj;\n    if (isWorklet) {\n      // `subObj` is worklet ctx. Shallow copy it to prevent the transformed worklet from referencing ctx.\n      // This would result in the value of `workletCache` referencing its key.\n      obj[key] = lynxWorkletImpl._workletMap[(subObj as Worklet)._wkltId]!\n        .bind({ ...subObj });\n      obj[key].ctx = subObj;\n      continue;\n    }\n    const isJsFn = '_jsFnId' in subObj;\n    if (isJsFn) {\n      subObj['_execId'] = (ctx as Worklet)._execId;\n      lynxWorkletImpl._jsFunctionLifecycleManager?.addRef(\n        (ctx as Worklet)._execId!,\n        subObj,\n      );\n      continue;\n    }\n  }\n};\n\nexport { initWorklet };\n","// Copyright 2024 The Lynx Authors. All rights reserved.\n// Licensed under the Apache License Version 2.0 that can be found in the\n// LICENSE file in the root directory of this source tree.\nimport { initApiEnv } from './api/lynxApi.js';\nimport { initEventListeners } from './listeners.js';\nimport { initWorklet } from './workletRuntime.js';\n\nif (globalThis.lynxWorkletImpl === undefined) {\n  initWorklet();\n  initApiEnv();\n  initEventListeners();\n}\n"],"names":["Animation","__ElementAnimate","effect","KeyframeEffect","target","keyframes","options","TRACE_LIMIT","DEFAULT_FLUSH_LIMIT","trace","flushCountInWindow","resetScheduled","trippedError","pushTrace","marker","compressTrace","markers","out","prev","count","i","cur","mainThreadFlushLoopMark","mainThreadFlushLoopOnFlushMicrotask","setTimeout","mainThreadFlushLoopReset","limit","traceText","Error","mainThreadFlushLoopReport","error","isSdkVersionGt","major","minor","_SystemInfo_lynxSdkVersion","lynxSdkVersion","version","Number","willFlush","shouldFlush","setShouldFlush","value","Element","name","__SetAttribute","__AddInlineStyle","styles","Object","key","attributeName","__GetAttributeByName","__GetAttributeNames","selector","ref","__QuerySelector","__QuerySelectorAll","element","__GetComputedStyleByKey","normalizedOptions","methodName","params","Promise","resolve","reject","__InvokeUIMethod","res","JSON","__FlushElementTree","PageElement","_PageElement","__GetPageElement","querySelector","cssSelector","pageElement","querySelectorAll","initApiEnv","_lynx_clearInterval","lynx","globalThis","requestAnimationFrame","callback","runRunOnMainThreadTask","task","resolveId","returnValue","runWorklet","WorkletEvents","profile","sliceName","f","_console","_console1","impl","initWorkletRef","updateWorkletRef","updateWorkletRefInitValueChanges","clearFirstScreenWorkletRefMap","createWorkletRef","id","getFromWorkletRefMap","refImpl","undefined","removeValueFromWorkletRefMap","handle","patch","initEventListeners","jsContext","event","data","initRunOnBackgroundDelay","delayRunOnBackground","runDelayedBackgroundFunctions","fnObj","_fnObj","delayIndices","details","initEventDelay","Map","runDelayedWorklet","clearDelayedWorklets","delayExecUntilJsReady","hash","map","paramVec","worklet","paramsVec","leftParamsVec","_firstParam_currentTarget","firstParam","initEomImpl","EventResult","isEventObject","ctx","Array","RunWorkletSource","addEventMethodsIfNeeded","eventCtx","eventObj","_eventCtx__eventReturnResult","hydrateCtx","firstScreenCtx","hydrateCtxImpl","execId","ctxObj","firstScreenCtxObj","hydrateMainThreadRef","hydrateDelayRunOnBackgroundTasks","firstScreenValue","refId","lynxWorkletImpl","fnObjs","firstScreenFnObjs","fnName","firstScreenFnObj","index","JsFunctionLifecycleManager","objToRef","_this_execIdRefCount_get","rc","Set","FinalizationRegistry","isRunOnBackgroundEnabled","initWorklet","registerWorklet","_type","validateWorklet","console","first","t","String","runWorkletImpl","transformWorklet","params_","hasEventMethods","result","workletCache","WeakMap","isWorklet","transformWorkletInner","depth","obj","subObj","isWorkletRef","isJsFn","_lynxWorkletImpl__jsFunctionLifecycleManager"],"mappings":"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"}