wasm-idle 0.4.1 → 0.6.0

package/dist/lsp/registry.d.ts

@@ -0,0 +1,2 @@
+import type { EditorLanguageServerRuntimeOptions, EditorLanguageServerHandle } from './types';
+export declare function getEditorLanguageServer(language: string, options?: string | EditorLanguageServerRuntimeOptions): Promise<EditorLanguageServerHandle | null>;

package/dist/lsp/registry.js

@@ -0,0 +1,12 @@
+import { getCppLanguageServer } from './cpp/server';
+import { getPythonLanguageServer } from './python/server';
+export async function getEditorLanguageServer(language, options) {
+    const normalized = language.toLowerCase();
+    if (normalized === 'c' || normalized === 'cpp') {
+        return getCppLanguageServer(options);
+    }
+    if (normalized === 'python') {
+        return getPythonLanguageServer(options);
+    }
+    return null;
+}

package/dist/lsp/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { EditorLanguageServerRuntimeOptions } from './types';
+export declare function resolveCppLanguageServerBaseUrl(options: string | EditorLanguageServerRuntimeOptions | undefined, currentUrl?: string): string;
+export declare function resolvePythonLanguageServerBaseUrl(options: string | EditorLanguageServerRuntimeOptions | undefined, currentUrl?: string): string;

package/dist/lsp/runtime.js

