wasm-idle 0.3.2 → 0.4.1

package/dist/debug/expression.js

@@ -8,6 +8,38 @@ export function evaluateDebugExpression(expression, variables) {
         values.set(variable.name, variable.value);
     const parsedValues = new Map();
     const tokens = [];
+    const parseQuotedValue = (text, start) => {
+        const quote = text[start];
+        if (quote !== "'" && quote !== '"')
+            throw new Error('expected quoted string');
+        let index = start + 1;
+        let value = '';
+        while (index < text.length) {
+            const character = text[index];
+            if (!character)
+                break;
+            if (character === '\\') {
+                const escaped = text[index + 1];
+                if (!escaped)
+                    throw new Error('unterminated string literal');
+                if (escaped === 'n')
+                    value += '\n';
+                else if (escaped === 'r')
+                    value += '\r';
+                else if (escaped === 't')
+                    value += '\t';
+                else
+                    value += escaped;
+                index += 2;
+                continue;
+            }
+            if (character === quote)
+                return { value, next: index + 1 };
+            value += character;
+            index += 1;
+        }
+        throw new Error('unterminated string literal');
+    };
     for (let index = 0; index < source.length;) {
         const character = source[index];
         if (!character)
@@ -32,6 +64,12 @@ export function evaluateDebugExpression(expression, variables) {
             index += operator.length;
             continue;
         }
+        if (character === "'" || character === '"') {
+            const parsed = parseQuotedValue(source, index);
+            tokens.push({ type: 'string', value: parsed.value });
+            index = parsed.next;
+            continue;
+        }
         const number = source.slice(index).match(/^\d+(?:\.\d+)?/);
         if (number?.[0]) {
             tokens.push({ type: 'number', value: number[0] });
@@ -40,8 +78,26 @@ export function evaluateDebugExpression(expression, variables) {
         }
         const identifier = source.slice(index).match(/^[A-Za-z_]\w*/);
         if (identifier?.[0]) {
-            if (identifier[0] === 'true' || identifier[0] === 'false') {
-                tokens.push({ type: 'boolean', value: identifier[0] === 'true' });
+            if (identifier[0] === 'true' ||
+                identifier[0] === 'false' ||
+                identifier[0] === 'True' ||
+                identifier[0] === 'False') {
+                tokens.push({
+                    type: 'boolean',
+                    value: identifier[0] === 'true' || identifier[0] === 'True'
+                });
+            }
+            else if (identifier[0] === 'null' || identifier[0] === 'None') {
+                tokens.push({ type: 'null' });
+            }
+            else if (identifier[0] === 'and') {
+                tokens.push({ type: 'operator', value: '&&' });
+            }
+            else if (identifier[0] === 'or') {
+                tokens.push({ type: 'operator', value: '||' });
+            }
+            else if (identifier[0] === 'not') {
+                tokens.push({ type: 'operator', value: '!' });
             }
             else {
                 tokens.push({ type: 'identifier', value: identifier[0] });
@@ -81,16 +137,44 @@ export function evaluateDebugExpression(expression, variables) {
                 throw new Error('unsupported array preview');
             }
         }
-        if (character === "'") {
-            const end = text.indexOf("'", index + 1);
-            if (end === -1)
-                throw new Error('unsupported char preview');
-            return { value: text.slice(index + 1, end), next: end + 1 };
+        if (character === '(') {
+            index += 1;
+            const items = [];
+            while (true) {
+                while (/\s/.test(text[index] || ''))
+                    index += 1;
+                if (text[index] === ')')
+                    return { value: items, next: index + 1 };
+                if (text.startsWith('...', index))
+                    throw new Error('unavailable');
+                const item = parsePreviewValue(text, index);
+                items.push(item.value);
+                index = item.next;
+                while (/\s/.test(text[index] || ''))
+                    index += 1;
+                if (text[index] === ',') {
+                    index += 1;
+                    continue;
+                }
+                if (text[index] === ')')
+                    return { value: items, next: index + 1 };
+                throw new Error('unsupported tuple preview');
+            }
         }
+        if (character === "'" || character === '"')
+            return parseQuotedValue(text, index);
         if (text.startsWith('true', index))
             return { value: true, next: index + 4 };
         if (text.startsWith('false', index))
             return { value: false, next: index + 5 };
+        if (text.startsWith('True', index))
+            return { value: true, next: index + 4 };
+        if (text.startsWith('False', index))
+            return { value: false, next: index + 5 };
+        if (text.startsWith('null', index))
+            return { value: null, next: index + 4 };
+        if (text.startsWith('None', index))
+            return { value: null, next: index + 4 };
         const number = text.slice(index).match(/^-?\d+(?:\.\d+)?/);
         if (number?.[0])
             return { value: Number(number[0]), next: index + number[0].length };
@@ -102,17 +186,24 @@ export function evaluateDebugExpression(expression, variables) {
         const value = values.get(name);
         if (value == null || value === '?')
             throw new Error('unavailable');
-        if (value === 'true' || value === 'false') {
-            const parsed = value === 'true';
+        if (value === 'true' || value === 'false' || value === 'True' || value === 'False') {
+            const parsed = value === 'true' || value === 'True';
             parsedValues.set(name, parsed);
             return parsed;
         }
+        if (value === 'null' || value === 'None') {
+            parsedValues.set(name, null);
+            return null;
+        }
         const numeric = Number(value);
         if (!Number.isNaN(numeric)) {
             parsedValues.set(name, numeric);
             return numeric;
         }
-        if (value.startsWith('[')) {
+        if (value.startsWith('[') ||
+            value.startsWith('(') ||
+            value.startsWith("'") ||
+            value.startsWith('"')) {
             const parsed = parsePreviewValue(value).value;
             parsedValues.set(name, parsed);
             return parsed;
@@ -131,10 +222,21 @@ export function evaluateDebugExpression(expression, variables) {
             cursor += 1;
             return token.value;
         }
+        if (token.type === 'null') {
+            cursor += 1;
+            return null;
+        }
+        if (token.type === 'string') {
+            cursor += 1;
+            return token.value;
+        }
         if (token.type === 'identifier') {
             cursor += 1;
             let resolved = resolveIdentifierValue(token.value);
-            while (tokens[cursor]?.type === 'bracket' && tokens[cursor]?.value === '[') {
+            while (true) {
+                const bracket = tokens[cursor];
+                if (!bracket || bracket.type !== 'bracket' || bracket.value !== '[')
+                    break;
                 cursor += 1;
                 const index = Number(parseOr());
                 const closing = tokens[cursor];
@@ -201,8 +303,14 @@ export function evaluateDebugExpression(expression, variables) {
                 return left;
             cursor += 1;
             const right = parseMul();
-            if (operator.value === '+')
-                left = Number(left) + Number(right);
+            if (operator.value === '+') {
+                if (typeof left === 'string' || typeof right === 'string') {
+                    left = `${left ?? 'null'}${right ?? 'null'}`;
+                }
+                else {
+                    left = Number(left) + Number(right);
+                }
+            }
             if (operator.value === '-')
                 left = Number(left) - Number(right);
         }
@@ -215,14 +323,16 @@ export function evaluateDebugExpression(expression, variables) {
                 return left;
             cursor += 1;
             const right = parseAdd();
+            const leftValue = typeof left === 'string' && typeof right === 'string' ? left : Number(left);
+            const rightValue = typeof left === 'string' && typeof right === 'string' ? right : Number(right);
             if (operator.value === '<')
-                left = Number(left) < Number(right);
+                left = leftValue < rightValue;
             if (operator.value === '<=')
-                left = Number(left) <= Number(right);
+                left = leftValue <= rightValue;
             if (operator.value === '>')
-                left = Number(left) > Number(right);
+                left = leftValue > rightValue;
             if (operator.value === '>=')
-                left = Number(left) >= Number(right);
+                left = leftValue >= rightValue;
         }
     };
     const parseEquality = () => {
@@ -241,7 +351,10 @@ export function evaluateDebugExpression(expression, variables) {
     };
     const parseAnd = () => {
         let left = parseEquality();
-        while (tokens[cursor]?.type === 'operator' && tokens[cursor]?.value === '&&') {
+        while (true) {
+            const operator = tokens[cursor];
+            if (!operator || operator.type !== 'operator' || operator.value !== '&&')
+                break;
             cursor += 1;
             left = Boolean(left) && Boolean(parseEquality());
         }
@@ -249,7 +362,10 @@ export function evaluateDebugExpression(expression, variables) {
     };
     const parseOr = () => {
         let left = parseAnd();
-        while (tokens[cursor]?.type === 'operator' && tokens[cursor]?.value === '||') {
+        while (true) {
+            const operator = tokens[cursor];
+            if (!operator || operator.type !== 'operator' || operator.value !== '||')
+                break;
             cursor += 1;
             left = Boolean(left) || Boolean(parseAnd());
         }

package/dist/debug/index.d.ts

@@ -1,5 +1,5 @@
 export { evaluateDebugExpression } from './expression';
 export { selectInlineDebugLocals } from './locals';
-export { cppDebugLanguageAdapter } from './language';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter } from './language';
 export { MonacoDebugView } from './editor';
 export type { DebugLanguageAdapter } from './language';

package/dist/debug/index.js

@@ -1,4 +1,4 @@
 export { evaluateDebugExpression } from './expression';
 export { selectInlineDebugLocals } from './locals';
-export { cppDebugLanguageAdapter } from './language';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter } from './language';
 export { MonacoDebugView } from './editor';

package/dist/debug/language/index.d.ts

@@ -1,2 +1,3 @@
 export { cppDebugLanguageAdapter } from './cpp';
+export { pythonDebugLanguageAdapter } from './python';
 export type { DebugLanguageAdapter } from './types';

package/dist/debug/language/index.js

@@ -1 +1,2 @@
 export { cppDebugLanguageAdapter } from './cpp';
+export { pythonDebugLanguageAdapter } from './python';

package/dist/debug/language/python.d.ts

@@ -0,0 +1,2 @@
+import type { DebugLanguageAdapter } from './types';
+export declare const pythonDebugLanguageAdapter: DebugLanguageAdapter;

package/dist/debug/language/python.js

@@ -0,0 +1,14 @@
+import { evaluateDebugExpression } from '../expression';
+const selectInlinePythonLocals = (lineText, locals) => {
+    const sanitized = lineText
+        .replace(/#.*$/g, ' ')
+        .replace(/"(?:\\.|[^"\\])*"/g, ' ')
+        .replace(/'(?:\\.|[^'\\])*'/g, ' ');
+    const identifiers = new Set(sanitized.match(/[A-Za-z_]\w*/g) || []);
+    return locals.filter((variable) => identifiers.has(variable.name));
+};
+export const pythonDebugLanguageAdapter = {
+    id: 'python',
+    evaluateExpression: evaluateDebugExpression,
+    selectInlineLocals: selectInlinePythonLocals
+};

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 import Terminal from './terminal';
-export { cppDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
 import playground from './playground';
 export default Terminal;
 export { playground };
 export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl } from './terminal';
+export type { CompilerDiagnostic } from './playground/options';
+export type { PlaygroundRuntimeAssets, RuntimeAssetConfig, RuntimeAssetLoadRequest, RuntimeAssetLoader, RuntimeAssetLoaderResult } from './playground/assets';
 export type { DebugLanguageAdapter } from './debug';

package/dist/index.js

@@ -1,5 +1,5 @@
 import Terminal from './terminal';
-export { cppDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
 import playground from './playground';
 export default Terminal;
 export { playground };

package/dist/playground/assetBridge.d.ts

@@ -0,0 +1,20 @@
+import { type ResolvedRuntimeAssetConfig, type RuntimeAssetRuntime } from './assets';
+type ProgressLike = {
+    set?: (value: number) => void;
+};
+export declare class WorkerAssetBridge {
+    private worker;
+    private readonly runtime;
+    private config;
+    private readonly progress;
+    constructor(worker: Worker, runtime: RuntimeAssetRuntime, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike);
+    matches(config: ResolvedRuntimeAssetConfig): boolean;
+    rebind(worker: Worker, config: ResolvedRuntimeAssetConfig, progress?: ProgressLike): void;
+    resetProgress(progress?: ProgressLike): void;
+    handleMessage(event: MessageEvent<any>): boolean;
+    private respond;
+    private loadAsset;
+    private normalizeLoaderResult;
+    private fetchAsset;
+}
+export {};

package/dist/playground/assetBridge.js

@@ -0,0 +1,192 @@
+import { JAVA_RUNTIME_LOAD_ASSETS, PYTHON_RUNTIME_LOAD_ASSETS } from './assets';
+const encoder = new TextEncoder();
+const transferBuffer = (bytes) => bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+    ? bytes.buffer
+    : bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+const expectedAssetsForRuntime = (runtime) => new Set(runtime === 'python' ? [...PYTHON_RUNTIME_LOAD_ASSETS] : [...JAVA_RUNTIME_LOAD_ASSETS]);
+class RuntimeLoadProgress {
+    fractions = new Map();
+    expectedAssets;
+    progress;
+    constructor(runtime) {
+        this.expectedAssets = expectedAssetsForRuntime(runtime);
+        this.reset();
+    }
+    reset(progress) {
+        this.progress = progress;
+        this.fractions.clear();
+        for (const asset of this.expectedAssets)
+            this.fractions.set(asset, 0);
+        this.emit();
+    }
+    update(asset, loaded, total) {
+        if (!this.expectedAssets.has(asset))
+            return;
+        const fraction = total && total > 0 ? Math.min(loaded / total, 1) : loaded > 0 ? 1 : 0;
+        this.fractions.set(asset, fraction);
+        this.emit();
+    }
+    emit() {
+        if (!this.progress)
+            return;
+        if (!this.fractions.size)
+            return this.progress.set?.(0);
+        let total = 0;
+        for (const fraction of this.fractions.values())
+            total += fraction;
+        this.progress.set?.(total / this.fractions.size);
+    }
+}
+export class WorkerAssetBridge {
+    worker;
+    runtime;
+    config;
+    progress;
+    constructor(worker, runtime, config, progress) {
+        this.worker = worker;
+        this.runtime = runtime;
+        this.config = config;
+        this.progress = new RuntimeLoadProgress(runtime);
+        this.progress.reset(progress);
+    }
+    matches(config) {
+        return (this.config.baseUrl === config.baseUrl &&
+            this.config.loader === config.loader &&
+            this.config.useAssetBridge === config.useAssetBridge);
+    }
+    rebind(worker, config, progress) {
+        this.worker = worker;
+        this.config = config;
+        this.progress.reset(progress);
+    }
+    resetProgress(progress) {
+        this.progress.reset(progress);
+    }
+    handleMessage(event) {
+        const assetRequest = event.data?.assetRequest;
+        if (assetRequest) {
+            void this.respond(assetRequest);
+            return true;
+        }
+        const assetProgress = event.data?.assetProgress;
+        if (assetProgress) {
+            this.progress.update(assetProgress.asset, assetProgress.loaded, assetProgress.total);
+            return true;
+        }
+        return false;
+    }
+    async respond(request) {
+        try {
+            const loaded = await this.loadAsset(request.asset);
+            const buffer = transferBuffer(loaded.bytes);
+            this.worker.postMessage({
+                assetResponse: {
+                    id: request.id,
+                    ok: true,
+                    bytes: buffer,
+                    mimeType: loaded.mimeType
+                }
+            }, [buffer]);
+        }
+        catch (error) {
+            this.worker.postMessage({
+                assetResponse: {
+                    id: request.id,
+                    ok: false,
+                    error: error instanceof Error ? error.message : String(error)
+                }
+            });
+        }
+    }
+    async loadAsset(asset) {
+        const reportProgress = (loaded, total) => this.progress.update(asset, loaded, total);
+        if (this.config.loader) {
+            const loaded = await this.normalizeLoaderResult(await this.config.loader({
+                runtime: this.runtime,
+                asset,
+                reportProgress
+            }), asset);
+            if (loaded)
+                return loaded;
+        }
+        return await this.fetchAsset(new URL(asset, this.config.baseUrl).href, asset);
+    }
+    async normalizeLoaderResult(result, asset) {
+        if (!result)
+            return null;
+        if (typeof result === 'string' || result instanceof URL) {
+            return await this.fetchAsset(String(result), asset);
+        }
+        if (result instanceof ArrayBuffer) {
+            const bytes = new Uint8Array(result);
+            this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+            return { bytes };
+        }
+        if (result instanceof Uint8Array) {
+            this.progress.update(asset, result.byteLength, result.byteLength);
+            return { bytes: result };
+        }
+        if (result instanceof Blob) {
+            const bytes = new Uint8Array(await result.arrayBuffer());
+            this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+            return { bytes, mimeType: result.type || undefined };
+        }
+        if ('url' in result && result.url) {
+            return await this.fetchAsset(String(result.url), asset);
+        }
+        if ('data' in result) {
+            if (typeof result.data === 'string') {
+                const bytes = encoder.encode(result.data);
+                this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+                return { bytes, mimeType: result.mimeType };
+            }
+            if (result.data instanceof ArrayBuffer) {
+                const bytes = new Uint8Array(result.data);
+                this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+                return { bytes, mimeType: result.mimeType };
+            }
+            if (result.data instanceof Uint8Array) {
+                this.progress.update(asset, result.data.byteLength, result.data.byteLength);
+                return { bytes: result.data, mimeType: result.mimeType };
+            }
+            const bytes = new Uint8Array(await result.data.arrayBuffer());
+            this.progress.update(asset, bytes.byteLength, bytes.byteLength);
+            return { bytes, mimeType: result.mimeType || result.data.type || undefined };
+        }
+        return null;
+    }
+    async fetchAsset(url, asset) {
+        const response = await fetch(url);
+        if (!response.ok)
+            throw new Error(`Failed to load ${asset}: ${response.status}`);
+        const contentLength = Number(response.headers.get('content-length') || 0) || undefined;
+        const mimeType = response.headers.get('content-type') || undefined;
+        if (!response.body) {
+            const bytes = new Uint8Array(await response.arrayBuffer());
+            this.progress.update(asset, bytes.byteLength, contentLength ?? bytes.byteLength);
+            return { bytes, mimeType };
+        }
+        const reader = response.body.getReader();
+        let receivedLength = 0;
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            const chunk = Uint8Array.from(value);
+            chunks.push(chunk);
+            receivedLength += chunk.byteLength;
+            this.progress.update(asset, receivedLength, contentLength);
+        }
+        const bytes = new Uint8Array(receivedLength);
+        let position = 0;
+        for (const chunk of chunks) {
+            bytes.set(chunk, position);
+            position += chunk.byteLength;
+        }
+        this.progress.update(asset, receivedLength, contentLength ?? receivedLength);
+        return { bytes, mimeType };
+    }
+}

package/dist/playground/assets.d.ts

@@ -0,0 +1,32 @@
+export type RuntimeAssetRuntime = 'python' | 'java';
+export interface RuntimeAssetLoadRequest {
+    runtime: RuntimeAssetRuntime;
+    asset: string;
+    reportProgress: (loaded: number, total?: number) => void;
+}
+export interface RuntimeAssetDataResult {
+    data: string | ArrayBuffer | Uint8Array | Blob;
+    mimeType?: string;
+}
+export interface RuntimeAssetUrlResult {
+    url: string | URL;
+}
+export type RuntimeAssetLoaderResult = RuntimeAssetDataResult | RuntimeAssetUrlResult | string | URL | ArrayBuffer | Uint8Array | Blob | null | undefined;
+export type RuntimeAssetLoader = (request: RuntimeAssetLoadRequest) => RuntimeAssetLoaderResult | Promise<RuntimeAssetLoaderResult>;
+export interface RuntimeAssetConfig {
+    baseUrl?: string;
+    loader?: RuntimeAssetLoader;
+}
+export interface PlaygroundRuntimeAssets {
+    rootUrl?: string;
+    python?: RuntimeAssetConfig;
+    java?: RuntimeAssetConfig;
+}
+export interface ResolvedRuntimeAssetConfig {
+    baseUrl: string;
+    loader?: RuntimeAssetLoader;
+    useAssetBridge: boolean;
+}
+export declare const PYTHON_RUNTIME_LOAD_ASSETS: readonly ["pyodide.asm.js", "pyodide-lock.json", "pyodide.asm.wasm", "python_stdlib.zip"];
+export declare const JAVA_RUNTIME_LOAD_ASSETS: readonly ["compiler.wasm-runtime.js", "compiler.wasm", "compile-classlib-teavm.bin", "runtime-classlib-teavm.bin"];
+export declare function resolveRuntimeAssetConfig(runtime: RuntimeAssetRuntime, options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): ResolvedRuntimeAssetConfig;

package/dist/playground/assets.js

@@ -0,0 +1,97 @@
+import { normalizeTeaVmBaseUrl, resolveTeaVmBaseUrl } from './teavmConfig';
+export const PYTHON_RUNTIME_LOAD_ASSETS = [
+    'pyodide.asm.js',
+    'pyodide-lock.json',
+    'pyodide.asm.wasm',
+    'python_stdlib.zip'
+];
+export const JAVA_RUNTIME_LOAD_ASSETS = [
+    'compiler.wasm-runtime.js',
+    'compiler.wasm',
+    'compile-classlib-teavm.bin',
+    'runtime-classlib-teavm.bin'
+];
+const PYTHON_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/python/';
+const JAVA_VIRTUAL_BASE_URL = 'https://wasm-idle.invalid/java/';
+const normalizeBaseUrl = (baseUrl, currentUrl = '') => {
+    const normalized = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    return currentUrl ? new URL(normalized, currentUrl).href : normalized;
+};
+const normalizeRootUrl = (rootUrl) => rootUrl.endsWith('/') ? rootUrl.slice(0, -1) : rootUrl;
+const resolvePythonBaseUrl = (rootUrl = '', currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}/pyodide/`, currentUrl);
+const resolvePythonRuntimeAssetConfig = (options, currentUrl = '') => {
+    if (typeof options === 'string') {
+        return {
+            baseUrl: resolvePythonBaseUrl(options, currentUrl),
+            useAssetBridge: false
+        };
+    }
+    const runtimeConfig = options?.python;
+    if (runtimeConfig?.baseUrl) {
+        return {
+            baseUrl: normalizeBaseUrl(runtimeConfig.baseUrl, currentUrl),
+            loader: runtimeConfig.loader,
+            useAssetBridge: !!runtimeConfig.loader
+        };
+    }
+    if (options?.rootUrl) {
+        return {
+            baseUrl: resolvePythonBaseUrl(options.rootUrl, currentUrl),
+            loader: runtimeConfig?.loader,
+            useAssetBridge: !!runtimeConfig?.loader
+        };
+    }
+    if (runtimeConfig?.loader) {
+        return {
+            baseUrl: PYTHON_VIRTUAL_BASE_URL,
+            loader: runtimeConfig.loader,
+            useAssetBridge: true
+        };
+    }
+    return {
+        baseUrl: resolvePythonBaseUrl('', currentUrl),
+        useAssetBridge: false
+    };
+};
+const resolveJavaBaseUrl = (rootUrl = '', currentUrl = '') => resolveTeaVmBaseUrl(rootUrl, currentUrl);
+const resolveJavaRuntimeAssetConfig = (options, currentUrl = '') => {
+    if (typeof options === 'string') {
+        return {
+            baseUrl: resolveJavaBaseUrl(options, currentUrl),
+            useAssetBridge: false
+        };
+    }
+    const runtimeConfig = options?.java;
+    if (runtimeConfig?.baseUrl) {
+        return {
+            baseUrl: currentUrl
+                ? new URL(normalizeTeaVmBaseUrl(runtimeConfig.baseUrl), currentUrl).href
+                : normalizeTeaVmBaseUrl(runtimeConfig.baseUrl),
+            loader: runtimeConfig.loader,
+            useAssetBridge: !!runtimeConfig.loader
+        };
+    }
+    if (options?.rootUrl) {
+        return {
+            baseUrl: resolveJavaBaseUrl(options.rootUrl, currentUrl),
+            loader: runtimeConfig?.loader,
+            useAssetBridge: !!runtimeConfig?.loader
+        };
+    }
+    if (runtimeConfig?.loader) {
+        return {
+            baseUrl: JAVA_VIRTUAL_BASE_URL,
+            loader: runtimeConfig.loader,
+            useAssetBridge: true
+        };
+    }
+    return {
+        baseUrl: resolveJavaBaseUrl('', currentUrl),
+        useAssetBridge: false
+    };
+};
+export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '') {
+    return runtime === 'python'
+        ? resolvePythonRuntimeAssetConfig(options, currentUrl)
+        : resolveJavaRuntimeAssetConfig(options, currentUrl);
+}