wasm-idle 0.7.2 → 1.0.0

package/dist/clangd/worker.js

@@ -1,131 +0,0 @@
-/// <reference lib="WebWorker" />
-import { CLANGD_CPP_FILE_PATH, CLANGD_WORKSPACE_PATH, createClangdCompileFlags, normalizeClangdBaseUrl } from './config';
-import { writeGccCompatibilityHeaders } from '../clang/gccCompat';
-import { JsonStream } from './jsonStream';
-import { configureWorkerRuntimeAssets, handleWorkerAssetMessage, loadWorkerRuntimeAsset } from '../playground/worker/assets';
-import { BrowserMessageReader, BrowserMessageWriter } from '../utils/vscodeJsonrpcBrowser';
-const textEncoder = new TextEncoder();
-const jsonStream = new JsonStream();
-let resolveStdinReady = () => { };
-const stdinChunks = [];
-const currentStdinChunk = [];
-const stdin = () => {
-    if (currentStdinChunk.length === 0) {
-        if (stdinChunks.length === 0)
-            return null;
-        const nextChunk = stdinChunks.shift();
-        if (!nextChunk)
-            return null;
-        currentStdinChunk.push(...textEncoder.encode(nextChunk), null);
-    }
-    return currentStdinChunk.shift() ?? null;
-};
-const stdinReady = async () => {
-    if (stdinChunks.length === 0) {
-        return new Promise((resolve) => {
-            resolveStdinReady = resolve;
-        });
-    }
-};
-let writer = null;
-let clangdRuntime = null;
-const stdout = (charCode) => {
-    const json = jsonStream.insert(charCode);
-    if (json && writer)
-        writer.write(JSON.parse(json));
-};
-const stderr = () => { };
-const onAbort = () => {
-    writer?.end();
-    self.reportError?.('clangd aborted');
-};
-const syncWorkspaceFile = (filePath) => {
-    if (!clangdRuntime)
-        return;
-    const normalizedFilePath = filePath.startsWith(CLANGD_WORKSPACE_PATH)
-        ? filePath
-        : `${CLANGD_WORKSPACE_PATH}/${filePath.replace(/^\/+/, '')}`;
-    const lastSlash = normalizedFilePath.lastIndexOf('/');
-    const directoryPath = lastSlash > 0 ? normalizedFilePath.slice(0, lastSlash) : CLANGD_WORKSPACE_PATH;
-    clangdRuntime.FS.mkdirTree(directoryPath);
-    clangdRuntime.FS.writeFile(normalizedFilePath, '');
-};
-self.addEventListener('message', async (event) => {
-    if (handleWorkerAssetMessage(event.data))
-        return;
-    if (event.data?.type === 'sync-file' && typeof event.data?.name === 'string') {
-        syncWorkspaceFile(event.data.name);
-        return;
-    }
-    if (event.data?.type !== 'init')
-        return;
-    const runtimeAssets = event.data.assets;
-    const normalizedBaseUrl = normalizeClangdBaseUrl(event.data.baseUrl || '');
-    const baseUrl = runtimeAssets?.baseUrl || (normalizedBaseUrl ? `${normalizedBaseUrl}/` : '/clangd/');
-    configureWorkerRuntimeAssets({
-        baseUrl,
-        useAssetBridge: !!runtimeAssets?.useAssetBridge
-    });
-    try {
-        const jsSource = new TextDecoder().decode((await loadWorkerRuntimeAsset('clangd.js')).bytes);
-        self.postMessage({ type: 'progress', value: 1, max: 3 });
-        const jsDataUrl = URL.createObjectURL(new Blob([jsSource], { type: 'text/javascript;charset=utf-8' }));
-        const jsModule = import(/* @vite-ignore */ jsDataUrl);
-        const compressedWasmBytes = (await loadWorkerRuntimeAsset('clangd.wasm.gz')).bytes;
-        self.postMessage({ type: 'progress', value: 2, max: 3 });
-        let wasmBytes = compressedWasmBytes;
-        if (compressedWasmBytes[0] === 0x1f && compressedWasmBytes[1] === 0x8b) {
-            if (typeof DecompressionStream === 'undefined') {
-                throw new Error('Failed to decompress clangd.wasm.gz: DecompressionStream is unavailable');
-            }
-            const compressedWasmCopy = new Uint8Array(compressedWasmBytes.byteLength);
-            compressedWasmCopy.set(compressedWasmBytes);
-            const stream = new Blob([compressedWasmCopy.buffer])
-                .stream()
-                .pipeThrough(new DecompressionStream('gzip'));
-            wasmBytes = new Uint8Array(await new Response(stream).arrayBuffer());
-        }
-        self.postMessage({ type: 'progress', value: 3, max: 3 });
-        const wasmBlobBytes = new Uint8Array(wasmBytes.byteLength);
-        wasmBlobBytes.set(wasmBytes);
-        const wasmBlob = new Blob([wasmBlobBytes.buffer], { type: 'application/wasm' });
-        const wasmDataUrl = URL.createObjectURL(wasmBlob);
-        const { default: Clangd } = await jsModule;
-        clangdRuntime = await Clangd({
-            thisProgram: '/usr/bin/clangd',
-            mainScriptUrlOrBlob: jsDataUrl,
-            locateFile: (path, prefix) => path.endsWith('.wasm') ? wasmDataUrl : `${prefix}${path}`,
-            stdinReady,
-            stdin,
-            stdout,
-            stderr,
-            onExit: onAbort,
-            onAbort
-        });
-        clangdRuntime.FS.mkdirTree(CLANGD_WORKSPACE_PATH);
-        writeGccCompatibilityHeaders(clangdRuntime.FS, '/usr');
-        syncWorkspaceFile(CLANGD_CPP_FILE_PATH);
-        clangdRuntime.FS.writeFile(`${CLANGD_WORKSPACE_PATH}/.clangd`, JSON.stringify({
-            CompileFlags: {
-                Add: createClangdCompileFlags()
-            }
-        }));
-        clangdRuntime.callMain([]);
-        writer = new BrowserMessageWriter(self);
-        const reader = new BrowserMessageReader(self);
-        reader.listen((data) => {
-            const body = JSON.stringify(data).replace(/[\u007F-\uFFFF]/g, (character) => {
-                return '\\u' + character.codePointAt(0)?.toString(16).padStart(4, '0');
-            });
-            stdinChunks.push(`Content-Length: ${body.length}\r\n`, '\r\n', body);
-            resolveStdinReady();
-        });
-        self.postMessage({ type: 'ready', value: wasmBytes.byteLength });
-    }
-    catch (error) {
-        self.postMessage({
-            type: 'error',
-            message: error instanceof Error ? error.message : String(error)
-        });
-    }
-});

