@lynx-js/web-core-wasm-canary 0.0.0 → 0.0.1-canary-20260116-ce265e8f

package/dist/encode/encodeElementTemplate.js

@@ -0,0 +1,52 @@
+import { ElementTemplateSection, RawElementTemplate,
+// @ts-ignore
+ } from '../../binary/encode/encode.js';
+export function encodeElementTemplates(elementTemplates) {
+    const elementTemplateSection = new ElementTemplateSection();
+    for (const [key, templateData] of Object.entries(elementTemplates)) {
+        let uniqueId = 1;
+        const elementTemplate = new RawElementTemplate();
+        function createEncodeOneElementTemplateData(data) {
+            const currentId = uniqueId;
+            elementTemplate.create_element(data.type, uniqueId);
+            uniqueId += 1;
+            if (data.attributes) {
+                for (const [attrKey, attrValue] of Object.entries(data.attributes)) {
+                    elementTemplate.set_attribute(currentId, attrKey, attrValue);
+                }
+            }
+            if (data.builtinAttributes) {
+                for (const [attrKey, attrValue] of Object.entries(data.builtinAttributes)) {
+                    elementTemplate.set_attribute(currentId, attrKey, attrValue);
+                }
+            }
+            if (data.class) {
+                elementTemplate.set_attribute(currentId, 'class', data.class.join(' '));
+            }
+            if (data.dataset) {
+                for (const [dataKey, dataValue] of Object.entries(data.dataset)) {
+                    elementTemplate.set_dataset(currentId, dataKey, dataValue);
+                }
+            }
+            if (data.events) {
+                for (const event of data.events) {
+                    elementTemplate.set_cross_thread_event(currentId, event.type, event.name, event.value);
+                }
+            }
+            if (data.idSelector) {
+                elementTemplate.set_attribute(currentId, 'id', data.idSelector);
+            }
+            if (data.children) {
+                for (const child of data.children) {
+                    const childId = createEncodeOneElementTemplateData(child);
+                    elementTemplate.append_child(currentId, childId);
+                }
+            }
+            return currentId;
+        }
+        elementTemplate.append_to_root(createEncodeOneElementTemplateData(templateData));
+        elementTemplateSection.add_element_template(key, elementTemplate);
+    }
+    return elementTemplateSection.encode();
+}
+//# sourceMappingURL=encodeElementTemplate.js.map

package/dist/encode/index.d.ts

@@ -0,0 +1 @@
+export { encode, type TasmJSONInfo } from './webEncoder.js';

package/dist/encode/index.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright 2025 The Lynx Authors. All rights reserved.
+ * Licensed under the Apache License Version 2.0 that can be found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export { encode } from './webEncoder.js';
+//# sourceMappingURL=index.js.map

package/dist/encode/webEncoder.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) 2025 The Lynx Authors. All rights reserved.
+ * Licensed under the Apache License Version 2.0 that can be found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type * as CSS from '@lynx-js/css-serializer';
+import type { ElementTemplateData } from '../types/index.js';
+export type TasmJSONInfo = {
+    styleInfo: Record<string, CSS.LynxStyleNode[]>;
+    manifest: Record<string, string>;
+    cardType: string;
+    appType: string;
+    pageConfig: Record<string, unknown>;
+    lepusCode: Record<string, string>;
+    customSections: Record<string, {
+        type?: 'lazy';
+        content: string | Record<string, unknown>;
+    }>;
+    elementTemplates: Record<string, ElementTemplateData>;
+};
+export declare function encode(tasmJSON: TasmJSONInfo): Uint8Array;

package/dist/encode/webEncoder.js

