@lynx-js/web-core-wasm 0.0.0 → 0.0.2

package/dist/client/background/background-apis/crossThreadHandlers/createJSObjectDestructionObserver.js

@@ -0,0 +1,12 @@
+// 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 function createJSObjectDestructionObserver() {
+    const registry = new FinalizationRegistry((callback) => callback());
+    return (cleanupCallback) => {
+        const observedObject = {};
+        registry.register(observedObject, cleanupCallback);
+        return observedObject;
+    };
+}
+//# sourceMappingURL=createJSObjectDestructionObserver.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerDisposeHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeApp } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerDisposeHandler(rpc: Rpc, nativeApp: NativeApp, destroyCard: typeof import('@lynx-js/lynx-core/web')['destroyCard'], callDestroyLifetimeFun: typeof import('@lynx-js/lynx-core/web')['callDestroyLifetimeFun']): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerDisposeHandler.js

@@ -0,0 +1,9 @@
+import { disposeEndpoint } from '../../../endpoints.js';
+export function registerDisposeHandler(rpc, nativeApp, destroyCard, callDestroyLifetimeFun) {
+    rpc.registerHandler(disposeEndpoint, () => {
+        const id = nativeApp.id;
+        callDestroyLifetimeFun(id);
+        destroyCard(id);
+    });
+}
+//# sourceMappingURL=registerDisposeHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerPublicComponentEventHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerPublicComponentEventHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerPublicComponentEventHandler.js

@@ -0,0 +1,8 @@
+// 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 { publicComponentEventEndpoint } from '../../../endpoints.js';
+export function registerPublicComponentEventHandler(rpc, tt) {
+    rpc.registerHandlerLazy(publicComponentEventEndpoint, tt, 'publicComponentEvent');
+}
+//# sourceMappingURL=registerPublicComponentEventHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerPublishEventHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerPublishEventHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerPublishEventHandler.js

@@ -0,0 +1,8 @@
+// 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 { publishEventEndpoint } from '../../../endpoints.js';
+export function registerPublishEventHandler(rpc, tt) {
+    rpc.registerHandlerLazy(publishEventEndpoint, tt, 'publishEvent');
+}
+//# sourceMappingURL=registerPublishEventHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerSendGlobalEvent.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerSendGlobalEventHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerSendGlobalEvent.js

@@ -0,0 +1,10 @@
+// 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 { sendGlobalEventEndpoint } from '../../../endpoints.js';
+export function registerSendGlobalEventHandler(rpc, tt) {
+    rpc.registerHandler(sendGlobalEventEndpoint, (...args) => {
+        tt.GlobalEventEmitter.emit(...args);
+    });
+}
+//# sourceMappingURL=registerSendGlobalEvent.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateDataHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerUpdateDataHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateDataHandler.js

@@ -0,0 +1,5 @@
+import { updateDataEndpoint } from '../../../endpoints.js';
+export function registerUpdateDataHandler(rpc, tt) {
+    rpc.registerHandlerLazy(updateDataEndpoint, tt, 'updateCardData');
+}
+//# sourceMappingURL=registerUpdateDataHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateGlobalPropsHandler.d.ts

