@mirascript/monaco 0.1.0

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mirascript/monaco",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Monaco Editor integration for Mirascript.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "@mirascript/dev": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./basic": {
+      "@mirascript/dev": "./src/basic/index.ts",
+      "default": "./dist/basic/index.js"
+    },
+    "./lsp": {
+      "@mirascript/dev": "./src/lsp/index.ts",
+      "default": "./dist/lsp/index.js"
+    }
+  },
+  "imports": {
+    "#lsp/worker": {
+      "@mirascript/dev": "./src/lsp/worker.ts",
+      "default": "./dist/lsp/worker.js"
+    }
+  },
+  "dependencies": {
+    "@mirascript/wasm": "~0.1.0",
+    "@mirascript/mirascript": "~0.1.0"
+  },
+  "peerDependencies": {
+    "monaco-editor": ">= 0.0.40 < 0.53.0"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc && node ./esbuild.config.js",
+    "clean": "rimraf dist"
+  }
+}

package/src/basic/index.ts

@@ -0,0 +1,11 @@
+import { ready } from '@mirascript/wasm';
+import type { IDisposable } from '../monaco-api.js';
+import { setLanguageConfiguration, configuration } from './language-configuration.js';
+import { registerMiraScriptTokensProvider } from './tokens-provider.js';
+
+export { configuration };
+/** 注册 */
+export async function registerBasic(): Promise<IDisposable[]> {
+    await ready;
+    return [...setLanguageConfiguration(), ...registerMiraScriptTokensProvider()];
+}

package/src/basic/language-configuration.ts

