wasm-idle 0.4.0 → 0.5.0

package/dist/debug/expression.js

@@ -1,45 +1,46 @@
 const operators = ['&&', '||', '==', '!=', '<=', '>=', '+', '-', '*', '/', '%', '<', '>', '!'];
-export function evaluateDebugExpression(expression, variables) {
-    const source = expression.trim();
-    if (!source)
-        throw new Error('empty expression');
-    const values = new Map();
-    for (const variable of 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;
+const isDebugExpressionIndexedValue = (value) => !!value &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    value.__debugExpressionKind === 'array';
+const isDebugExpressionObjectValue = (value) => !!value &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    value.__debugExpressionKind === 'object';
+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;
         }
-        throw new Error('unterminated string literal');
-    };
+        if (character === quote)
+            return { value, next: index + 1 };
+        value += character;
+        index += 1;
+    }
+    throw new Error('unterminated string literal');
+};
+const tokenizeDebugExpression = (source) => {
+    const tokens = [];
     for (let index = 0; index < source.length;) {
         const character = source[index];
         if (!character)
@@ -58,6 +59,11 @@ export function evaluateDebugExpression(expression, variables) {
             index += 1;
             continue;
         }
+        if (character === '.') {
+            tokens.push({ type: 'dot' });
+            index += 1;
+            continue;
+        }
         const operator = operators.find((candidate) => source.startsWith(candidate, index));
         if (operator) {
             tokens.push({ type: 'operator', value: operator });
@@ -107,109 +113,253 @@ export function evaluateDebugExpression(expression, variables) {
         }
         throw new Error(`unsupported token near "${source.slice(index)}"`);
     }
-    let cursor = 0;
-    const parsePreviewValue = (text, start = 0) => {
-        let index = start;
-        while (/\s/.test(text[index] || ''))
-            index += 1;
-        const character = text[index];
-        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;
+    return tokens;
+};
+const parseDebugPreviewValueAt = (text, start = 0) => {
+    let index = start;
+    while (/\s/.test(text[index] || ''))
+        index += 1;
+    const character = text[index];
+    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)) {
+                items.truncated = true;
+                index += 3;
                 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 array preview');
             }
+            const item = parseDebugPreviewValueAt(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 array preview');
         }
-        if (character === '(') {
-            index += 1;
-            const items = [];
-            while (true) {
+    }
+    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)) {
+                items.truncated = true;
+                index += 3;
                 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');
             }
