wasm-idle 0.3.1 → 0.4.0

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,8 @@
 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 { 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/clang.d.ts

@@ -9,20 +9,23 @@ declare class Clang implements Sandbox {
     buffer: SharedArrayBuffer;
     debugBuffer: SharedArrayBuffer;
     interruptBuffer: SharedArrayBuffer;
-    internalBuffer: string[];
+    pendingInput: string[];
     begin: number;
     elapse: number;
     uid: number;
     log: boolean;
+    waitingForInput: boolean;
+    pendingEof: boolean;
     exit: boolean;
     load(path: string, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
     write(input: string): void;
-    _write(input: string): void;
     eof(): void;
+    private flushPendingInput;
     run(code: string, prepare: boolean, log?: boolean, prog?: Writable<number> | {
         set?: (value: number) => void;
     }, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
     debugCommand(command: DebugCommand): void;
+    kill(): void;
     terminate(): void;
     clear(): Promise<void>;
 }

package/dist/playground/clang.js

@@ -1,3 +1,4 @@
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
 class Clang {
     ts = Date.now();
     output = null;
@@ -6,16 +7,20 @@ class Clang {
     buffer = new SharedArrayBuffer(1024);
     debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 4);
     interruptBuffer = new SharedArrayBuffer(1);
-    internalBuffer = [];
+    pendingInput = [];
     begin = 0;
     elapse = 0;
     uid = 0;
     log = true;
+    waitingForInput = false;
+    pendingEof = false;
     exit = true;
     load(path, code = '', log = true, args = [], _options = {}) {
         return new Promise(async (resolve) => {
             this.log = log;
-            this.internalBuffer = [];
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
             if (!this.worker) {
                 this.worker = new (await import('./worker/clang?worker')).default();
                 this.worker.onmessage = () => resolve();
@@ -28,19 +33,27 @@ class Clang {
         });
     }
     write(input) {
-        this.internalBuffer.push(input);
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.flushPendingInput();
     }
-    _write(input) {
-        let strInfo = input, padding = 4 - (strInfo.length % 4);
-        while (strInfo.length % 4 !== 3)
-            strInfo += ' ';
-        strInfo += padding;
-        const buffer = new Int32Array(this.buffer);
-        const enc = new TextEncoder();
-        const data = enc.encode(strInfo);
-        buffer.set(new Int32Array(data.buffer.slice(data.byteOffset), 0));
+    eof() {
+        this.pendingEof = true;
+        this.flushPendingInput();
+    }
+    flushPendingInput() {
+        if (!this.waitingForInput)
+            return;
+        if (flushQueuedStdin(this.pendingInput, this.buffer)) {
+            this.waitingForInput = false;
+            return;
+        }
+        if (this.pendingEof) {
+            flushBufferedEof(this.buffer);
+            this.pendingEof = false;
+            this.waitingForInput = false;
+        }
     }
-    eof() { }
     run(code, prepare, log = this.log, prog, args = [], options = {}) {
         this.exit = false;
         return new Promise(async (resolve, reject) => {
@@ -53,8 +66,10 @@ class Clang {
                 if (_uid !== this.uid)
                     return (this.worker.onmessage = null);
                 const { id, output, results, log, error, buffer, progress, debugEvent } = event.data;
-                if (buffer && this.internalBuffer.length)
-                    this._write(this.internalBuffer.splice(0, 1)[0]);
+                if (buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
                 if (output)
                     this.output(output);
                 if (debugEvent)
@@ -62,6 +77,8 @@ class Clang {
                 if (results) {
                     this.elapse = Date.now() - this.begin;
                     this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
                     this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
@@ -69,6 +86,10 @@ class Clang {
                     console.log(log);
                 if (error) {
                     this.elapse = Date.now() - this.begin;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.exit = true;
+                    this.ondebug?.({ type: 'stop' });
                     reject(error);
                 }
                 if (progress)
@@ -99,7 +120,11 @@ class Clang {
         Atomics.notify(control, 0);
         this.ondebug?.({ type: 'resume', command });
     }
+    kill() {
+        this.terminate();
+    }
     terminate() {
+        this.pendingEof = false;
         new Uint8Array(this.interruptBuffer)[0] = 2;
         const control = new Int32Array(this.debugBuffer);
         Atomics.add(control, 0, 1);
@@ -107,11 +132,12 @@ class Clang {
     }
     async clear() {
         this.terminate();
-        this.internalBuffer = [];
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
         if (this.worker)
             this.worker.onmessage = null;
-        const buffer = new Int32Array(this.buffer);
-        buffer.fill(0);
+        resetBufferedStdin(this.buffer);
         const debugBuffer = new Int32Array(this.debugBuffer);
         debugBuffer.fill(0);
         await new Promise((resolve) => setTimeout(resolve, 200));

package/dist/playground/index.d.ts

@@ -1,5 +1,6 @@
 import Clang from './clang';
+import Java from './java';
 import Python from './python';
 import type { Sandbox } from './sandbox';
 export declare const supportedLanguages: string[];
-export default function load(language: string): Promise<Sandbox | Clang | Python>;
+export default function load(language: string): Promise<Sandbox | Clang | Java | Python>;

package/dist/playground/index.js

@@ -1,7 +1,8 @@
 import Clang from './clang';
+import Java from './java';
 import Python from './python';
 const sandboxCache = {};
-export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP'];
+export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP', 'JAVA'];
 export default async function load(language) {
     if (sandboxCache[language])
         return sandboxCache[language];
@@ -16,6 +17,9 @@ export default async function load(language) {
         case 'CPP':
             sandbox = new Clang();
             break;
+        case 'JAVA':
+            sandbox = new Java();
+            break;
         default:
             throw new Error(`Unsupported language: ${language}`);
     }
@@ -31,6 +35,8 @@ export default async function load(language) {
             sandboxCache['C'] = sandbox;
         if (language === 'CPP')
             sandboxCache['CPP'] = sandbox;
+        if (language === 'JAVA')
+            sandboxCache['JAVA'] = sandbox;
     }
     return sandbox;
 }

package/dist/playground/java.d.ts

@@ -0,0 +1,28 @@
+import type { CompilerDiagnostic, SandboxExecutionOptions } from './options';
+import type { Sandbox } from './sandbox';
+declare class Java implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: SharedArrayBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    baseUrl: string;
+    activeReject: ((reason: string) => void) | null;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    load(path: string, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions): Promise<void>;
+    write(input: string): void;
+    eof(): void;
+    private flushPendingInput;
+    run(code: string, prepare: boolean, _log?: boolean, _prog?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
+    kill(): void;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default Java;

package/dist/playground/java.js

@@ -0,0 +1,135 @@
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { resolveTeaVmBaseUrl } from './teavmConfig';
+class Java {
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    baseUrl = '';
+    activeReject = null;
+    oncompilerdiagnostic;
+    waitingForInput = false;
+    pendingEof = false;
+    load(path, _code = '', _log = true, _args = [], _options = {}) {
+        return new Promise(async (resolve, reject) => {
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            this.baseUrl = resolveTeaVmBaseUrl(path, typeof window !== 'undefined' ? window.location.href : '');
+            if (!this.worker) {
+                this.worker = new (await import('./worker/java?worker')).default();
+                this.worker.onmessage = (event) => {
+                    if (event.data?.load)
+                        resolve();
+                    if (event.data?.error)
+                        reject(event.data.error);
+                };
+                this.worker.postMessage({ load: true, baseUrl: this.baseUrl });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    write(input) {
+        this.pendingInput.push(input);
+        this.pendingEof = false;
+        this.flushPendingInput();
+    }
+    eof() {
+        this.pendingEof = true;
+        this.flushPendingInput();
+    }
+    flushPendingInput() {
+        if (!this.waitingForInput)
+            return;
+        if (flushQueuedStdin(this.pendingInput, this.buffer)) {
+            this.waitingForInput = false;
+            return;
+        }
+        if (this.pendingEof) {
+            flushBufferedEof(this.buffer);
+            this.pendingEof = false;
+            this.waitingForInput = false;
+        }
+    }
+    run(code, prepare, _log = true, _prog, args = [], options = {}) {
+        this.exit = false;
+        return new Promise((resolve, reject) => {
+            if (!this.worker)
+                return reject('Worker not loaded');
+            const _uid = ++this.uid;
+            this.activeReject = reject;
+            const handler = (event) => {
+                if (!this.worker)
+                    return reject('Worker not loaded');
+                if (_uid !== this.uid)
+                    return (this.worker.onmessage = null);
+                const { output, results, error, buffer, diagnostic } = event.data;
+                if (buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
+                if (output)
+                    this.output(output);
+                if (diagnostic)
+                    this.oncompilerdiagnostic?.(diagnostic);
+                if (results) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.activeReject = null;
+                    resolve(results);
+                }
+                if (error) {
+                    this.elapse = Date.now() - this.begin;
+                    this.exit = true;
+                    this.waitingForInput = false;
+                    this.pendingEof = false;
+                    this.activeReject = null;
+                    reject(error);
+                }
+            };
+            this.worker.onmessage = handler;
+            this.begin = Date.now();
+            this.worker.postMessage({
+                code,
+                prepare,
+                buffer: this.buffer,
+                args,
+                stdin: options.stdin || '',
+                baseUrl: this.baseUrl
+            });
+        });
+    }
+    kill() {
+        this.terminate();
+    }
+    terminate() {
+        this.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        this.uid += 1;
+        this.worker?.terminate?.();
+        delete this.worker;
+        this.exit = true;
+    }
+    async clear() {
+        this.pendingInput = [];
+        this.waitingForInput = false;
+        this.pendingEof = false;
+        if (this.worker)
+            this.worker.onmessage = null;
+        resetBufferedStdin(this.buffer);
+        if (!this.exit) {
+            this.terminate();
+        }
+    }
+}
+export default Java;

package/dist/playground/javaStdin.d.ts

@@ -0,0 +1,8 @@
+export interface PreparedJavaStdinInjection {
+    usesStdin: boolean;
+    stdinCacheKey: string;
+    transformedCode: string;
+    helperSourcePath: string | null;
+    helperSource: string | null;
+}
+export declare const prepareJavaStdinInjection: (code: string, stdin: string) => PreparedJavaStdinInjection;