package/dist/debug/controller.svelte.d.ts

@@ -1,43 +0,0 @@
-import type { DebugLanguageAdapter } from './language';
-import type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable } from '../playground/options';
-import type { TerminalControl } from '../terminal';
-export type DebugWatchValue = {
-    expression: string;
-    value: string;
-};
-export type DebugSessionControllerOptions = {
-    terminal?: TerminalControl;
-    adapter?: DebugLanguageAdapter | null;
-    breakpoints?: number[];
-    cursorLine?: number | null;
-    syncBreakpointsWhile?: boolean | (() => boolean);
-};
-export declare function createDebugSessionController(options?: DebugSessionControllerOptions): {
-    readonly active: boolean;
-    readonly paused: boolean;
-    readonly pausedLine: number | null;
-    readonly locals: DebugVariable[];
-    readonly callStack: DebugFrame[];
-    readonly runToCursorLine: number | null;
-    readonly breakpoints: number[];
-    readonly effectiveBreakpoints: number[];
-    readonly cursorLine: number | null;
-    readonly canRunToCursor: boolean;
-    watchInput: string;
-    readonly watchExpressions: string[];
-    readonly watchValues: DebugWatchValue[];
-    begin: () => void;
-    reset: () => void;
-    handleEvent: (event: DebugSessionEvent) => void;
-    setTerminal: (terminal?: TerminalControl) => void;
-    setAdapter: (adapter: DebugLanguageAdapter | null) => void;
-    setBreakpoints: (lines: number[]) => void;
-    setCursorLine: (line: number | null) => void;
-    sendCommand: (command: DebugCommand) => Promise<boolean>;
-    runToCursor: (targetLine?: number | null) => Promise<boolean>;
-    stop: () => Promise<boolean>;
-    addWatchExpression: (expression?: string) => boolean;
-    removeWatchExpression: (expression: string) => void;
-    clearWatches: () => void;
-};
-export type DebugSessionController = ReturnType<typeof createDebugSessionController>;

package/dist/debug/controller.svelte.js