@@ -0,0 +1,125 @@
+import { encodeCSS } from './encodeCSS.js';
+import { encodeElementTemplates } from './encodeElementTemplate.js';
+import { MagicHeader, TemplateSectionLabel } from '../constants.js';
+function encodeAsJSON(map) {
+    const jsonString = JSON.stringify(map);
+    const utf16Array = new Uint16Array(jsonString.length);
+    for (let i = 0; i < jsonString.length; i++) {
+        utf16Array[i] = jsonString.charCodeAt(i);
+    }
+    return new Uint8Array(utf16Array.buffer);
+}
+function encodeStringMap(map) {
+    const entries = Object.entries(map);
+    const count = entries.length;
+    // Calculate size
+    let size = 4; // count
+    const encoder = new TextEncoder();
+    const encodedEntries = [];
+    for (const [key, val] of entries) {
+        const keyBytes = encoder.encode(key);
+        const valBytes = encoder.encode(val);
+        encodedEntries.push({ keyBytes, valBytes });
+        size += 4 + keyBytes.length + 4 + valBytes.length;
+    }
+    const buffer = new Uint8Array(size);
+    const view = new DataView(buffer.buffer);
+    let offset = 0;
+    view.setUint32(offset, count, true);
+    offset += 4;
+    for (const { keyBytes, valBytes } of encodedEntries) {
+        view.setUint32(offset, keyBytes.length, true);
+        offset += 4;
+        buffer.set(keyBytes, offset);
+        offset += keyBytes.length;
+        view.setUint32(offset, valBytes.length, true);
+        offset += 4;
+        buffer.set(valBytes, offset);
+        offset += valBytes.length;
+    }
+    return buffer;
+}
+export function encode(tasmJSON) {
+    const { styleInfo, manifest, cardType, appType, pageConfig, lepusCode, customSections, elementTemplates, } = tasmJSON;
+    const encodedStyleInfo = encodeCSS(styleInfo);
+    const hasElementTemplates = Object.keys(elementTemplates).length > 0;
+    const encodedElementTemplates = hasElementTemplates
+        ? encodeElementTemplates(elementTemplates)
+        : new Uint8Array(0);
+    const encodedManifest = encodeStringMap(manifest);
+    const encodedLepusCode = encodeStringMap(lepusCode);
+    const encodedCustomSections = encodeAsJSON(customSections);
+    const configMap = {};
+    configMap['cardType'] = cardType;
+    configMap['isLazy'] = appType !== 'card' ? 'true' : 'false';
+    for (const [key, value] of Object.entries(pageConfig)) {
+        configMap[key] = String(value);
+    }
+    const encodedConfigurations = encodeAsJSON(configMap);
+    const bufferLength = 8 // Magic Header
+        + 4 // Version
+        /*section label*/
+        /*section length*/
+        + 4 + 4 + encodedConfigurations.length // Configurations
+        + 4 + 4 + encodedStyleInfo.length // Style Info
+        + (hasElementTemplates ? 4 + 4 + encodedElementTemplates.length : 0) // Element Templates
+        + 4 + 4 + encodedLepusCode.length // Lepus Code
+        + 4 + 4 + encodedCustomSections.length // Custom Sections
+        + 4 + 4 + encodedManifest.length // Manifest
+    ;
+    // generate final buffer in order
+    const buffer = new Uint8Array(bufferLength);
+    let offset = 0;
+    const dataView = new DataView(buffer.buffer);
+    dataView.setBigUint64(offset, BigInt(MagicHeader), true);
+    offset += 8;
+    // Version
+    dataView.setUint32(offset, 1, true);
+    offset += 4;
+    // Configurations
+    dataView.setUint32(offset, TemplateSectionLabel.Configurations, true); // section label
+    offset += 4;
+    dataView.setUint32(offset, encodedConfigurations.length, true); // section length
+    offset += 4;
+    buffer.set(encodedConfigurations, offset);
+    offset += encodedConfigurations.length;
+    // Element Templates
+    if (hasElementTemplates) {
+        dataView.setUint32(offset, TemplateSectionLabel.ElementTemplates, true); // section label
+        offset += 4;
+        dataView.setUint32(offset, encodedElementTemplates.length, true); // section length
+        offset += 4;
+        buffer.set(encodedElementTemplates, offset);
+        offset += encodedElementTemplates.length;
+    }
+    // Lepus Code
+    dataView.setUint32(offset, TemplateSectionLabel.LepusCode, true); // section label
+    offset += 4;
+    dataView.setUint32(offset, encodedLepusCode.length, true); // section length
+    offset += 4;
+    buffer.set(encodedLepusCode, offset);
+    offset += encodedLepusCode.length;
+    // Custom Sections
+    dataView.setUint32(offset, TemplateSectionLabel.CustomSections, true); // section label
+    offset += 4;
+    dataView.setUint32(offset, encodedCustomSections.length, true); // section length
+    offset += 4;
+    buffer.set(encodedCustomSections, offset);
+    offset += encodedCustomSections.length;
+    // Style Info
+    dataView.setUint32(offset, TemplateSectionLabel.StyleInfo, true); // section label
+    offset += 4;
+    dataView.setUint32(offset, encodedStyleInfo.length, true); // section length
+    offset += 4;
+    buffer.set(encodedStyleInfo, offset);
+    offset += encodedStyleInfo.length;
+    // Manifest
+    dataView.setUint32(offset, TemplateSectionLabel.Manifest, true); // section label
+    offset += 4;
+    dataView.setUint32(offset, encodedManifest.length, true); // section length
+    offset += 4;
+    buffer.set(encodedManifest, offset);
+    offset += encodedManifest.length;
+    return buffer;
+}
+//# sourceMappingURL=webEncoder.js.map

