@lynx-js/web-core-wasm-canary 0.0.2-canary-20260129-b0205255 → 0.0.2-canary-20260129-d02a6062

package/binary/encode/encode_debug.js

@@ -1,301 +1,5 @@
 /* @ts-self-types="./encode_debug.d.ts" */
 
-export class DecodedStyleData {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        DecodedStyleDataFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_decodedstyledata_free(ptr, 0);
-    }
-    /**
-     * @param {Uint8Array} buffer
-     * @param {string | null | undefined} entry_name
-     * @param {boolean} config_enable_css_selector
-     * @returns {Uint8Array}
-     */
-    static decode_into(buffer, entry_name, config_enable_css_selector) {
-        var ptr0 = isLikeNone(entry_name) ? 0 : passStringToWasm0(entry_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.decodedstyledata_decode_into(buffer, ptr0, len0, config_enable_css_selector);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @param {RawStyleInfo} raw_style_info
-     * @param {boolean} config_enable_css_selector
-     * @param {string | null} [entry_name]
-     * @returns {Uint8Array}
-     */
-    static encode_from_raw_style_info(raw_style_info, config_enable_css_selector, entry_name) {
-        _assertClass(raw_style_info, RawStyleInfo);
-        var ptr0 = raw_style_info.__destroy_into_raw();
-        var ptr1 = isLikeNone(entry_name) ? 0 : passStringToWasm0(entry_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        var len1 = WASM_VECTOR_LEN;
-        const ret = wasm.decodedstyledata_encode_from_raw_style_info(ptr0, config_enable_css_selector, ptr1, len1);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return takeFromExternrefTable0(ret[0]);
-    }
-    /**
-     * @returns {string}
-     */
-    get font_face_content() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.decodedstyledata_font_face_content(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-    /**
-     * @param {Uint8Array} buffer
-     */
-    constructor(buffer) {
-        const ret = wasm.decodedstyledata_new(buffer);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0] >>> 0;
-        DecodedStyleDataFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @param {number} css_id
-     * @param {string[]} class_name
-     * @returns {string}
-     */
-    query_css_og_declarations_by_css_id(css_id, class_name) {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const ptr0 = passArrayJsValueToWasm0(class_name, wasm.__wbindgen_malloc);
-            const len0 = WASM_VECTOR_LEN;
-            const ret = wasm.decodedstyledata_query_css_og_declarations_by_css_id(this.__wbg_ptr, css_id, ptr0, len0);
-            deferred2_0 = ret[0];
-            deferred2_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
-        }
-    }
-    /**
-     * @returns {string}
-     */
-    get style_content() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.decodedstyledata_style_content(this.__wbg_ptr);
-            deferred1_0 = ret[0];
-            deferred1_1 = ret[1];
-            return getStringFromWasm0(ret[0], ret[1]);
-        } finally {
-            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-        }
-    }
-}
-if (Symbol.dispose) DecodedStyleData.prototype[Symbol.dispose] = DecodedStyleData.prototype.free;
-
-export class ElementTemplateSection {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ElementTemplateSection.prototype);
-        obj.__wbg_ptr = ptr;
-        ElementTemplateSectionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ElementTemplateSectionFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_elementtemplatesection_free(ptr, 0);
-    }
-    /**
-     * @param {string} id
-     * @param {RawElementTemplate} raw_element_template
-     */
-    add_element_template(id, raw_element_template) {
-        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        _assertClass(raw_element_template, RawElementTemplate);
-        var ptr1 = raw_element_template.__destroy_into_raw();
-        wasm.elementtemplatesection_add_element_template(this.__wbg_ptr, ptr0, len0, ptr1);
-    }
-    /**
-     * @returns {Uint8Array}
-     */
-    encode() {
-        const ret = wasm.elementtemplatesection_encode(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @param {Uint8Array} buffer
-     * @returns {ElementTemplateSection}
-     */
-    static from_encoded(buffer) {
-        const ret = wasm.elementtemplatesection_from_encoded(buffer);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ElementTemplateSection.__wrap(ret[0]);
-    }
-    constructor() {
-        const ret = wasm.elementtemplatesection_new();
-        this.__wbg_ptr = ret >>> 0;
-        ElementTemplateSectionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-}
-if (Symbol.dispose) ElementTemplateSection.prototype[Symbol.dispose] = ElementTemplateSection.prototype.free;
-
-/**
- * @enum {1 | 3 | 5 | 6 | 7 | 8 | 10 | 11 | 12}
- */
-export const LEOAsmOpcode = Object.freeze({
-    SetAttribute: 1, "1": "SetAttribute",
-    RemoveChild: 3, "3": "RemoveChild",
-    AppendChild: 5, "5": "AppendChild",
-    CreateElement: 6, "6": "CreateElement",
-    SetAttributeSlot: 7, "7": "SetAttributeSlot",
-    AppendElementSlot: 8, "8": "AppendElementSlot",
-    SetDataset: 10, "10": "SetDataset",
-    AddEvent: 11, "11": "AddEvent",
-    AppendToRoot: 12, "12": "AppendToRoot",
-});
-
-export class Operation {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        OperationFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_operation_free(ptr, 0);
-    }
-}
-if (Symbol.dispose) Operation.prototype[Symbol.dispose] = Operation.prototype.free;
-
-export class RawElementTemplate {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        RawElementTemplateFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_rawelementtemplate_free(ptr, 0);
-    }
-    /**
-     * @param {number} parent_element_id
-     * @param {number} child_element_id
-     */
-    append_child(parent_element_id, child_element_id) {
-        wasm.rawelementtemplate_append_child(this.__wbg_ptr, parent_element_id, child_element_id);
-    }
-    /**
-     * @param {number} parent_element_id
-     * @param {number} child_element_slot_id
-     */
-    append_element_slot(parent_element_id, child_element_slot_id) {
-        wasm.rawelementtemplate_append_element_slot(this.__wbg_ptr, parent_element_id, child_element_slot_id);
-    }
-    /**
-     * @param {number} element_id
-     */
-    append_to_root(element_id) {
-        wasm.rawelementtemplate_append_to_root(this.__wbg_ptr, element_id);
-    }
-    /**
-     * @param {string} tag_names
-     * @param {number} element_id
-     */
-    create_element(tag_names, element_id) {
-        const ptr0 = passStringToWasm0(tag_names, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.rawelementtemplate_create_element(this.__wbg_ptr, ptr0, len0, element_id);
-    }
-    constructor() {
-        const ret = wasm.rawelementtemplate_new();
-        this.__wbg_ptr = ret >>> 0;
-        RawElementTemplateFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @param {number} element_id
-     * @param {string} attr_name
-     * @param {string} attr_value
-     */
-    set_attribute(element_id, attr_name, attr_value) {
-        const ptr0 = passStringToWasm0(attr_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(attr_value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        wasm.rawelementtemplate_set_attribute(this.__wbg_ptr, element_id, ptr0, len0, ptr1, len1);
-    }
-    /**
-     * @param {number} element_id
-     * @param {number} attribute_slot_id
-     * @param {string} attr_name
-     */
-    set_attribute_slot(element_id, attribute_slot_id, attr_name) {
-        const ptr0 = passStringToWasm0(attr_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.rawelementtemplate_set_attribute_slot(this.__wbg_ptr, element_id, attribute_slot_id, ptr0, len0);
-    }
-    /**
-     * @param {number} element_id
-     * @param {string} event_type
-     * @param {string} event_name
-     * @param {string} event_value
-     */
-    set_cross_thread_event(element_id, event_type, event_name, event_value) {
-        const ptr0 = passStringToWasm0(event_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(event_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passStringToWasm0(event_value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len2 = WASM_VECTOR_LEN;
-        wasm.rawelementtemplate_set_cross_thread_event(this.__wbg_ptr, element_id, ptr0, len0, ptr1, len1, ptr2, len2);
-    }
-    /**
-     * @param {number} element_id
-     * @param {string} data_name
-     * @param {string} data_value
-     */
-    set_dataset(element_id, data_name, data_value) {
-        const ptr0 = passStringToWasm0(data_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(data_value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        wasm.rawelementtemplate_set_dataset(this.__wbg_ptr, element_id, ptr0, len0, ptr1, len1);
-    }
-}
-if (Symbol.dispose) RawElementTemplate.prototype[Symbol.dispose] = RawElementTemplate.prototype.free;
-
-/**
- *
- * * key: cssId
- * * value: StyleSheet
- *
- */
 export class RawStyleInfo {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -322,7 +26,7 @@ export class RawStyleInfo {
     }
     /**
      *
-     *   * Encodes the RawStyleInfo into a Uint8Array using bincode serialization.
+     *   * Encodes the RawStyleInfo into a Uint8Array using rkyv serialization.
      *   * @returns A Uint8Array containing the serialized RawStyleInfo.
      *
      * @returns {Uint8Array}
@@ -390,6 +94,7 @@ export class Rule {
     /**
      *
      *   * Pushes a declaration to the rule's declaration block.
+     *   * LynxJS doesn't support !important
      *   * @param property_name - The property name.
      *   * @param value - The property value.
      *
@@ -524,6 +229,86 @@ export class StyleInfoDecoder {
 }
 if (Symbol.dispose) StyleInfoDecoder.prototype[Symbol.dispose] = StyleInfoDecoder.prototype.free;
 
+/**
+ * @param {Uint8Array} buffer
+ * @param {string | null | undefined} entry_name
+ * @param {boolean} config_enable_css_selector
+ * @returns {Uint8Array}
+ */
+export function decode_style_info(buffer, entry_name, config_enable_css_selector) {
+    var ptr0 = isLikeNone(entry_name) ? 0 : passStringToWasm0(entry_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.decode_style_info(buffer, ptr0, len0, config_enable_css_selector);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {RawStyleInfo} raw_style_info
+ * @param {boolean} config_enable_css_selector
+ * @param {string | null} [entry_name]
+ * @returns {Uint8Array}
+ */
+export function encode_legacy_json_generated_raw_style_info(raw_style_info, config_enable_css_selector, entry_name) {
+    _assertClass(raw_style_info, RawStyleInfo);
+    var ptr0 = raw_style_info.__destroy_into_raw();
+    var ptr1 = isLikeNone(entry_name) ? 0 : passStringToWasm0(entry_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.encode_legacy_json_generated_raw_style_info(ptr0, config_enable_css_selector, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} buffer
+ * @returns {string}
+ */
+export function get_font_face_content(buffer) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.get_font_face_content(buffer);
+        var ptr1 = ret[0];
+        var len1 = ret[1];
+        if (ret[3]) {
+            ptr1 = 0; len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {Uint8Array} buffer
+ * @returns {string}
+ */
+export function get_style_content(buffer) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.get_style_content(buffer);
+        var ptr1 = ret[0];
+        var len1 = ret[1];
+        if (ret[3]) {
+            ptr1 = 0; len1 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -538,14 +323,6 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_string_get_72fb696202c56729: function(arg0, arg1) {
-            const obj = arg1;
-            const ret = typeof(obj) === 'string' ? obj : undefined;
-            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            var len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
         __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
@@ -576,18 +353,6 @@ function __wbg_get_imports() {
     };
 }
 
-const DecodedStyleDataFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_decodedstyledata_free(ptr >>> 0, 1));
-const ElementTemplateSectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_elementtemplatesection_free(ptr >>> 0, 1));
-const OperationFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_operation_free(ptr >>> 0, 1));
-const RawElementTemplateFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_rawelementtemplate_free(ptr >>> 0, 1));
 const RawStyleInfoFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rawstyleinfo_free(ptr >>> 0, 1));
@@ -604,12 +369,6 @@ const StyleInfoDecoderFinalization = (typeof FinalizationRegistry === 'undefined
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_styleinfodecoder_free(ptr >>> 0, 1));
 
-function addToExternrefTable0(obj) {
-    const idx = wasm.__externref_table_alloc();
-    wasm.__wbindgen_externrefs.set(idx, obj);
-    return idx;
-}
-
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
@@ -711,16 +470,6 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    for (let i = 0; i < array.length; i++) {
-        const add = addToExternrefTable0(array[i]);
-        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
-    }
-    WASM_VECTOR_LEN = array.length;
-    return ptr;
-}
-
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/binary/encode/encode_debug_bg.wasm.d.ts

@@ -1,17 +1,6 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const __wbg_styleinfodecoder_free: (a: number, b: number) => void;
-export const __wbg_rawelementtemplate_free: (a: number, b: number) => void;
-export const rawelementtemplate_append_child: (a: number, b: number, c: number) => void;
-export const rawelementtemplate_append_element_slot: (a: number, b: number, c: number) => void;
-export const rawelementtemplate_append_to_root: (a: number, b: number) => void;
-export const rawelementtemplate_create_element: (a: number, b: number, c: number, d: number) => void;
-export const rawelementtemplate_new: () => number;
-export const rawelementtemplate_set_attribute: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const rawelementtemplate_set_attribute_slot: (a: number, b: number, c: number, d: number, e: number) => void;
-export const rawelementtemplate_set_cross_thread_event: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
-export const rawelementtemplate_set_dataset: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const __wbg_rawstyleinfo_free: (a: number, b: number) => void;
 export const __wbg_rule_free: (a: number, b: number) => void;
 export const __wbg_ruleprelude_free: (a: number, b: number) => void;
@@ -28,23 +17,14 @@ export const ruleprelude_new: () => number;
 export const ruleprelude_push_selector: (a: number, b: number) => void;
 export const selector_new: () => number;
 export const selector_push_one_selector_section: (a: number, b: number, c: number, d: number, e: number) => [number, number];
-export const __wbg_decodedstyledata_free: (a: number, b: number) => void;
-export const decodedstyledata_decode_into: (a: any, b: number, c: number, d: number) => [number, number, number];
-export const decodedstyledata_encode_from_raw_style_info: (a: number, b: number, c: number, d: number) => [number, number, number];
-export const decodedstyledata_font_face_content: (a: number) => [number, number];
-export const decodedstyledata_new: (a: any) => [number, number, number];
-export const decodedstyledata_query_css_og_declarations_by_css_id: (a: number, b: number, c: number, d: number) => [number, number];
-export const decodedstyledata_style_content: (a: number) => [number, number];
-export const __wbg_operation_free: (a: number, b: number) => void;
-export const __wbg_elementtemplatesection_free: (a: number, b: number) => void;
-export const elementtemplatesection_add_element_template: (a: number, b: number, c: number, d: number) => void;
-export const elementtemplatesection_encode: (a: number) => any;
-export const elementtemplatesection_from_encoded: (a: any) => [number, number, number];
-export const elementtemplatesection_new: () => number;
+export const decode_style_info: (a: any, b: number, c: number, d: number) => [number, number, number];
+export const encode_legacy_json_generated_raw_style_info: (a: number, b: number, c: number, d: number) => [number, number, number];
+export const get_font_face_content: (a: any) => [number, number, number, number];
+export const get_style_content: (a: any) => [number, number, number, number];
+export const __wbg_styleinfodecoder_free: (a: number, b: number) => void;
 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_externrefs: WebAssembly.Table;
 export const __externref_table_dealloc: (a: number) => void;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __externref_table_alloc: () => number;
 export const __wbindgen_start: () => void;

package/dist/client/decodeWorker/cssLoader.d.ts

@@ -8,5 +8,5 @@ interface OneInfo {
     imports?: string[];
 }
 type StyleInfo = Record<string, OneInfo>;
-export declare function loadStyleFromJSON(styleInfo: StyleInfo, configEnableCssSelector: boolean, entryName?: string): Uint8Array;
+export declare function loadStyleFromJSON(styleInfo: StyleInfo, configEnableCSSSelector: boolean, entryName?: string): Uint8Array;
 export {};

package/dist/client/decodeWorker/cssLoader.js

@@ -1,5 +1,5 @@
 import { wasmInstance } from '../wasm.js';
-export function loadStyleFromJSON(styleInfo, configEnableCssSelector, entryName) {
+export function loadStyleFromJSON(styleInfo, configEnableCSSSelector, entryName) {
     const rawStyleInfo = new wasmInstance.RawStyleInfo();
     for (const [cssIdStr, info] of Object.entries(styleInfo)) {
         const cssId = parseInt(cssIdStr, 10);
@@ -64,8 +64,7 @@ export function loadStyleFromJSON(styleInfo, configEnableCssSelector, entryName)
             rawStyleInfo.push_rule(cssId, wasmRule);
         }
     }
-    // Use the new Rust method
-    return wasmInstance.DecodedStyleData.encode_from_raw_style_info(rawStyleInfo, configEnableCssSelector, entryName);
+    return wasmInstance.encode_legacy_json_generated_raw_style_info(rawStyleInfo, configEnableCSSSelector, entryName);
 }
 function parseAndPushSelector(selector, s) {
     if (s.startsWith('.')) {

package/dist/client/decodeWorker/decode.worker.js

@@ -1,5 +1,5 @@
 import { TemplateSectionLabel, MagicHeader } from '../../constants.js';
-import { DecodedStyle, wasmInstance } from '../wasm.js';
+import { wasmInstance } from '../wasm.js';
 let wasmModuleLoadedResolve;
 const wasmModuleLoadedPromise = new Promise((resolve) => {
     wasmModuleLoadedResolve = resolve;
@@ -188,7 +188,7 @@ async function handleStream(url, reader, overrideConfig) {
             }
             case TemplateSectionLabel.StyleInfo: {
                 await wasmModuleLoadedPromise;
-                const buffer = DecodedStyle.webWorkerDecode(content, config['enableCSSSelector'] === 'true', config['isLazy'] === 'true' ? url : undefined);
+                const buffer = wasmInstance.decode_style_info(content, config['isLazy'] === 'true' ? url : undefined, config['enableCSSSelector'] === 'true');
                 postMessage({
                     type: 'section',
                     label,
@@ -252,6 +252,7 @@ async function handleJSON(json, url, overrideConfig) {
     if (overrideConfig) {
         config = { ...config, ...overrideConfig };
     }
+    config = Object.fromEntries(Object.entries(config).map(([key, value]) => [key, value.toString()]));
     postMessage({
         type: 'section',
         label: TemplateSectionLabel.Configurations,
@@ -328,7 +329,7 @@ async function handleJSON(json, url, overrideConfig) {
         });
     }
     // ElementTemplates
-    if (json.elementTemplates) {
+    if (json.elementTemplates && Object.keys(json.elementTemplates).length > 0) {
         // TemplateManager expects Uint8Array for ElementTemplates.
         // We can't support this easily for JSON.
         throw new Error('ElementTemplates in JSON artifacts are not supported yet.');

package/dist/client/mainthread/LynxViewInstance.d.ts

@@ -1,11 +1,9 @@
 import type { Cloneable, InitI18nResources, JSRealm, MainThreadGlobalThis, NapiModulesMap, NativeModulesMap, PageConfig } from '../../types/index.js';
-import type { DecodedStyle } from '../wasm.js';
 import { BackgroundThread } from './Background.js';
 import { I18nManager } from './I18n.js';
 import { WASMJSBinding } from './elementAPIs/WASMJSBinding.js';
 import { ExposureServices } from './ExposureServices.js';
 import type { LynxViewElement } from './LynxView.js';
-import { StyleManager } from './StyleManager.js';
 export declare const systemInfo: Readonly<{
     pixelRatio: number;
     pixelWidth: number;
@@ -38,15 +36,13 @@ export declare class LynxViewInstance implements AsyncDisposable {
     readonly webElementsLoadingPromises: Promise<void>[];
     readonly styleReadyPromise: Promise<void>;
     readonly styleReadyResolve: () => void;
-    styleManager?: StyleManager;
     lepusCodeUrls: Map<string, Record<string, string>>;
     constructor(parentDom: LynxViewElement, initData: Cloneable, globalprops: Cloneable, templateUrl: string, rootDom: ShadowRoot, mtsRealm: JSRealm, lynxGroupId: number | undefined, nativeModulesMap?: NativeModulesMap, napiModulesMap?: NapiModulesMap, initI18nResources?: InitI18nResources);
     onPageConfigReady(config: PageConfig): void;
-    onStyleInfoReady(styleInfo: DecodedStyle, currentUrl: string): void;
+    onStyleInfoReady(currentUrl: string): void;
     onMTSScriptsLoaded(currentUrl: string, isLazy: boolean): void;
     onMTSScriptsExecuted(): Promise<void>;
     onBTSScriptsLoaded(url: string): Promise<void>;
-    loadWebElement(id: number): void;
     loadUnknownElement(tagName: string): void;
     queryComponent(url: string): Promise<unknown>;
     updateData(data: Cloneable, processorName?: string): Promise<void>;

package/dist/client/mainthread/LynxViewInstance.js

@@ -6,8 +6,8 @@ import { ExposureServices } from './ExposureServices.js';
 import { createElementAPI } from './elementAPIs/createElementAPI.js';
 import { createMainThreadGlobalAPIs } from './createMainThreadGlobalAPIs.js';
 import { templateManager } from './TemplateManager.js';
-import { loadAllWebElements, loadWebElement, } from '../webElementsDynamicLoader.js';
-import { StyleManager } from './StyleManager.js';
+import { loadAllWebElements } from '../webElementsDynamicLoader.js';
+import { templateManagerWasm } from '../wasm.js';
 const pixelRatio = window.devicePixelRatio;
 const screenWidth = window.screen.availWidth * pixelRatio;
 const screenHeight = window.screen.availHeight * pixelRatio;
@@ -33,7 +33,6 @@ export class LynxViewInstance {
     webElementsLoadingPromises = [];
     styleReadyPromise;
     styleReadyResolve;
-    styleManager;
     #renderPageFunction = null;
     #queryComponentCache = new Map();
     #pageConfig;
@@ -72,8 +71,7 @@ export class LynxViewInstance {
         const enableCSSSelector = config['enableCSSSelector'] == 'true';
         const defaultDisplayLinear = config['defaultDisplayLinear'] == 'true';
         const defaultOverflowVisible = config['defaultOverflowVisible'] == 'true';
-        this.styleManager = new StyleManager(this.rootDom);
-        Object.assign(this.mtsRealm.globalWindow, createElementAPI(this.templateUrl, this.rootDom, this.mtsWasmBinding, enableCSSSelector, defaultDisplayLinear, defaultOverflowVisible), createMainThreadGlobalAPIs(this));
+        Object.assign(this.mtsRealm.globalWindow, createElementAPI(this.rootDom, this.mtsWasmBinding, enableCSSSelector, defaultDisplayLinear, defaultOverflowVisible), createMainThreadGlobalAPIs(this));
         Object.defineProperty(this.mainThreadGlobalThis, 'renderPage', {
             get: () => {
                 return this.#renderPageFunction;
@@ -86,8 +84,10 @@ export class LynxViewInstance {
             enumerable: true,
         });
     }
-    onStyleInfoReady(styleInfo, currentUrl) {
-        this.styleManager?.pushStyleSheet(styleInfo, currentUrl === this.templateUrl ? undefined : currentUrl);
+    onStyleInfoReady(currentUrl) {
+        if (this.mtsWasmBinding.wasmContext) {
+            this.mtsWasmBinding.wasmContext.push_style_sheet(templateManagerWasm, currentUrl, this.templateUrl === currentUrl);
+        }
         this.parentDom.style.display = 'flex';
         this.styleReadyResolve();
     }
@@ -102,9 +102,7 @@ export class LynxViewInstance {
     }
     async onMTSScriptsExecuted() {
         this.backgroundThread.markTiming('lepus_execute_end');
-        if (!templateManager.getTemplate(this.templateUrl)?.elementTemplates) {
-            this.webElementsLoadingPromises.push(loadAllWebElements());
-        }
+        this.webElementsLoadingPromises.push(loadAllWebElements());
         await Promise.all([
             ...this.webElementsLoadingPromises,
             this.styleReadyPromise,
@@ -125,12 +123,6 @@ export class LynxViewInstance {
         await this.backgroundThread.updateBTSChunk(url, btsUrls);
         this.backgroundThread.startBTS();
     }
-    loadWebElement(id) {
-        const loadPromise = loadWebElement(id);
-        if (loadPromise) {
-            this.webElementsLoadingPromises.push(loadPromise);
-        }
-    }
     loadUnknownElement(tagName) {
         if (tagName.includes('-') && !customElements.get(tagName)) {
             this.rootDom.dispatchEvent(new CustomEvent(loadUnknownElementEventName, {

package/dist/client/mainthread/TemplateManager.d.ts

@@ -5,7 +5,6 @@ export declare class TemplateManager {
     constructor();
     fetchBundle(url: string, lynxViewInstancePromise: Promise<LynxViewInstance>, overrideConfig?: Record<string, string>): Promise<void>;
     createTemplate(url: string): void;
-    setElementTemplateSection(url: string, section: any): void;
     getTemplate(url: string): DecodedTemplate | undefined;
 }
 export declare const templateManager: TemplateManager;