wasm-idle 0.7.2 → 1.0.0

package/dist/clang/memory/index.d.ts

@@ -1,4 +0,0 @@
-import MemFS from './memFs';
-import Memory from './memory';
-import untar from './tar';
-export { MemFS, Memory, untar };

package/dist/clang/memory/index.js

@@ -1,4 +0,0 @@
-import MemFS from './memFs';
-import Memory from './memory';
-import untar from './tar';
-export { MemFS, Memory, untar };

package/dist/clang/memory/memFs.d.ts

@@ -1,35 +0,0 @@
-import { Memory } from './';
-import type { Writable } from 'svelte/store';
-interface MemFsOptions {
-    stdin: () => string;
-    stdout: (str: string) => void;
-    stdinStr?: string;
-    path: string;
-    progress?: Writable<number>;
-    trace?: (message: string) => void;
-}
-export default class MemFS {
-    ready: Promise<void>;
-    mem: Memory;
-    hostMem_: Memory;
-    stdinStr: string;
-    stdin: () => string;
-    stdout: (str: string) => void;
-    trace: (message: string) => void;
-    instance: WebAssembly.Instance;
-    exports: any;
-    out: boolean;
-    constructor(options: MemFsOptions);
-    set hostMem(mem: Memory);
-    setStdinStr(str: string): void;
-    addDirectory(path: string): void;
-    addFile(path: string, contents: string | ArrayBuffer | Uint8Array): void;
-    getFileContents(path: string): Uint8Array<ArrayBufferLike>;
-    abort(): void;
-    host_write(fd: number, iovs: number, iovs_len: number, nwritten_out: number): number;
-    host_read(fd: number, iovs: number, iovs_len: number, nread: number): number;
-    memfs_log(buf: number, len: number): void;
-    copy_out(clang_dst: number, memfs_src: number, size: number): void;
-    copy_in(memfs_dst: number, clang_src: number, size: number): void;
-}
-export {};

package/dist/clang/memory/memFs.js