package/dist/types/BTSChunk.d.ts

@@ -0,0 +1,3 @@
+export type BTSChunkEntry = (postMessage: undefined, module: {
+    exports: unknown;
+}, exports: unknown, lynxCoreInject: unknown, Card: unknown, setTimeout: unknown, setInterval: unknown, clearInterval: unknown, clearTimeout: unknown, NativeModules: unknown, Component: unknown, ReactLynx: unknown, nativeAppId: unknown, Behavior: unknown, LynxJSBI: unknown, lynx: unknown, window: unknown, document: unknown, frames: unknown, location: unknown, navigator: unknown, localStorage: unknown, history: unknown, Caches: unknown, screen: unknown, alert: unknown, confirm: unknown, prompt: unknown, fetch: unknown, XMLHttpRequest: unknown, webkit: unknown, Reporter: unknown, print: unknown, global: unknown, requestAnimationFrame: unknown, cancelAnimationFrame: unknown) => unknown;

package/dist/types/BTSChunk.js

@@ -0,0 +1,5 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+export {};
+//# sourceMappingURL=BTSChunk.js.map

package/dist/types/Cloneable.d.ts

@@ -0,0 +1,2 @@
+export type Cloneable<T = string | number | null | boolean | undefined> = T | Record<string, T> | T[] | Array<Record<string, Cloneable>>;
+export type CloneableObject<T = string | number | null | boolean | undefined> = Record<string, T | T[]>;

package/dist/types/Cloneable.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Cloneable.js.map

package/dist/types/DecodedTemplate.d.ts

@@ -0,0 +1,10 @@
+import type { DecodedStyle } from '../client/wasm.js';
+import type { PageConfig } from './PageConfig.js';
+export interface DecodedTemplate {
+    config?: PageConfig;
+    styleInfo?: DecodedStyle;
+    lepusCode?: Record<string, string>;
+    elementTemplates?: any;
+    customSections?: Record<string, any>;
+    backgroundCode?: Record<string, string>;
+}

package/dist/types/DecodedTemplate.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright 2025 The Lynx Authors. All rights reserved.
+ * Licensed under the Apache License Version 2.0 that can be found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};
+//# sourceMappingURL=DecodedTemplate.js.map

package/dist/types/Element.d.ts

