@mirascript/mirascript 0.1.0

package/src/compiler/index.ts

@@ -0,0 +1,67 @@
+import type { VmScript } from '../vm/index.js';
+import type { ScriptInput, TranspileOptions } from './types.js';
+import './types.js';
+import { emit } from './emit.js';
+import { createScript } from './create-script.js';
+import { compileFast } from './compile-fast.js';
+import { formatDiagnostic, parseDiagnostics } from './diagnostic.js';
+import { compileBytecode, compileBytecodeSync, loadModule } from './compile-bytecode.js';
+import { compileWorker } from './worker-manager.js';
+await loadModule();
+
+export type { TranspileOptions, ScriptInput, InputMode } from './types.js';
+
+// 目前编译速度约 2000kB/s
+const WORKER_MIN_LEN = typeof Worker != 'function' ? Number.MAX_VALUE : 1024;
+
+/** 报告编译错误 */
+function reportDiagnostic(source: ScriptInput, diagnostics: Uint32Array): never {
+    const parsed = parseDiagnostics(source, diagnostics);
+    const messages = parsed.errors.map(formatDiagnostic);
+    throw new Error(`Failed to compile:\n${messages.join('\n')}`);
+}
+
+/**
+ * 生成 MiraScript 对应的 JavaScript 代码
+ */
+function emitImpl(
+    source: ScriptInput,
+    [code, diagnostics]: [Uint8Array | undefined, Uint32Array],
+    options: TranspileOptions,
+): VmScript {
+    if (!code) {
+        reportDiagnostic(source, diagnostics);
+    }
+    const target = emit(source, code, options);
+    return createScript(source, target);
+}
+
+/**
+ * 生成 MiraScript 对应的 JavaScript 代码
+ */
+export async function compile(this: void, source: ScriptInput, options: TranspileOptions = {}): Promise<VmScript> {
+    if (typeof source == 'string') {
+        const result = compileFast(source, options);
+        if (result) return result;
+    }
+    if (source.length < WORKER_MIN_LEN) {
+        const bc = await compileBytecode(source, options);
+        return emitImpl(source, bc, options);
+    }
+    const [target, diagnostics] = await compileWorker(source, options);
+    if (target == null) {
+        reportDiagnostic(source, diagnostics);
+    }
+    return createScript(source, target);
+}
+/**
+ * 生成 MiraScript 对应的 JavaScript 代码
+ */
+export function compileSync(this: void, source: ScriptInput, options: TranspileOptions = {}): VmScript {
+    if (typeof source == 'string') {
+        const result = compileFast(source, options);
+        if (result) return result;
+    }
+    const bc = compileBytecodeSync(source, options);
+    return emitImpl(source, bc, options);
+}

package/src/compiler/types.ts

@@ -0,0 +1,16 @@
+import type { Config } from '@mirascript/wasm/types';
+export type { InputMode, ScriptInput } from '@mirascript/wasm/types';
+
+/** 代码编译选项 */
+export type CompileOptions = Config;
+/** 代码生成选项 */
+export interface GenerateOptions {
+    /** 是否美化代码 */
+    readonly pretty?: boolean;
+    /** 是否生成源映射 */
+    readonly sourceMap?: boolean;
+    /** 代码文件名 */
+    readonly fileName?: string;
+}
+/** 转换选项 */
+export type TranspileOptions = GenerateOptions & CompileOptions;

package/src/compiler/worker-manager.ts