@@ -1,132 +0,0 @@
-import { Memory } from './';
-import { bindNew } from '../apply';
-import { AbortError, assert } from '../error';
-import { compile } from '../wasm';
-import { memfsUrl } from '../url';
-const ESUCCESS = 0;
-const previewText = (text) => JSON.stringify(text.length > 96 ? text.slice(0, 93) + '...' : text);
-export default class MemFS {
-    ready;
-    mem = null;
-    hostMem_ = null;
-    stdinStr;
-    stdin;
-    stdout;
-    trace;
-    instance = null;
-    exports;
-    out = true;
-    constructor(options) {
-        this.stdin = options.stdin;
-        this.stdout = options.stdout;
-        this.stdinStr = options.stdinStr || '';
-        this.trace = options.trace || (() => { });
-        const env = bindNew(this, 'abort', 'host_write', 'host_read', 'memfs_log', 'copy_in', 'copy_out');
-        this.ready = compile(memfsUrl(options.path), options.progress)
-            .then((module) => WebAssembly.instantiate(module, { env }))
-            .then((instance) => {
-            this.instance = instance;
-            this.exports = instance.exports;
-            this.mem = new Memory(this.exports.memory);
-            this.exports.init();
-        });
-    }
-    set hostMem(mem) {
-        this.hostMem_ = mem;
-    }
-    setStdinStr(str) {
-        this.stdinStr = str;
-    }
-    addDirectory(path) {
-        this.mem.check();
-        this.mem.write(this.exports.GetPathBuf(), path);
-        this.exports.AddDirectoryNode(path.length);
-    }
-    addFile(path, contents) {
-        const length = contents instanceof ArrayBuffer ? contents.byteLength : contents.length;
-        this.mem.check();
-        this.mem.write(this.exports.GetPathBuf(), path);
-        const inode = this.exports.AddFileNode(path.length, length);
-        const addr = this.exports.GetFileNodeAddress(inode);
-        this.mem.check();
-        this.mem.write(addr, contents);
-    }
-    getFileContents(path) {
-        this.mem.check();
-        this.mem.write(this.exports.GetPathBuf(), path);
-        const inode = this.exports.FindNode(path.length);
-        const addr = this.exports.GetFileNodeAddress(inode);
-        const size = this.exports.GetFileNodeSize(inode);
-        return new Uint8Array(this.mem.buffer, addr, size);
-    }
-    abort() {
-        this.trace('abort()');
-        throw new AbortError();
-    }
-    host_write(fd, iovs, iovs_len, nwritten_out) {
-        this.hostMem_.check();
-        assert(fd <= 2);
-        let size = 0;
-        let str = '';
-        for (let i = 0; i < iovs_len; ++i) {
-            const buf = this.hostMem_.read32(iovs);
-            iovs += 4;
-            const len = this.hostMem_.read32(iovs);
-            iovs += 4;
-            str += this.hostMem_.readStrR(buf, len);
-            size += len;
-        }
-        this.hostMem_.write32(nwritten_out, size);
-        this.trace(`host_write(fd=${fd}, bytes=${size}, data=${previewText(str)})`);
-        if (this.out)
-            this.stdout(str);
-        return ESUCCESS;
-    }
-    host_read(fd, iovs, iovs_len, nread) {
-        this.hostMem_.check();
-        assert(fd === 0);
-        let size = 0;
-        for (let i = 0; i < iovs_len; ++i) {
-            const buf = this.hostMem_.read32(iovs);
-            iovs += 4;
-            const len = this.hostMem_.read32(iovs);
-            iovs += 4;
-            if (!this.stdinStr.length)
-                this.stdinStr = this.stdin();
-            const lenToWrite = Math.min(len, this.stdinStr.length);
-            if (lenToWrite === 0)
-                break;
-            const chunk = this.stdinStr.substring(0, lenToWrite);
-            this.hostMem_.write(buf, this.stdinStr.substring(0, lenToWrite));
-            this.stdinStr = this.stdinStr.substring(lenToWrite);
-            size += lenToWrite;
-            this.trace(`host_read(fd=${fd}, bytes=${lenToWrite}, data=${previewText(chunk)})`);
-            if (lenToWrite !== len)
-                break;
-        }
-        this.hostMem_.write32(nread, size);
-        if (size === 0)
-            this.trace(`host_read(fd=${fd}, bytes=0)`);
-        return ESUCCESS;
-    }
-    memfs_log(buf, len) {
-        this.mem.check();
-        const message = this.mem.readStr(buf, len);
-        this.trace(`memfs_log(${previewText(message)})`);
-        console.log(message);
-    }
-    copy_out(clang_dst, memfs_src, size) {
-        this.hostMem_.check();
-        const dst = new Uint8Array(this.hostMem_.buffer, clang_dst, size);
-        this.mem.check();
-        const src = new Uint8Array(this.mem.buffer, memfs_src, size);
-        dst.set(src);
-    }
-    copy_in(memfs_dst, clang_src, size) {
-        this.mem.check();
-        const dst = new Uint8Array(this.mem.buffer, memfs_dst, size);
-        this.hostMem_.check();
-        const src = new Uint8Array(this.hostMem_.buffer, clang_src, size);
-        dst.set(src);
-    }
-}

package/dist/clang/memory/memory.d.ts

@@ -1,22 +0,0 @@
-export default class Memory {
-    memory: WebAssembly.Memory;
-    view: DataView;
-    buffer: ArrayBufferLike;
-    u8: Uint8Array;
-    u32: Uint32Array;
-    constructor(memory: WebAssembly.Memory);
-    check(): void;
-    read8(o: number): number;
-    read32(o: number): number;
-    readInt32(o: number): number;
-    readFloat32(o: number): number;
-    readFloat64(o: number): number;
-    readStr(o: number, len: number): string;
-    readStrR(o: number, len: number): string;
-    write8(o: number, v: number): void;
-    write32(o: number, v: number): void;
-    write64(o: number, vlo: number, vhi?: number): void;
-    writeStr(o: number, str: string): number;
-    writeUint8(o: number, arr: ArrayLike<number>): number;
-    write(o: number, buf: ArrayBufferLike | string | Uint8Array): number;
-}

package/dist/clang/memory/memory.js

