@lynx-js/web-mainthread-apis 0.18.3 → 0.19.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @lynx-js/web-mainthread-apis
 
+## 0.19.0
+
+### Patch Changes
+
+- fix: capture and bind event listener should be trigger correctly ([#1972](https://github.com/lynx-family/lynx-stack/pull/1972))
+
+- fix: the l-p-comp-uid of page should be '1' ([#1970](https://github.com/lynx-family/lynx-stack/pull/1970))
+
+- Updated dependencies []:
+  - @lynx-js/web-constants@0.19.0
+
+## 0.18.4
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @lynx-js/web-constants@0.18.4
+
 ## 0.18.3
 
 ### Patch Changes

package/binary/debug.d.ts

@@ -0,0 +1,4 @@
+/* tslint:disable */
+/* eslint-disable */
+export function transform_raw_u16_inline_style_ptr(str: string): string | undefined;
+export function transform_raw_u16_inline_style_ptr_parsed(name: string, value: string): Array<any> | undefined;

package/binary/debug.js

@@ -0,0 +1,5 @@
+import * as wasm from "./debug_bg.wasm";
+export * from "./debug_bg.js";
+import { __wbg_set_wasm } from "./debug_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/binary/debug_bg.js

@@ -0,0 +1,150 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+/**
+ * @param {string} str
+ * @returns {string | undefined}
+ */
+export function transform_raw_u16_inline_style_ptr(str) {
+    const ptr0 = passStringToWasm0(str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.transform_raw_u16_inline_style_ptr(ptr0, len0);
+    let v2;
+    if (ret[0] !== 0) {
+        v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v2;
+}
+
+/**
+ * @param {string} name
+ * @param {string} value
+ * @returns {Array<any> | undefined}
+ */
+export function transform_raw_u16_inline_style_ptr_parsed(name, value) {
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.transform_raw_u16_inline_style_ptr_parsed(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+export function __wbg___wbindgen_throw_b855445ff6a94295(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg_new_e17d9f43105b08be() {
+    const ret = new Array();
+    return ret;
+};
+
+export function __wbg_push_df81a39d04db858c(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+

package/binary/debug_bg.wasm.d.ts

@@ -0,0 +1,10 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const transform_raw_u16_inline_style_ptr: (a: number, b: number) => [number, number];
+export const transform_raw_u16_inline_style_ptr_parsed: (a: number, b: number, c: number, d: number) => any;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/binary/legacy.d.ts

@@ -0,0 +1,4 @@
+/* tslint:disable */
+/* eslint-disable */
+export function transform_raw_u16_inline_style_ptr(str: string): string | undefined;
+export function transform_raw_u16_inline_style_ptr_parsed(name: string, value: string): Array<any> | undefined;

package/binary/legacy.js

@@ -0,0 +1,4 @@
+import * as wasm from "./legacy_bg.wasm";
+export * from "./legacy_bg.js";
+import { __wbg_set_wasm } from "./legacy_bg.js";
+__wbg_set_wasm(wasm);

package/binary/legacy_bg.js

@@ -0,0 +1,188 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+/**
+ * @param {string} str
+ * @returns {string | undefined}
+ */
+export function transform_raw_u16_inline_style_ptr(str) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.transform_raw_u16_inline_style_ptr(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        let v2;
+        if (r0 !== 0) {
+            v2 = getStringFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export3(r0, r1 * 1, 1);
+        }
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * @param {string} name
+ * @param {string} value
+ * @returns {Array<any> | undefined}
+ */
+export function transform_raw_u16_inline_style_ptr_parsed(name, value) {
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(value, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.transform_raw_u16_inline_style_ptr_parsed(ptr0, len0, ptr1, len1);
+    return takeObject(ret);
+}
+
+export function __wbg___wbindgen_throw_b855445ff6a94295(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg_new_e17d9f43105b08be() {
+    const ret = new Array();
+    return addHeapObject(ret);
+};
+
+export function __wbg_push_df81a39d04db858c(arg0, arg1) {
+    const ret = getObject(arg0).push(getObject(arg1));
+    return ret;
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+

package/binary/legacy_bg.wasm.d.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const transform_raw_u16_inline_style_ptr: (a: number, b: number, c: number) => void;
+export const transform_raw_u16_inline_style_ptr_parsed: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number) => void;

package/binary/standard.d.ts

@@ -0,0 +1,4 @@
+/* tslint:disable */
+/* eslint-disable */
+export function transform_raw_u16_inline_style_ptr(str: string): string | undefined;
+export function transform_raw_u16_inline_style_ptr_parsed(name: string, value: string): Array<any> | undefined;

package/binary/standard.js

@@ -0,0 +1,5 @@
+import * as wasm from "./standard_bg.wasm";
+export * from "./standard_bg.js";
+import { __wbg_set_wasm } from "./standard_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/binary/standard_bg.js

@@ -0,0 +1,150 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+/**
+ * @param {string} str
+ * @returns {string | undefined}
+ */
+export function transform_raw_u16_inline_style_ptr(str) {
+    const ptr0 = passStringToWasm0(str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.transform_raw_u16_inline_style_ptr(ptr0, len0);
+    let v2;
+    if (ret[0] !== 0) {
+        v2 = getStringFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    }
+    return v2;
+}
+
+/**
+ * @param {string} name
+ * @param {string} value
+ * @returns {Array<any> | undefined}
+ */
+export function transform_raw_u16_inline_style_ptr_parsed(name, value) {
+    const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.transform_raw_u16_inline_style_ptr_parsed(ptr0, len0, ptr1, len1);
+    return ret;
+}
+
+export function __wbg___wbindgen_throw_b855445ff6a94295(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbg_new_e17d9f43105b08be() {
+    const ret = new Array();
+    return ret;
+};
+
+export function __wbg_push_df81a39d04db858c(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+export function __wbindgen_init_externref_table() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+    ;
+};
+

package/binary/standard_bg.wasm.d.ts

@@ -0,0 +1,10 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const transform_raw_u16_inline_style_ptr: (a: number, b: number) => [number, number];
+export const transform_raw_u16_inline_style_ptr_parsed: (a: number, b: number, c: number, d: number) => any;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/dist/createMainThreadGlobalThis.d.ts

@@ -1,7 +1,7 @@
-import { type LynxTemplate, type PageConfig, type FlushElementTreeOptions, type Cloneable, type BrowserConfig, type publishEventEndpoint, type publicComponentEventEndpoint, type reportErrorEndpoint, type RpcCallType, type LynxContextEventTarget, type MainThreadGlobalThis, type WebFiberElementImpl, type I18nResourceTranslationOptions, type SSRHydrateInfo, type SSRDehydrateHooks, type JSRealm, type QueryComponentPAPI } from '@lynx-js/web-constants';
+import { type LynxTemplate, type PageConfig, type FlushElementTreeOptions, type Cloneable, type BrowserConfig, type publishEventEndpoint, type publicComponentEventEndpoint, type reportErrorEndpoint, type RpcCallType, type LynxContextEventTarget, type MainThreadGlobalThis, type I18nResourceTranslationOptions, type SSRHydrateInfo, type SSRDehydrateHooks, type JSRealm, type QueryComponentPAPI } from '@lynx-js/web-constants';
 export interface MainThreadRuntimeCallbacks {
     mainChunkReady: () => void;
-    flushElementTree: (options: FlushElementTreeOptions, timingFlags: string[], exposureChangedElements: WebFiberElementImpl[]) => void;
+    flushElementTree: (options: FlushElementTreeOptions | undefined, timingFlags: string[], exposureChangedElements: HTMLElement[]) => void;
     _ReportError: RpcCallType<typeof reportErrorEndpoint>;
     __OnLifecycleEvent: (lifeCycleEvent: Cloneable) => void;
     markTiming: (pipelineId: string, timingKey: string) => void;

package/dist/createMainThreadGlobalThis.js

@@ -27,12 +27,22 @@ export function createMainThreadGlobalThis(config) {
         ?.deref();
     let uniqueIdInc = lynxUniqueIdToElement.length || 1;
     const exposureChangedElements = new Set();
-    const commonHandler = (event) => {
+    const commonHandler = (event, capture) => {
         if (!event.currentTarget) {
             return;
         }
+        // The `capture false` event should not be triggered during the capture-phase
+        // The `capture true` event should not be triggered during the bubbling phase
+        if ((event.eventPhase === Event.CAPTURING_PHASE && capture === false)
+            || (event.eventPhase === Event.BUBBLING_PHASE && capture === true)) {
+            return;
+        }
         const currentTarget = event.currentTarget;
-        const isCapture = event.eventPhase === Event.CAPTURING_PHASE;
+        // When the event is triggered by the target element, `event.eventPhase` is always `target`, and the listener type is determined by the passed-in `capture`.
+        // When the event is triggered by a non-target element, the listener type is determined by `event.eventPhase` (1, 3).
+        const isCapture = event.eventPhase === Event.AT_TARGET
+            ? capture
+            : event.eventPhase === event.CAPTURING_PHASE;
         const lynxEventName = W3cEventNameToLynx[event.type] ?? event.type;
         const runtimeInfo = elementToRuntimeInfoMap.get(currentTarget);
         if (runtimeInfo) {
@@ -70,11 +80,23 @@ export function createMainThreadGlobalThis(config) {
         }
         return false;
     };
-    const commonCatchHandler = (event) => {
-        const handlerTriggered = commonHandler(event);
+    const captureHandler = (e) => {
+        commonHandler(e, true);
+    };
+    const defaultHandler = (e) => {
+        commonHandler(e, false);
+    };
+    const commonCatchHandler = (event, isCapture) => {
+        const handlerTriggered = commonHandler(event, isCapture);
         if (handlerTriggered)
             event.stopPropagation();
     };
+    const catchCaptureHandler = (e) => {
+        commonCatchHandler(e, true);
+    };
+    const defaultCatchHandler = (e) => {
+        commonCatchHandler(e, false);
+    };
     const __AddEvent = (element, eventType, eventName, newEventHandler) => {
         eventName = eventName.toLowerCase();
         const isCatch = eventType === 'catchEvent' || eventType === 'capture-catch';
@@ -88,8 +110,8 @@ export function createMainThreadGlobalThis(config) {
             ? runtimeInfo.eventHandlerMap[eventName]?.capture
             : runtimeInfo.eventHandlerMap[eventName]?.bind;
         const currentRegisteredHandler = isCatch
-            ? commonCatchHandler
-            : commonHandler;
+            ? (isCapture ? catchCaptureHandler : defaultCatchHandler)
+            : (isCapture ? captureHandler : defaultHandler);
         if (currentHandler) {
             if (!newEventHandler) {
                 /**
@@ -210,7 +232,7 @@ export function createMainThreadGlobalThis(config) {
         const page = __CreateElement('page', 0);
         page.setAttribute('part', 'page');
         page.setAttribute(cssIdAttribute, cssID + '');
-        page.setAttribute(parentComponentUniqueIdAttribute, '0');
+        page.setAttribute(parentComponentUniqueIdAttribute, '1');
         page.setAttribute(componentIdAttribute, componentID);
         __MarkTemplateElement(page);
         if (pageConfig.defaultDisplayLinear === false) {
@@ -285,10 +307,8 @@ export function createMainThreadGlobalThis(config) {
     };
     const __SwapElement = (childA, childB) => {
         const temp = document.createElement('div');
-        // @ts-expect-error fixme
         childA.replaceWith(temp);
         childB.replaceWith(childA);
-        // @ts-expect-error fixme
         temp.replaceWith(childB);
     };
     const __SetCSSIdForCSSOG = (elements, cssId, entryName) => {
@@ -331,7 +351,6 @@ export function createMainThreadGlobalThis(config) {
         timingFlags = [];
         if (pageElement && !pageElement.parentNode
             && pageElement.getAttribute(lynxDisposedAttribute) !== '') {
-            // @ts-expect-error
             rootDom.append(pageElement);
         }
         const exposureChangedElementsArray = Array.from(exposureChangedElements);

package/dist/prepareMainThreadAPIs.js

@@ -6,10 +6,8 @@ import { registerCallLepusMethodHandler } from './crossThreadHandlers/registerCa
 import { registerGetCustomSectionHandler } from './crossThreadHandlers/registerGetCustomSectionHandler.js';
 import { createMainThreadGlobalThis } from './createMainThreadGlobalThis.js';
 import { createExposureService } from './utils/createExposureService.js';
-import { initWasm } from '@lynx-js/web-style-transformer';
 import { appendStyleElement } from './utils/processStyleInfo.js';
 import { createQueryComponent } from './crossThreadHandlers/createQueryComponent.js';
-const initWasmPromise = initWasm();
 export function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, document, mtsRealmPromise, commitDocument, markTimingInternal, flushMarkTimingInternal, reportError, triggerI18nResourceFallback, initialI18nResources, loadTemplate, ssrHooks) {
     const postTimingFlags = backgroundThreadRpc.createCall(postTimingFlagsEndpoint);
     const backgroundStart = backgroundThreadRpc.createCall(BackgroundThreadStartEndpoint);
@@ -25,7 +23,6 @@ export function prepareMainThreadAPIs(backgroundThreadRpc, rootDom, document, mt
         const { styleInfo, pageConfig, customSections, cardType, } = template;
         const mtsRealm = await mtsRealmPromise;
         markTimingInternal('decode_start');
-        await initWasmPromise;
         const jsContext = new LynxCrossThreadContext({
             rpc: backgroundThreadRpc,
             receiveEventEndpoint: dispatchJSContextOnMainThreadEndpoint,

package/dist/utils/tokenizer.js

@@ -1,4 +1,4 @@
-import { wasm } from '@lynx-js/web-style-transformer';
+import { wasm } from '../../wasm/index.js';
 export function transformInlineStyleString(str) {
     return wasm.transform_raw_u16_inline_style_ptr(str) ?? str;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lynx-js/web-mainthread-apis",
-  "version": "0.18.3",
+  "version": "0.19.0",
   "private": false,
   "description": "",
   "keywords": [],
@@ -16,7 +16,9 @@
   "files": [
     "dist",
     "binary",
+    "wasm",
     "!dist/**/*.js.map",
+    "!binary/**/*.js.map",
     "LICENSE.txt",
     "Notice.txt",
     "CHANGELOG.md",
@@ -25,7 +27,14 @@
   ],
   "dependencies": {
     "hyphenate-style-name": "^1.1.0",
-    "@lynx-js/web-constants": "0.18.3",
-    "@lynx-js/web-style-transformer": "0.18.3"
+    "wasm-feature-detect": "^1.8.0",
+    "@lynx-js/web-constants": "0.19.0"
+  },
+  "devDependencies": {
+    "binaryen": "^125.0.0",
+    "fb-dotslash": "^0.5.8"
+  },
+  "scripts": {
+    "build": "node scripts/build.js"
   }
 }

package/wasm/index.d.ts

@@ -0,0 +1,3 @@
+export type WASMModule = typeof import('./standard.js');
+export declare let wasm: WASMModule;
+export declare function initWasm(): Promise<void>;

package/wasm/index.js

@@ -0,0 +1,23 @@
+import { referenceTypes } from 'wasm-feature-detect';
+export let wasm;
+export async function initWasm() {
+  const supportsReferenceTypes = await referenceTypes();
+  if (supportsReferenceTypes) {
+    wasm = await import(
+      /* webpackMode: "eager" */
+      /* webpackFetchPriority: "high" */
+      /* webpackChunkName: "standard-wasm-chunk" */
+      /* webpackPrefetch: true */
+      /* webpackPreload: true */
+      './standard.js'
+    );
+  } else {
+    wasm = await import(
+      /* webpackMode: "lazy" */
+      /* webpackChunkName: "legacy-wasm-chunk" */
+      /* webpackPrefetch: false */
+      './legacy.js'
+    );
+  }
+}
+await initWasm();

package/wasm/legacy.js

@@ -0,0 +1 @@
+export * from '../binary/legacy.js';

package/wasm/standard.d.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+/* eslint-disable */
+export function transform_raw_u16_inline_style_ptr(
+  str: string,
+): string | undefined;
+export function transform_raw_u16_inline_style_ptr_parsed(
+  name: string,
+  value: string,
+): [[string, string][], [string, string][]] | undefined;

package/wasm/standard.js

@@ -0,0 +1 @@
+export * from '../binary/standard.js';