@@ -0,0 +1,35 @@
+import type { LynxEventType } from './EventType.js';
+import { uniqueIdSymbol, type AnimationOperation } from '../constants.js';
+export type DecoratedHTMLElement = HTMLElement & {
+    [uniqueIdSymbol]: number;
+    componentAtIndex?: ComponentAtIndexCallback;
+    enqueueComponent?: EnqueueComponentCallback;
+};
+export interface LynxRuntimeInfo {
+    eventHandlerMap: Record<string, {
+        capture: {
+            type: LynxEventType;
+            handler: string | {
+                type: 'worklet';
+                value: unknown;
+            };
+        } | undefined;
+        bind: {
+            type: LynxEventType;
+            handler: string | {
+                type: 'worklet';
+                value: unknown;
+            };
+        } | undefined;
+    }>;
+    componentAtIndex?: ComponentAtIndexCallback;
+    enqueueComponent?: EnqueueComponentCallback;
+}
+export type ComponentAtIndexCallback = (list: HTMLElement, listID: number, cellIndex: number, operationID: number, enableReuseNotification: boolean) => void;
+export type EnqueueComponentCallback = (list: HTMLElement, listID: number, sign: number) => void;
+export interface ElementAnimationOptions {
+    operation: AnimationOperation;
+    id: string;
+    keyframes?: any;
+    timingOptions?: Record<string, any>;
+}

package/dist/types/Element.js

@@ -0,0 +1,5 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { uniqueIdSymbol } from '../constants.js';
+//# sourceMappingURL=Element.js.map

package/dist/types/ElementTemplateData.d.ts

@@ -0,0 +1,15 @@
+import type { LynxEventType } from './EventType.js';
+export type ElementTemplateData = {
+    type: string;
+    idSelector?: string;
+    class?: string[];
+    attributes?: Record<string, string>;
+    builtinAttributes?: Record<string, string>;
+    children?: ElementTemplateData[];
+    events?: {
+        type: LynxEventType;
+        name: string;
+        value: string;
+    }[];
+    dataset?: Record<string, string>;
+};

package/dist/types/ElementTemplateData.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright 2023 The Lynx Authors. All rights reserved.
+ * Licensed under the Apache License Version 2.0 that can be found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};
+//# sourceMappingURL=ElementTemplateData.js.map

package/dist/types/EventType.d.ts

@@ -0,0 +1,56 @@
+import type { Cloneable } from './Cloneable.js';
+export type LynxEventType = 'bindEvent' | 'catchEvent' | 'capture-bind' | 'capture-catch';
+export interface LynxCrossThreadEventTarget {
+    dataset: {
+        [key: string]: Cloneable;
+    };
+    id: string | null;
+    uniqueId: number;
+}
+export interface LynxCrossThreadEvent<T = {
+    [key: string]: string | number | undefined | null;
+}> {
+    type: string;
+    timestamp: number;
+    target: LynxCrossThreadEventTarget;
+    currentTarget: LynxCrossThreadEventTarget | null;
+    detail: T;
+    [key: string]: string | number | undefined | null | {};
+}
+export interface MainThreadScriptEvent<T = {
+    [key: string]: string | number | undefined | null;
+}> extends LynxCrossThreadEvent<T> {
+    target: LynxCrossThreadEventTarget & {
+        elementRefptr: unknown;
+    };
+    currentTarget: (LynxCrossThreadEventTarget & {
+        elementRefptr: unknown;
+    }) | null;
+}
+export type ExposureEventDetail = {
+    'exposure-id': string;
+    'exposure-scene': string;
+    exposureID: string;
+    exposureScene: string;
+    'unique-id': number;
+};
+export type ExposureEvent = {
+    detail: ExposureEventDetail;
+};
+/**
+ * event passed by the GlobalEventEmitter(`sendGlobalEvent()`)
+ */
+export type GlobalExposureEvent = LynxCrossThreadEvent<ExposureEventDetail> & ExposureEventDetail;
+export type MinimalRawEventObject = {
+    type: string;
+    target: EventTarget | null;
+    currentTarget: EventTarget | null;
+    detail?: Cloneable;
+    isTrusted: boolean;
+    timeStamp: number;
+    propertyName?: string;
+    animationName?: string;
+    touches?: unknown[];
+    targetTouches?: unknown[];
+    changedTouches?: unknown[];
+};

