wasm-idle 0.4.1 → 0.5.0

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;

package/dist/playground/sandbox.d.ts

@@ -1,14 +1,15 @@
 import type { CompilerDiagnostic, DebugCommand, DebugSessionEvent, SandboxExecutionOptions } from './options';
 import type { PlaygroundRuntimeAssets } from './assets';
 import type { Writable } from 'svelte/store';
-type ProgressLike = Writable<number> | {
+export type SandboxRuntimeAssets = string | PlaygroundRuntimeAssets;
+export type SandboxProgress = Writable<number> | {
     set?: (value: number) => void;
 };
 export interface Sandbox {
     constructor: any;
     eof: () => void;
-    load: (runtimeAssets?: string | PlaygroundRuntimeAssets, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: ProgressLike) => Promise<void>;
-    run: (code: string, prepare: boolean, log?: boolean, prog?: ProgressLike, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
+    load: (runtimeAssets?: SandboxRuntimeAssets, code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress) => Promise<void>;
+    run: (code: string, prepare: boolean, log?: boolean, prog?: SandboxProgress, args?: string[], options?: SandboxExecutionOptions) => Promise<boolean | string>;
     terminate: () => void;
     clear: () => Promise<void>;
     kill?: () => void;
@@ -17,6 +18,7 @@ export interface Sandbox {
     ondebug?: (event: DebugSessionEvent) => void;
     oncompilerdiagnostic?: (diagnostic: CompilerDiagnostic) => void;
     debugCommand?: (command: DebugCommand) => void;
+    setBreakpoints?: (lines: number[]) => void;
     debugEvaluate?: (expression: string) => Promise<string>;
     image?: (data: {
         mime: string;
@@ -25,4 +27,16 @@ export interface Sandbox {
     }) => void;
     elapse?: number;
 }
-export {};
+export interface BoundSandbox extends Omit<Sandbox, 'load'> {
+    load: (code?: string, log?: boolean, args?: string[], options?: SandboxExecutionOptions, progress?: SandboxProgress) => Promise<void>;
+    runtimeAssets: SandboxRuntimeAssets;
+}
+export interface PlaygroundTerminalProps {
+    playground: PlaygroundBinding;
+    runtimeAssets: SandboxRuntimeAssets;
+}
+export interface PlaygroundBinding {
+    runtimeAssets: SandboxRuntimeAssets;
+    terminalProps: PlaygroundTerminalProps;
+    load: (language: string) => Promise<BoundSandbox>;
+}

package/dist/playground/wasmRustVersion.d.ts

@@ -0,0 +1 @@
+export declare const WASM_RUST_ASSET_VERSION = "2d36c8a3cd2cbbfd";

package/dist/playground/wasmRustVersion.js

@@ -0,0 +1 @@
+export const WASM_RUST_ASSET_VERSION = "2d36c8a3cd2cbbfd";

package/dist/playground/worker/clang.js

@@ -4,7 +4,7 @@ self.document = {
         return [];
     }
 };
-let stdinBufferClang, debugBufferClang, interruptBufferClang, clang;
+let stdinBufferClang, debugBufferClang, watchBufferClang, watchResultBufferClang, interruptBufferClang, clang;
 async function loadClang(path, log) {
     const { default: Clang } = await import('../../clang');
     clang = new Clang({
@@ -17,7 +17,7 @@ async function loadClang(path, log) {
     });
 }
 self.onmessage = async (event) => {
-    const { code, buffer, debugBuffer, load, interrupt, log, path, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
+    const { code, buffer, debugBuffer, watchBuffer, watchResultBuffer, load, interrupt, log, path, prepare, language, compileArgs, programArgs, cppVersion, cVersion, debug, breakpoints, pauseOnEntry } = event.data;
     if (load) {
         await loadClang(path, log);
         postMessage({ load: true });
@@ -25,6 +25,8 @@ self.onmessage = async (event) => {
     else if (prepare) {
         stdinBufferClang = new Int32Array(buffer);
         debugBufferClang = new Int32Array(debugBuffer);
+        watchBufferClang = new Int32Array(watchBuffer);
+        watchResultBufferClang = new Int32Array(watchResultBuffer);
         interruptBufferClang = new Uint8Array(interrupt);
         try {
             await clang.compileLink(code, {
@@ -37,7 +39,9 @@ self.onmessage = async (event) => {
                 breakpoints,
                 pauseOnEntry,
                 debugBuffer: debugBufferClang,
-                interruptBuffer: interruptBufferClang
+                interruptBuffer: interruptBufferClang,
+                watchBuffer: watchBufferClang,
+                watchResultBuffer: watchResultBufferClang
             });
             self.postMessage({ results: true });
         }
@@ -49,6 +53,8 @@ self.onmessage = async (event) => {
         clang.log = log;
         stdinBufferClang = new Int32Array(buffer);
         debugBufferClang = new Int32Array(debugBuffer);
+        watchBufferClang = new Int32Array(watchBuffer);
+        watchResultBufferClang = new Int32Array(watchResultBuffer);
         interruptBufferClang = new Uint8Array(interrupt);
         try {
             await clang.compileLinkRun(code, {
@@ -61,7 +67,9 @@ self.onmessage = async (event) => {
                 breakpoints,
                 pauseOnEntry,
                 debugBuffer: debugBufferClang,
-                interruptBuffer: interruptBufferClang
+                interruptBuffer: interruptBufferClang,
+                watchBuffer: watchBufferClang,
+                watchResultBuffer: watchResultBufferClang
             });
             self.postMessage({ results: true });
         }

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

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