+            const item = parseDebugPreviewValueAt(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 };
-        throw new Error('unsupported preview');
-    };
+    }
+    if (character === '{') {
+        index += 1;
+        const entries = {};
+        while (true) {
+            while (/\s/.test(text[index] || ''))
+                index += 1;
+            if (text[index] === '}')
+                return { value: entries, next: index + 1 };
+            if (text.startsWith('...', index))
+                throw new Error('unavailable');
+            let key = '';
+            if (text[index] === "'" || text[index] === '"') {
+                const parsedKey = parseQuotedValue(text, index);
+                key = parsedKey.value;
+                index = parsedKey.next;
+            }
+            else {
+                const identifier = text.slice(index).match(/^[A-Za-z_]\w*/)?.[0];
+                if (!identifier)
+                    throw new Error('unsupported object preview');
+                key = identifier;
+                index += identifier.length;
+            }
+            while (/\s/.test(text[index] || ''))
+                index += 1;
+            if (text[index] !== ':')
+                throw new Error('unsupported object preview');
+            index += 1;
+            const entry = parseDebugPreviewValueAt(text, index);
+            entries[key] = entry.value;
+            index = entry.next;
+            while (/\s/.test(text[index] || ''))
+                index += 1;
+            if (text[index] === ',') {
+                index += 1;
+                continue;
+            }
+            if (text[index] === '}')
+                return { value: entries, next: index + 1 };
+            throw new Error('unsupported object 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 };
+    throw new Error('unsupported preview');
+};
+export const parseStoredDebugValue = (value) => {
+    const source = value.trim();
+    if (!source || source === '?')
+        throw new Error('unavailable');
+    if (source === 'true' || source === 'false' || source === 'True' || source === 'False') {
+        return source === 'true' || source === 'True';
+    }
+    if (source === 'null' || source === 'None')
+        return null;
+    const numeric = Number(source);
+    if (!Number.isNaN(numeric))
+        return numeric;
+    if (source.startsWith('[') ||
+        source.startsWith('(') ||
+        source.startsWith('{') ||
+        source.startsWith("'") ||
+        source.startsWith('"')) {
+        const parsed = parseDebugPreviewValueAt(source);
+        const trailing = source.slice(parsed.next).trim();
+        if (trailing)
+            throw new Error('unsupported preview');
+        return parsed.value;
+    }
+    throw new Error('unsupported preview');
+};
+const quoteDebugString = (value) => `'${value
+    .replaceAll('\\', '\\\\')
+    .replaceAll("'", "\\'")
+    .replaceAll('\n', '\\n')
+    .replaceAll('\r', '\\r')
+    .replaceAll('\t', '\\t')}'`;
+const formatDebugExpressionValueInternal = (value, nested, depth) => {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return `${value}`;
+    if (typeof value === 'string')
+        return nested ? quoteDebugString(value) : value;
+    if (depth >= 4)
+        return '...';
+    if (Array.isArray(value)) {
+        const previewLength = Math.min(value.length, 8);
+        const items = value
+            .slice(0, previewLength)
+            .map((entry) => formatDebugExpressionValueInternal(entry, true, depth + 1));
+        return `[${items.join(', ')}${value.truncated || value.length > previewLength ? ', ...' : ''}]`;
+    }
+    if (isDebugExpressionIndexedValue(value)) {
+        const indexes = value.keys?.() || [];
+        const previewLength = Math.min(indexes.length || value.length || 0, 8);
+        const items = [];
+        for (let index = 0; index < previewLength; index += 1) {
+            const resolvedIndex = indexes[index] ?? index;
+            items.push(formatDebugExpressionValueInternal(value.get(resolvedIndex), true, depth + 1));
+        }
+        const isTruncated = value.truncated || (value.length != null && value.length > previewLength);
+        return `[${items.join(', ')}${isTruncated ? ', ...' : ''}]`;
+    }
+    if (isDebugExpressionObjectValue(value)) {
+        const keys = value.keys?.() || [];
+        const previewLength = Math.min(keys.length, 8);
+        const entries = keys.slice(0, previewLength).map((key) => {
+            return `${key}: ${formatDebugExpressionValueInternal(value.get(key), true, depth + 1)}`;
+        });
+        return `{${entries.join(', ')}${keys.length > previewLength ? ', ...' : ''}}`;
+    }
+    const keys = Object.keys(value);
+    const previewLength = Math.min(keys.length, 8);
+    const entries = keys.slice(0, previewLength).map((key) => {
+        return `${key}: ${formatDebugExpressionValueInternal(value[key], true, depth + 1)}`;
+    });
+    return `{${entries.join(', ')}${keys.length > previewLength ? ', ...' : ''}}`;
+};
+export const formatDebugExpressionValue = (value) => formatDebugExpressionValueInternal(value, false, 0);
+export const evaluateDebugExpressionWithResolver = (expression, resolveIdentifier) => {
+    const source = expression.trim();
+    if (!source)
+        throw new Error('empty expression');
+    const tokens = tokenizeDebugExpression(source);
+    const parsedValues = new Map();
     const resolveIdentifierValue = (name) => {
         if (parsedValues.has(name))
             return parsedValues.get(name);
-        const value = values.get(name);
-        if (value == null || value === '?')
-            throw new Error('unavailable');
-        if (value === 'true' || value === 'false' || value === 'True' || value === 'False') {
-            const parsed = value === 'true' || value === 'True';
-            parsedValues.set(name, parsed);
-            return parsed;
+        const value = resolveIdentifier(name);
+        parsedValues.set(name, value);
+        return value;
+    };
+    const readIndexedValue = (value, index) => {
+        if (!Number.isInteger(index))
+            throw new Error('unsupported index access');
+        if (Array.isArray(value)) {
+            if (index < 0 || index >= value.length)
+                throw new Error('unavailable');
+            return value[index];
         }
-        if (value === 'null' || value === 'None') {
-            parsedValues.set(name, null);
-            return null;
+        if (isDebugExpressionIndexedValue(value)) {
+            if (value.length != null && (index < 0 || index >= value.length)) {
+                throw new Error('unavailable');
+            }
+            return value.get(index);
         }
-        const numeric = Number(value);
-        if (!Number.isNaN(numeric)) {
-            parsedValues.set(name, numeric);
-            return numeric;
+        throw new Error('unsupported index access');
+    };
+    const readMemberValue = (value, name) => {
+        if (Array.isArray(value) || isDebugExpressionIndexedValue(value) || !value) {
+            throw new Error('unsupported member access');
         }
-        if (value.startsWith('[') ||
-            value.startsWith('(') ||
-            value.startsWith("'") ||
-            value.startsWith('"')) {
-            const parsed = parsePreviewValue(value).value;
-            parsedValues.set(name, parsed);
-            return parsed;
+        if (isDebugExpressionObjectValue(value)) {
+            if (!value.has(name))
+                throw new Error('unavailable');
+            return value.get(name);
         }
-        throw new Error(`unsupported value for ${name}`);
+        if (typeof value !== 'object' || !Object.hasOwn(value, name))
+            throw new Error('unavailable');
+        return value[name];
     };
+    let cursor = 0;
     const parsePrimary = () => {
         const token = tokens[cursor];
         if (!token)
@@ -235,20 +385,26 @@ export function evaluateDebugExpression(expression, variables) {
             let resolved = resolveIdentifierValue(token.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];
-                if (!closing || closing.type !== 'bracket' || closing.value !== ']')
-                    throw new Error('missing closing bracket');
-                cursor += 1;
-                if (!Array.isArray(resolved) || !Number.isInteger(index))
-                    throw new Error('unsupported index access');
-                const next = resolved[index];
-                if (next == null)
-                    throw new Error('unavailable');
-                resolved = next;
+                if (bracket?.type === 'bracket' && bracket.value === '[') {
+                    cursor += 1;
+                    const index = Number(parseOr());
+                    const closing = tokens[cursor];
+                    if (!closing || closing.type !== 'bracket' || closing.value !== ']')
+                        throw new Error('missing closing bracket');
+                    cursor += 1;
+                    resolved = readIndexedValue(resolved, index);
+                    continue;
+                }
+                if (bracket?.type === 'dot') {
+                    cursor += 1;
+                    const property = tokens[cursor];
+                    if (!property || property.type !== 'identifier')
+                        throw new Error('missing property name');
+                    cursor += 1;
+                    resolved = readMemberValue(resolved, property.value);
+                    continue;
+                }
+                break;
             }
             return resolved;
         }
@@ -283,8 +439,9 @@ export function evaluateDebugExpression(expression, variables) {
         let left = parseUnary();
         while (true) {
             const operator = tokens[cursor];
-            if (operator?.type !== 'operator' || !['*', '/', '%'].includes(operator.value))
+            if (operator?.type !== 'operator' || !['*', '/', '%'].includes(operator.value)) {
                 return left;
+            }
             cursor += 1;
             const right = parseUnary();
             if (operator.value === '*')
@@ -319,8 +476,9 @@ export function evaluateDebugExpression(expression, variables) {
         let left = parseAdd();
         while (true) {
             const operator = tokens[cursor];
-            if (operator?.type !== 'operator' || !['<', '<=', '>', '>='].includes(operator.value))
+            if (operator?.type !== 'operator' || !['<', '<=', '>', '>='].includes(operator.value)) {
                 return left;
+            }
             cursor += 1;
             const right = parseAdd();
             const leftValue = typeof left === 'string' && typeof right === 'string' ? left : Number(left);
@@ -374,5 +532,16 @@ export function evaluateDebugExpression(expression, variables) {
     const result = parseOr();
     if (cursor !== tokens.length)
         throw new Error('unexpected trailing tokens');
-    return `${result}`;
+    return formatDebugExpressionValue(result);
+};
+export function evaluateDebugExpression(expression, variables) {
+    const values = new Map();
+    for (const variable of variables)
+        values.set(variable.name, variable.value);
+    return evaluateDebugExpressionWithResolver(expression, (name) => {
+        const value = values.get(name);
+        if (value == null || value === '?')
+            throw new Error('unavailable');
+        return parseStoredDebugValue(value);
+    });
 }

package/dist/debug/index.d.ts

@@ -1,5 +1,8 @@
 export { evaluateDebugExpression } from './expression';
 export { selectInlineDebugLocals } from './locals';
 export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter } from './language';
-export { MonacoDebugView } from './editor';
+export { createDebugSessionController } from './controller.svelte';
+export { MonacoDebugView, attachMonacoDebugActions } from './editor';
 export type { DebugLanguageAdapter } from './language';
+export type { DebugSessionController, DebugSessionControllerOptions, DebugWatchValue } from './controller.svelte';
+export type { MonacoDebugActionsOptions } from './editor';

package/dist/debug/index.js

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

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 import Terminal from './terminal';
-export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
-import playground from './playground';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, createDebugSessionController, MonacoDebugView, attachMonacoDebugActions, selectInlineDebugLocals } from './debug';
+import playground, { createPlaygroundBinding } from './playground';
 export default Terminal;
-export { playground };
+export { createPlaygroundBinding, playground };
 export type { DebugCommand, DebugFrame, DebugSessionEvent, DebugVariable, SandboxExecutionOptions, TerminalControl } from './terminal';
 export type { CompilerDiagnostic } from './playground/options';
+export type { DebugSessionController, DebugSessionControllerOptions, DebugWatchValue, MonacoDebugActionsOptions } from './debug';
+export type { PlaygroundRuntimeAssets, RuntimeAssetConfig, RuntimeAssetLoadRequest, RuntimeAssetLoader, RuntimeAssetLoaderResult } from './playground/assets';
+export type { BoundSandbox, PlaygroundBinding, PlaygroundTerminalProps, SandboxProgress, SandboxRuntimeAssets } from './playground/sandbox';
 export type { DebugLanguageAdapter } from './debug';

package/dist/index.js

@@ -1,5 +1,5 @@
 import Terminal from './terminal';
-export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, MonacoDebugView, selectInlineDebugLocals } from './debug';
-import playground from './playground';
+export { cppDebugLanguageAdapter, pythonDebugLanguageAdapter, evaluateDebugExpression, createDebugSessionController, MonacoDebugView, attachMonacoDebugActions, selectInlineDebugLocals } from './debug';
+import playground, { createPlaygroundBinding } from './playground';
 export default Terminal;
-export { playground };
+export { createPlaygroundBinding, 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 {};