@@ -0,0 +1,90 @@
+import { type IDisposable, languages } from '../monaco-api.js';
+import { MAX_VERBATIM_LENGTH } from '../constants.js';
+
+/** 缩进配置 */
+function indentAction(action: keyof typeof languages.IndentAction): { indentAction: languages.IndentAction } {
+    if (languages == null) {
+        // vscode
+        return {
+            indent: action[0]?.toLowerCase() + action.slice(1),
+        } as unknown as { indentAction: languages.IndentAction };
+    }
+    return { indentAction: languages.IndentAction[action] };
+}
+
+export const configuration = (): languages.LanguageConfiguration => ({
+    comments: {
+        lineComment: '//',
+        blockComment: ['/*', '*/'],
+    },
+    brackets: [
+        ...Array.from({ length: MAX_VERBATIM_LENGTH }).flatMap((_, i): languages.CharacterPair[] => {
+            const prefix = '$'.repeat(MAX_VERBATIM_LENGTH - i - 1);
+            return [
+                [`${prefix}{`, '}'],
+                [`${prefix}(`, ')'],
+            ];
+        }),
+        ['[', ']'],
+    ],
+    wordPattern: /(-?\d+\.\w+([+-]\w*)?)|([^`~!#%^&*()\-=+[{\]}\\|;:'",.<>/?\s]+)/g,
+    autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"', notIn: ['string'] },
+        { open: "'", close: "'", notIn: ['string', 'comment'] },
+        { open: '`', close: '`', notIn: ['string', 'comment'] },
+        { open: '/**', close: ' */', notIn: ['string'] },
+    ],
+    onEnterRules: [
+        {
+            // e.g. /** | */
+            beforeText: /^\s*\/\*\*(?!\/)([^*]|\*(?!\/))*$/,
+            afterText: /^\s*\*\/$/,
+            action: {
+                ...indentAction('IndentOutdent'),
+                appendText: ' * ',
+            },
+        },
+        {
+            // e.g. /** ...|
+            beforeText: /^\s*\/\*\*(?!\/)([^*]|\*(?!\/))*$/,
+            action: {
+                ...indentAction('None'),
+                appendText: ' * ',
+            },
+        },
+        {
+            // e.g.  * ...|
+            beforeText: /^(\t|( {2}))* \*( ([^*]|\*(?!\/))*)?$/,
+            action: {
+                ...indentAction('None'),
+                appendText: '* ',
+            },
+        },
+        {
+            // e.g.  */|
+            beforeText: /^(\t|( {2}))* \*\/\s*$/,
+            action: {
+                ...indentAction('None'),
+                removeText: 1,
+            },
+        },
+    ],
+    autoCloseBefore: '*/%^ &| ><= )}] ;,?: \'"` \n\t ~#\\',
+    folding: {
+        markers: {
+            start: /^\s*\/\/#?\s*?region\b/gu,
+            end: /^\s*\/\/#?\s*?endregion\b/gu,
+        },
+    },
+});
+
+/** 注册语言配置 */
+export function setLanguageConfiguration(): IDisposable[] {
+    return [
+        languages.setLanguageConfiguration('mirascript', configuration()),
+        languages.setLanguageConfiguration('mirascript-template', configuration()),
+    ];
+}

package/src/basic/tokens-provider.ts

@@ -0,0 +1,358 @@
+import { languages, type IDisposable } from '../monaco-api.js';
+import {
+    REG_WHITESPACE,
+    REG_ORDINAL,
+    REG_OCT,
+    REG_BIN,
+    REG_HEX,
+    REG_NUMBER,
+    REG_IDENTIFIER,
+    DOC_HEADER,
+    MAX_VERBATIM_LENGTH,
+    constantKeywords,
+    controlKeywords,
+    keywords,
+    numericKeywords,
+} from '../constants.js';
+
+/** 匹配 identifier */
+function identifierCases(
+    data?: Partial<languages.IExpandedMonarchLanguageAction>,
+    defaultToken = 'variable',
+): Record<string, languages.IExpandedMonarchLanguageAction> {
+    return {
+        '@numericKeywords': { ...data, token: `constant.numeric` },
+        '@constantKeywords': { ...data, token: `constant.language` },
+        '@controlKeywords': { ...data, token: `keyword.control` },
+        '@keywords': { ...data, token: `keyword` },
+        '[@]+.*': { ...data, token: `variable.other.constant` },
+        '~it': { ...data, token: `variable.other.constant.emphasis` },
+        '@default': { ...data, token: defaultToken },
+    };
+}
+
+/** 生成 TokensProvider */
+function getTokensProvider(mode: string): languages.IMonarchLanguage {
+    return {
+        ignoreCase: false,
+        unicode: true,
+        includeLF: false,
+        brackets: [
+            { open: '{', close: '}', token: 'delimiter.curly' },
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+        ],
+        defaultToken: 'invalid',
+
+        whitespace: REG_WHITESPACE,
+        identifier: REG_IDENTIFIER,
+        docHeader: DOC_HEADER,
+
+        keywords: keywords(),
+        controlKeywords: controlKeywords(),
+        constantKeywords: constantKeywords(),
+        numericKeywords: numericKeywords(),
+
+        inlineDocParam: /\(parameter(?: pattern)?\)/,
+
+        start: mode === 'template' ? 'root_template' : 'root',
+        tokenPostfix: '.mirascript',
+        tokenizer: {
+            root: [
+                [/^(?=\0)/, '', '@doc_mode'],
+                [/^\/\*\*@docHeader\*\*\/$/, 'comment.doc', '@doc_mode'],
+                [/[[\](){}]/, '@brackets'],
+                { include: '@common' },
+            ],
+            root_template: [
+                [/[^$]+/, 'string'],
+                [/(?=\$)/, '', '@string_interpolation.$S3'],
+                [/[$]/, 'string'],
+            ],
+            common: [
+                [/(@identifier)(@whitespace*)(\??:)(?!:)/, ['support.type.property-name', '', 'delimiter']],
+                [
+                    /(fn)(@whitespace+)(@identifier)(?=$|@whitespace|[[({,;])/,
+                    ['keyword', '', { cases: identifierCases(undefined, 'entity.name.function') }],
+                ],
+                [
+                    /(for)(@whitespace+)(mut)(@whitespace+)(@identifier)(@whitespace+)(in)/,
+                    ['keyword.control', '', 'keyword', '', { cases: identifierCases() }, '', 'keyword.control'],
+                ],
+                [
+                    /(for)(@whitespace+)(@identifier)(@whitespace+)(in)/,
+                    ['keyword.control', '', { cases: identifierCases() }, '', 'keyword.control'],
+                ],
+                [
+                    /(\.)(@whitespace*)(\d+)/,
+                    [
+                        'delimiter',
+                        '',
+                        {
+                            cases: {
+                                [REG_ORDINAL.source]: 'number.ordinal',
+                                '@default': 'number.float',
+                            },
+                        },
+                    ],
+                ],
+                [
+                    /(\.)(@whitespace*)(@identifier)(@whitespace*)(!?)(@whitespace*(?=\())/,
+                    ['delimiter', '', 'entity.name.function', '', 'delimiter', ''],
+                ],
+                [/(\.)(@whitespace*)(@identifier)/, ['delimiter', '', 'variable']],
+                [
+                    /(@identifier)(@whitespace*(?=\())/,
+                    [
+                        {
+                            cases: identifierCases(undefined, `entity.name.function`),
+                        },
+                        '',
+                    ],
+                ],
+                { include: '@whitespace' },
+                { include: '@string' },
+                [/(@identifier)/, { cases: identifierCases() }],
+                [REG_OCT, 'number.octal'],
+                [REG_BIN, 'number.binary'],
+                [REG_HEX, 'number.hex'],
+                [
+                    REG_NUMBER,
+                    {
+                        cases: {
+                            [REG_ORDINAL.source]: 'number.ordinal',
+                            '@default': 'number.float',
+                        },
+                    },
+                ],
+                [/(\.\.|\?:|[-+=/~?:;,.!@$%^&|*<>])/, 'delimiter'],
+                [REG_ORDINAL, 'number.ordinal'],
+            ],
+            whitespace: [
+                [/(@whitespace)+/, ''],
+                [/\/\/.*$/, 'comment.line'],
+                [/\/\*{2}/, 'comment.doc', '@doc_comment'],
+                [/\/\*/, 'comment.block', '@block_comment'],
+            ],
+            string: [
+                [/["'`]/, { token: 'string.quote.open', next: '@string_normal.$#', bracket: '@open' }],
+                [
+                    /(@+)(["'`])/,
+                    { token: 'string.quote.open.$2$1.raw', next: '@string_verbatim.$2$1.$1', bracket: '@open' },
+                ],
+            ],
+            string_normal: [
+                [/[^'"`\\$]+/, 'string'],
+                { include: '@string_escape' },
+                [/(?=\$)/, '', '@string_interpolation.'],
+                [
+                    /['"`]/,
+                    {
+                        cases: {
+                            '$S2==$#': { token: 'string.quote.close', next: '@pop', bracket: '@close' },
+                            '@default': 'string',
+                        },
+                    },
+                ],
+            ],
+            string_verbatim: [
+                [/[^'"`$]+/, 'string'],
+                [/(?=\$)/, '', '@string_interpolation.$S3'],
+                [
+                    /(['"`]@+)/,
+                    {
+                        cases: {
+                            '$S2==$#': { token: 'string.quote.close.raw.$#', next: '@pop', bracket: '@close' },
+                            '@default': 'string',
+                        },
+                    },
+                ],
+                [/['"`$]/, 'string'],
+            ],
+            string_escape: [
+                [/\\([\\'"`$rntbfv0])/, 'string.escape'],
+                [/\\u\{([0-9a-fA-F]+)\}/, 'string.escape.unicode'],
+                [/\\x([0-9a-fA-F]{2})/, 'string.escape.ascii'],
+                [/\\./, { token: 'string.escape.invalid' }],
+            ],
+            ...Object.fromEntries(
+                Array.from({ length: MAX_VERBATIM_LENGTH }, (_, i) => {
+                    const dollarCount = i === 0 ? 1 : i;
+                    const dollarRegex = `\\\${${dollarCount}}`;
+                    return [
+                        `string_interpolation.${'@'.repeat(i)}`,
+                        [
+                            [
+                                `(${dollarRegex})(${REG_IDENTIFIER.source})`,
+                                ['punctuation.section.embedded', { cases: identifierCases({ next: '@pop' }) }],
+                            ],
+                            [
+                                `(${dollarRegex}\\{)`,
+                                {
+                                    token: 'punctuation.section.embedded',
+                                    bracket: '@open',
+                                    next: '@braced',
+                                },
+                            ],
+                            [
+                                `(${dollarRegex}\\()`,
+                                {
+                                    token: 'punctuation.section.embedded',
+                                    bracket: '@open',
+                                    next: '@parenthesized',
+                                },
+                            ],
+                            [`\\\${0,${dollarCount}}`, 'string', '@pop'],
+                            ['', '', '@pop'],
+                        ],
+                    ];
+                }),
+            ),
+            string_interpolation: [[/\$*/, 'string', '@pop']],
+
+            braced: [
+                [/\{/, { token: '@brackets', next: '@push' }],
+                [/\}/, { token: '@brackets', next: '@pop' }],
+                [/[[\]()]/, '@brackets'],
+                { include: '@common' },
+            ],
+            parenthesized: [
+                [/\(/, { token: '@brackets', next: '@push' }],
+                [/\)/, { token: '@brackets', next: '@pop' }],
+                [/[[\]{}]/, '@brackets'],
+                { include: '@common' },
+            ],
+            bracketed: [
+                [/\[/, { token: '@brackets', next: '@push' }],
+                [/\]/, { token: '@brackets', next: '@pop' }],
+                [/[(){}]/, '@brackets'],
+                { include: '@common' },
+            ],
+
+            block_comment: [
+                [/\*\//, { token: 'comment.block', next: '@pop' }],
+                [/[^*]+/, { token: 'comment.block' }],
+                [/\*/, { token: 'comment.block' }],
+            ],
+
+            doc_comment: [
+                [/\*\//, { token: 'comment.doc', next: '@pop' }],
+                [/^(\s*)\*(?!\/)/, { token: 'comment.doc' }],
+                [/\\\*(?!\/)/, { token: 'comment.doc.escape' }],
+                [/@(param|returns)/, { token: 'entity.name.tag.doc' }],
+                [/\*{2}(\S|\S.*?\S)\*{2}(?!\/)/, { token: 'comment.strong' }],
+                [/\*(\S|\S.*?\S)\*(?!\/)/, { token: 'comment.emphasis' }],
+                [/[^*@\\]+/, { token: 'comment.doc' }],
+                [/[*@\\]/, { token: 'comment.doc' }],
+            ],
+
+            doc_mode: [
+                // inline doc, start with `\0`
+                [
+                    /^(\0@inlineDocParam)(@whitespace+)(\.\.|)(mut)(@whitespace+)(@identifier)/,
+                    ['entity.name.label', '', 'delimiter', 'keyword.mut', '', 'variable.emphasis'],
+                ],
+                [
+                    /^(\0@inlineDocParam)(@whitespace+)(\.\.|)(@identifier)/,
+                    ['entity.name.label', '', 'delimiter', 'variable.other.constant.emphasis'],
+                ],
+                [/^(\0\(@identifier\))(@whitespace+)/, ['entity.name.label', '']],
+
+                [
+                    /(@identifier)(@whitespace*)(:)(@whitespace*)(\/\*@whitespace*<)(extern )([.\w]*Function)(>@whitespace*\*\/)/,
+                    [
+                        'entity.name.function.doc',
+                        '',
+                        'delimiter',
+                        '',
+                        'comment.doc',
+                        'type',
+                        'entity.name.label',
+                        'comment.doc',
+                    ],
+                ],
+                [
+                    /(@identifier)(@whitespace*)(:)(@whitespace*)(\/\*@whitespace*<)(function )([.\w]*)(>@whitespace*\*\/)/,
+                    [
+                        'entity.name.function.doc',
+                        '',
+                        'delimiter',
+                        '',
+                        'comment.doc',
+                        'type',
+                        'entity.name.label',
+                        'comment.doc',
+                    ],
+                ],
+                [/(@identifier)(@whitespace*)(:)(@whitespace+)/, ['support.type.property-name', '', 'delimiter', '']],
+                [
+                    /(\/\*@whitespace*<)(\w+@whitespace*)([.\w]*)(>@whitespace*\*\/)/,
+                    ['comment.doc', 'type', 'entity.name.label', 'comment.doc'],
+                ],
+                [/(\s*)(\(module\))(\s*)(@identifier)/, ['', 'entity.name.label', '', 'entity.name.namespace']],
+
+                [/(fn)(@whitespace+)(@identifier)$/, ['keyword.fn.doc', '', 'entity.name.function.doc']],
+                [
+                    /(fn)(@whitespace+)(@identifier)(\()(\.\.)(\))$/,
+                    ['keyword.fn.doc', '', 'entity.name.function.doc', '@brackets', 'delimiter', '@brackets'],
+                ],
+                [/fn/, 'keyword.fn.doc', '@fn_doc'],
+                [
+                    /(let)(@whitespace+)(mut)(@whitespace+)(@identifier)/,
+                    [{ token: 'keyword.$1' }, '', 'keyword.mut', '', { token: 'variable', next: '@root' }],
+                ],
+                [
+                    /(let|const)(@whitespace+)(@identifier)/,
+                    [{ token: 'keyword.$1' }, '', { token: 'variable.other.constant', next: '@root' }],
+                ],
+                { include: '@common' },
+                [/[[\](){}]/, '@brackets'],
+            ],
+            fn_doc: [
+                [/(@identifier)(\()/, ['entity.name.function.doc', '@brackets']],
+                [/@whitespace+/, ''],
+                [
+                    /(\.\.|)(@identifier)(\s*)(:|,|\))/,
+                    [
+                        'delimiter',
+                        'variable.emphasis.doc',
+                        '',
+                        {
+                            cases: {
+                                ':': { token: 'delimiter', next: '@type_doc' },
+                                '\\)': '@brackets',
+                                '@default': 'delimiter',
+                            },
+                        },
+                    ],
+                ],
+                [/[()]/, '@brackets'],
+                [/(->)/, 'delimiter', '@type_doc'],
+                [/;/, { token: 'delimiter', next: '@pop', goBack: 1 }],
+            ],
+            type_doc: [
+                { include: '@type_doc_common' },
+                [/[,)]/, 'delimiter', '@pop'],
+                [/;/, { token: 'delimiter', next: '@pop', goBack: 1 }],
+            ],
+            type_doc_inner: [{ include: '@type_doc_common' }, [/[,;]/, 'delimiter']],
+            type_doc_common: [
+                [/fn\b/, 'type', '@fn_doc'],
+                [/(type)(\()(@identifier)(\))/, ['type', '@brackets', 'variable.emphasis.doc', '@brackets']],
+                [/@identifier/, 'type'],
+                [/[[(]/, '@brackets', '@type_doc_inner'],
+                [/[\])]/, '@brackets', '@pop'],
+                [/[&|.]/, 'delimiter'],
+                [/@whitespace+/, ''],
+            ],
+        },
+    };
+}
+
+/** 注册 Mirascript 的 TokensProvider */
+export function registerMiraScriptTokensProvider(): IDisposable[] {
+    return [
+        languages.setMonarchTokensProvider('mirascript', getTokensProvider('script')),
+        languages.setMonarchTokensProvider('mirascript-template', getTokensProvider('template')),
+    ];
+}

package/src/constants.ts

@@ -0,0 +1,56 @@
+import { constants } from '@mirascript/mirascript/subtle';
+import { wasm } from '@mirascript/wasm';
+
+/** 所有 MiraScript 关键字 */
+export let keywords = (): readonly string[] => {
+    const kw = wasm.keywords();
+    Object.freeze(kw);
+    keywords = () => kw;
+    return kw;
+};
+
+/** MiraScript 控制流关键字 */
+export let controlKeywords = (): readonly string[] => {
+    const kw = wasm.control_keywords();
+    Object.freeze(kw);
+    controlKeywords = () => kw;
+    return kw;
+};
+
+/** MiraScript 数值字面量关键字 */
+export let numericKeywords = (): readonly string[] => {
+    const kw = wasm.numeric_keywords();
+    Object.freeze(kw);
+    numericKeywords = () => kw;
+    return kw;
+};
+
+/** MiraScript 字面量关键字 */
+export let constantKeywords = (): readonly string[] => {
+    const kw = wasm.constant_keywords();
+    Object.freeze(kw);
+    constantKeywords = () => kw;
+    return kw;
+};
+
+/** MiraScript 保留字关键字 */
+export let reservedKeywords = (): readonly string[] => {
+    const kw = wasm.reserved_keywords();
+    Object.freeze(kw);
+    reservedKeywords = () => kw;
+    return kw;
+};
+
+export const { REG_IDENTIFIER, REG_ORDINAL } = constants;
+
+export const REG_WHITESPACE = /[ \t\v\f\r\n]/u;
+export const REG_HEX = /0[xX][a-fA-F0-9_]*[a-fA-F0-9]/;
+export const REG_OCT = /0[oO][0-7_]*[0-7]/;
+export const REG_BIN = /0[bB][01_]*[01]/;
+export const REG_NUMBER = /\d[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?[\d_]*\d)?/u;
+
+// Special characters
+export const DOC_HEADER = ' 𝙼𝚒𝚛𝚊𝚂𝚌𝚛𝚒𝚙𝚝 𝙶𝚕𝚘𝚋𝚊𝚕 𝙳𝚎𝚏𝚒𝚗𝚒𝚝𝚒𝚘𝚗𝚜 ';
+
+/** 基础语言服务支持的最大插值字符串 `$` 数量 */
+export const MAX_VERBATIM_LENGTH = 16;

package/src/contribute.ts

@@ -0,0 +1,18 @@
+import { languages } from './monaco-api.js';
+
+/** 注册语言 */
+export function registerContribution(): void {
+    languages.register({
+        id: 'mirascript',
+        extensions: ['.mira'],
+        aliases: ['MiraScript', 'mirascript', 'mira'],
+        mimetypes: ['text/x-mirascript'],
+    });
+
+    languages.register({
+        id: 'mirascript-template',
+        extensions: ['.miratpl'],
+        aliases: ['MiraScriptTemplate', 'mirascript-template', 'miratpl'],
+        mimetypes: ['text/x-mirascript-template'],
+    });
+}

package/src/index.ts

@@ -0,0 +1,71 @@
+import type { VmContext } from '@mirascript/mirascript';
+import { type editor, languages, registerMonacoApi, type IDisposable, type MonacoApi } from './monaco-api.js';
+import { registerContribution } from './contribute.js';
+
+/** 提供全局变量信息 */
+export type VmContextProvider = (model: editor.ITextModel) => languages.ProviderResult<VmContext>;
+
+/** 加载器 */
+export class MiraScriptMonacoLoader implements IDisposable {
+    constructor(readonly contextProvider?: VmContextProvider) {
+        registerContribution();
+
+        const _loadBasicFeatures = () => void this.loadBasicFeatures();
+        const _loadFullFeatures = () => void this.loadLSPFeatures();
+
+        languages.onLanguageEncountered('mirascript', _loadBasicFeatures);
+        languages.onLanguage('mirascript', _loadFullFeatures);
+
+        languages.onLanguageEncountered('mirascript-template', _loadBasicFeatures);
+        languages.onLanguage('mirascript-template', _loadFullFeatures);
+    }
+    private _basicFeaturesLoaded = false;
+    private _lspFeaturesLoaded = false;
+    /** 加载基础功能 */
+    async loadBasicFeatures(): Promise<void> {
+        try {
+            const { registerBasic } = await import('./basic/index.js');
+            if (this._basicFeaturesLoaded || this.disposed) return;
+            this._basicFeaturesLoaded = true;
+            this.disposables.push(...(await registerBasic()));
+        } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('Failed to load MiraScript basic features:', error);
+        }
+    }
+    /** 加载 LSP 功能 */
+    async loadLSPFeatures(): Promise<void> {
+        try {
+            const basic = this.loadBasicFeatures();
+            const { registerLSP } = await import('./lsp/index.js');
+            await basic; // 确保基础功能已加载
+            if (this._lspFeaturesLoaded || this.disposed) return;
+            this._lspFeaturesLoaded = true;
+            this.disposables.push(...(await registerLSP(this.contextProvider)));
+        } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('Failed to load MiraScript LSP features:', error);
+        }
+    }
+
+    private readonly disposables: IDisposable[] = [];
+    private disposed = false;
+    /** @inheritdoc */
+    dispose(): void {
+        if (this.disposed) {
+            throw new Error('MiraScriptMonacoLoader has already been disposed.');
+        }
+        this.disposed = true;
+        for (const d of this.disposables.splice(0)) {
+            d.dispose();
+        }
+    }
+}
+export { registerMonacoApi, registerContribution };
+/**
+ * 注册 MiraScript Monaco 编辑器扩展。
+ */
+export function registerMiraScript(monacoApi: MonacoApi, globalProvider?: VmContextProvider): MiraScriptMonacoLoader {
+    registerMonacoApi(monacoApi);
+    return new MiraScriptMonacoLoader(globalProvider);
+}