@lynx-js/web-mainthread-apis-canary 0.18.4-canary-20251120-e2c78043 → 0.18.4

package/CHANGELOG.md

@@ -1,12 +1,11 @@
 # @lynx-js/web-mainthread-apis
 
-## 0.18.4-canary-20251120164658-e2c780434772d9abd8f92c67ce87e3935f495429
+## 0.18.4
 
 ### Patch Changes
 
 - Updated dependencies []:
-  - @lynx-js/web-constants@0.18.4-canary-20251120164658-e2c780434772d9abd8f92c67ce87e3935f495429
-  - @lynx-js/web-style-transformer@0.18.4-canary-20251120164658-e2c780434772d9abd8f92c67ce87e3935f495429
+  - @lynx-js/web-constants@0.18.4
 
 ## 0.18.3
 
@@ -304,25 +303,25 @@
   lynxView.initI18nResources = [
     {
       options: {
-        locale: "en",
-        channel: "1",
-        fallback_url: "",
+        locale: 'en',
+        channel: '1',
+        fallback_url: '',
       },
       resource: {
-        hello: "hello",
-        lynx: "lynx web platform1",
+        hello: 'hello',
+        lynx: 'lynx web platform1',
       },
     },
   ];
-  lynxView.addEventListener("i18nResourceMissed", (e) => {
+  lynxView.addEventListener('i18nResourceMissed', (e) => {
     console.log(e);
   });
 
   // mts
   _I18nResourceTranslation({
-    locale: "en",
-    channel: "1",
-    fallback_url: "",
+    locale: 'en',
+    channel: '1',
+    fallback_url: '',
   });
   ```
 

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/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-canary",
-  "version": "0.18.4-canary-20251120-e2c78043",
+  "version": "0.18.4",
   "private": false,
   "description": "",
   "keywords": [],
@@ -16,7 +16,9 @@
   "files": [
     "dist",
     "binary",
+    "wasm",
     "!dist/**/*.js.map",
+    "!binary/**/*.js.map",
     "LICENSE.txt",
     "Notice.txt",
     "CHANGELOG.md",
@@ -24,8 +26,15 @@
     "**/*.css"
   ],
   "dependencies": {
-    "@lynx-js/web-constants": "npm:@lynx-js/web-constants-canary@0.18.4-canary-20251120-e2c78043",
-    "@lynx-js/web-style-transformer": "npm:@lynx-js/web-style-transformer-canary@0.18.4-canary-20251120-e2c78043",
-    "hyphenate-style-name": "^1.1.0"
+    "@lynx-js/web-constants": "npm:@lynx-js/web-constants-canary@0.18.4",
+    "hyphenate-style-name": "^1.1.0",
+    "wasm-feature-detect": "^1.8.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';