wasm-idle 0.0.1

package/dist/clang/memory/tar.js

@@ -0,0 +1,59 @@
+import { readStr, readOct } from "../encode";
+import { assert } from "../error";
+function* readEntry(buffer) {
+    const u8 = new Uint8Array(buffer);
+    let offset = 0;
+    const str = (len) => {
+        offset += len;
+        return readStr(u8, offset - len, len);
+    }, oct = (len) => {
+        offset += len;
+        return readOct(u8, offset - len, len);
+    }, align = () => offset = (offset + 511) & ~511;
+    while (offset + 512 <= u8.length) {
+        const entryInit = {
+            filename: str(100),
+            mode: oct(8),
+            owner: oct(8),
+            group: oct(8),
+            size: oct(12),
+            mtime: oct(12),
+            checksum: oct(8),
+            type: str(1),
+            linkname: str(100),
+            ustar: str(8),
+        };
+        if (!entryInit.ustar)
+            return;
+        const entry = {
+            ...entryInit,
+            ownerName: str(32),
+            groupName: str(32),
+            devMajor: str(8),
+            devMinor: str(8),
+            filenamePrefix: str(155),
+        };
+        align();
+        if (entry.type === '0') {
+            entry.contents = u8.subarray(offset, offset + entry.size);
+            offset += entry.size;
+            align();
+        }
+        yield entry;
+    }
+}
+export default function untar(buffer, memfs) {
+    for (const entry of readEntry(buffer)) {
+        switch (entry.type) {
+            case '0': // Regular file.
+                memfs.addFile(entry.filename, entry.contents);
+                break;
+            case '5': // Folder.
+                memfs.addDirectory(entry.filename);
+                break;
+            default:
+                console.log('type', entry.type);
+                assert(false);
+        }
+    }
+}

package/dist/clang/url.d.ts

@@ -0,0 +1,4 @@
+export declare const memfsUrl: (prefix: string) => string;
+export declare const clangUrl: (prefix: string) => string;
+export declare const lldUrl: (prefix: string) => string;
+export declare const rootUrl: (prefix: string) => string;

package/dist/clang/url.js

@@ -0,0 +1,4 @@
+export const memfsUrl = (prefix) => prefix + '/clang/bin/memfs';
+export const clangUrl = (prefix) => prefix + '/clang/bin/clang';
+export const lldUrl = (prefix) => prefix + '/clang/bin/lld';
+export const rootUrl = (prefix) => prefix + '/clang/bin/sysroot.tar';

package/dist/clang/wasm.d.ts

@@ -0,0 +1,3 @@
+export declare function compile(filename: string): Promise<WebAssembly.Module>;
+export declare function getInstance(module: WebAssembly.Module, imports: WebAssembly.Imports): Promise<WebAssembly.Instance>;
+export declare const readBuffer: (name: string) => Promise<ArrayBuffer>;

package/dist/clang/wasm.js

@@ -0,0 +1,16 @@
+const url = (url) => url;
+export async function compile(filename) {
+    // TODO: make compileStreaming work. It needs the server to use the
+    // application/wasm mimetype.
+    if (false && WebAssembly.compileStreaming) {
+        return WebAssembly.compileStreaming(fetch(url(filename)));
+    }
+    else {
+        const response = await fetch(url(filename));
+        return WebAssembly.compile(await response.arrayBuffer());
+    }
+}
+export function getInstance(module, imports) {
+    return WebAssembly.instantiate(module, imports);
+}
+export const readBuffer = (name) => fetch(url(name)).then(r => r.arrayBuffer());

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import Terminal from "./terminal";
+export default Terminal;

package/dist/index.js

@@ -0,0 +1,2 @@
+import Terminal from "./terminal";
+export default Terminal;

package/dist/playground/clang.d.ts