@@ -1,268 +0,0 @@
-import { fromStore, get, writable } from 'svelte/store';
-export function createDebugSessionController(options = {}) {
-    const activeStore = writable(false);
-    const pausedStore = writable(false);
-    const pausedLineStore = writable(null);
-    const localsStore = writable([]);
-    const callStackStore = writable([]);
-    const runToCursorLineStore = writable(null);
-    const watchInputStore = writable('');
-    const watchExpressionsStore = writable([]);
-    const watchValuesStore = writable([]);
-    const breakpointsStore = writable([...(options.breakpoints || [])]);
-    const cursorLineStore = writable(options.cursorLine ?? null);
-    const terminalStore = writable(options.terminal);
-    const adapterStore = writable(options.adapter ?? null);
-    const activeState = fromStore(activeStore);
-    const pausedState = fromStore(pausedStore);
-    const pausedLineState = fromStore(pausedLineStore);
-    const localsState = fromStore(localsStore);
-    const callStackState = fromStore(callStackStore);
-    const runToCursorLineState = fromStore(runToCursorLineStore);
-    const watchInputState = fromStore(watchInputStore);
-    const watchExpressionsState = fromStore(watchExpressionsStore);
-    const watchValuesState = fromStore(watchValuesStore);
-    const breakpointsState = fromStore(breakpointsStore);
-    const cursorLineState = fromStore(cursorLineStore);
-    const terminalState = fromStore(terminalStore);
-    const adapterState = fromStore(adapterStore);
-    let watchRequestVersion = 0;
-    function shouldSyncBreakpoints() {
-        if (typeof options.syncBreakpointsWhile === 'function') {
-            return options.syncBreakpointsWhile();
-        }
-        if (typeof options.syncBreakpointsWhile === 'boolean') {
-            return options.syncBreakpointsWhile;
-        }
-        return get(activeStore);
-    }
-    function getEffectiveBreakpoints() {
-        const lines = [...get(breakpointsStore)];
-        const runToCursorLine = get(runToCursorLineStore);
-        if (runToCursorLine !== null && !lines.includes(runToCursorLine))
-            lines.push(runToCursorLine);
-        return lines.sort((left, right) => left - right);
-    }
-    function refreshWatchValues() {
-        const expressions = [...get(watchExpressionsStore)];
-        const adapter = get(adapterStore);
-        const localVariables = [...get(localsStore)];
-        const paused = get(pausedStore);
-        const terminal = get(terminalStore);
-        const version = ++watchRequestVersion;
-        if (!expressions.length) {
-            watchValuesStore.set([]);
-            return;
-        }
-        if (paused && terminal?.debugEvaluate) {
-            watchValuesStore.set(expressions.map((expression) => ({ expression, value: '...' })));
-            (async () => {
-                const resolved = [];
-                for (const expression of expressions) {
-                    resolved.push({
-                        expression,
-                        value: await terminal.debugEvaluate(expression)
-                    });
-                }
-                if (version === watchRequestVersion)
-                    watchValuesStore.set(resolved);
-            })().catch(() => {
-                if (version === watchRequestVersion) {
-                    watchValuesStore.set(expressions.map((expression) => ({ expression, value: 'error' })));
-                }
-            });
-            return;
-        }
-        watchValuesStore.set(expressions.map((expression) => {
-            try {
-                return {
-                    expression,
-                    value: adapter ? adapter.evaluateExpression(expression, localVariables) : 'error'
-                };
-            }
-            catch (error) {
-                return {
-                    expression,
-                    value: error instanceof Error && error.message === 'unavailable' ? '?' : 'error'
-                };
-            }
-        }));
-    }
-    function syncBreakpoints() {
-        const terminal = get(terminalStore);
-        if (!shouldSyncBreakpoints() || !terminal?.setBreakpoints)
-            return;
-        void terminal.setBreakpoints(getEffectiveBreakpoints());
-    }
-    function clearPauseState() {
-        runToCursorLineStore.set(null);
-        pausedLineStore.set(null);
-        localsStore.set([]);
-        callStackStore.set([]);
-        pausedStore.set(false);
-    }
-    function reset() {
-        activeStore.set(false);
-        clearPauseState();
-        refreshWatchValues();
-    }
-    function begin() {
-        activeStore.set(true);
-        clearPauseState();
-        refreshWatchValues();
-        syncBreakpoints();
-    }
-    function handleEvent(event) {
-        if (event.type === 'pause') {
-            activeStore.set(true);
-            runToCursorLineStore.set(null);
-            pausedLineStore.set(event.line);
-            localsStore.set(event.locals);
-            callStackStore.set(event.callStack);
-            pausedStore.set(true);
-            refreshWatchValues();
-            return;
-        }
-        if (event.type === 'resume') {
-            pausedStore.set(false);
-            pausedLineStore.set(null);
-            localsStore.set([]);
-            callStackStore.set([]);
-            refreshWatchValues();
-            return;
-        }
-        reset();
-    }
-    function setTerminal(terminal) {
-        terminalStore.set(terminal);
-        refreshWatchValues();
-        syncBreakpoints();
-    }
-    function setAdapter(adapter) {
-        adapterStore.set(adapter);
-        refreshWatchValues();
-    }
-    function setBreakpoints(lines) {
-        breakpointsStore.set([...lines]);
-        syncBreakpoints();
-    }
-    function setCursorLine(line) {
-        cursorLineStore.set(line);
-    }
-    function addWatchExpression(expression) {
-        const watchInput = get(watchInputStore);
-        const watchExpressions = get(watchExpressionsStore);
-        const nextExpression = (expression || watchInput).trim();
-        if (!nextExpression || watchExpressions.includes(nextExpression))
-            return false;
-        watchExpressionsStore.set([...watchExpressions, nextExpression]);
-        watchInputStore.set('');
-        refreshWatchValues();
-        return true;
-    }
-    function removeWatchExpression(expression) {
-        watchExpressionsStore.set(get(watchExpressionsStore).filter((entry) => entry !== expression));
-        refreshWatchValues();
-    }
-    function clearWatches() {
-        watchInputStore.set('');
-        watchExpressionsStore.set([]);
-        refreshWatchValues();
-    }
-    async function sendCommand(command) {
-        const terminal = get(terminalStore);
-        if (!terminal || !get(pausedStore))
-            return false;
-        await terminal.debugCommand(command);
-        return true;
-    }
-    async function runToCursor(targetLine = get(cursorLineStore)) {
-        const terminal = get(terminalStore);
-        const breakpoints = get(breakpointsStore);
-        if (!terminal ||
-            !get(pausedStore) ||
-            !targetLine ||
-            targetLine === get(pausedLineStore) ||
-            !terminal.setBreakpoints) {
-            return false;
-        }
-        const nextBreakpoints = breakpoints.includes(targetLine)
-            ? [...breakpoints]
-            : [...breakpoints, targetLine].sort((left, right) => left - right);
-        runToCursorLineStore.set(breakpoints.includes(targetLine) ? null : targetLine);
-        await terminal.setBreakpoints(nextBreakpoints);
-        await terminal.debugCommand('continue');
-        return true;
-    }
-    async function stop() {
-        const terminal = get(terminalStore);
-        if (!terminal)
-            return false;
-        reset();
-        await terminal.stop?.();
-        return true;
-    }
-    return {
-        get active() {
-            return activeState.current;
-        },
-        get paused() {
-            return pausedState.current;
-        },
-        get pausedLine() {
-            return pausedLineState.current;
-        },
-        get locals() {
-            return localsState.current;
-        },
-        get callStack() {
-            return callStackState.current;
-        },
-        get runToCursorLine() {
-            return runToCursorLineState.current;
-        },
-        get breakpoints() {
-            return breakpointsState.current;
-        },
-        get effectiveBreakpoints() {
-            return getEffectiveBreakpoints();
-        },
-        get cursorLine() {
-            return cursorLineState.current;
-        },
-        get canRunToCursor() {
-            const cursorLine = cursorLineState.current;
-            const terminal = terminalState.current;
-            return (pausedState.current &&
-                cursorLine !== null &&
-                cursorLine > 0 &&
-                cursorLine !== pausedLineState.current &&
-                !!terminal?.setBreakpoints);
-        },
-        get watchInput() {
-            return watchInputState.current;
-        },
-        set watchInput(value) {
-            watchInputStore.set(value);
-        },
-        get watchExpressions() {
-            return watchExpressionsState.current;
-        },
-        get watchValues() {
-            return watchValuesState.current;
-        },
-        begin,
-        reset,
-        handleEvent,
-        setTerminal,
-        setAdapter,
-        setBreakpoints,
-        setCursorLine,
-        sendCommand,
-        runToCursor,
-        stop,
-        addWatchExpression,
-        removeWatchExpression,
-        clearWatches
-    };
-}

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