@@ -1,73 +0,0 @@
-import { readStr, readStrR } from '../encode';
-export default class Memory {
-    memory;
-    view;
-    buffer;
-    u8;
-    u32;
-    constructor(memory) {
-        this.memory = memory;
-        this.buffer = memory.buffer;
-        this.view = new DataView(this.buffer);
-        this.u8 = new Uint8Array(this.buffer);
-        this.u32 = new Uint32Array(this.buffer);
-    }
-    check() {
-        if (this.buffer.byteLength === 0) {
-            this.buffer = this.memory.buffer;
-            this.view = new DataView(this.buffer);
-            this.u8 = new Uint8Array(this.buffer);
-            this.u32 = new Uint32Array(this.buffer);
-        }
-    }
-    read8(o) {
-        return this.u8[o];
-    }
-    read32(o) {
-        return this.u32[o >> 2];
-    }
-    readInt32(o) {
-        return this.view.getInt32(o, true);
-    }
-    readFloat32(o) {
-        return this.view.getFloat32(o, true);
-    }
-    readFloat64(o) {
-        return this.view.getFloat64(o, true);
-    }
-    readStr(o, len) {
-        return readStr(this.u8, o, len);
-    }
-    readStrR(o, len) {
-        return readStrR(this.u8, o, len);
-    }
-    write8(o, v) {
-        this.u8[o] = v;
-    }
-    write32(o, v) {
-        this.u32[o >> 2] = v;
-    }
-    write64(o, vlo, vhi = 0) {
-        this.write32(o, vlo);
-        this.write32(o + 4, vhi);
-    }
-    writeStr(o, str) {
-        o += this.write(o, str);
-        this.write8(o, 0);
-        return str.length + 1;
-    }
-    writeUint8(o, arr) {
-        new Uint8Array(this.buffer, o, arr.length).set(arr);
-        return arr.length;
-    }
-    write(o, buf) {
-        if (buf instanceof ArrayBuffer)
-            return this.writeUint8(o, new Uint8Array(buf));
-        if (buf instanceof SharedArrayBuffer)
-            return this.writeUint8(o, new Uint8Array(buf));
-        else if (typeof buf === 'string')
-            return this.writeUint8(o, buf.split('').map((x) => x.charCodeAt(0)));
-        else
-            return this.writeUint8(o, buf);
-    }
-}

package/dist/clang/memory/tar.d.ts

@@ -1,2 +0,0 @@
-import type { MemFS } from './';
-export default function untar(buffer: Uint8Array | ArrayBufferLike, memfs: MemFS): void;

package/dist/clang/memory/tar.js