@@ -0,0 +1,60 @@
+import type { compile } from './worker.js';
+
+let worker: Promise<Worker> | undefined;
+/** 获取 worker */
+async function getWorker(): Promise<Worker> {
+    if (worker) return worker;
+    worker = new Promise((resolve, reject) => {
+        const w = new Worker(new URL('#compiler/worker', import.meta.url), {
+            type: 'module',
+            name: '@mirascript/compiler',
+        });
+        const onError = (e: ErrorEvent) => {
+            cleanUp();
+            reject(new Error(`Worker failed to start: ${e.message}`));
+        };
+        const onMessage = (e: MessageEvent<'ready' | Error>) => {
+            if (e.data === 'ready') {
+                cleanUp();
+                resolve(w);
+            } else if (e.data instanceof Error) {
+                cleanUp();
+                reject(e.data);
+            }
+        };
+        w.addEventListener('error', onError);
+        w.addEventListener('message', onMessage);
+        const cleanUp = () => {
+            w.removeEventListener('error', onError);
+            w.removeEventListener('message', onMessage);
+        };
+        setTimeout(() => {
+            onError(new ErrorEvent('error', { message: 'Worker did not respond in time' }));
+        }, 30000);
+    });
+    return worker;
+}
+
+/**
+ * 生成 MiraScript 对应的 JavaScript 代码
+ */
+export async function compileWorker(...args: Parameters<typeof compile>): Promise<[string | undefined, Uint32Array]> {
+    const worker = await getWorker();
+    const seq = Math.random();
+    worker.postMessage([seq, ...args]);
+    return await new Promise<[string | undefined, Uint32Array]>((resolve, reject) => {
+        const callback = (ev: MessageEvent) => {
+            const data = ev.data as [number, string | undefined, Uint32Array] | [number, Error];
+            if (!Array.isArray(data)) return;
+            const [retSeq, ...rest] = data;
+            if (seq !== retSeq) return; // Ignore messages not matching the request
+            worker.removeEventListener('message', callback);
+            if (rest.length === 2) {
+                resolve(rest);
+            } else {
+                reject(rest[0]);
+            }
+        };
+        worker.addEventListener('message', callback);
+    });
+}

package/src/compiler/worker.ts

@@ -0,0 +1,37 @@
+import type { ScriptInput, TranspileOptions } from './types.js';
+import { emit } from './emit.js';
+import { compileBytecode } from './compile-bytecode.js';
+
+/**
+ * 生成 MiraScript 对应的 JavaScript 代码
+ */
+export async function compile(
+    script: ScriptInput,
+    options: TranspileOptions,
+): Promise<[string | undefined, Uint32Array]> {
+    const [bytecode, errors] = await compileBytecode(script, options);
+    if (bytecode == null) {
+        return [undefined, errors];
+    }
+    const generatedCode = emit(script, bytecode, options);
+    return [generatedCode, errors];
+}
+
+addEventListener('message', (ev) => {
+    const data = ev.data as [number, ...Parameters<typeof compile>];
+    if (!Array.isArray(data)) return;
+    const [seq, ...args] = data;
+    if (typeof seq != 'number' || !args.length) return;
+    void compile(...args)
+        .then(([script, errors]) => {
+            postMessage([seq, script, errors], { transfer: [errors.buffer] });
+        })
+        .catch((error) => {
+            postMessage([seq, error instanceof Error ? error : new Error(String(error))]);
+        });
+});
+
+compile('{}', {}).then(
+    () => postMessage('ready'),
+    (ex) => postMessage(ex),
+);

package/src/helpers/constants.ts

@@ -0,0 +1,3 @@
+export const REG_IDENTIFIER = /(?:_+|@+|\$+|\p{XID_Start})\p{XID_Continue}*/u;
+export const REG_ORDINAL =
+    /(?:0|[1-9]\d{0,8}|1\d{9}|20\d{8}|21[0-3]\d{7}|214[0-6]\d{6}|2147[0-3]\d{5}|21474[0-7]\d{4}|214748[0-2]\d{3}|2147483[0-5]\d{2}|21474836[0-3]\d|214748364[0-7])/;

package/src/helpers/serialize.ts