@@ -1,2 +0,0 @@
-export { MonacoDebugView, attachMonacoDebugActions } from './monaco';
-export type { MonacoDebugActionsOptions } from './monaco';

package/dist/debug/editor/index.js

@@ -1 +0,0 @@
-export { MonacoDebugView, attachMonacoDebugActions } from './monaco';

package/dist/debug/editor/monaco.d.ts

@@ -1,26 +0,0 @@
-import type { DebugVariable } from '../../playground/options';
-import type { DebugLanguageAdapter } from '../language';
-import type monaco from 'monaco-editor';
-export type MonacoDebugActionsOptions = {
-    runToCursorLabel?: string;
-    onCursorLineChange?: (line: number | null) => void;
-    onRunToCursor?: (line: number | null) => void;
-};
-export declare class MonacoDebugView {
-    Monaco: typeof monaco;
-    editor: monaco.editor.IStandaloneCodeEditor;
-    breakpointDecorations: monaco.editor.IEditorDecorationsCollection;
-    inlineValueDecorations: monaco.editor.IEditorDecorationsCollection;
-    pausedLineWidget: monaco.editor.IContentWidget | null;
-    pausedLineWidgetNode: HTMLDivElement | null;
-    mouseHandler: monaco.IDisposable | null;
-    breakpoints: number[];
-    onBreakpointsChange?: (lines: number[]) => void;
-    constructor(MonacoModule: typeof monaco, editor: monaco.editor.IStandaloneCodeEditor, onBreakpointsChange?: (lines: number[]) => void);
-    setBreakpoints(lines: number[]): void;
-    setPauseState(pausedLine: number | null, locals: DebugVariable[], adapter: DebugLanguageAdapter | null): void;
-    dispose(): void;
-}
-export declare function attachMonacoDebugActions(editor: monaco.editor.IStandaloneCodeEditor, options?: MonacoDebugActionsOptions): {
-    dispose(): void;
-};