@@ -1,59 +0,0 @@
-import { readStr, readOct } from '../encode';
-import { assert } from '../error';
-function* readEntry(buffer) {
-    const u8 = buffer instanceof Uint8Array ? buffer : 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

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

package/dist/clang/url.js

@@ -1,5 +0,0 @@
-const normalizeBaseUrl = (baseUrl) => baseUrl ? (baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`) : '/clang/';
-export const memfsUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}bin/memfs.zip`;
-export const clangUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}bin/clang.zip`;
-export const lldUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}bin/lld.zip`;
-export const rootUrl = (baseUrl) => `${normalizeBaseUrl(baseUrl)}bin/sysroot.tar.zip`;

package/dist/clang/wasm.d.ts

@@ -1,4 +0,0 @@
-import type { Writable } from 'svelte/store';
-export declare const readBuffer: (name: string, progress?: Writable<number>) => Promise<Uint8Array<ArrayBuffer>>;
-export declare function compile(filename: string, progress?: Writable<number>): Promise<any>;
-export declare function getInstance(module: WebAssembly.Module, imports: WebAssembly.Imports): Promise<WebAssembly.Instance>;

package/dist/clang/wasm.js

@@ -1,50 +0,0 @@
-import * as zip from '@zip.js/zip.js';
-const store = {};
-export const readBuffer = async (name, progress) => {
-    const response = await fetch(name);
-    const contentLength = +(response.headers.get('Content-Length') || 0);
-    if (!response.body) {
-        progress?.set?.(1);
-        return new Uint8Array(await response.arrayBuffer());
-    }
-    const r = response.body.getReader();
-    let receivedLength = 0;
-    const chunks = [];
-    while (true) {
-        const { done, value } = await r.read();
-        if (done)
-            break;
-        if (!value)
-            continue;
-        chunks.push(Uint8Array.from(value));
-        receivedLength += value.length;
-        if (contentLength > 0)
-            progress?.set?.(receivedLength / contentLength);
-    }
-    progress?.set?.(1);
-    const chunksAll = new Uint8Array(receivedLength); // (4.1)
-    let position = 0;
-    for (const chunk of chunks) {
-        chunksAll.set(chunk, position);
-        position += chunk.length;
-    }
-    const reader = new zip.ZipReader(new zip.Uint8ArrayReader(chunksAll));
-    const entries = await reader.getEntries();
-    for (const entry of entries) {
-        if (!('getData' in entry))
-            continue;
-        const data = await entry.getData(new zip.Uint8ArrayWriter());
-        return data;
-    }
-    throw new Error('No entry found');
-};
-export async function compile(filename, progress) {
-    // TODO: make compileStreaming work. It needs the server to use the
-    // application/wasm mimetype.
-    if (store[filename])
-        return store[filename];
-    return (store[filename] = WebAssembly.compile(await readBuffer(filename, progress)));
-}
-export function getInstance(module, imports) {
-    return WebAssembly.instantiate(module, imports);
-}

package/dist/clangd/config.d.ts

@@ -1,18 +0,0 @@
-export declare const CLANGD_WORKSPACE_PATH = "/workspace";
-export declare const CLANGD_WORKSPACE_URI = "file:///workspace";
-export declare const CLANGD_CPP_FILE_PATH = "/workspace/main.cpp";
-export declare const CLANGD_CPP_FILE_URI = "file:///workspace/main.cpp";
-export type ClangdStatus = {
-    state: 'disabled';
-} | {
-    state: 'loading';
-    loaded?: number;
-    total?: number;
-} | {
-    state: 'ready';
-} | {
-    state: 'error';
-    message: string;
-};
-export declare const normalizeClangdBaseUrl: (baseUrl: string) => string;
-export declare const createClangdCompileFlags: () => string[];

package/dist/clangd/config.js

@@ -1,14 +0,0 @@
-export const CLANGD_WORKSPACE_PATH = '/workspace';
-export const CLANGD_WORKSPACE_URI = `file://${CLANGD_WORKSPACE_PATH}`;
-export const CLANGD_CPP_FILE_PATH = `${CLANGD_WORKSPACE_PATH}/main.cpp`;
-export const CLANGD_CPP_FILE_URI = `file://${CLANGD_CPP_FILE_PATH}`;
-export const normalizeClangdBaseUrl = (baseUrl) => baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
-export const createClangdCompileFlags = () => [
-    '-std=gnu++2a',
-    '-xc++',
-    '--target=wasm32-wasi',
-    '-isystem/usr/include/c++/v1',
-    '-isystem/usr/include/wasm32-wasi/c++/v1',
-    '-isystem/usr/include',
-    '-isystem/usr/include/wasm32-wasi'
-];

package/dist/clangd/jsonStream.d.ts

@@ -1,9 +0,0 @@
-export declare class JsonStream {
-    inJson: boolean;
-    rawText: number[];
-    unbalancedBraces: number;
-    inString: boolean;
-    inEscape: number;
-    textDecoder: TextDecoder;
-    insert(charCode: number): string | null;
-}

package/dist/clangd/jsonStream.js

@@ -1,48 +0,0 @@
-const QUOTE = 34;
-const LEFT_BRACE = 123;
-const RIGHT_BRACE = 125;
-const BACKSLASH = 92;
-export class JsonStream {
-    inJson = false;
-    rawText = [];
-    unbalancedBraces = 0;
-    inString = false;
-    inEscape = 0;
-    textDecoder = new TextDecoder();
-    insert(charCode) {
-        if (!this.inJson && charCode === LEFT_BRACE) {
-            this.inJson = true;
-            this.rawText = [];
-        }
-        if (!this.inJson)
-            return null;
-        this.rawText.push(charCode);
-        if (this.inString) {
-            if (this.inEscape) {
-                if (charCode === 75)
-                    this.inEscape += 4;
-                this.inEscape -= 1;
-            }
-            else if (charCode === BACKSLASH) {
-                this.inEscape = 1;
-            }
-            else if (charCode === QUOTE) {
-                this.inString = false;
-            }
-        }
-        else if (charCode === LEFT_BRACE) {
-            this.unbalancedBraces += 1;
-        }
-        else if (charCode === RIGHT_BRACE) {
-            this.unbalancedBraces -= 1;
-            if (this.unbalancedBraces === 0) {
-                this.inJson = false;
-                return this.textDecoder.decode(new Uint8Array(this.rawText));
-            }
-        }
-        else if (charCode === QUOTE) {
-            this.inString = true;
-        }
-        return null;
-    }
-}

package/dist/clangd/session.d.ts

@@ -1,18 +0,0 @@
-import { MonacoLanguageClient } from '@hancomac/monaco-languageclient';
-import type * as Monaco from 'monaco-editor';
-import { type ClangdStatus } from './config';
-import { WorkerAssetBridge } from '../playground/assetBridge';
-import { type ResolvedRuntimeAssetConfig, type RuntimeAssetConfig } from '../playground/assets';
-export declare class ClangdSession {
-    Monaco: typeof Monaco;
-    baseUrl: string;
-    assetConfig: ResolvedRuntimeAssetConfig;
-    assetBridge: WorkerAssetBridge | null;
-    onStatus?: (status: ClangdStatus) => void;
-    worker: Worker | null;
-    languageClient: MonacoLanguageClient | null;
-    constructor(MonacoModule: typeof Monaco, baseUrl: string | RuntimeAssetConfig, onStatus?: (status: ClangdStatus) => void);
-    createModel(value: string): Monaco.editor.ITextModel;
-    start(): Promise<void>;
-    dispose(): void;
-}

package/dist/clangd/session.js

@@ -1,112 +0,0 @@
-import { CloseAction, ErrorAction, MonacoLanguageClient, MonacoServices } from '@hancomac/monaco-languageclient';
-import { CLANGD_CPP_FILE_URI, CLANGD_WORKSPACE_URI } from './config';
-import ClangdWorker from './worker?worker';
-import { WorkerAssetBridge } from '../playground/assetBridge';
-import { resolveRuntimeAssetConfig } from '../playground/assets';
-import { BrowserMessageReader, BrowserMessageWriter } from '../utils/vscodeJsonrpcBrowser';
-let servicesInstalled = false;
-export class ClangdSession {
-    Monaco;
-    baseUrl;
-    assetConfig;
-    assetBridge = null;
-    onStatus;
-    worker = null;
-    languageClient = null;
-    constructor(MonacoModule, baseUrl, onStatus) {
-        this.Monaco = MonacoModule;
-        this.onStatus = onStatus;
-        this.assetConfig = resolveRuntimeAssetConfig('clangd', { clangd: typeof baseUrl === 'string' ? { baseUrl } : baseUrl }, globalThis.location?.href || '');
-        this.baseUrl = this.assetConfig.baseUrl;
-        if (!servicesInstalled) {
-            MonacoServices.install(MonacoModule);
-            servicesInstalled = true;
-        }
-    }
-    createModel(value) {
-        const uri = this.Monaco.Uri.parse(CLANGD_CPP_FILE_URI);
-        this.Monaco.editor.getModel(uri)?.dispose();
-        return this.Monaco.editor.createModel(value, 'cpp', uri);
-    }
-    async start() {
-        if (this.worker)
-            return;
-        this.onStatus?.({ state: 'loading' });
-        const worker = new ClangdWorker();
-        this.worker = worker;
-        this.assetBridge = new WorkerAssetBridge(worker, 'clangd', this.assetConfig, {
-            set: (value) => this.onStatus?.({ state: 'loading', loaded: value, total: 1 })
-        });
-        await new Promise((resolve, reject) => {
-            const cleanup = () => {
-                worker.removeEventListener('message', handleMessage);
-                worker.removeEventListener('error', handleError);
-            };
-            const handleMessage = (event) => {
-                if (this.assetBridge?.handleMessage(event))
-                    return;
-                const { type, value, max, message } = event.data || {};
-                if (type === 'progress') {
-                    this.onStatus?.({ state: 'loading', loaded: value, total: max });
-                    return;
-                }
-                if (type === 'ready') {
-                    cleanup();
-                    resolve();
-                    return;
-                }
-                if (type === 'error') {
-                    cleanup();
-                    reject(new Error(message || 'clangd failed to start'));
-                }
-            };
-            const handleError = (event) => {
-                cleanup();
-                reject(event.error || new Error(event.message || 'clangd worker failed'));
-            };
-            worker.addEventListener('message', handleMessage);
-            worker.addEventListener('error', handleError);
-            worker.postMessage({
-                type: 'init',
-                baseUrl: this.baseUrl,
-                assets: {
-                    baseUrl: this.assetConfig.baseUrl,
-                    useAssetBridge: this.assetConfig.useAssetBridge
-                }
-            });
-        });
-        const reader = new BrowserMessageReader(worker);
-        const writer = new BrowserMessageWriter(worker);
-        this.languageClient = new MonacoLanguageClient({
-            name: 'wasm-idle clangd',
-            clientOptions: {
-                documentSelector: ['cpp'],
-                errorHandler: {
-                    error: () => ({ action: ErrorAction.Continue }),
-                    closed: () => ({ action: CloseAction.DoNotRestart })
-                },
-                workspaceFolder: {
-                    index: 0,
-                    name: 'workspace',
-                    uri: this.Monaco.Uri.parse(CLANGD_WORKSPACE_URI)
-                }
-            },
-            connectionProvider: {
-                get: async () => ({ reader, writer })
-            }
-        });
-        this.languageClient.start();
-        reader.onClose(() => {
-            this.languageClient?.stop();
-            this.onStatus?.({ state: 'disabled' });
-        });
-        this.onStatus?.({ state: 'ready' });
-    }
-    dispose() {
-        this.languageClient?.stop();
-        this.languageClient = null;
-        this.worker?.terminate();
-        this.worker = null;
-        this.assetBridge = null;
-    }
-}