package/dist/types/EventType.js

@@ -0,0 +1,5 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+export {};
+//# sourceMappingURL=EventType.js.map

package/dist/types/I18nTypes.d.ts

@@ -0,0 +1,21 @@
+import type { Cloneable } from './Cloneable.js';
+export interface I18nResourceTranslationOptions {
+    locale: string;
+    channel: string;
+    fallback_url?: string;
+    [key: string]: Cloneable;
+}
+export interface CacheI18nResources {
+    /** the i18nResource key currently being used by the page */
+    curCacheKey: string;
+    /** the complete set of all requested i18nResources */
+    i18nResources: Map<string, unknown>;
+}
+export type InitI18nResources = Array<{
+    options: I18nResourceTranslationOptions;
+    resource: Record<string, unknown>;
+}>;
+export interface II18nResource {
+    data?: Cloneable;
+    setData(data: Cloneable): void;
+}

package/dist/types/I18nTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=I18nTypes.js.map

package/dist/types/IElementPAPI.d.ts

@@ -0,0 +1,184 @@
+import type { Cloneable } from './Cloneable.js';
+import type { ComponentAtIndexCallback, EnqueueComponentCallback } from './Element.js';
+import type { LynxEventType } from './EventType.js';
+import type { I18nResourceTranslationOptions, PerformancePipelineOptions } from './index.js';
+import type { MainThreadLynx } from './MainThreadLynx.js';
+import type { ProcessDataCallback } from './ProcessDataCallback.js';
+import type { UpdateDataOptions } from './UpdateDataOptions.js';
+export interface FlushElementTreeOptions {
+    pipelineOptions?: PerformancePipelineOptions;
+}
+type ElementPAPIEventHandler = string | {
+    type: 'worklet';
+    value: unknown;
+} | undefined;
+export type AddEventPAPI = (element: HTMLElement, eventType: LynxEventType, eventName: string, newEventHandler: ElementPAPIEventHandler) => void;
+export type GetEventPAPI = (element: HTMLElement, eventName: string, eventType: LynxEventType) => ElementPAPIEventHandler;
+export type GetEventsPAPI = (element: HTMLElement) => {
+    type: LynxEventType;
+    name: string;
+    function: ElementPAPIEventHandler;
+}[];
+export type SetEventsPAPI = (element: HTMLElement, listeners: {
+    type: LynxEventType;
+    name: string;
+    function: ElementPAPIEventHandler;
+}[]) => void;
+export type AppendElementPAPI = (parent: HTMLElement, child: HTMLElement) => void;
+export type ElementIsEqualPAPI = (left: HTMLElement | null, right: HTMLElement | null) => boolean;
+export type FirstElementPAPI = (element: HTMLElement) => HTMLElement | null;
+export type GetChildrenPAPI = (element: HTMLElement) => HTMLElement[];
+export type GetParentPAPI = (element: HTMLElement) => HTMLElement | null;
+export type InsertElementBeforePAPI = (parent: HTMLElement, child: HTMLElement, ref?: HTMLElement | null) => HTMLElement;
+export type LastElementPAPI = (element: HTMLElement) => HTMLElement | null;
+export type NextElementPAPI = (element: HTMLElement) => HTMLElement | null;
+export type RemoveElementPAPI = (parent: HTMLElement, child: HTMLElement) => HTMLElement;
+export type ReplaceElementPAPI = (newElement: HTMLElement, oldElement: HTMLElement) => void;
+export type ReplaceElementsPAPI = (parent: HTMLElement, newChildren: HTMLElement[] | HTMLElement, oldChildren?: HTMLElement[] | HTMLElement | null | undefined) => void;
+export type AddConfigPAPI = (element: HTMLElement, type: string, value: Cloneable) => void;
+export type AddDatasetPAPI = (element: HTMLElement, key: string, value: Cloneable) => void;
+export type GetDatasetPAPI = (element: HTMLElement) => Record<string, Cloneable>;
+export type GetDataByKeyPAPI = (element: HTMLElement, key: string) => Cloneable | undefined;
+export type GetAttributesPAPI = (element: HTMLElement) => Record<string, string>;
+export type GetComponentIdPAPI = (element: HTMLElement) => string | null | undefined;
+export type GetElementConfigPAPI = (element: HTMLElement) => Record<string, Cloneable>;
+export type GetElementUniqueIDPAPI = (element: HTMLElement) => number;
+export type GetIDPAPI = (element: HTMLElement) => string | null;
+export type GetTagPAPI = (element: HTMLElement) => string;
+export type SetConfigPAPI = (element: HTMLElement, config: Record<string, Cloneable>) => void;
+export type SetDatasetPAPI = (element: HTMLElement, dataset: Record<string, Cloneable>) => void;
+export type SetIDPAPI = (element: HTMLElement, id: string | null) => void;
+export type UpdateComponentIDPAPI = (element: HTMLElement, componentID: string) => void;
+export type UpdateComponentInfoPAPI = (element: HTMLElement, params: {
+    componentID?: string;
+    name?: string;
+    path?: string;
+    entry?: string;
+    cssID?: number;
+}) => void;
+export type GetClassesPAPI = (element: HTMLElement) => string[];
+export type CreateViewPAPI = (parentComponentUniqueID: number) => HTMLElement;
+export type SwapElementPAPI = (childA: HTMLElement, childB: HTMLElement) => void;
+export type UpdateListInfoAttributeValue = {
+    insertAction: {
+        position: number;
+    }[];
+    removeAction: {
+        position: number;
+    }[];
+};
+export type SetAttributePAPI = (element: HTMLElement, key: Exclude<string, 'update-list-info'>, value: string | null | undefined | boolean) => void;
+export type SetAttributePAPIUpdateListInfo = (element: HTMLElement, key: 'update-list-info', value: UpdateListInfoAttributeValue | null) => void;
+export type UpdateListCallbacksPAPI = (element: HTMLElement, componentAtIndex: ComponentAtIndexCallback, enqueueComponent: EnqueueComponentCallback) => void;
+export type CreateTextPAPI = CreateViewPAPI;
+export type CreateRawTextPAPI = (text: string) => HTMLElement;
+export type CreateImagePAPI = CreateViewPAPI;
+export type CreateScrollViewPAPI = CreateViewPAPI;
+export type CreateWrapperElementPAPI = CreateViewPAPI;
+export type CreateComponentPAPI = (componentParentUniqueID: number, componentID: string, cssID: number, entryName: string, name: string, path: string, config: Record<string, Cloneable> | null | undefined, info: Record<string, Cloneable> | null | undefined) => HTMLElement;
+export type CreateElementPAPI = (tagName: string, parentComponentUniqueId: number, info?: Record<string, Cloneable> | null | undefined) => HTMLElement;
+export type CreatePagePAPI = (componentID: string, cssID: number, info?: Record<string, Cloneable> | null | undefined) => HTMLElement;
+export type CreateListPAPI = (parentComponentUniqueId: number, componentAtIndex: ComponentAtIndexCallback, enqueueComponent: EnqueueComponentCallback) => HTMLElement;
+export type AddClassPAPI = (element: HTMLElement, className: string) => void;
+export type SetClassesPAPI = (element: HTMLElement, classNames: string | null) => void;
+export type AddInlineStylePAPI = (element: HTMLElement, key: number | string, value: string | number | null | undefined) => void;
+export type SetInlineStylesPAPI = (element: HTMLElement, value: string | Record<string, string> | undefined) => void;
+export type SetCSSIdPAPI = (elements: HTMLElement[], cssId: number | null, entryName: string | undefined) => void;
+export type GetPageElementPAPI = () => HTMLElement | undefined;
+export type MarkTemplateElementPAPI = (element: HTMLElement) => void;
+export type MarkPartElementPAPI = (element: HTMLElement, partId: string) => void;
+export type GetTemplatePartsPAPI = (templateElement: HTMLElement) => Record<string, HTMLElement>;
+interface JSErrorInfo {
+    release: string;
+}
+export type ElementFromBinaryPAPI = (templateId: string, parentComponentUniId: number) => HTMLElement;
+export type GetAttributeByNamePAPI = (element: HTMLElement, name: string) => string | null;
+export type QueryComponentPAPI = (source: string, resultCallback?: (result: {
+    code: number;
+    data?: {
+        url: string;
+        evalResult: unknown;
+    };
+}) => void) => null;
+export interface ElementPAPIs {
+    __ElementFromBinary: ElementFromBinaryPAPI;
+    __GetTemplateParts: GetTemplatePartsPAPI;
+    __MarkPartElement: MarkPartElementPAPI;
+    __MarkTemplateElement: MarkTemplateElementPAPI;
+    __AddEvent: AddEventPAPI;
+    __GetEvent: GetEventPAPI;
+    __GetEvents: GetEventsPAPI;
+    __SetEvents: SetEventsPAPI;
+    __AppendElement: AppendElementPAPI;
+    __ElementIsEqual: ElementIsEqualPAPI;
+    __FirstElement: FirstElementPAPI;
+    __GetChildren: GetChildrenPAPI;
+    __GetParent: GetParentPAPI;
+    __InsertElementBefore: InsertElementBeforePAPI;
+    __LastElement: LastElementPAPI;
+    __NextElement: NextElementPAPI;
+    __RemoveElement: RemoveElementPAPI;
+    __ReplaceElement: ReplaceElementPAPI;
+    __ReplaceElements: ReplaceElementsPAPI;
+    __AddConfig: AddConfigPAPI;
+    __AddDataset: AddDatasetPAPI;
+    __GetDataset: GetDatasetPAPI;
+    __GetDataByKey: GetDataByKeyPAPI;
+    __GetAttributes: GetAttributesPAPI;
+    __GetComponentID: GetComponentIdPAPI;
+    __GetElementConfig: GetElementConfigPAPI;
+    __GetElementUniqueID: GetElementUniqueIDPAPI;
+    __GetID: GetIDPAPI;
+    __GetTag: GetTagPAPI;
+    __SetConfig: SetConfigPAPI;
+    __GetConfig: GetElementConfigPAPI;
+    __SetDataset: SetDatasetPAPI;
+    __SetID: SetIDPAPI;
+    __UpdateComponentID: UpdateComponentIDPAPI;
+    __UpdateComponentInfo: UpdateComponentInfoPAPI;
+    __GetClasses: GetClassesPAPI;
+    __CreateView: CreateViewPAPI;
+    __SwapElement: SwapElementPAPI;
+    __CreateText: CreateTextPAPI;
+    __CreateRawText: CreateRawTextPAPI;
+    __CreateImage: CreateImagePAPI;
+    __CreateScrollView: CreateScrollViewPAPI;
+    __CreateWrapperElement: CreateWrapperElementPAPI;
+    __CreateComponent: CreateComponentPAPI;
+    __CreateElement: CreateElementPAPI;
+    __CreatePage: CreatePagePAPI;
+    __CreateList: CreateListPAPI;
+    __SetAttribute: SetAttributePAPI & SetAttributePAPIUpdateListInfo;
+    __UpdateListCallbacks: UpdateListCallbacksPAPI;
+    __AddClass: AddClassPAPI;
+    __SetClasses: SetClassesPAPI;
+    __AddInlineStyle: AddInlineStylePAPI;
+    __SetInlineStyles: SetInlineStylesPAPI;
+    __SetCSSId: SetCSSIdPAPI;
+    __GetPageElement: GetPageElementPAPI;
+    __GetAttributeByName: GetAttributeByNamePAPI;
+    __FlushElementTree: (_subTree?: unknown, options?: FlushElementTreeOptions) => void;
+}
+export interface MainThreadGlobalAPIs {
+    __globalProps: unknown;
+    SystemInfo: Cloneable;
+    lynx: MainThreadLynx;
+    _ReportError: (error: Error, _: unknown) => void;
+    _SetSourceMapRelease: (errInfo: JSErrorInfo) => void;
+    __OnLifecycleEvent: (lifeCycleEvent: Cloneable) => void;
+    __LoadLepusChunk: (path: string) => boolean;
+    _I18nResourceTranslation: (options: I18nResourceTranslationOptions) => unknown | undefined;
+    _AddEventListener: (...args: unknown[]) => void;
+    __QueryComponent: QueryComponentPAPI;
+}
+export type JSFrameworkInjectedHandlers = {
+    renderPage: ((data: unknown) => void) | undefined;
+    updatePage?: (data: Cloneable, options?: UpdateDataOptions) => void;
+    runWorklet?: (obj: unknown, event: unknown) => void;
+    processData?: ProcessDataCallback;
+    ssrEncode?: () => string;
+    ssrHydrate?: (encodeData?: string | null) => void;
+    processEvalResult?: (exports: unknown, schema: string) => unknown;
+};
+export type MainThreadGlobalThis = MainThreadGlobalAPIs & ElementPAPIs & JSFrameworkInjectedHandlers;
+export {};