package/dist/debug/editor/monaco.js

@@ -1,128 +0,0 @@
-export class MonacoDebugView {
-    Monaco;
-    editor;
-    breakpointDecorations;
-    inlineValueDecorations;
-    pausedLineWidget = null;
-    pausedLineWidgetNode = null;
-    mouseHandler = null;
-    breakpoints = [];
-    onBreakpointsChange;
-    constructor(MonacoModule, editor, onBreakpointsChange) {
-        this.Monaco = MonacoModule;
-        this.editor = editor;
-        this.onBreakpointsChange = onBreakpointsChange;
-        this.breakpointDecorations = editor.createDecorationsCollection();
-        this.inlineValueDecorations = editor.createDecorationsCollection();
-        this.mouseHandler = editor.onMouseDown((event) => {
-            if (event.target.type !== this.Monaco.editor.MouseTargetType.GUTTER_GLYPH_MARGIN &&
-                event.target.type !== this.Monaco.editor.MouseTargetType.GUTTER_LINE_DECORATIONS) {
-                return;
-            }
-            const line = event.target.position?.lineNumber;
-            if (!line)
-                return;
-            const next = this.breakpoints.includes(line)
-                ? this.breakpoints.filter((value) => value !== line)
-                : [...this.breakpoints, line].sort((a, b) => a - b);
-            this.onBreakpointsChange?.(next);
-        });
-    }
-    setBreakpoints(lines) {
-        this.breakpoints = lines;
-        this.breakpointDecorations.set(lines.map((line) => ({
-            range: new this.Monaco.Range(line, 1, line, 1),
-            options: {
-                isWholeLine: false,
-                glyphMarginClassName: 'debug-breakpoint-glyph',
-                glyphMarginHoverMessage: { value: 'Breakpoint' }
-            }
-        })));
-    }
-    setPauseState(pausedLine, locals, adapter) {
-        const lineMaxColumn = pausedLine ? this.editor.getModel()?.getLineMaxColumn(pausedLine) || 1 : 1;
-        if (pausedLine) {
-            const fontInfo = this.editor.getOption(this.Monaco.editor.EditorOption.fontInfo);
-            if (!this.pausedLineWidgetNode) {
-                this.pausedLineWidgetNode = document.createElement('div');
-                this.pausedLineWidgetNode.className = 'debug-paused-line-widget';
-            }
-            this.pausedLineWidgetNode.style.height = `${fontInfo.lineHeight}px`;
-            this.pausedLineWidgetNode.style.width = `${this.editor.getLayoutInfo().contentWidth}px`;
-            if (!this.pausedLineWidget) {
-                this.pausedLineWidget = {
-                    getId: () => 'wasm-idle-debug-current-line',
-                    getDomNode: () => this.pausedLineWidgetNode,
-                    getPosition: () => ({
-                        position: { lineNumber: pausedLine, column: 1 },
-                        preference: [this.Monaco.editor.ContentWidgetPositionPreference.EXACT]
-                    })
-                };
-                this.editor.addContentWidget(this.pausedLineWidget);
-            }
-            else {
-                this.editor.layoutContentWidget(this.pausedLineWidget);
-            }
-            this.editor.revealLineInCenterIfOutsideViewport(pausedLine);
-        }
-        else if (this.pausedLineWidget) {
-            this.editor.removeContentWidget(this.pausedLineWidget);
-            this.pausedLineWidget = null;
-            this.pausedLineWidgetNode = null;
-        }
-        const inlineLocals = pausedLine && adapter
-            ? adapter.selectInlineLocals(this.editor.getModel()?.getLineContent(pausedLine) || '', locals)
-            : [];
-        this.inlineValueDecorations.set(pausedLine && inlineLocals.length
-            ? [
-                {
-                    range: new this.Monaco.Range(pausedLine, lineMaxColumn, pausedLine, lineMaxColumn),
-                    options: {
-                        showIfCollapsed: true,
-                        after: {
-                            content: `  ${inlineLocals
-                                .map((variable) => `${variable.name} = ${variable.value}`)
-                                .join(', ')}`,
-                            inlineClassName: 'debug-inline-values',
-                            inlineClassNameAffectsLetterSpacing: true
-                        },
-                        zIndex: 20
-                    }
-                }
-            ]
-            : []);
-    }
-    dispose() {
-        this.breakpointDecorations.clear();
-        this.inlineValueDecorations.clear();
-        if (this.pausedLineWidget)
-            this.editor.removeContentWidget(this.pausedLineWidget);
-        this.pausedLineWidget = null;
-        this.pausedLineWidgetNode = null;
-        this.mouseHandler?.dispose();
-        this.mouseHandler = null;
-    }
-}
-export function attachMonacoDebugActions(editor, options = {}) {
-    const disposables = [];
-    disposables.push(editor.onDidChangeCursorPosition((event) => {
-        options.onCursorLineChange?.(event.position?.lineNumber || null);
-    }));
-    options.onCursorLineChange?.(editor.getPosition()?.lineNumber || 1);
-    if (options.onRunToCursor) {
-        disposables.push(editor.addAction({
-            id: 'wasm-idle-run-to-cursor',
-            label: options.runToCursorLabel || 'Run to Cursor',
-            contextMenuGroupId: 'navigation',
-            contextMenuOrder: 0.5,
-            run: () => options.onRunToCursor?.(editor.getPosition()?.lineNumber || null)
-        }));
-    }
-    return {
-        dispose() {
-            while (disposables.length)
-                disposables.pop()?.dispose();
-            options.onCursorLineChange?.(null);
-        }
-    };
-}