@@ -0,0 +1,20 @@
+import type Sandbox from './sandbox';
+declare class Clang implements Sandbox {
+    ts: number;
+    output: null;
+    worker: Worker;
+    buffer: SharedArrayBuffer;
+    interruptBuffer: SharedArrayBuffer;
+    internalBuffer: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    load(path: string, code?: string, log?: boolean): Promise<void>;
+    write(input: string): void;
+    _write(input: string): void;
+    eof(): void;
+    run(code: string): Promise<string>;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default Clang;

package/dist/playground/clang.js

@@ -0,0 +1,89 @@
+class Clang {
+    ts = Date.now();
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    interruptBuffer = new SharedArrayBuffer(1);
+    internalBuffer = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    load(path, code = '', log = true) {
+        return new Promise(async (resolve) => {
+            this.internalBuffer = [];
+            if (!this.worker) {
+                this.worker = new (await import('./worker/clang?worker')).default();
+                this.worker.onmessage = (event) => {
+                    resolve();
+                };
+                this.worker.postMessage({ load: true, path, log, code });
+            }
+            else
+                resolve();
+        });
+    }
+    write(input) {
+        this.internalBuffer.push(input);
+    }
+    _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() {
+    }
+    run(code) {
+        return new Promise(async (resolve, reject) => {
+            const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
+            const handler = (event) => {
+                if (_uid !== this.uid) {
+                    this.worker.onmessage = null;
+                    return;
+                }
+                const { id, output, results, log, error, buffer } = event.data;
+                if (buffer && this.internalBuffer.length)
+                    this._write(this.internalBuffer.splice(0, 1)[0]);
+                if (output)
+                    this.output(output);
+                if (results) {
+                    this.elapse = Date.now() - this.begin;
+                    resolve(results);
+                }
+                if (log)
+                    console.log(log);
+                if (error) {
+                    this.elapse = Date.now() - this.begin;
+                    reject(error);
+                }
+            };
+            interrupt[0] = 0;
+            this.worker.onmessage = handler;
+            this.begin = Date.now();
+            this.worker.postMessage({
+                code,
+                buffer: this.buffer,
+                interrupt: this.interruptBuffer,
+                context: {}
+            });
+        });
+    }
+    terminate() {
+        const interrupt = new Uint8Array(this.interruptBuffer);
+        interrupt[0] = 2;
+    }
+    async clear() {
+        this.terminate();
+        this.internalBuffer = [];
+        if (this.worker)
+            this.worker.onmessage = null;
+        const buffer = new Int32Array(this.buffer);
+        buffer.fill(0);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+}
+export default Clang;

package/dist/playground/index.d.ts

@@ -0,0 +1,3 @@
+import type Sandbox from './sandbox';
+export declare const supportedLanguages: string[];
+export declare function load(language: string): Promise<Sandbox | undefined>;

package/dist/playground/index.js

@@ -0,0 +1,33 @@
+import Clang from './clang';
+import Python from './python';
+const sandboxCache = {};
+export const supportedLanguages = ['PYTHON3', 'PYPY3', 'C', 'CPP'];
+export async function load(language) {
+    if (sandboxCache[language])
+        return sandboxCache[language];
+    let sandbox;
+    switch (language) {
+        case 'PYTHON3':
+        case 'PYTHON':
+        case 'PYPY3':
+            sandbox = new Python();
+            break;
+        case 'C':
+        case 'CPP':
+            sandbox = new Clang();
+    }
+    sandboxCache[language] = sandbox;
+    if (sandbox) {
+        if (language === 'PYTHON3')
+            sandboxCache['PYPY3'] = sandboxCache['PYTHON'] = sandbox;
+        if (language === 'PYTHON')
+            sandboxCache['PYTHON3'] = sandboxCache['PYPY3'] = sandbox;
+        if (language === 'PYPY3')
+            sandboxCache['PYTHON3'] = sandboxCache['PYTHON'] = sandbox;
+        if (language === 'C')
+            sandboxCache['C'] = sandbox;
+        if (language === 'CPP')
+            sandboxCache['CPP'] = sandbox;
+    }
+    return sandbox;
+}

package/dist/playground/python.d.ts

@@ -0,0 +1,20 @@
+import type Sandbox from './sandbox';
+declare class Python implements Sandbox {
+    ts: number;
+    output: null;
+    worker: Worker;
+    buffer: SharedArrayBuffer;
+    interruptBuffer: SharedArrayBuffer;
+    internalBuffer: string[];
+    begin: number;
+    elapse: number;
+    uid: number;
+    load(path: string, code?: string, log?: boolean): Promise<void>;
+    write(input: string): void;
+    _write(input: string): void;
+    eof(): void;
+    run(code: string): Promise<string>;
+    terminate(): void;
+    clear(): Promise<void>;
+}
+export default Python;

package/dist/playground/python.js

@@ -0,0 +1,88 @@
+class Python {
+    ts = Date.now();
+    output = null;
+    worker = null;
+    buffer = new SharedArrayBuffer(1024);
+    interruptBuffer = new SharedArrayBuffer(1);
+    internalBuffer = [];
+    begin = 0;
+    elapse = 0;
+    uid = 0;
+    load(path, code = '', log = true) {
+        return new Promise(async (resolve) => {
+            this.internalBuffer = [];
+            if (!this.worker) {
+                this.worker = new (await import('./worker/python?worker')).default();
+                this.worker.onmessage = (event) => {
+                    resolve();
+                };
+                this.worker.postMessage({ load: true, path, log, code });
+            }
+            else
+                resolve();
+        });
+    }
+    write(input) {
+        this.internalBuffer.push(input);
+    }
+    _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() {
+    }
+    run(code) {
+        return new Promise(async (resolve, reject) => {
+            const interrupt = new Uint8Array(this.interruptBuffer), _uid = ++this.uid;
+            const handler = (event) => {
+                if (_uid !== this.uid) {
+                    this.worker.onmessage = null;
+                    return;
+                }
+                const { id, output, results, log, error, buffer } = event.data;
+                if (buffer && this.internalBuffer.length)
+                    this._write(this.internalBuffer.splice(0, 1)[0]);
+                if (output)
+                    this.output(output);
+                if (results) {
+                    this.elapse = Date.now() - this.begin;
+                    resolve(results);
+                }
+                if (log)
+                    console.log(log);
+                if (error) {
+                    this.elapse = Date.now() - this.begin;
+                    reject(error);
+                }
+            };
+            interrupt[0] = 0;
+            this.worker.onmessage = handler;
+            this.begin = Date.now();
+            this.worker.postMessage({
+                code,
+                buffer: this.buffer,
+                interrupt: this.interruptBuffer,
+                context: {}
+            });
+        });
+    }
+    terminate() {
+        new Uint8Array(this.interruptBuffer)[0] = 2;
+    }
+    async clear() {
+        this.terminate();
+        this.internalBuffer = [];
+        if (this.worker)
+            this.worker.onmessage = null;
+        const buffer = new Int32Array(this.buffer);
+        buffer.fill(0);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+}
+export default Python;

package/dist/playground/sandbox.d.ts

@@ -0,0 +1,9 @@
+interface sandbox {
+    constructor: any;
+    eof: () => void;
+    load: (path: string, code?: string, log?: boolean) => Promise<void>;
+    run: (code: string) => Promise<string>;
+    terminate: () => void;
+    clear: () => Promise<void>;
+}
+export default sandbox;

package/dist/playground/sandbox.js

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

package/dist/playground/worker/clang.d.ts

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

package/dist/playground/worker/clang.js

@@ -0,0 +1,46 @@
+let stdinBufferClang, interruptBufferClang, clang;
+async function loadClang(path, log) {
+    const { default: Clang } = await import('../../clang');
+    clang = new Clang({
+        stdout: (output) => postMessage({ output }),
+        stdin: () => {
+            while (true) {
+                postMessage({ buffer: true });
+                const res = Atomics.wait(stdinBufferClang, 0, 0, 100);
+                if (res === 'not-equal') {
+                    try {
+                        const cpy = new Int32Array(stdinBufferClang.byteLength);
+                        cpy.set(stdinBufferClang);
+                        stdinBufferClang.fill(0);
+                        const dec = new TextDecoder();
+                        const strInfo = dec.decode(cpy).replace(/\x00/g, ''), padding = parseInt(strInfo.slice(-1));
+                        return strInfo.slice(0, -padding);
+                    }
+                    catch (e) {
+                        postMessage({ log: { e } });
+                    }
+                }
+            }
+        },
+        log, path,
+    });
+}
+self.onmessage = async (event) => {
+    const { code, buffer, load, interrupt, log, path } = event.data;
+    if (load) {
+        await loadClang(path, log);
+        postMessage({ load: true });
+    }
+    else if (code) {
+        stdinBufferClang = new Int32Array(buffer);
+        interruptBufferClang = new Uint8Array(interrupt);
+        try {
+            await clang.compileLinkRun(code);
+            self.postMessage({ results: true });
+        }
+        catch (error) {
+            self.postMessage({ error: error.message });
+        }
+    }
+};
+export {};

package/dist/playground/worker/python.d.ts

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

package/dist/playground/worker/python.js

@@ -0,0 +1,77 @@
+let stdinBufferPyodide, interruptBufferPyodide, pyodide;
+async function loadPyodideAndPackages(path) {
+    const { loadPyodide } = await import('pyodide');
+    pyodide = await loadPyodide({ indexURL: path + '/pyodide' });
+}
+self.onmessage = async (event) => {
+    const { code, buffer, load, interrupt, path } = event.data;
+    if (load) {
+        await loadPyodideAndPackages(path);
+        await pyodide.loadPackagesFromImports(code);
+        postMessage({ load: true });
+    }
+    else if (code) {
+        const ts = Date.now();
+        stdinBufferPyodide = new Int32Array(buffer);
+        interruptBufferPyodide = new Uint8Array(interrupt);
+        pyodide.setInterruptBuffer(interruptBufferPyodide);
+        self['__pyodide__input_' + ts] = (output) => {
+            if (output)
+                postMessage({ output });
+            while (true) {
+                postMessage({ buffer: true });
+                const res = Atomics.wait(stdinBufferPyodide, 0, 0, 100);
+                if (res === 'not-equal') {
+                    try {
+                        const cpy = new Int32Array(stdinBufferPyodide.byteLength);
+                        cpy.set(stdinBufferPyodide);
+                        stdinBufferPyodide.fill(0);
+                        const dec = new TextDecoder();
+                        const strInfo = dec.decode(cpy).replace(/\x00/g, ''), padding = parseInt(strInfo.slice(-1));
+                        return strInfo.slice(0, -padding);
+                    }
+                    catch (e) {
+                        postMessage({ log: { e } });
+                    }
+                }
+            }
+        };
+        self['__pyodide__output_' + ts] = (...data) => {
+            let sep = ' ', end = '\r\n', output = '', clear = [];
+            for (const i of data) {
+                if (i.end !== undefined)
+                    end = i.end.toString();
+                else if (i.sep !== undefined)
+                    sep = i.sep.toString();
+                else
+                    clear.push(i);
+            }
+            for (let i = 0; i < clear.length; i++) {
+                if (typeof clear[i] === 'string' || (!clear[i].end && !clear[i].sep)) {
+                    output += clear[i].toString();
+                    if (i < clear.length - 1)
+                        output += sep;
+                }
+            }
+            output += end;
+            postMessage({ output });
+        };
+        try {
+            let results = await pyodide.runPythonAsync(`import asyncio
+from js import __pyodide__input_${ts}, __pyodide__output_${ts}
+
+input = __pyodide__input_${ts}
+print = __pyodide__output_${ts}
+
+__builtins__.input = __pyodide__input_${ts}
+__builtins__.print = __pyodide__output_${ts}
+
+${code}`);
+            self.postMessage({ results: true });
+        }
+        catch (error) {
+            self.postMessage({ error: error.message });
+        }
+    }
+};
+export {};

package/dist/terminal/Terminal.svelte

@@ -0,0 +1,130 @@
+<script>import { onMount } from "svelte";
+import { Theme, registerAllPlugins } from "./";
+import { createEventDispatcher } from "svelte";
+import { load } from "../playground";
+import "xterm/css/xterm.css";
+const dispatch = createEventDispatcher();
+let ref, clientWidth, clientHeight, term, finish = true, input = "", sandbox, first = true;
+export const terminal = {
+  clear() {
+    term.clear();
+    term.write(`\x1B[?25l`);
+    term.write("\x1B[0m");
+    term.options.cursorBlink = false;
+    first = true;
+  },
+  async run(language, code, log = true) {
+    if (sandbox)
+      await sandbox.clear();
+    input = "";
+    finish = false;
+    sandbox = await load(language, path);
+    await sandbox.clear();
+    sandbox.output = (output) => {
+      term.write(output.replaceAll("\n", "\r\n"));
+    };
+    term.options.cursorBlink = true;
+    if (!first)
+      term.write(`\r
+\x1B[0m`);
+    await sandbox.load(path, code, log);
+    term.focus();
+    first = false;
+    sandbox.run(code).then(() => {
+      dispatch("finish");
+      finish = true;
+      term.write(`\r
+Process finished after ${sandbox.elapse}ms\r
+\x1B[?25l`);
+      term.options.cursorBlink = false;
+    }).catch((msg) => {
+      dispatch("finish");
+      finish = true;
+      term.write(`\r
+\x1B[1;3;31m${msg}`);
+      term.options.cursorBlink = false;
+    });
+  }
+};
+export let dark = false, path = "";
+$:
+  if (term) {
+    if (dark)
+      term.options.theme = Theme.Tango_Dark;
+    else
+      term.options.theme = Theme.Tango_Light;
+  }
+let plugin;
+$:
+  if (plugin) {
+    void 0, clientHeight;
+    try {
+      plugin.fit.fit();
+    } catch (e) {
+    }
+  }
+onMount(() => {
+  import("xterm").then(async ({ Terminal }) => {
+    term = new Terminal({
+      theme: dark ? Theme.Tango_Dark : Theme.Tango_Light,
+      cursorBlink: false,
+      allowTransparency: true,
+      fontFamily: "'D2 coding', monospace",
+      fontWeight: "bold",
+      allowProposedApi: true
+    });
+    term.open(ref);
+    term.onKey((e) => {
+      if (finish)
+        return;
+      const ev = e.domEvent;
+      const printable = !ev.altKey && !ev.ctrlKey && !ev.metaKey;
+      if (ev.key === "Enter") {
+        term.write("\r\n");
+        sandbox.write(input + "\n");
+        input = "";
+      } else if (ev.key === "Backspace") {
+        if (term._core.buffer.x > 0) {
+          term.write("\b \b");
+          if (input.length > 0) {
+            input = input.substring(0, input.length - 1);
+          }
+        }
+      } else if (printable) {
+        if (e.key >= String.fromCharCode(32) && e.key <= String.fromCharCode(126) || e.key >= "\xA0") {
+          input += e.key;
+          term.write(e.key);
+        }
+      } else if (ev.ctrlKey && ev.key === "c") {
+        sandbox.kill();
+      }
+    });
+    plugin = await registerAllPlugins(term);
+  });
+  dispatch("load");
+  return async () => {
+    term.dispose();
+    if (sandbox)
+      await sandbox.clear();
+  };
+});
+</script>
+
+<main>
+    <div bind:this={ref} bind:clientWidth bind:clientHeight></div>
+</main>
+
+
+<style>
+    main {
+        padding: 10px;
+        width: calc(100% - 20px);
+        height: calc(100% - 20px);
+        overflow: hidden;
+    }
+
+    div {
+        width: 100%;
+        height: 100%;
+    }
+</style>

package/dist/terminal/Terminal.svelte.d.ts

@@ -0,0 +1,29 @@
+import { SvelteComponentTyped } from "svelte";
+import 'xterm/css/xterm.css';
+declare const __propDef: {
+    props: {
+        terminal?: {
+            clear(): void;
+            run(language: any, code: any, log?: boolean): Promise<void>;
+        } | undefined;
+        dark?: boolean | undefined;
+        path?: string | undefined;
+    };
+    events: {
+        finish: CustomEvent<any>;
+        load: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type TerminalProps = typeof __propDef.props;
+export type TerminalEvents = typeof __propDef.events;
+export type TerminalSlots = typeof __propDef.slots;
+export default class Terminal extends SvelteComponentTyped<TerminalProps, TerminalEvents, TerminalSlots> {
+    get terminal(): {
+        clear(): void;
+        run(language: any, code: any, log?: boolean): Promise<void>;
+    };
+}
+export {};

package/dist/terminal/index.d.ts

@@ -0,0 +1,5 @@
+import Theme from "./theme";
+import registerAllPlugins from "./plugin";
+import Terminal from "./Terminal.svelte";
+export { Theme, registerAllPlugins };
+export default Terminal;

package/dist/terminal/index.js

@@ -0,0 +1,5 @@
+import Theme from "./theme";
+import registerAllPlugins from "./plugin";
+import Terminal from "./Terminal.svelte";
+export { Theme, registerAllPlugins };
+export default Terminal;