@@ -0,0 +1,30 @@
+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 resolveRuntimeRootBaseUrl = (rootUrl, suffix, currentUrl = '') => normalizeBaseUrl(`${normalizeRootUrl(rootUrl) || ''}${suffix}`, currentUrl);
+export function resolveCppLanguageServerBaseUrl(options, currentUrl = '') {
+    if (typeof options === 'string') {
+        return resolveRuntimeRootBaseUrl(options, '/clangd/', currentUrl);
+    }
+    if (options?.cpp?.baseUrl) {
+        return normalizeBaseUrl(options.cpp.baseUrl, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveRuntimeRootBaseUrl(options.rootUrl, '/clangd/', currentUrl);
+    }
+    return normalizeBaseUrl('/clangd/', currentUrl);
+}
+export function resolvePythonLanguageServerBaseUrl(options, currentUrl = '') {
+    if (typeof options === 'string') {
+        return resolveRuntimeRootBaseUrl(options, '/pyodide/', currentUrl);
+    }
+    if (options?.python?.baseUrl) {
+        return normalizeBaseUrl(options.python.baseUrl, currentUrl);
+    }
+    if (options?.rootUrl) {
+        return resolveRuntimeRootBaseUrl(options.rootUrl, '/pyodide/', currentUrl);
+    }
+    return normalizeBaseUrl('/pyodide/', currentUrl);
+}

package/dist/lsp/types.d.ts

@@ -0,0 +1,15 @@
+import type { MessageTransports } from '@hancomac/monaco-languageclient';
+export interface EditorLanguageServerHandle {
+    transport: string | MessageTransports;
+    syncFile?: (path: string) => void;
+    dispose: () => void;
+}
+export interface EditorLanguageServerRuntimeOptions {
+    rootUrl?: string;
+    cpp?: {
+        baseUrl?: string;
+    };
+    python?: {
+        baseUrl?: string;
+    };
+}

package/dist/lsp/types.js

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

package/dist/playground/assets.d.ts

@@ -17,10 +17,14 @@ export interface RuntimeAssetConfig {
     baseUrl?: string;
     loader?: RuntimeAssetLoader;
 }
+export interface RustRuntimeAssetConfig {
+    compilerUrl?: string;
+}
 export interface PlaygroundRuntimeAssets {
     rootUrl?: string;
     python?: RuntimeAssetConfig;
     java?: RuntimeAssetConfig;
+    rust?: RustRuntimeAssetConfig;
 }
 export interface ResolvedRuntimeAssetConfig {
     baseUrl: string;
@@ -30,3 +34,4 @@ export interface ResolvedRuntimeAssetConfig {
 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;
+export declare function resolveRustCompilerUrl(options: string | PlaygroundRuntimeAssets | undefined, currentUrl?: string): any;

package/dist/playground/assets.js

@@ -1,3 +1,4 @@
+import { env as publicEnv } from '$env/dynamic/public';
 import { normalizeTeaVmBaseUrl, resolveTeaVmBaseUrl } from './teavmConfig';
 export const PYTHON_RUNTIME_LOAD_ASSETS = [
     'pyodide.asm.js',
@@ -95,3 +96,10 @@ export function resolveRuntimeAssetConfig(runtime, options, currentUrl = '') {
         ? resolvePythonRuntimeAssetConfig(options, currentUrl)
         : resolveJavaRuntimeAssetConfig(options, currentUrl);
 }
+export function resolveRustCompilerUrl(options, currentUrl = '') {
+    const configuredCompilerUrl = (typeof options === 'object' && options?.rust?.compilerUrl) ||
+        (publicEnv.PUBLIC_WASM_RUST_COMPILER_URL || '').trim();
+    if (!configuredCompilerUrl)
+        return '';
+    return currentUrl ? new URL(configuredCompilerUrl, currentUrl).href : configuredCompilerUrl;
+}

package/dist/playground/clang.d.ts

@@ -10,6 +10,8 @@ declare class Clang implements Sandbox {
     worker?: Worker;
     buffer: SharedArrayBuffer;
     debugBuffer: SharedArrayBuffer;
+    watchBuffer: SharedArrayBuffer;
+    watchResultBuffer: SharedArrayBuffer;
     interruptBuffer: SharedArrayBuffer;
     pendingInput: string[];
     begin: number;
@@ -19,6 +21,7 @@ declare class Clang implements Sandbox {
     waitingForInput: boolean;
     pendingEof: boolean;
     exit: boolean;
+    activeReject: ((reason?: string) => void) | null;
     constructor(language: 'C' | 'CPP');
     load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], _options?: SandboxExecutionOptions, _progress?: {
         set?: (value: number) => void;
@@ -30,6 +33,8 @@ declare class Clang implements Sandbox {
         set?: (value: number) => void;
     }, args?: string[], options?: SandboxExecutionOptions): Promise<boolean | string>;
     debugCommand(command: DebugCommand): void;
+    setBreakpoints(lines: number[]): void;
+    debugEvaluate(expression: string): Promise<string>;
     kill(): void;
     terminate(): void;
     clear(): Promise<void>;

package/dist/playground/clang.js

@@ -1,5 +1,6 @@
 import { resolveSandboxExecutionArgs } from './options';
-import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+import { bufferedSequence, flushBufferedEof, flushQueuedStdin, resetBufferedStdin, waitForBufferedSequenceChange } from './stdinBuffer';
+const debugBreakpointBufferInts = 1028;
 class Clang {
     language;
     ts = Date.now();
@@ -7,7 +8,9 @@ class Clang {
     ondebug;
     worker = null;
     buffer = new SharedArrayBuffer(1024);
-    debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * 4);
+    debugBuffer = new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * debugBreakpointBufferInts);
+    watchBuffer = new SharedArrayBuffer(1024);
+    watchResultBuffer = new SharedArrayBuffer(1024);
     interruptBuffer = new SharedArrayBuffer(1);
     pendingInput = [];
     begin = 0;
@@ -17,6 +20,7 @@ class Clang {
     waitingForInput = false;
     pendingEof = false;
     exit = true;
+    activeReject = null;
     constructor(language) {
         this.language = language;
     }
@@ -65,7 +69,9 @@ class Clang {
         return new Promise(async (resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
+            this.activeReject = reject;
             const { compileArgs, programArgs } = resolveSandboxExecutionArgs(this.language, args, options);
+            this.setBreakpoints(options.debug ? [...(options.breakpoints || [])] : []);
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
                 if (!this.worker)
@@ -86,6 +92,7 @@ class Clang {
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
+                    this.activeReject = null;
                     this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
@@ -95,6 +102,7 @@ class Clang {
                     this.elapse = Date.now() - this.begin;
                     this.waitingForInput = false;
                     this.pendingEof = false;
+                    this.activeReject = null;
                     this.exit = true;
                     this.ondebug?.({ type: 'stop' });
                     reject(error);
@@ -110,6 +118,8 @@ class Clang {
                 prepare,
                 buffer: this.buffer,
                 debugBuffer: this.debugBuffer,
+                watchBuffer: this.watchBuffer,
+                watchResultBuffer: this.watchResultBuffer,
                 interrupt: this.interruptBuffer,
                 context: {},
                 log,
@@ -131,15 +141,46 @@ class Clang {
         Atomics.notify(control, 0);
         this.ondebug?.({ type: 'resume', command });
     }
+    setBreakpoints(lines) {
+        const control = new Int32Array(this.debugBuffer);
+        const next = [...new Set(lines.filter((line) => Number.isInteger(line) && line > 0))]
+            .sort((left, right) => left - right)
+            .slice(0, Math.max(0, control.length - 4));
+        for (let index = 4; index < control.length; index += 1) {
+            Atomics.store(control, index, next[index - 4] || 0);
+        }
+        Atomics.store(control, 3, next.length);
+        Atomics.add(control, 2, 1);
+    }
+    async debugEvaluate(expression) {
+        if (!this.worker)
+            throw new Error('Worker not loaded');
+        resetBufferedStdin(this.watchResultBuffer);
+        const previousSequence = bufferedSequence(this.watchResultBuffer);
+        flushQueuedStdin([expression], this.watchBuffer);
+        const control = new Int32Array(this.debugBuffer);
+        Atomics.store(control, 1, 5);
+        Atomics.add(control, 0, 1);
+        Atomics.notify(control, 0);
+        return ((await waitForBufferedSequenceChange(this.watchResultBuffer, previousSequence, 5000)) ??
+            '?');
+    }
     kill() {
         this.terminate();
     }
     terminate() {
+        this.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.waitingForInput = false;
         this.pendingEof = false;
+        this.uid += 1;
         new Uint8Array(this.interruptBuffer)[0] = 2;
         const control = new Int32Array(this.debugBuffer);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
+        this.worker?.terminate?.();
+        delete this.worker;
+        this.exit = true;
     }
     async clear() {
         this.terminate();
@@ -149,6 +190,8 @@ class Clang {
         if (this.worker)
             this.worker.onmessage = null;
         resetBufferedStdin(this.buffer);
+        resetBufferedStdin(this.watchBuffer);
+        resetBufferedStdin(this.watchResultBuffer);
         const debugBuffer = new Int32Array(this.debugBuffer);
         debugBuffer.fill(0);
         await new Promise((resolve) => setTimeout(resolve, 200));

package/dist/playground/index.d.ts

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

package/dist/playground/index.js

@@ -1,11 +1,45 @@
 import Clang from './clang';
 import Java from './java';
 import Python from './python';
+import Rust from './rust';
 const sandboxCache = {};
-export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP', 'JAVA'];
-export default async function load(language) {
-    if (sandboxCache[language])
-        return sandboxCache[language];
+export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP', 'JAVA', 'RUST'];
+function bindRuntimeAssets(sandbox, runtimeAssets) {
+    return new Proxy(sandbox, {
+        get(target, prop, receiver) {
+            if (prop === 'runtimeAssets')
+                return runtimeAssets;
+            if (prop === 'load') {
+                return (code = '', log = true, args = [], options = {}, progress) => target.load(runtimeAssets, code, log, args, options, progress);
+            }
+            const value = Reflect.get(target, prop, receiver);
+            return typeof value === 'function' ? value.bind(target) : value;
+        },
+        set(target, prop, value, receiver) {
+            return Reflect.set(target, prop, value, receiver);
+        }
+    });
+}
+export function createPlaygroundBinding(runtimeAssets) {
+    const binding = {
+        runtimeAssets,
+        terminalProps: {},
+        async load(language) {
+            return bindRuntimeAssets(await playground(language), runtimeAssets);
+        }
+    };
+    binding.terminalProps = {
+        playground: binding,
+        runtimeAssets
+    };
+    return binding;
+}
+async function playground(language, runtimeAssets) {
+    if (sandboxCache[language]) {
+        return runtimeAssets
+            ? bindRuntimeAssets(sandboxCache[language], runtimeAssets)
+            : sandboxCache[language];
+    }
     let sandbox;
     switch (language) {
         case 'PYTHON3':
@@ -22,6 +56,9 @@ export default async function load(language) {
         case 'JAVA':
             sandbox = new Java();
             break;
+        case 'RUST':
+            sandbox = new Rust();
+            break;
         default:
             throw new Error(`Unsupported language: ${language}`);
     }
@@ -39,6 +76,9 @@ export default async function load(language) {
             sandboxCache['CPP'] = sandbox;
         if (language === 'JAVA')
             sandboxCache['JAVA'] = sandbox;
+        if (language === 'RUST')
+            sandboxCache['RUST'] = sandbox;
     }
-    return sandbox;
+    return runtimeAssets ? bindRuntimeAssets(sandbox, runtimeAssets) : sandbox;
 }
+export default playground;

package/dist/playground/options.d.ts

@@ -13,8 +13,14 @@ export interface CompilerDiagnostic {
     severity: CompilerDiagnosticSeverity;
     message: string;
 }
+export type RustTargetTriple = 'wasm32-wasip1' | 'wasm32-wasip2' | 'wasm32-wasip3';
 export type DebugVariableKind = 'number' | 'bool' | 'array' | 'text';
 export type DebugArrayElementKind = 'int' | 'float' | 'double' | 'bool' | 'char';
+export interface DebugStructFieldMetadata {
+    name: string;
+    kind: DebugArrayElementKind;
+    offset: number;
+}
 export interface DebugVariableMetadata {
     slot: number;
     name: string;
@@ -24,6 +30,8 @@ export interface DebugVariableMetadata {
     elementKind?: DebugArrayElementKind;
     length?: number;
     dimensions?: number[];
+    structFields?: DebugStructFieldMetadata[];
+    structSize?: number;
 }
 export interface DebugFrame {
     functionName: string;
@@ -50,6 +58,7 @@ export interface SandboxExecutionOptions {
     programArgs?: string[];
     cppVersion?: string;
     cVersion?: string;
+    rustTargetTriple?: RustTargetTriple;
 }
 export interface ResolvedSandboxExecutionArgs {
     compileArgs: string[];

package/dist/playground/python.d.ts

@@ -25,6 +25,7 @@ declare class Python implements Sandbox {
     pendingEof: boolean;
     exit: boolean;
     assetBridge: WorkerAssetBridge | null;
+    activeReject: ((reason?: string) => void) | null;
     load(runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
         set?: (value: number) => void;
     } | import('svelte/store').Writable<number>): Promise<void>;

package/dist/playground/python.js

@@ -20,6 +20,7 @@ class Python {
     pendingEof = false;
     exit = true;
     assetBridge = null;
+    activeReject = null;
     load(runtimeAssets = '', code = '', log = true, _args = [], _options = {}, progress) {
         return new Promise(async (resolve, reject) => {
             this.pendingInput = [];
@@ -89,6 +90,7 @@ class Python {
         return new Promise(async (resolve, reject) => {
             if (!this.worker)
                 return reject('Worker not loaded');
+            this.activeReject = reject;
             const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
             const handler = (event) => {
                 if (this.assetBridge?.handleMessage(event))
@@ -113,6 +115,7 @@ class Python {
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
+                    this.activeReject = null;
                     this.ondebug?.({ type: 'stop' });
                     resolve(results);
                 }
@@ -123,6 +126,7 @@ class Python {
                     this.exit = true;
                     this.waitingForInput = false;
                     this.pendingEof = false;
+                    this.activeReject = null;
                     this.ondebug?.({ type: 'stop' });
                     reject(error);
                 }
@@ -169,11 +173,19 @@ class Python {
         this.terminate();
     }
     terminate() {
+        this.activeReject?.('Process terminated');
+        this.activeReject = null;
+        this.waitingForInput = false;
         this.pendingEof = false;
+        this.uid += 1;
         new Uint8Array(this.interruptBuffer)[0] = 2;
         const control = new Int32Array(this.debugBuffer);
         Atomics.add(control, 0, 1);
         Atomics.notify(control, 0);
+        this.worker?.terminate?.();
+        delete this.worker;
+        this.assetBridge = null;
+        this.exit = true;
     }
     async clear() {
         this.terminate();

package/dist/playground/rust.d.ts

@@ -0,0 +1,32 @@
+import { type PlaygroundRuntimeAssets } from './assets';
+import { type CompilerDiagnostic, type SandboxExecutionOptions } from './options';
+import type { Sandbox } from './sandbox';
+declare class Rust implements Sandbox {
+    output: any;
+    worker?: Worker;
+    buffer: SharedArrayBuffer;
+    pendingInput: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    exit: boolean;
+    compilerUrl: string;
+    assetPath: string;
+    activeReject: ((reason: string) => void) | null;
+    oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
+    waitingForInput: boolean;
+    pendingEof: boolean;
+    load(runtimeAssets?: string | PlaygroundRuntimeAssets, _code?: string, _log?: boolean, _args?: string[], _options?: SandboxExecutionOptions, progress?: {
+        set?: (value: number) => void;
+    } | import('svelte/store').Writable<number>): 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 Rust;

package/dist/playground/rust.js

@@ -0,0 +1,175 @@
+import { resolveRustCompilerUrl } from './assets';
+import { resolveSandboxExecutionArgs } from './options';
+import { flushBufferedEof, flushQueuedStdin, resetBufferedStdin } from './stdinBuffer';
+class Rust {
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    pendingInput = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    exit = true;
+    compilerUrl = '';
+    assetPath = '';
+    activeReject = null;
+    oncompilerdiagnostic;
+    waitingForInput = false;
+    pendingEof = false;
+    load(runtimeAssets = '', _code = '', _log = true, _args = [], _options = {}, progress) {
+        return new Promise(async (resolve, reject) => {
+            this.pendingInput = [];
+            this.waitingForInput = false;
+            this.pendingEof = false;
+            const currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+            const nextCompilerUrl = resolveRustCompilerUrl(runtimeAssets, currentUrl);
+            const nextAssetPath = typeof runtimeAssets === 'string'
+                ? runtimeAssets
+                : runtimeAssets?.rootUrl ||
+                    (typeof window !== 'undefined'
+                        ? window.location.pathname.replace(/\/$/, '')
+                        : '');
+            if (!nextCompilerUrl) {
+                return reject('Rust runtime is not configured. Set PUBLIC_WASM_RUST_COMPILER_URL or runtimeAssets.rust.compilerUrl.');
+            }
+            const needsWorkerReset = !this.worker || this.compilerUrl !== nextCompilerUrl || this.assetPath !== nextAssetPath;
+            this.compilerUrl = nextCompilerUrl;
+            this.assetPath = nextAssetPath;
+            if (needsWorkerReset && this.worker) {
+                this.worker.terminate();
+                delete this.worker;
+            }
+            if (!this.worker) {
+                this.worker = new (await import('./worker/rust?worker')).default();
+                this.worker.onerror = (event) => {
+                    const location = event.filename && event.lineno
+                        ? ` (${event.filename}:${event.lineno}:${event.colno})`
+                        : '';
+                    reject(`Rust worker script error: ${event.message || 'unknown error'}${location}`);
+                };
+                this.worker.onmessageerror = () => {
+                    reject('Rust worker message deserialization failed');
+                };
+                this.worker.onmessage = (event) => {
+                    if (event.data?.load) {
+                        progress?.set?.(1);
+                        resolve();
+                    }
+                    if (event.data?.error)
+                        reject(event.data.error);
+                };
+                this.worker.postMessage({
+                    load: true,
+                    compilerUrl: this.compilerUrl,
+                    path: this.assetPath
+                });
+            }
+            else {
+                progress?.set?.(1);
+                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 { programArgs } = resolveSandboxExecutionArgs('RUST', args, options);
+            const targetTriple = options.rustTargetTriple || 'wasm32-wasip1';
+            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, progress } = event.data;
+                if (buffer) {
+                    this.waitingForInput = true;
+                    this.flushPendingInput();
+                }
+                if (progress && typeof progress.percent === 'number') {
+                    _prog?.set?.(Math.max(0, Math.min(progress.percent / 100, 1)));
+                }
+                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: programArgs,
+                targetTriple,
+                log: _log
+            });
+        });
+    }
+    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 Rust;