package/dist/types/IElementPAPI.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IElementPAPI.js.map

package/dist/types/IMtsBinding.d.ts

@@ -0,0 +1,11 @@
+import type { CloneableObject } from './Cloneable.js';
+import type { LynxCrossThreadEvent } from './EventType.js';
+/**
+ * The JS binding for the WASM main thread context instance.
+ */
+export interface RustMainthreadContextBinding {
+    runWorklet(handler: unknown, eventObject: LynxCrossThreadEvent, targetUniqueId: number, targetDataset: CloneableObject, currentTargetUniqueId: number, currentTargetDataset: CloneableObject): void;
+    publishEvent(handlerName: string, parentComponentId: string | undefined, eventObject: LynxCrossThreadEvent, targetUniqueId: number, targetDataset: CloneableObject, currentTargetUniqueId: number, currentTargetDataset: CloneableObject): void;
+    addEventListener(event_name: string): void;
+    markExposureRelatedElementByUniqueId(uniqueId: number, toEnable: boolean): void;
+}

package/dist/types/IMtsBinding.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright 2025 The Lynx Authors. All rights reserved.
+ * Licensed under the Apache License Version 2.0 that can be found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};
+//# sourceMappingURL=IMtsBinding.js.map

package/dist/types/JSRealm.d.ts