@@ -0,0 +1,3 @@
+import type { NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerUpdateGlobalPropsHandler(rpc: Rpc, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateGlobalPropsHandler.js

@@ -0,0 +1,5 @@
+import { updateGlobalPropsEndpoint } from '../../../endpoints.js';
+export function registerUpdateGlobalPropsHandler(rpc, tt) {
+    rpc.registerHandlerLazy(updateGlobalPropsEndpoint, tt, 'updateGlobalProps');
+}
+//# sourceMappingURL=registerUpdateGlobalPropsHandler.js.map

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateI18nResource.d.ts

@@ -0,0 +1,3 @@
+import type { II18nResource, NativeTTObject } from '../../../../types/index.js';
+import type { Rpc } from '@lynx-js/web-worker-rpc';
+export declare function registerUpdateI18nResource(mainThreadRpc: Rpc, i18nResource: II18nResource, tt: NativeTTObject): void;

package/dist/client/background/background-apis/crossThreadHandlers/registerUpdateI18nResource.js

@@ -0,0 +1,9 @@
+import { dispatchI18nResourceEndpoint } from '../../../endpoints.js';
+export function registerUpdateI18nResource(mainThreadRpc, i18nResource, tt) {
+    // dispatchI18nResource from mts
+    mainThreadRpc.registerHandler(dispatchI18nResourceEndpoint, (data) => {
+        i18nResource.setData(data);
+        tt.GlobalEventEmitter.emit('onI18nResourceReady', []);
+    });
+}
+//# sourceMappingURL=registerUpdateI18nResource.js.map

package/dist/client/background/background-apis/startBackgroundThread.d.ts

@@ -0,0 +1,2 @@
+import type { WorkerStartMessage } from '../../../types/WorkerStartMessage.js';
+export declare function startBackgroundThread(startMessage: WorkerStartMessage): void;

package/dist/client/background/background-apis/startBackgroundThread.js

@@ -0,0 +1,42 @@
+// 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 { Rpc } from '@lynx-js/web-worker-rpc';
+import { createBackgroundLynx } from './createBackgroundLynx.js';
+import { createNativeApp } from './createNativeApp.js';
+import { registerDisposeHandler } from './crossThreadHandlers/registerDisposeHandler.js';
+import { BackgroundThreadStartEndpoint } from '../../endpoints.js';
+import { createNapiLoader } from './createNapiLoader.js';
+import { createTimingSystem } from './createTimingSystem.js';
+export function startBackgroundThread(startMessage) {
+    const { mainThreadMessagePort, napiModulesMap, nativeModulesMap, initData, globalProps, customSections, cardType, entryTemplateUrl, } = startMessage;
+    const mainThreadPort = mainThreadMessagePort;
+    const mainThreadRpc = new Rpc(mainThreadPort, 'bg-to-main');
+    const timingSystem = createTimingSystem(mainThreadRpc, mainThreadRpc);
+    timingSystem.markTimingInternal('load_core_start');
+    const nativeApp = createNativeApp(mainThreadRpc, timingSystem, nativeModulesMap, entryTemplateUrl);
+    const lynxCore = import(
+    /* webpackChunkName: "lynx-core-chunk" */
+    '@lynx-js/lynx-core/web');
+    const napiLoader = createNapiLoader(mainThreadRpc, napiModulesMap);
+    Promise.all([lynxCore, nativeApp, napiLoader]).then(([lynxCore, nativeApp, napiLoader]) => {
+        timingSystem.markTimingInternal('load_core_end');
+        globalThis['napiLoaderOnRT' + nativeApp.id] = napiLoader;
+        const nativeLynx = createBackgroundLynx(globalProps, customSections, nativeApp, mainThreadRpc);
+        const { loadCard, destroyCard, callDestroyLifetimeFun, nativeGlobal, loadDynamicComponent, } = lynxCore;
+        // @lynx-js/lynx-core >= 0.1.3 will export nativeGlobal and loadDynamicComponent
+        if (nativeGlobal && loadDynamicComponent) {
+            nativeGlobal.loadDynamicComponent = loadDynamicComponent;
+        }
+        mainThreadRpc.registerHandler(BackgroundThreadStartEndpoint, () => {
+            loadCard(nativeApp, {
+                initData,
+                cardType,
+                // @ts-ignore
+                updateData: initData,
+            }, nativeLynx);
+        });
+        registerDisposeHandler(mainThreadRpc, nativeApp, destroyCard, callDestroyLifetimeFun);
+    });
+}
+//# sourceMappingURL=startBackgroundThread.js.map

package/dist/client/background/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/background/index.js

@@ -0,0 +1,15 @@
+import { startBackgroundThread } from './background-apis/startBackgroundThread.js';
+// @ts-expect-error
+globalThis.nativeConsole = console;
+globalThis.onmessage = async (ev) => {
+    const message = ev
+        .data;
+    if (!globalThis.SystemInfo) {
+        globalThis.SystemInfo = message.systemInfo;
+    }
+    startBackgroundThread(message);
+};
+Object.assign(globalThis, {
+    module: { exports: null },
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,12 @@
+interface CSSRule {
+    sel: string[][][];
+    decl: [string, string][];
+}
+interface OneInfo {
+    content: string[];
+    rules: CSSRule[];
+    imports?: string[];
+}
+type StyleInfo = Record<string, OneInfo>;
+export declare function loadStyleFromJSON(styleInfo: StyleInfo, configEnableCSSSelector: boolean, entryName?: string): Uint8Array;
+export {};

package/dist/client/decodeWorker/cssLoader.js

@@ -0,0 +1,95 @@
+import { wasmInstance } from '../wasm.js';
+export function loadStyleFromJSON(styleInfo, configEnableCSSSelector, entryName) {
+    const rawStyleInfo = new wasmInstance.RawStyleInfo();
+    for (const [cssIdStr, info] of Object.entries(styleInfo)) {
+        const cssId = parseInt(cssIdStr, 10);
+        // Handle imports
+        if (info.imports) {
+            // imports in StyleInfo are filenames/hrefs, but RawStyleInfo expects cssIds.
+            // Wait, genStyleInfo output imports as string hrefs?
+            // RawStyleInfo: imports: Vec<i32>
+            // It seems genStyleInfo.ts produces imports array of strings, but RawStyleInfo needs integers.
+            // If the JSON only contains strings, we might have a problem mapping them back to IDs unless we have a map.
+            // However, WebEncodePlugin usually handles mapping.
+            // Let's check genStyleInfo again.
+            // node.type === 'ImportRule' => imports.push(node.href).
+            // If imports are paths, we can't easily convert to ID without extra info.
+            // BUT, current usage of imports in RawStyleInfo is strictly ID-based.
+            // If the input JSON has hrefs, we might skip imports or error.
+            // For now, I will omit imports if they are strings, or try to parse if they look like IDs.
+            // Actually, in the ecosystem, imports might not be fully supported in JSON mode yet or resolved differently.
+            // I will log or ignore for now, focusing on Rules.
+        }
+        // Handle rules
+        for (const rule of info.rules) {
+            const wasmRule = new wasmInstance.Rule('StyleRule');
+            // Declarations
+            for (const [prop, val] of rule.decl) {
+                wasmRule.push_declaration(prop, val);
+            }
+            // Selectors
+            const prelude = new wasmInstance.RulePrelude();
+            for (const selectorChain of rule.sel) {
+                const selector = new wasmInstance.Selector();
+                // Iterate in chunks of 4
+                for (let i = 0; i < selectorChain.length; i += 4) {
+                    const plain = selectorChain[i] || [];
+                    const pseudoClass = selectorChain[i + 1] || [];
+                    const pseudoElement = selectorChain[i + 2] || [];
+                    const combinator = selectorChain[i + 3] || [];
+                    for (const s of plain) {
+                        parseAndPushSelector(selector, s);
+                    }
+                    for (const s of pseudoClass) {
+                        // Strip leading :
+                        const val = s.startsWith(':') ? s.substring(1) : s;
+                        selector.push_one_selector_section('PseudoClassSelector', val);
+                    }
+                    for (const s of pseudoElement) {
+                        // Strip leading ::
+                        const val = s.startsWith('::')
+                            ? s.substring(2)
+                            : s.startsWith(':')
+                                ? s.substring(1)
+                                : s;
+                        selector.push_one_selector_section('PseudoElementSelector', val);
+                    }
+                    if (combinator.length > 0) {
+                        selector.push_one_selector_section('Combinator', combinator[0]);
+                    }
+                }
+                prelude.push_selector(selector);
+            }
+            wasmRule.set_prelude(prelude);
+            rawStyleInfo.push_rule(cssId, wasmRule);
+        }
+    }
+    return wasmInstance.encode_legacy_json_generated_raw_style_info(rawStyleInfo, configEnableCSSSelector, entryName);
+}
+function parseAndPushSelector(selector, s) {
+    if (s.startsWith('.')) {
+        selector.push_one_selector_section('ClassSelector', s.substring(1));
+    }
+    else if (s.startsWith('#')) {
+        selector.push_one_selector_section('IdSelector', s.substring(1));
+    }
+    else if (s.startsWith('[')) {
+        // Attribute: [attr=val]
+        // Remove enclosing []
+        const content = s.substring(1, s.length - 1);
+        selector.push_one_selector_section('AttributeSelector', content);
+    }
+    else if (s === '*') {
+        selector.push_one_selector_section('UniversalSelector', '*');
+    }
+    else {
+        // Type selector
+        // It comes as [lynx-tag="div"] usually.
+        let content = s;
+        if (s.startsWith('[') && s.endsWith(']')) {
+            content = s.substring(1, s.length - 1);
+        }
+        selector.push_one_selector_section('AttributeSelector', content);
+    }
+}
+//# sourceMappingURL=cssLoader.js.map

package/dist/client/decodeWorker/decode.worker.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,339 @@
+import { TemplateSectionLabel, MagicHeader } from '../../constants.js';
+import { wasmInstance } from '../wasm.js';
+let wasmModuleLoadedResolve;
+const wasmModuleLoadedPromise = new Promise((resolve) => {
+    wasmModuleLoadedResolve = resolve;
+});
+import { loadStyleFromJSON } from './cssLoader.js';
+class StreamReader {
+    #reader;
+    #buffer = new Uint8Array(0);
+    constructor(reader) {
+        this.#reader = reader;
+    }
+    async read(size) {
+        if (this.#buffer.length >= size) {
+            const result = this.#buffer.slice(0, size);
+            this.#buffer = this.#buffer.slice(size);
+            return result;
+        }
+        while (this.#buffer.length < size) {
+            const { done, value } = await this.#reader.read();
+            if (value) {
+                const newBuffer = new Uint8Array(this.#buffer.length + value.length);
+                newBuffer.set(this.#buffer);
+                newBuffer.set(value, this.#buffer.length);
+                this.#buffer = newBuffer;
+            }
+            if (done) {
+                break;
+            }
+        }
+        if (this.#buffer.length < size) {
+            if (this.#buffer.length === 0) {
+                return null;
+            }
+            throw new Error(`Unexpected end of stream. Expected ${size} bytes, got ${this.#buffer.length}`);
+        }
+        const result = this.#buffer.slice(0, size);
+        this.#buffer = this.#buffer.slice(size);
+        return result;
+    }
+    async readRest() {
+        while (true) {
+            const { done, value } = await this.#reader.read();
+            if (value) {
+                const newBuffer = new Uint8Array(this.#buffer.length + value.length);
+                newBuffer.set(this.#buffer);
+                newBuffer.set(value, this.#buffer.length);
+                this.#buffer = newBuffer;
+            }
+            if (done) {
+                break;
+            }
+        }
+        const result = this.#buffer;
+        this.#buffer = new Uint8Array(0);
+        return result;
+    }
+}
+function decodeJSONMap(buffer) {
+    const utf16Array = new Uint16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 2);
+    let jsonString = '';
+    const CHUNK_SIZE = 8192;
+    for (let i = 0; i < utf16Array.length; i += CHUNK_SIZE) {
+        jsonString += String.fromCharCode.apply(null, utf16Array.subarray(i, i + CHUNK_SIZE));
+    }
+    return JSON.parse(jsonString);
+}
+function decodeBinaryMap(buffer) {
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let offset = 0;
+    if (buffer.byteLength < 4) {
+        throw new Error('Buffer too short for count');
+    }
+    const count = view.getUint32(offset, true);
+    offset += 4;
+    const result = {};
+    const decoder = new TextDecoder();
+    for (let i = 0; i < count; i++) {
+        if (buffer.byteLength < offset + 4) {
+            throw new Error('Buffer too short for key length');
+        }
+        const keyLen = view.getUint32(offset, true);
+        offset += 4;
+        if (buffer.byteLength < offset + keyLen) {
+            throw new Error('Buffer too short for key');
+        }
+        const key = decoder.decode(buffer.subarray(offset, offset + keyLen));
+        offset += keyLen;
+        if (buffer.byteLength < offset + 4) {
+            throw new Error('Buffer too short for value length');
+        }
+        const valLen = view.getUint32(offset, true);
+        offset += 4;
+        if (buffer.byteLength < offset + valLen) {
+            throw new Error('Buffer too short for value');
+        }
+        const val = buffer.subarray(offset, offset + valLen);
+        offset += valLen;
+        result[key] = val;
+    }
+    return result;
+}
+self.onmessage = async (event) => {
+    const data = event.data;
+    if (data.type === 'init') {
+        const { wasmModule } = data;
+        wasmInstance.initSync({ module: wasmModule });
+        wasmModuleLoadedResolve();
+    }
+    else if (data.type === 'load') {
+        const { url, fetchUrl, overrideConfig } = data;
+        try {
+            const response = await fetch(fetchUrl, {
+                headers: {
+                    'Content-Type': 'octet-stream',
+                },
+            });
+            if (!response.body || response.status !== 200) {
+                throw new Error(`Failed to fetch template: ${response.statusText}`);
+            }
+            const reader = response.body.getReader();
+            await handleStream(url, reader, overrideConfig);
+            postMessage({ type: 'done', url });
+        }
+        catch (error) {
+            postMessage({ type: 'error', url, error: error.message });
+        }
+    }
+};
+async function handleStream(url, reader, overrideConfig) {
+    const streamReader = new StreamReader(reader);
+    let config = {};
+    // 1. Check MagicHeader
+    const headerBytes = await streamReader.read(8);
+    if (!headerBytes) {
+        throw new Error('Empty stream');
+    }
+    // Check if JSON (starts with {)
+    if (headerBytes[0] === 123) {
+        const rest = await streamReader.readRest();
+        const decoder = new TextDecoder();
+        const jsonStr = decoder.decode(headerBytes) + decoder.decode(rest);
+        const json = JSON.parse(jsonStr);
+        await handleJSON(json, url, overrideConfig);
+        return;
+    }
+    const view = new DataView(headerBytes.buffer, headerBytes.byteOffset, headerBytes.byteLength);
+    const magic = view.getBigUint64(0, true); // Little Endian
+    if (magic !== BigInt(MagicHeader)) {
+        throw new Error('Invalid Magic Header');
+    }
+    // 2. Check Version
+    const versionBytes = await streamReader.read(4);
+    if (!versionBytes) {
+        throw new Error('Unexpected EOF reading version');
+    }
+    const versionView = new DataView(versionBytes.buffer, versionBytes.byteOffset, versionBytes.byteLength);
+    const version = versionView.getUint32(0, true);
+    if (version > 1) {
+        throw new Error(`Unsupported version: ${version}`);
+    }
+    // 3. Read Sections
+    while (true) {
+        const labelBytes = await streamReader.read(4);
+        if (!labelBytes) {
+            break; // EOF
+        }
+        const labelView = new DataView(labelBytes.buffer, labelBytes.byteOffset, labelBytes.byteLength);
+        const label = labelView.getUint32(0, true);
+        const lengthBytes = await streamReader.read(4);
+        if (!lengthBytes) {
+            throw new Error('Unexpected EOF reading section length');
+        }
+        const lengthView = new DataView(lengthBytes.buffer, lengthBytes.byteOffset, lengthBytes.byteLength);
+        const length = lengthView.getUint32(0, true);
+        const content = await streamReader.read(length);
+        if (!content) {
+            throw new Error(`Unexpected EOF reading section content. Expected ${length} bytes.`);
+        }
+        switch (label) {
+            case TemplateSectionLabel.Configurations: {
+                config = overrideConfig
+                    ? { ...decodeJSONMap(content), ...overrideConfig }
+                    : decodeJSONMap(content);
+                postMessage({ type: 'section', label, url, data: config });
+                break;
+            }
+            case TemplateSectionLabel.StyleInfo: {
+                await wasmModuleLoadedPromise;
+                const buffer = wasmInstance.decode_style_info(content, config['isLazy'] === 'true' ? url : undefined, config['enableCSSSelector'] === 'true');
+                postMessage({
+                    type: 'section',
+                    label,
+                    url,
+                    data: buffer.buffer,
+                    config,
+                }, {
+                    transfer: [buffer.buffer],
+                });
+                break;
+            }
+            case TemplateSectionLabel.LepusCode: {
+                const codeMap = decodeBinaryMap(content);
+                const isLazy = config['isLazy'] === 'true';
+                const blobMap = {};
+                for (const [key, code] of Object.entries(codeMap)) {
+                    const prefix = `(function(){ "use strict"; const navigator=void 0,postMessage=void 0,window=void 0; ${isLazy ? 'module.exports=' : ''} `;
+                    const suffix = ` \n })()\n//# sourceURL=${url}\n`;
+                    const blob = new Blob([prefix, code, suffix], {
+                        type: 'text/javascript; charset=utf-8',
+                    });
+                    blobMap[key] = URL.createObjectURL(blob);
+                }
+                postMessage({ type: 'section', label, url, data: blobMap, config });
+                break;
+            }
+            case TemplateSectionLabel.ElementTemplates: {
+                postMessage({ type: 'section', label, url, data: content }, [content.buffer]);
+                break;
+            }
+            case TemplateSectionLabel.CustomSections: {
+                postMessage({ type: 'section', label, url, data: content.buffer }, {
+                    transfer: [content.buffer],
+                });
+                break;
+            }
+            case TemplateSectionLabel.Manifest: {
+                const codeMap = decodeBinaryMap(content);
+                const blobMap = {};
+                for (const [key, code] of Object.entries(codeMap)) {
+                    const suffix = `//# sourceURL=${url}/${key}`;
+                    const blob = new Blob([code, suffix], {
+                        type: 'text/javascript; charset=utf-8',
+                    });
+                    blobMap[key] = URL.createObjectURL(blob);
+                }
+                postMessage({ type: 'section', label, url, data: blobMap });
+                break;
+            }
+            default:
+                throw new Error(`Unknown section label: ${label}`);
+        }
+    }
+}
+async function handleJSON(json, url, overrideConfig) {
+    // Configurations
+    let config = {};
+    if (json.pageConfig) {
+        config = { ...json.pageConfig };
+    }
+    if (overrideConfig) {
+        config = { ...config, ...overrideConfig };
+    }
+    config = Object.fromEntries(Object.entries(config).map(([key, value]) => [key, value.toString()]));
+    postMessage({
+        type: 'section',
+        label: TemplateSectionLabel.Configurations,
+        url,
+        data: config,
+    });
+    // StyleInfo
+    if (json.styleInfo) {
+        await wasmModuleLoadedPromise;
+        const buffer = loadStyleFromJSON(json.styleInfo, config['enableCSSSelector'] === 'true', config['isLazy'] === 'true' ? url : undefined);
+        postMessage({
+            type: 'section',
+            label: TemplateSectionLabel.StyleInfo,
+            url,
+            data: buffer.buffer,
+            config,
+        }, {
+            transfer: [buffer.buffer],
+        });
+    }
+    // LepusCode
+    if (json.lepusCode) {
+        // Flattened structure in json: { root: "...", chunk1: "..." }
+        const isLazy = config['isLazy'] === 'true';
+        const blobMap = {};
+        for (const [key, code] of Object.entries(json.lepusCode)) {
+            if (typeof code !== 'string')
+                continue;
+            const prefix = `(function(){ "use strict"; const navigator=void 0,postMessage=void 0,window=void 0; ${isLazy ? 'module.exports=' : ''} `;
+            const suffix = ` \n })()\n//# sourceURL=${url}/${key}\n`;
+            const blob = new Blob([prefix, code, suffix], {
+                type: 'text/javascript;',
+            });
+            blobMap[key] = URL.createObjectURL(blob);
+        }
+        postMessage({
+            type: 'section',
+            label: TemplateSectionLabel.LepusCode,
+            url,
+            data: blobMap,
+            config,
+        });
+    }
+    // Manifest
+    if (json.manifest) {
+        const blobMap = {};
+        for (const [key, code] of Object.entries(json.manifest)) {
+            if (typeof code !== 'string')
+                continue;
+            const blob = new Blob([code], {
+                type: 'text/javascript;',
+            });
+            blobMap[key] = URL.createObjectURL(blob);
+        }
+        postMessage({
+            type: 'section',
+            label: TemplateSectionLabel.Manifest,
+            url,
+            data: blobMap,
+        });
+    }
+    // CustomSections
+    if (json.customSections) {
+        // Currently we don't have a way to encode custom sections here.
+        // If main thread accepts generic object, we send it.
+        // But TemplateManager expects buffer?
+        // TemplateManager: case CustomSections: #setCustomSection(url, data). data: any.
+        // So passing object is fine!
+        postMessage({
+            type: 'section',
+            label: TemplateSectionLabel.CustomSections,
+            url,
+            data: json.customSections,
+        });
+    }
+    // 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.');
+    }
+}
+postMessage({ type: 'ready' });
+//# sourceMappingURL=decode.worker.js.map