package/dist/debug/expression.d.ts

@@ -1,26 +0,0 @@
-import type { DebugVariable } from '../playground/options';
-export type DebugExpressionScalar = number | boolean | string | null;
-export type DebugExpressionArray = DebugExpressionValue[] & {
-    truncated?: boolean;
-};
-export interface DebugExpressionIndexedValue {
-    __debugExpressionKind: 'array';
-    length?: number;
-    truncated?: boolean;
-    get: (index: number) => DebugExpressionValue;
-    keys?: () => number[];
-}
-export interface DebugExpressionObjectValue {
-    __debugExpressionKind: 'object';
-    has: (name: string) => boolean;
-    get: (name: string) => DebugExpressionValue;
-    keys?: () => string[];
-}
-export interface DebugExpressionRecord {
-    [key: string]: DebugExpressionValue;
-}
-export type DebugExpressionValue = DebugExpressionScalar | DebugExpressionArray | DebugExpressionIndexedValue | DebugExpressionObjectValue | DebugExpressionRecord;
-export declare const parseStoredDebugValue: (value: string) => DebugExpressionValue;
-export declare const formatDebugExpressionValue: (value: DebugExpressionValue) => string;
-export declare const evaluateDebugExpressionWithResolver: (expression: string, resolveIdentifier: (name: string) => DebugExpressionValue) => string;
-export declare function evaluateDebugExpression(expression: string, variables: DebugVariable[]): string;