@mirascript/monaco 0.1.90 → 0.1.92

package/dist/{worker-core-MG2FDDNN.js → worker-core-IBUPKM67.js}

@@ -1,7 +1,7 @@
 // src/lsp/worker-core.ts
 var { loadModule } = await import("@mirascript/bindings/wasm");
-var mod = await loadModule();
-var { wasm, createConfig } = mod;
+var module = await loadModule();
+var { wasm, createConfig } = module;
 var configTemplate = createConfig({
   diagnostic_position_encoding: "Utf16",
   diagnostic_tag: true,
@@ -16,30 +16,25 @@ var configScript = createConfig({
   trivia: true,
   input_mode: "Script"
 });
+function config(mode) {
+  return mode === "Script" ? configScript : configTemplate;
+}
 function compile(script, mode) {
-  const config = mode === "Script" ? configScript : configTemplate;
-  const compiler = new wasm.MonacoCompiler(script, config);
+  const compiler = new wasm.MonacoCompiler(script, config(mode));
   try {
     const parseOk = compiler.parse();
-    if (!parseOk) {
-      return { diagnostics: compiler.diagnostics(), chunk: void 0 };
-    }
+    if (!parseOk) return { diagnostics: compiler.diagnostics(), chunk: void 0 };
     const chunk = compiler.emit();
-    const formatted = compiler.format();
-    return {
-      diagnostics: compiler.diagnostics(),
-      chunk,
-      formatted
-    };
+    return { diagnostics: compiler.diagnostics(), chunk };
   } finally {
-    try {
-      compiler.free();
-    } catch (ex) {
-      console.error(ex);
-    }
+    compiler.free();
   }
 }
+function formatSource(script, mode, options, ranges) {
+  return module.formatSync(script, config(mode), options, ranges);
+}
 export {
-  compile
+  compile,
+  formatSource
 };
-//# sourceMappingURL=worker-core-MG2FDDNN.js.map
+//# sourceMappingURL=worker-core-IBUPKM67.js.map

package/dist/worker-core-IBUPKM67.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../src/lsp/worker-core.ts"],
+  "mappings": ";AAIA,IAAM,EAAE,WAAW,IAAI,MAAM,OAAO,2BAA2B;AAC/D,IAAM,SAAS,MAAM,WAAW;AAChC,IAAM,EAAE,MAAM,aAAa,IAAI;AAwE/B,IAAM,iBAAiB,aAAa;AAAA,EAChC,8BAA8B;AAAA,EAC9B,gBAAgB;AAAA,EAChB,sBAAsB;AAAA,EACtB,QAAQ;AAAA,EACR,YAAY;AAChB,CAAC;AACD,IAAM,eAAe,aAAa;AAAA,EAC9B,8BAA8B;AAAA,EAC9B,gBAAgB;AAAA,EAChB,sBAAsB;AAAA,EACtB,QAAQ;AAAA,EACR,YAAY;AAChB,CAAC;AAGD,SAAS,OAAO,MAA8C;AAC1D,SAAO,SAAS,WAAW,eAAe;AAC9C;AAGO,SAAS,QAAQ,QAAgB,MAA+B;AACnE,QAAM,WAAW,IAAI,KAAK,eAAe,QAAQ,OAAO,IAAI,CAAC;AAC7D,MAAI;AACA,UAAM,UAAU,SAAS,MAAM;AAC/B,QAAI,CAAC,QAAS,QAAO,EAAE,aAAa,SAAS,YAAY,GAAG,OAAO,OAAU;AAC7E,UAAM,QAAQ,SAAS,KAAK;AAC5B,WAAO,EAAE,aAAa,SAAS,YAAY,GAAG,MAAM;AAAA,EACxD,UAAE;AACE,aAAS,KAAK;AAAA,EAClB;AACJ;AAGO,SAAS,aACZ,QACA,MACA,SACA,QACqB;AACrB,SAAO,OAAO,WAAW,QAAQ,OAAO,IAAI,GAAG,SAAS,MAAM;AAClE;",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirascript/monaco",
-  "version": "0.1.90",
+  "version": "0.1.92",
   "author": "CloudPSS",
   "license": "MIT",
   "description": "Monaco Editor integration for Mirascript.",
@@ -41,11 +41,11 @@
     }
   },
   "dependencies": {
-    "@mirascript/bindings": "~0.1.90",
-    "@mirascript/constants": "~0.1.90",
-    "@mirascript/help": "~0.1.90",
-    "@mirascript/mirascript": "~0.1.90",
-    "@mirascript/textmate": "~0.1.90",
+    "@mirascript/bindings": "~0.1.92",
+    "@mirascript/constants": "~0.1.92",
+    "@mirascript/help": "~0.1.92",
+    "@mirascript/mirascript": "~0.1.92",
+    "@mirascript/textmate": "~0.1.92",
     "@shikijs/core": "^4.4.3",
     "@shikijs/engine-javascript": "^4.4.3",
     "@shikijs/vscode-textmate": "^10.0.2"
@@ -59,7 +59,7 @@
     }
   },
   "devDependencies": {
-    "type-fest": "^5.8.0"
+    "type-fest": "^5.9.0"
   },
   "scripts": {
     "build": "pnpm clean && tsc && node ./esbuild.config.js",

package/src/lsp/index.ts

@@ -94,8 +94,7 @@ export async function registerLSP(
     registerIfEnabled('formatter', FormatterProvider, (language, provider) => {
         return [
             languages.registerDocumentFormattingEditProvider(language, provider),
-            // languages.registerDocumentRangeFormattingEditProvider(language, provider),
-            // languages.registerOnTypeFormattingEditProvider(language, provider),
+            languages.registerDocumentRangeFormattingEditProvider(language, provider),
         ];
     });
 

package/src/lsp/providers/formatter-provider.ts

@@ -1,87 +1,93 @@
-import {
-    type languages,
-    type editor,
-    type IRange,
-    Range,
-    type CancellationToken,
-    type Position,
-} from '../../monaco-api.js';
+import { type languages, type editor, type IRange, Range, type CancellationToken } from '../../monaco-api.js';
+import { parseDiagnostics } from '@mirascript/mirascript/subtle';
+import { formatModel } from '../worker-helper.js';
 import { Provider } from './base.js';
 
-/** 进行格式化 */
+const DEFAULT_PRINT_WIDTH = 80;
+
+/** 请求格式化并将 UTF-16 偏移编辑转换为 Monaco 编辑。 */
 async function format(
     model: editor.ITextModel,
-    ranges: readonly IRange[],
+    ranges: readonly IRange[] | undefined,
     options: languages.FormattingOptions | undefined,
-    hint: 'full' | 'range' | 'expression' | 'statement',
     token: CancellationToken | undefined,
-): Promise<languages.TextEdit[]> {
-    if (hint !== 'full') return [];
-    const compiled = await Provider.getCompileResult(model);
-    if (compiled?.result.formatted == null) return [];
-    return [
-        {
-            range: model.getFullModelRange(),
-            text: compiled.result.formatted,
-        },
-    ];
+): Promise<languages.TextEdit[] | null> {
+    if (model.uri.scheme === 'mirascript' || token?.isCancellationRequested) return [];
+    if (ranges?.length === 0) return [];
+    const version = model.getVersionId();
+    const offsetRanges = ranges?.map((range) => ({
+        start: model.getOffsetAt(Range.getStartPosition(range)),
+        end: model.getOffsetAt(Range.getEndPosition(range)),
+    }));
+    try {
+        const result = await formatModel(model, offsetRanges, {
+            tabSize: options?.tabSize ?? 2,
+            insertSpaces: options?.insertSpaces ?? true,
+            printWidth: DEFAULT_PRINT_WIDTH,
+        });
+        if (model.isDisposed() || token?.isCancellationRequested || model.getVersionId() !== version) return [];
+        if (ranges == null && parseDiagnostics(model.getValue(), result.diagnostics).errors.length > 0) return null;
+        return result.edits.map((edit) => ({
+            range: Range.fromPositions(model.getPositionAt(edit.start), model.getPositionAt(edit.end)),
+            text: edit.text,
+        }));
+    } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('MiraScript formatting failed:', error);
+        return null;
+    }
 }
 
-/** 格式化 */
+/** MiraScript 整文及选区格式化。 */
 export class FormatterProvider
     extends Provider
-    implements
-        languages.DocumentFormattingEditProvider,
-        languages.DocumentRangeFormattingEditProvider,
-        languages.OnTypeFormattingEditProvider
+    implements languages.DocumentFormattingEditProvider, languages.DocumentRangeFormattingEditProvider
 {
-    /** 进行完整格式化 */
+    /** 返回完整格式化文本；源码已规范时返回原文本。 */
     static async format(model: editor.ITextModel, options?: languages.FormattingOptions): Promise<string | null> {
-        const formatted = await format(model, [], options, 'full', undefined);
-        return formatted.length === 1 ? formatted[0]!.text : null;
+        const edits = await format(model, undefined, options, undefined);
+        if (edits == null) return null;
+        if (edits.length === 0) return model.getValue();
+        let output = model.getValue();
+        const offsetEdits = edits
+            .map((edit) => ({
+                start: model.getOffsetAt(Range.getStartPosition(edit.range)),
+                end: model.getOffsetAt(Range.getEndPosition(edit.range)),
+                text: edit.text,
+            }))
+            .toSorted((left, right) => right.start - left.start);
+        for (const edit of offsetEdits) {
+            output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+        }
+        return output;
     }
-    /** @inheritdoc */
+
+    /** 提供整篇文档格式化编辑。 */
     provideDocumentFormattingEdits(
         model: editor.ITextModel,
         options: languages.FormattingOptions,
         token: CancellationToken,
     ): languages.ProviderResult<languages.TextEdit[]> {
-        return format(model, [], options, 'full', token);
+        return format(model, undefined, options, token).then((edits) => edits ?? []);
     }
-    /** @inheritdoc */
+
+    /** 提供单个选区格式化编辑。 */
     provideDocumentRangeFormattingEdits(
         model: editor.ITextModel,
         range: Range,
         options: languages.FormattingOptions,
         token: CancellationToken,
     ): languages.ProviderResult<languages.TextEdit[]> {
-        return format(model, [range], options, 'range', token);
+        return format(model, [range], options, token).then((edits) => edits ?? []);
     }
-    /** @inheritdoc */
+
+    /** 提供多个选区格式化编辑。 */
     provideDocumentRangesFormattingEdits(
         model: editor.ITextModel,
         ranges: Range[],
         options: languages.FormattingOptions,
         token: CancellationToken,
     ): languages.ProviderResult<languages.TextEdit[]> {
-        return format(model, ranges, options, 'range', token);
-    }
-    /** @inheritdoc */
-    readonly autoFormatTriggerCharacters = [';', '}', ']', ')'];
-    /** @inheritdoc */
-    provideOnTypeFormattingEdits(
-        model: editor.ITextModel,
-        position: Position,
-        ch: string,
-        options: languages.FormattingOptions,
-        token: CancellationToken,
-    ): languages.ProviderResult<languages.TextEdit[]> {
-        return format(
-            model,
-            [Range.fromPositions(position, position)],
-            options,
-            ch === ';' ? 'statement' : 'expression',
-            token,
-        );
+        return format(model, ranges, options, token).then((edits) => edits ?? []);
     }
 }

package/src/lsp/worker-core.ts

@@ -3,26 +3,77 @@ import type { BcModule } from '@mirascript/bindings/wasm';
 import type { Tagged } from 'type-fest';
 
 const { loadModule } = await import('@mirascript/bindings/wasm');
-const mod = await loadModule();
-const { wasm, createConfig } = mod;
+const module = await loadModule();
+const { wasm, createConfig } = module;
 
 /** Monaco 编译结果 */
-export interface MonacoResult extends BcModule.CompileResult {
-    /** 格式化结果 */
-    formatted?: string;
-}
-
+export type MonacoResult = BcModule.CompileResult;
 /** 缓存 Key (model id) */
 export type CacheKey = Tagged<string, 'modelId'>;
-/** 请求参数 */
-export type Req = [key: CacheKey, version: number, script: string, mode: InputMode];
-/** 编译结果 */
-export type ResOk = [key: CacheKey, version: number, result: MonacoResult];
-/** 编译结果 */
-export type ResErr = [key: CacheKey, version: number, error: Error];
-/** 编译结果 */
-export type Res = ResOk | ResErr;
-/** Ready */
+/** Worker 请求标识。 */
+export type RequestId = Tagged<number, 'requestId'>;
+
+/** UTF-16 绝对偏移范围。 */
+export interface OffsetRange {
+    /** 起始偏移。 */
+    readonly start: number;
+    /** 结束偏移。 */
+    readonly end: number;
+}
+
+/** Worker 格式化选项。 */
+export interface WorkerFormatOptions {
+    /** 制表符宽度。 */
+    readonly tabSize: number;
+    /** 是否使用空格缩进。 */
+    readonly insertSpaces: boolean;
+    /** 最大打印宽度。 */
+    readonly printWidth: number;
+}
+
+/** Worker 请求公共字段。 */
+interface BaseRequest {
+    /** 请求标识。 */
+    readonly id: RequestId;
+    /** Monaco model 缓存键。 */
+    readonly key: CacheKey;
+    /** Model 版本。 */
+    readonly version: number;
+    /** 源码文本。 */
+    readonly script: string;
+    /** 编译输入模式。 */
+    readonly mode: InputMode;
+}
+
+/** 编译请求。 */
+export interface CompileRequest extends BaseRequest {
+    /** 请求种类。 */
+    readonly kind: 'compile';
+}
+
+/** 格式化请求。 */
+export interface FormatRequest extends BaseRequest {
+    /** 请求种类。 */
+    readonly kind: 'format';
+    /** 待格式化的 UTF-16 范围；省略时格式化整篇文档。 */
+    readonly ranges?: readonly OffsetRange[];
+    /** 格式化选项。 */
+    readonly options: WorkerFormatOptions;
+}
+
+/** Worker 请求联合类型。 */
+export type Req = CompileRequest | FormatRequest;
+/** Worker 响应联合类型。 */
+export type Res =
+    | { readonly id: RequestId; readonly ok: true; readonly kind: 'compile'; readonly result: MonacoResult }
+    | {
+          readonly id: RequestId;
+          readonly ok: true;
+          readonly kind: 'format';
+          readonly result: BcModule.FormatResult;
+      }
+    | { readonly id: RequestId; readonly ok: false; readonly error: string };
+/** Worker 就绪消息。 */
 export type Ready = 'mirascript lsp ready';
 
 const configTemplate = createConfig({
@@ -40,29 +91,30 @@ const configScript = createConfig({
     input_mode: 'Script',
 });
 
+/** 选择与输入模式对应的可复用编译配置。 */
+function config(mode: InputMode): BcModule.wasm.CompileConfig {
+    return mode === 'Script' ? configScript : configTemplate;
+}
+
 /** 编译 */
 export function compile(script: string, mode: InputMode): MonacoResult {
-    const config = mode === 'Script' ? configScript : configTemplate;
-    const compiler = new wasm.MonacoCompiler(script, config);
+    const compiler = new wasm.MonacoCompiler(script, config(mode));
     try {
         const parseOk = compiler.parse();
-        if (!parseOk) {
-            return { diagnostics: compiler.diagnostics(), chunk: undefined };
-        }
+        if (!parseOk) return { diagnostics: compiler.diagnostics(), chunk: undefined };
         const chunk = compiler.emit();
-        const formatted = compiler.format();
-        return {
-            diagnostics: compiler.diagnostics(),
-            chunk,
-            formatted,
-        };
+        return { diagnostics: compiler.diagnostics(), chunk };
     } finally {
-        try {
-            compiler.free();
-        } catch (ex) {
-            /* 忽略错误 */
-            // eslint-disable-next-line no-console
-            console.error(ex);
-        }
+        compiler.free();
     }
 }
+
+/** 按需格式化，不进入普通编译缓存。 */
+export function formatSource(
+    script: string,
+    mode: InputMode,
+    options: WorkerFormatOptions,
+    ranges?: readonly OffsetRange[],
+): BcModule.FormatResult {
+    return module.formatSync(script, config(mode), options, ranges);
+}

package/src/lsp/worker-helper.ts

@@ -1,141 +1,188 @@
 import type { InputMode } from '@mirascript/constants';
 import { editor } from '../monaco-api.js';
-import type { Ready, CacheKey, Req, Res, ResOk } from './worker-core.js';
+import type {
+    CacheKey,
+    CompileRequest,
+    FormatRequest,
+    OffsetRange,
+    Ready,
+    Req,
+    Res,
+    RequestId,
+    WorkerFormatOptions,
+} from './worker-core.js';
 import { CompileResult } from './compile-result.js';
 import { makeModelMarkers } from './diagnostics.js';
 
-/** 缓存 */
+/** 编译缓存项。 */
 type CacheValue = {
     readonly version: number;
     readonly result: Promise<CompileResult>;
     readonly mode: InputMode;
     lastAccess: number;
 };
-/** 编译结果缓存，避免重复编译 */
+
 const cache = new Map<CacheKey, CacheValue>();
-let worker: Promise<Worker> | undefined = undefined;
+let worker: Promise<Worker> | undefined;
+let requestSequence = 0;
 
-// 清理缓存
 const CACHE_MAX_AGE = 30000;
 setInterval(() => {
     const now = Date.now();
     for (const [key, { lastAccess }] of cache) {
-        if (now - lastAccess > CACHE_MAX_AGE) {
-            cache.delete(key);
-        }
+        if (now - lastAccess > CACHE_MAX_AGE) cache.delete(key);
     }
 }, CACHE_MAX_AGE);
 
-/** 使用 worker 进行编译 */
-async function compileWorker(req: Req): Promise<CompileResult> {
+/** 生成当前进程内唯一的请求标识。 */
+function nextRequestId(): RequestId {
+    requestSequence = (requestSequence + 1) % Number.MAX_SAFE_INTEGER;
+    return requestSequence as RequestId;
+}
+
+/** 从 Monaco model 推断编译输入模式。 */
+function modeOf(model: editor.ITextModel): InputMode {
+    return model.getLanguageId() === 'mirascript-template' ? 'Template' : 'Script';
+}
+
+/** 创建并等待 LSP worker 就绪。 */
+async function getWorker(): Promise<Worker> {
     if (!worker) {
-        const w = new Worker(new URL('#lsp/worker', import.meta.url), {
+        const instance = new Worker(new URL('#lsp/worker', import.meta.url), {
             type: 'module',
             name: '@mirascript/lsp-server',
         });
         worker = new Promise((resolve, reject) => {
-            const onError = (e: ErrorEvent) => {
+            const timeout = setTimeout(() => {
                 cleanUp();
-                reject(new Error(`Worker failed to start: ${e.message}`));
+                reject(new Error('Worker did not respond in time'));
+            }, 30000);
+            const cleanUp = () => {
+                clearTimeout(timeout);
+                instance.removeEventListener('error', onError);
+                instance.removeEventListener('message', onMessage);
             };
-            const onMessage = (e: MessageEvent<Ready | Error>) => {
-                if (e.data === 'mirascript lsp ready') {
-                    cleanUp();
-                    resolve(w);
-                } else if (e.data instanceof Error) {
-                    cleanUp();
-                    reject(e.data);
-                }
+            const onError = (event: ErrorEvent) => {
+                cleanUp();
+                reject(new Error(`Worker failed to start: ${event.message}`));
             };
-            w.addEventListener('error', onError);
-            w.addEventListener('message', onMessage);
-            const cleanUp = () => {
-                w.removeEventListener('error', onError);
-                w.removeEventListener('message', onMessage);
+            const onMessage = (event: MessageEvent<Ready>) => {
+                if (event.data !== 'mirascript lsp ready') return;
+                cleanUp();
+                resolve(instance);
             };
-            setTimeout(() => {
-                onError(new ErrorEvent('error', { message: 'Worker did not respond in time' }));
-            }, 30000);
+            instance.addEventListener('error', onError);
+            instance.addEventListener('message', onMessage);
         });
     }
+    return worker;
+}
 
-    try {
-        await worker;
-    } catch (ex) {
-        // eslint-disable-next-line no-console
-        console.error('Failed to initialize worker, use sync compile:', ex);
-        USE_WORKER = false;
-        return compileSync(req);
-    }
-
-    const instance = await worker;
-    instance.postMessage(req);
-    const [key, version, source] = req;
-    const [_key, _version, result] = await new Promise<ResOk>((resolve, reject) => {
-        const onMessage = (e: MessageEvent<Res>) => {
-            if (!(e.data[0] === key && e.data[1] === version)) {
-                return;
-            }
-
+/** 发送带标识的 worker 请求并等待对应响应。 */
+async function requestWorker(request: Req): Promise<Res> {
+    const instance = await getWorker();
+    return new Promise<Res>((resolve) => {
+        const onMessage = (event: MessageEvent<Res>) => {
+            if (event.data?.id !== request.id) return;
             instance.removeEventListener('message', onMessage);
-            if (e.data[2] instanceof Error) {
-                reject(e.data[2]);
-            } else {
-                resolve(e.data as ResOk);
-            }
+            resolve(event.data);
         };
         instance.addEventListener('message', onMessage);
+        instance.postMessage(request);
     });
-    return new CompileResult(key, version, source, result);
 }
 
 let compileImpl: typeof import('./worker-core.js').compile;
-/** 使用当前线程编译 */
-async function compileSync(req: Req): Promise<CompileResult> {
-    const [key, version, script, mode] = req;
-    if (compileImpl == null) {
-        const mod = await import('./worker-core.js');
-        compileImpl = mod.compile;
+/** 在当前线程执行编译。 */
+async function compileSync(request: CompileRequest): Promise<CompileResult> {
+    compileImpl ??= (await import('./worker-core.js')).compile;
+    const result = compileImpl(request.script, request.mode);
+    return new CompileResult(request.key, request.version, request.script, result);
+}
+
+/** 优先使用 worker 编译，失败时回退当前线程。 */
+async function compileWorker(request: CompileRequest): Promise<CompileResult> {
+    try {
+        const response = await requestWorker(request);
+        if (!response.ok) throw new Error(response.error);
+        if (response.kind !== 'compile') throw new Error('Unexpected formatter response to compile request');
+        return new CompileResult(request.key, request.version, request.script, response.result);
+    } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Failed to use MiraScript worker, falling back to the current thread:', error);
+        USE_WORKER = false;
+        worker = undefined;
+        return compileSync(request);
     }
-    const result = compileImpl(script, mode);
-    return new CompileResult(key, version, script, result);
 }
 
 let USE_WORKER = typeof Worker === 'function';
+
 /** 编译并设置缓存 */
 export async function compile(model: editor.ITextModel): Promise<CompileResult> {
     const version = model.getVersionId();
-    const mode = model.getLanguageId() === 'mirascript-template' ? 'Template' : 'Script';
-    const cacheKey = model.id as CacheKey;
-    const cached = cache.get(cacheKey);
+    const mode = modeOf(model);
+    const key = model.id as CacheKey;
+    const cached = cache.get(key);
     if (cached?.version === version && cached.mode === mode) {
         cached.lastAccess = Date.now();
         return cached.result;
     }
 
-    const value = model.getValue();
-    const req: Req = [cacheKey, version, value, mode];
-    const res = USE_WORKER ? compileWorker(req) : compileSync(req);
-    void res.then(async (result) => {
+    const script = model.getValue();
+    const request: CompileRequest = { kind: 'compile', id: nextRequestId(), key, version, script, mode };
+    const result = USE_WORKER ? compileWorker(request) : compileSync(request);
+    void result.then(async (compiled) => {
         if (model.isDisposed()) return;
         const setModelMarkers = editor?.setModelMarkers;
-        if (typeof setModelMarkers != 'function') return;
-        const markers = await makeModelMarkers(model, result);
-        if (!markers) return;
-        setModelMarkers(model, 'mirascript', markers);
+        if (typeof setModelMarkers !== 'function') return;
+        const markers = await makeModelMarkers(model, compiled);
+        if (markers) setModelMarkers(model, 'mirascript', markers);
     });
-    const item: CacheValue = {
-        version,
-        lastAccess: Date.now(),
-        mode,
-        result: res,
-    };
-    cache.set(cacheKey, item);
-    res.catch(() => {
-        const current = cache.get(cacheKey);
-        if (current === item) {
-            cache.delete(cacheKey);
-        }
+    const item: CacheValue = { version, lastAccess: Date.now(), mode, result };
+    cache.set(key, item);
+    result.catch(() => {
+        if (cache.get(key) === item) cache.delete(key);
     });
-    return res;
+    return result;
+}
+
+let formatImpl: typeof import('./worker-core.js').formatSource;
+
+/** 对指定 model 发起独立的按需格式化请求。 */
+export async function formatModel(
+    model: editor.ITextModel,
+    ranges: readonly OffsetRange[] | undefined,
+    options: WorkerFormatOptions,
+): Promise<{
+    readonly diagnostics: Uint32Array;
+    readonly edits: ReadonlyArray<{ start: number; end: number; text: string }>;
+}> {
+    const request: FormatRequest = {
+        kind: 'format',
+        id: nextRequestId(),
+        key: model.id as CacheKey,
+        version: model.getVersionId(),
+        script: model.getValue(),
+        mode: modeOf(model),
+        ranges,
+        options,
+    };
+    if (!USE_WORKER) {
+        formatImpl ??= (await import('./worker-core.js')).formatSource;
+        return formatImpl(request.script, request.mode, request.options, request.ranges);
+    }
+    try {
+        const response = await requestWorker(request);
+        if (!response.ok) throw new Error(response.error);
+        if (response.kind !== 'format') throw new Error('Unexpected compile response to format request');
+        return response.result;
+    } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error('Failed to use MiraScript worker, formatting on the current thread:', error);
+        USE_WORKER = false;
+        worker = undefined;
+        formatImpl ??= (await import('./worker-core.js')).formatSource;
+        return formatImpl(request.script, request.mode, request.options, request.ranges);
+    }
 }