@@ -0,0 +1,5 @@
+export type JSRealm = {
+    globalWindow: typeof globalThis;
+    loadScript: (url: string) => Promise<unknown>;
+    loadScriptSync: (url: string) => unknown;
+};

package/dist/types/JSRealm.js

@@ -0,0 +1,7 @@
+/*
+ * Copyright (C) 2025 The Lynx Authors. All rights reserved.
+ * Licensed under the Apache License Version 2.0 that can be found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export {};
+//# sourceMappingURL=JSRealm.js.map

package/dist/types/LynxContextEventTarget.d.ts

@@ -0,0 +1,12 @@
+import type { Cloneable } from './Cloneable.js';
+export type ContextCrossThreadEvent = {
+    type: string;
+    data: Cloneable;
+};
+export interface LynxContextEventTarget {
+    onTriggerEvent?: (event: ContextCrossThreadEvent) => void;
+    postMessage(message: any): void;
+    dispatchEvent(event: ContextCrossThreadEvent): number;
+    addEventListener(type: string, listener: (event: Event) => void): void;
+    removeEventListener(type: string, listener: (event: Event) => void): void;
+}

package/dist/types/LynxContextEventTarget.js

@@ -0,0 +1,5 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+export {};
+//# sourceMappingURL=LynxContextEventTarget.js.map