@@ -0,0 +1,280 @@
+import {
+    isVmArray,
+    isVmRecord,
+    type VmArray,
+    type VmExtern,
+    type VmFunction,
+    type VmModule,
+    type VmAny,
+    type VmRecord,
+    isVmFunction,
+    isVmModule,
+    isVmExtern,
+} from '../vm/index.js';
+import { REG_IDENTIFIER, REG_ORDINAL } from './constants.js';
+import { entries, isFinite, isNaN } from '../helpers/utils.js';
+
+const REG_IDENTIFIER_FULL = new RegExp(`^${REG_IDENTIFIER.source}$`, REG_IDENTIFIER.flags);
+const REG_ORDINAL_FULL = new RegExp(`^${REG_ORDINAL.source}$`, REG_ORDINAL.flags);
+
+/** 序列化设置 */
+export interface SerializeOptions {
+    /** 最大递归深度，超过该深度的值将被序列化为 `nil`，默认值为 128 */
+    maxDepth: number;
+    /** 序列化 nil 值 */
+    serializeNil: (options: SerializeOptions) => string;
+    /** 序列化布尔值 */
+    serializeBoolean: (value: boolean, options: SerializeOptions) => string;
+    /** 序列化数字 */
+    serializeNumber: (value: number, options: SerializeOptions) => string;
+    /** 序列化字符串 */
+    serializeString: (value: string, options: SerializeOptions) => string;
+    /** 序列化字符串引号 */
+    serializeStringQuote: (value: string, open: boolean, options: SerializeOptions) => string;
+    /** 序列化字符串转义序列 */
+    serializeStringEscape: (value: string, options: SerializeOptions) => string;
+    /** 序列化字符串常规内容 */
+    serializeStringContent: (value: string, options: SerializeOptions) => string;
+    /** 序列化函数 */
+    serializeFunction: (value: VmFunction, options: SerializeOptions) => string;
+    /** 序列化数组 */
+    serializeArray: (value: VmArray, depth: number, options: SerializeOptions) => string;
+    /** 序列化记录 */
+    serializeRecord: (value: VmRecord, depth: number, options: SerializeOptions) => string;
+    /** 序列化属性名 */
+    serializePropName: (value: string | number, options: SerializeOptions) => string;
+    /** 序列化模块 */
+    serializeModule: (value: VmModule, depth: number, options: SerializeOptions) => string;
+    /** 序列化外部值 */
+    serializeExtern: (value: VmExtern, depth: number, options: SerializeOptions) => string;
+}
+
+const DEFAULT_OPTIONS = Object.freeze({
+    maxDepth: 128,
+    serializeNil,
+    serializeBoolean,
+    serializeNumber,
+    serializeString: serializeStringImpl,
+    serializeStringQuote: (value) => value,
+    serializeStringEscape: (value) => value,
+    serializeStringContent: (value) => value,
+    serializeArray,
+    serializeRecord,
+    serializePropName: String,
+    serializeFunction: serializeNil,
+    serializeModule: serializeNil,
+    serializeExtern: serializeNil,
+} satisfies SerializeOptions);
+
+/** 获取选项 */
+export function getSerializeOptions(options: Partial<SerializeOptions> | undefined): SerializeOptions {
+    if (options == null) return DEFAULT_OPTIONS;
+    const opt = { ...DEFAULT_OPTIONS };
+    for (const key in options) {
+        const el = options[key as keyof SerializeOptions];
+        if (el != null) {
+            opt[key as keyof SerializeOptions] = el as never;
+        }
+    }
+    return Object.freeze(opt);
+}
+
+/**
+ * 将 MiraScript 字符串序列化为 MiraScript 字面量。
+ */
+function serializeStringImpl(value: string, options: SerializeOptions): string {
+    if (!/[\p{C}'"`$\\]/u.test(value)) {
+        // 不包含特殊字符
+        const oq = options.serializeStringQuote(`'`, true, options);
+        const cq = options.serializeStringQuote(`'`, false, options);
+        const c = options.serializeStringContent(value, options);
+        return oq + c + cq;
+    }
+    let ret = options.serializeStringQuote(`'`, true, options);
+    for (const char of value) {
+        if (char === "'") {
+            ret += options.serializeStringEscape(String.raw`\'`, options);
+        } else if (char === '\0') {
+            ret += options.serializeStringEscape(String.raw`\0`, options);
+        } else if (char === '\n') {
+            ret += options.serializeStringEscape(String.raw`\n`, options);
+        } else if (char === '\r') {
+            ret += options.serializeStringEscape(String.raw`\r`, options);
+        } else if (char === '\t') {
+            ret += options.serializeStringEscape(String.raw`\t`, options);
+        } else if (char === '\b') {
+            ret += options.serializeStringEscape(String.raw`\b`, options);
+        } else if (char === '\f') {
+            ret += options.serializeStringEscape(String.raw`\f`, options);
+        } else if (char === '\v') {
+            ret += options.serializeStringEscape(String.raw`\v`, options);
+        } else if (char === '\\') {
+            ret += options.serializeStringEscape(String.raw`\\`, options);
+        } else if (char === '$') {
+            ret += options.serializeStringEscape(String.raw`\$`, options);
+        } else if (/\p{C}/u.test(char)) {
+            const code = char.codePointAt(0)!;
+            if (code <= 0x7f) {
+                ret += options.serializeStringEscape(String.raw`\x${code.toString(16).padStart(2, '0')}`, options);
+            } else if (code >= 0xd800 && code <= 0xdfff) {
+                // 无效的代理对
+                ret += options.serializeStringContent('�', options);
+            } else {
+                ret += options.serializeStringEscape(String.raw`\u{${code.toString(16)}}`, options);
+            }
+        } else {
+            ret += options.serializeStringContent(char, options); // 普通字符直接添加
+        }
+    }
+    ret += options.serializeStringQuote(`'`, false, options);
+    return ret;
+}
+
+/**
+ * 将 MiraScript 字符串序列化为 MiraScript 字面量。
+ */
+export function serializeString(value: string, options?: Partial<SerializeOptions>): string {
+    return serializeStringImpl(value, getSerializeOptions(options));
+}
+
+/** 序列化属性名 */
+function serializePropNameImpl(value: string, options: SerializeOptions): string {
+    if (REG_ORDINAL_FULL.test(value)) {
+        // 合法的数字属性名
+        return options.serializePropName(Number(value), options);
+    }
+    if (REG_IDENTIFIER_FULL.test(value)) {
+        // 合法的标识符
+        return options.serializePropName(value, options);
+    }
+    // 否则，序列化为字符串
+    return options.serializeString(value, options);
+}
+
+/** 序列化属性名 */
+export function serializePropName(value: string, options?: Partial<SerializeOptions>): string {
+    return serializePropNameImpl(value, getSerializeOptions(options));
+}
+
+/** 序列化 nil 值 */
+function serializeNil(): string {
+    return 'nil';
+}
+
+/** 序列化布尔值 */
+function serializeBoolean(value: boolean): string {
+    return value ? 'true' : 'false';
+}
+
+/** 序列化数字 */
+function serializeNumber(value: number): string {
+    if (isNaN(value)) return 'nan';
+    if (!isFinite(value)) return value < 0 ? '-inf' : 'inf';
+    if (value === 0) {
+        if (1 / value < 0) return '-0';
+        return '0';
+    }
+    return String(value);
+}
+
+/** 序列化数组 */
+function serializeArray(value: VmArray, depth: number, options: SerializeOptions): string {
+    if (depth > options.maxDepth) return `[]`;
+    if (value.length === 0) return '[]';
+    let str = '[';
+    for (let i = 0; i < value.length; i++) {
+        if (i > 0) str += ', ';
+        str += serializeImpl(value[i], depth, options);
+    }
+    str += ']';
+    return str;
+}
+
+// eslint-disable-next-line @typescript-eslint/unbound-method
+const { valueOf } = Object.prototype;
+/**
+ * 如果值有自定义的 valueOf 方法，调用它并返回结果，否则返回 undefined。
+ */
+function customValueOf(value: VmRecord): VmAny | undefined {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    const thisValueOf = value.valueOf;
+    if (typeof thisValueOf != 'function' || thisValueOf === valueOf) {
+        return undefined;
+    }
+    const customValue = thisValueOf.call(value) as VmAny | undefined;
+    if (customValue === value) return undefined;
+    return customValue;
+}
+
+/** 序列化记录 */
+function serializeRecord(value: VmRecord, depth: number, options: SerializeOptions): string {
+    const customValue = customValueOf(value);
+    if (customValue !== undefined) {
+        return serializeImpl(customValue, depth - 1, options);
+    }
+    if (depth > options.maxDepth) return `()`;
+    const e = entries(value);
+    if (e.length === 0) return '()';
+    if (e.length === 1) {
+        const [k, v] = e[0]!;
+        if (k === '0') {
+            return `(${serializeImpl(v, depth, options)},)`; // 单个元素数组
+        }
+        return `(${serializePropNameImpl(k, options)}: ${serializeImpl(v, depth, options)})`;
+    }
+
+    // 根据 ES 标准，数字 key 会按顺序枚举
+    const omitKey = e.length < 10 && e.every(([key], index) => key === String(index));
+    let str = '(';
+    for (const [key, val] of e) {
+        if (str.length > 1) str += ', ';
+        if (omitKey) {
+            str += serializeImpl(val, depth, options);
+        } else {
+            str += `${serializePropNameImpl(key, options)}: ${serializeImpl(val, depth, options)}`;
+        }
+    }
+    str += ')';
+    return str;
+}
+
+/** 序列化 */
+function serializeImpl(value: VmAny | undefined, depth: number, options: SerializeOptions): string {
+    if (value == null) {
+        return options.serializeNil(options);
+    }
+    if (typeof value == 'boolean') {
+        return options.serializeBoolean(value, options);
+    }
+    if (typeof value == 'number') {
+        return options.serializeNumber(value, options);
+    }
+    if (typeof value == 'string') {
+        return options.serializeString(value, options);
+    }
+    if (isVmFunction(value)) {
+        return options.serializeFunction(value, options);
+    }
+    if (isVmModule(value)) {
+        return options.serializeModule(value, depth + 1, options);
+    }
+    if (isVmExtern(value)) {
+        return options.serializeExtern(value, depth + 1, options);
+    }
+    if (isVmArray(value)) {
+        return options.serializeArray(value, depth + 1, options);
+    }
+    if (isVmRecord(value)) {
+        return options.serializeRecord(value, depth + 1, options);
+    }
+    // 不支持序列化的值
+    value satisfies never;
+    return options.serializeNil(options);
+}
+
+/**
+ * 将 MiraScript 值序列化为 MiraScript 字面量字符串，非常量值将被转换为 `nil`。
+ */
+export function serialize(value: VmAny, options?: Partial<SerializeOptions>): string {
+    return serializeImpl(value, 0, getSerializeOptions(options));
+}

package/src/helpers/utils.ts

@@ -0,0 +1,16 @@
+export const { isArray } = Array;
+export const { isFinite, isNaN, isInteger, isSafeInteger } = Number;
+export const { hasOwn, keys, values, entries, create, getPrototypeOf, fromEntries, defineProperty } = Object;
+
+/**
+ * Determines whether an object has an enumerable property with the specified name.
+ */
+export const hasOwnEnumerable = Function.call.bind<
+    object['propertyIsEnumerable'],
+    [],
+    [o: object, v: PropertyKey],
+    boolean
+>(
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    Object.prototype.propertyIsEnumerable,
+);

package/src/index.ts

@@ -0,0 +1,3 @@
+export { serialize } from './helpers/serialize.js';
+export * from './compiler/index.js';
+export * from './vm/index.js';

package/src/subtle.ts

@@ -0,0 +1,6 @@
+export * as constants from './helpers/constants.js';
+export { VmSharedContext, DefaultVmContext } from './vm/types/context.js';
+export * as operations from './vm/operations.js';
+export { serialize, serializeString, serializePropName, type SerializeOptions } from './helpers/serialize.js';
+export { lib } from './vm/lib/_loader.js';
+export * from './compiler/diagnostic.js';

package/src/vm/env.ts

@@ -0,0 +1,16 @@
+import * as operations from './operations.js';
+import * as helpers from './helpers.js';
+import { entries } from '../helpers/utils.js';
+
+export const keys: string[] = [];
+export const values: unknown[] = [];
+
+for (const [key, value] of entries(operations)) {
+    keys.push(key);
+    values.push(value);
+}
+
+for (const [key, value] of entries(helpers)) {
+    keys.push(key);
+    values.push(value);
+}

package/src/vm/error.ts

@@ -0,0 +1,22 @@
+import type { VmAny } from './types/index.js';
+
+/**
+ * VM 预期的错误
+ */
+export class VmError extends Error {
+    constructor(
+        message: string,
+        readonly recovered: VmAny,
+    ) {
+        super(message);
+        this.name = 'VmError';
+    }
+
+    /** 从其他错误构造 */
+    static from(prefix: string, error: unknown, recovered: VmAny): VmError {
+        if (prefix && !prefix.endsWith(': ')) prefix += ': ';
+        const vmError = new VmError(`${prefix}${error instanceof Error ? error.message : String(error)}`, recovered);
+        vmError.stack = error instanceof Error ? error.stack : undefined;
+        return vmError;
+    }
+}

package/src/vm/helpers.ts

@@ -0,0 +1,121 @@
+import { $AssertInit, $ToNumber } from './operations.js';
+import type { VmFunctionLike } from './types/function.js';
+import { DefaultVmContext, type VmContext } from './types/context.js';
+import {
+    isVmConst,
+    VmFunction,
+    type VmConst,
+    type VmAny,
+    type VmArray,
+    type VmValue,
+    VM_ARRAY_MAX_LENGTH,
+} from './types/index.js';
+import { isFinite } from '../helpers/utils.js';
+
+export const Vargs = (varags: VmAny[]): VmArray => {
+    for (let i = 0, l = varags.length; i < l; i++) {
+        const el = varags[i];
+        if (!isVmConst(el)) {
+            varags[i] = null;
+        }
+    }
+    return varags as VmArray;
+};
+export const Element = (value: VmAny): VmConst => {
+    $AssertInit(value);
+    if (!isVmConst(value)) return null;
+    return value;
+};
+
+export const ElementOpt = (key: string, value: VmAny): VmConst => {
+    $AssertInit(value);
+    if (value == null || !isVmConst(value)) return {};
+    return { [key]: value };
+};
+
+export const Function = (fn: VmFunctionLike): VmFunction => {
+    return VmFunction(fn, { isLib: false, injectCp: false });
+};
+
+export const Upvalue = (value: VmAny): VmValue => {
+    $AssertInit(value);
+    return value;
+};
+
+const assertArrayLength = (start: number, end: number) => {
+    if (end - start > VM_ARRAY_MAX_LENGTH) {
+        throw new RangeError(`Array length exceeds maximum limit of ${VM_ARRAY_MAX_LENGTH}`);
+    }
+};
+const isEmptyRange = (start: number, end: number) => {
+    return !isFinite(start) || !isFinite(end) || start > end;
+};
+export const ArrayRange = (start: VmAny, end: VmAny): VmArray => {
+    const s = $ToNumber(start);
+    const e = $ToNumber(end);
+    if (isEmptyRange(s, e)) return [];
+    assertArrayLength(s, e);
+    const arr = [];
+    for (let i = s; i <= e; i++) {
+        arr.push(i);
+    }
+    return arr;
+};
+export const ArrayRangeExclusive = (start: VmAny, end: VmAny): VmArray => {
+    const s = $ToNumber(start);
+    const e = $ToNumber(end);
+    if (isEmptyRange(s, e)) return [];
+    assertArrayLength(s, e);
+    const arr = [];
+    for (let i = s; i < e; i++) {
+        arr.push(i);
+    }
+    return arr;
+};
+
+const MAX_DEPTH = 128;
+
+let cpDepth = 0;
+let cp = Number.NaN;
+let cpTimeout = 100; // Default timeout in milliseconds
+/** 检查点 */
+export function Cp(): void {
+    if (!cp) {
+        cp = Date.now();
+    } else if (Date.now() - cp > cpTimeout) {
+        throw new RangeError('Execution timeout');
+    }
+}
+/** 检查点 */
+export function CpEnter(): void {
+    cpDepth++;
+    if (cpDepth <= 1) {
+        cp = Date.now();
+        cpDepth = 1;
+    } else if (cpDepth > MAX_DEPTH) {
+        throw new RangeError('Maximum call depth exceeded');
+    } else {
+        Cp();
+    }
+}
+/** 检查点 */
+export function CpExit(): void {
+    cpDepth--;
+    if (cpDepth < 1) {
+        cp = Number.NaN;
+        cpDepth = 0;
+    } else {
+        Cp();
+    }
+}
+/** 设置检查点超时时间 */
+export function configCheckpoint(timeout = 100): void {
+    if (typeof timeout !== 'number' || timeout <= 0 || Number.isNaN(timeout)) {
+        throw new RangeError('Invalid timeout value');
+    }
+    cpTimeout = timeout;
+}
+/** 默认执行上下文 */
+export function GlobalFallback(): VmContext {
+    return DefaultVmContext;
+}

package/src/vm/index.ts

@@ -0,0 +1,5 @@
+import './lib/_loader.js';
+
+export * from './error.js';
+export * from './types/index.js';
+export { configCheckpoint } from './helpers.js';