@mirascript/monaco 0.1.0

package/dist/lsp/index.js

@@ -0,0 +1,2285 @@
+import {
+  DOC_HEADER,
+  REG_IDENTIFIER,
+  REG_ORDINAL,
+  keywords,
+  reservedKeywords
+} from "../chunk-PTNWRTNM.js";
+import {
+  Emitter,
+  MarkerSeverity,
+  MarkerTag,
+  Position,
+  Range,
+  Uri,
+  editor,
+  languages
+} from "../chunk-CEFEXBF7.js";
+
+// src/lsp/providers/base.ts
+import { DefaultVmContext } from "@mirascript/mirascript/subtle";
+
+// src/lsp/utils.ts
+import { DiagnosticCode } from "@mirascript/wasm";
+import {
+  getVmFunctionInfo,
+  isVmArray,
+  isVmExtern,
+  isVmFunction,
+  isVmModule,
+  isVmPrimitive,
+  isVmRecord,
+  serialize
+} from "@mirascript/mirascript";
+import { operations, serializePropName, serializeString } from "@mirascript/mirascript/subtle";
+function globalParamsSignature(info) {
+  if (info == null || !info.params && !info.paramsType) return [["..", "..", ""]];
+  const paramItems = [];
+  const params = Object.keys(info.paramsType ?? {});
+  for (const key of Object.keys(info.params ?? {})) {
+    if (params.includes(key)) continue;
+    params.push(key);
+  }
+  for (const key of params) {
+    const type = info.paramsType?.[key] ?? "";
+    const doc = info.params?.[key] ?? "";
+    paramItems.push([key, type ? `${key}: ${type}` : key, doc ? `\`${key}\`: ${doc}` : ""]);
+  }
+  return paramItems;
+}
+var SIG_WIDTH = 60;
+function fnSignature(id, info) {
+  const prefix = id ? `fn ${id}` : "fn";
+  const params = globalParamsSignature(info);
+  const returns = info.returnsType ? ` -> ${info.returnsType}` : "";
+  return {
+    params,
+    returns,
+    toString() {
+      let p;
+      if (this.params.length >= 1 && (prefix.length + this.returns.length > SIG_WIDTH || prefix.length + this.returns.length + params.reduce((a, b) => a + b[1].length, 0) > SIG_WIDTH)) {
+        p = `(
+${params.map((item) => `  ${item[1]},`).join("\n")}
+)`;
+      } else {
+        p = `(${params.map((item) => item[1]).join(", ")})`;
+      }
+      return `${prefix}${p}${this.returns}`;
+    }
+  };
+}
+function localParamSignature(model, info) {
+  const {
+    args,
+    scope: { params }
+  } = info;
+  if (params[0]?.code === DiagnosticCode.ParameterIt) {
+    return params[0].references.length ? [["it", "it", ""]] : [];
+  }
+  return params.map((a, i) => {
+    const rest = a.code === DiagnosticCode.ParameterRestPattern || a.code === DiagnosticCode.ParameterMutableRest || a.code === DiagnosticCode.ParameterImmutableRest;
+    const argsInParam = args.filter((arg) => Range.containsRange(a.range, arg.definition.range));
+    const argName = argsInParam.length === 0 ? `arg_${i}` : argsInParam.map((arg) => model.getValueInRange(arg.definition.range)).join("_");
+    if (rest) return [`..${argName}`, `..${argName}`, ""];
+    return [argName, argName, ""];
+  });
+}
+function paramsList(model, info) {
+  if (!info) return "(..)";
+  if ("scope" in info) {
+    return `(${localParamSignature(model, info).map((p) => p[1]).join(", ")})`;
+  } else {
+    if (!info.params) return "(..)";
+    const paramItems = Object.keys(info.params).join(", ");
+    return `(${paramItems})`;
+  }
+}
+function globalFnDoc(info) {
+  const doc = [];
+  if (info.summary) {
+    doc.push(info.summary);
+  }
+  const paramDoc = [];
+  if (info.params) {
+    for (const [key, value] of Object.entries(info.params)) {
+      if (!value) continue;
+      paramDoc.push(`- \`${key}\`: ${value}`);
+    }
+  }
+  if (info.returns) {
+    paramDoc.push(`- **返回值**: ${info.returns}`);
+  }
+  if (paramDoc.length) {
+    doc.push(paramDoc.join("\n"));
+  }
+  if (info.examples?.length) {
+    let exp = `### 示例`;
+    for (const example of info.examples) {
+      exp += codeblock(example);
+    }
+    doc.push(exp);
+  }
+  return doc;
+}
+function codeblock(value) {
+  const includeFences = /`{3,}/.exec(value);
+  const CODEBLOCK_FENCE = includeFences ? "`".repeat(includeFences[0].length + 1) : "```";
+  return `
+${CODEBLOCK_FENCE}mirascript
+${value}
+${CODEBLOCK_FENCE}
+`;
+}
+function strictContainsPosition(range, position) {
+  return !Range.isEmpty(range) && Range.containsPosition(range, position);
+}
+function wordAt(model, position) {
+  const word = model.getWordAtPosition(position);
+  if (!word) return void 0;
+  const range = new Range(position.lineNumber, word.startColumn, position.lineNumber, word.endColumn);
+  return { word: word.word, range };
+}
+function serializeForDisplayInner(value, maxWidth) {
+  if (maxWidth < 10) maxWidth = 10;
+  if (typeof value === "string") {
+    if (value.length < maxWidth) {
+      return serializeString(value);
+    }
+    return `${serializeString(value.slice(0, maxWidth))}..`;
+  }
+  if (isVmPrimitive(value)) {
+    return serialize(value);
+  }
+  if (isVmArray(value)) {
+    const len = value.length;
+    if (!len) return "[]";
+    return `[../* x${len} */]`;
+  }
+  if (isVmRecord(value)) {
+    const len = Object.keys(value).length;
+    if (!len) return "()";
+    return `(../* x${len} */)`;
+  }
+  return `/* ${operations.$ToString(value)} */`;
+}
+function serializeForDisplay(value, maxEntries = 100, maxWidth = 40) {
+  if (isVmPrimitive(value) || isVmFunction(value)) {
+    return serializeForDisplayInner(value, maxWidth);
+  }
+  let begin, end;
+  const entries = [];
+  let resultLength = 0;
+  if (isVmArray(value)) {
+    begin = "[";
+    end = "]";
+    for (const v of value) {
+      if (entries.length > maxEntries) {
+        entries.push(`../* x${value.length - entries.length} */`);
+        break;
+      }
+      const entry = serializeForDisplayInner(v ?? null, maxWidth - 2);
+      entries.push(entry);
+      resultLength += entry.length;
+    }
+  } else if (isVmRecord(value)) {
+    begin = "(";
+    end = ")";
+    const e = Object.entries(value);
+    for (const [key, value2] of e) {
+      if (entries.length > maxEntries) {
+        entries.push(`../* x${e.length - entries.length} */`);
+        break;
+      }
+      const sk = serializePropName(key);
+      const entry = `${sk}: ${serializeForDisplayInner(value2 ?? null, maxWidth - sk.length - 4)}`;
+      entries.push(entry);
+      resultLength += entry.length;
+    }
+  } else {
+    const hint = serializeForDisplayInner(value, 100);
+    const isArray = isVmExtern(value) && Array.isArray(value.value);
+    begin = `${hint} ${isArray ? "[" : "("}`;
+    end = isArray ? "]" : ")";
+    const keys = value.keys();
+    for (const [index, key] of keys.entries()) {
+      if (entries.length > maxEntries) {
+        entries.push(`../* x${keys.length - entries.length} */`);
+        break;
+      }
+      let entry;
+      if (isArray && String(index) === key) {
+        entry = serializeForDisplayInner(value.get(key) ?? null, maxWidth - 2);
+      } else {
+        const sk = serializePropName(key);
+        entry = `${sk}: ${serializeForDisplayInner(value.get(key) ?? null, maxWidth - sk.length - 4)}`;
+      }
+      entries.push(entry);
+      resultLength += entry.length;
+    }
+  }
+  if (resultLength >= maxWidth) {
+    return `${begin}
+  ${entries.join(",\n  ")}
+${end}`;
+  }
+  return `${begin}${entries.join(", ")}${end}`;
+}
+function valueDoc(name, value, type) {
+  const info = getVmFunctionInfo(value);
+  if (info) {
+    return {
+      script: fnSignature(name, info).toString() + (type === "declare" ? ";" : ""),
+      doc: globalFnDoc(info)
+    };
+  }
+  let prefix;
+  let suffix = "";
+  if (type === "hint") {
+    prefix = `${name} = `;
+  } else if (type === "declare") {
+    if (name.startsWith("@")) {
+      prefix = `const ${name} = `;
+    } else {
+      prefix = `let ${name} = `;
+    }
+    suffix = ";";
+  } else if (/^\d/.test(name)) {
+    prefix = `[${name}]: `;
+  } else {
+    prefix = `${name}: `;
+  }
+  if (isVmModule(value)) {
+    const doc = `模块 \`${value.name}\``;
+    let script;
+    if (type === "declare") {
+      const exports = value.keys();
+      script = "\n";
+      for (const k of exports) {
+        const v = value.get(k);
+        const vDoc = valueDoc(k, v, isVmModule(v) ? "field" : "declare");
+        const code = [
+          `/**`,
+          ...vDoc.doc.flatMap((sec) => sec.split("\n")).map((line) => ` * ${line}`),
+          ` */`,
+          "export " + vDoc.script,
+          "",
+          ""
+        ];
+        script += code.join("\n");
+      }
+      script = script.trimEnd();
+    } else {
+      script = `(module) ${value.name}`;
+      if (value.name !== name) {
+        script = `${prefix}${script}`;
+      }
+    }
+    return { script, doc: doc ? [doc] : [] };
+  }
+  let valueStr;
+  if (value === void 0) {
+    valueStr = "/* ... */";
+  } else {
+    valueStr = serializeForDisplay(value, type === "declare" ? 1e3 : 100, type === "declare" ? 80 : 40);
+  }
+  return { script: `${prefix}${valueStr}${suffix}`, doc: [] };
+}
+function getDeep(value, path) {
+  let current = value;
+  for (const key of path) {
+    if (current == null) return null;
+    current = operations.$Get(current, key);
+  }
+  return current ?? null;
+}
+
+// src/lsp/compile-result.ts
+import {
+  parseDiagnostics,
+  DiagnosticCode as DiagnosticCode2
+} from "@mirascript/mirascript/subtle";
+var LocalFunctionType = [DiagnosticCode2.LocalFunction];
+var LocalVariableType = [
+  DiagnosticCode2.LocalMutable,
+  DiagnosticCode2.LocalImmutable,
+  DiagnosticCode2.LocalConst
+];
+var ParameterExplicitType = [
+  DiagnosticCode2.ParameterMutable,
+  DiagnosticCode2.ParameterImmutable,
+  DiagnosticCode2.ParameterMutableRest,
+  DiagnosticCode2.ParameterImmutableRest
+];
+var ParameterSubPatternType = [
+  DiagnosticCode2.ParameterSubPatternImmutable,
+  DiagnosticCode2.ParameterSubPatternMutable
+];
+var ParameterPatternType = [DiagnosticCode2.ParameterPattern, DiagnosticCode2.ParameterRestPattern];
+var ParameterItType = [DiagnosticCode2.ParameterIt];
+var ParameterDefinitionType = [
+  ...ParameterExplicitType,
+  ...ParameterSubPatternType,
+  ...ParameterItType
+];
+var ParameterPlaceholderType = [
+  ...ParameterExplicitType,
+  ...ParameterPatternType,
+  ...ParameterItType
+];
+var LocalDefinitionType = [...LocalVariableType, ...LocalFunctionType, ...ParameterDefinitionType];
+var CompileResult = class {
+  constructor(cacheKey, version, source, result) {
+    this.cacheKey = cacheKey;
+    this.version = version;
+    this.source = source;
+    this.result = result;
+    this.diagnosticsReady = false;
+    this._errors = [];
+    this._warnings = [];
+    this._infos = [];
+    this._hints = [];
+    this._references = [];
+    this._tags = [];
+    this._tagsReferences = [];
+    this.diagnostics = result.diagnostics;
+    this.chunk = result.chunk;
+  }
+  /** 源代码诊断信息 */
+  get errors() {
+    if (!this.diagnosticsReady) {
+      this.readDiagnostics();
+    }
+    return this._errors;
+  }
+  /** 源代码诊断信息 */
+  get warnings() {
+    if (!this.diagnosticsReady) {
+      this.readDiagnostics();
+    }
+    return this._warnings;
+  }
+  /** 源代码诊断信息 */
+  get infos() {
+    if (!this.diagnosticsReady) {
+      this.readDiagnostics();
+    }
+    return this._infos;
+  }
+  /** 源代码诊断信息 */
+  get hints() {
+    if (!this.diagnosticsReady) {
+      this.readDiagnostics();
+    }
+    return this._hints;
+  }
+  /** 源代码诊断信息 */
+  get references() {
+    if (!this.diagnosticsReady) {
+      this.readDiagnostics();
+    }
+    return this._references;
+  }
+  /** 源代码诊断信息 */
+  get tags() {
+    if (!this.diagnosticsReady) {
+      this.readDiagnostics();
+    }
+    return this._tags;
+  }
+  /** 源代码诊断信息 */
+  get tagsReferences() {
+    if (!this.diagnosticsReady) {
+      this.readDiagnostics();
+    }
+    return this._tagsReferences;
+  }
+  /** 分析诊断信息 */
+  readDiagnostics() {
+    const parsed = parseDiagnostics(this.source, this.diagnostics);
+    this._errors = parsed.errors;
+    this._warnings = parsed.warnings;
+    this._infos = parsed.infos;
+    this._hints = parsed.hints;
+    this._tags = parsed.tags;
+    this._references = parsed.references;
+    this._tagsReferences = parsed.tagsReferences;
+    this.diagnosticsReady = true;
+  }
+  /** 获取源代码定义 */
+  groupedTags(model) {
+    if (this._groupedTags) {
+      return this._groupedTags;
+    }
+    const getText = (range) => {
+      if (model.getVersionId() !== this.version) {
+        return void 0;
+      }
+      return model.getValueInRange(range);
+    };
+    const locals = [];
+    const params = [];
+    const globals = [];
+    const ranges = [];
+    const omitNameFields = [];
+    for (const tag of this.tags) {
+      if (ParameterPlaceholderType.includes(tag.code)) {
+        params.push(tag);
+      }
+      if (LocalDefinitionType.includes(tag.code)) {
+        locals.push({
+          definition: tag,
+          references: tag.references
+        });
+      } else if (tag.code === DiagnosticCode2.GlobalVariable) {
+        const name = getText(tag.range);
+        let def = globals.find((def2) => name === def2.name);
+        if (!def) {
+          def = {
+            name: name ?? "",
+            references: []
+          };
+          globals.push(def);
+        }
+        def.references.push(tag);
+      } else if (tag.code === DiagnosticCode2.Scope || tag.code === DiagnosticCode2.String || tag.code === DiagnosticCode2.Interpolation || tag.code === DiagnosticCode2.FunctionCall || tag.code === DiagnosticCode2.ExtensionCall) {
+        ranges.push(tag);
+      } else if (tag.code === DiagnosticCode2.OmitNamedRecordField) {
+        omitNameFields.push(tag);
+      }
+    }
+    locals.sort(
+      (a, b) => Range.compareRangesUsingStarts(a.definition.range, b.definition.range)
+    );
+    params.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
+    globals.sort((a, b) => a.name.localeCompare(b.name));
+    ranges.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
+    this._groupedTags = {
+      locals,
+      params,
+      globals,
+      ranges,
+      omitNameFields
+    };
+    return this._groupedTags;
+  }
+  /** 获取指定位置的变量访问信息 */
+  variableAccessAt(model, position) {
+    const { globals } = this.groupedTags(model);
+    for (const d of globals) {
+      const refIndex = d.references.findIndex((u) => strictContainsPosition(u.range, position));
+      if (refIndex >= 0) {
+        return { def: d, ref: refIndex, range: d.references[refIndex].range };
+      }
+    }
+    this.scopes(model);
+    const { locals } = this.groupedTags(model);
+    for (const d of locals) {
+      if (strictContainsPosition(d.definition.range, position)) {
+        return { def: d, ref: void 0, range: d.definition.range };
+      }
+      const refIndex = d.references.findIndex((u) => strictContainsPosition(u.range, position));
+      if (refIndex >= 0) {
+        return { def: d, ref: refIndex, range: d.references[refIndex].range };
+      }
+    }
+    return void 0;
+  }
+  /** 获取作用域信息 */
+  scopes(model) {
+    if (this._scopes) {
+      return this._scopes;
+    }
+    const { locals, params, ranges } = this.groupedTags(model);
+    const scopes = ranges.filter((r) => r.code === DiagnosticCode2.Scope).map((r) => {
+      return {
+        range: r.range,
+        locals: [],
+        params: [],
+        parent: void 0,
+        children: []
+      };
+    });
+    for (let i = 0; i < scopes.length; i++) {
+      const scopeA = scopes[i];
+      let parent;
+      for (let j = 0; j < scopes.length; j++) {
+        if (i === j) continue;
+        const scopeB = scopes[j];
+        const aRange = scopeA.range;
+        const bRange = scopeB.range;
+        const isContained = Range.containsRange(bRange, aRange);
+        if (isContained) {
+          if (!parent || Range.containsRange(parent.range, bRange)) {
+            parent = scopeB;
+          }
+        }
+      }
+      if (parent) {
+        if (parent.parent === scopeA) {
+          continue;
+        }
+        scopeA.parent = parent;
+        parent.children.push(scopeA);
+      }
+    }
+    const root = scopes.find((s) => !s.parent);
+    if (!root) {
+      this._scopes = [
+        {
+          range: model.getFullModelRange(),
+          locals: [],
+          params: [],
+          parent: void 0,
+          children: []
+        }
+      ];
+      return this._scopes;
+    }
+    const queue = [root];
+    const sortedScopes = [];
+    while (queue.length > 0) {
+      const scope = queue.shift();
+      sortedScopes.push(scope);
+      scope.children.sort(
+        (a, b) => Range.compareRangesUsingStarts(a.range, b.range)
+      );
+      for (const child of scope.children) {
+        queue.push(child);
+      }
+    }
+    for (const local of locals) {
+      const { range } = local.definition;
+      const scope = sortedScopes.findLast((s) => Range.containsRange(s.range, range));
+      if (scope) {
+        scope.locals.push(local);
+      }
+    }
+    for (const param of params) {
+      const { range } = param;
+      const scope = sortedScopes.findLast((s) => Range.containsRange(s.range, range));
+      if (scope) {
+        scope.params.push(param);
+      }
+    }
+    const scopeMap = /* @__PURE__ */ new Map();
+    for (const scope of sortedScopes) {
+      scope.locals.sort(
+        (a, b) => Range.compareRangesUsingStarts(a.definition.range, b.definition.range)
+      );
+      scope.params.sort(
+        (a, b) => Range.compareRangesUsingStarts(a.range, b.range)
+      );
+      for (const local of scope.locals) {
+        scopeMap.set(local, scope);
+        if (local.definition.code === DiagnosticCode2.LocalFunction) {
+          const funcScope = scope.children.find(
+            (s) => Range.compareRangesUsingStarts(s.range, local.definition.range) > 0
+          );
+          if (funcScope) {
+            const args = funcScope.locals.filter(
+              (l) => ParameterDefinitionType.includes(l.definition.code)
+            );
+            local.fn = {
+              scope: funcScope,
+              args
+            };
+          }
+        }
+      }
+    }
+    this._scopeMap = scopeMap;
+    this._scopes = sortedScopes;
+    return this._scopes;
+  }
+  /** 获取定义所在作用域 */
+  scopeOf(model, def) {
+    if (!this._scopeMap) {
+      this.scopes(model);
+    }
+    return this._scopeMap.get(def);
+  }
+  /** 获取位置所在作用域 */
+  scopeAt(model, position) {
+    const scopes = this.scopes(model);
+    let scope = scopes.findLast((s) => Range.containsPosition(s.range, position)) ?? scopes[0];
+    while (scope.children.length > 0) {
+      const inner = scope.children.find((s) => Range.containsPosition(s.range, position));
+      if (!inner) break;
+      scope = inner;
+    }
+    return scope;
+  }
+  /** 获取指定位置的字段访问信息 */
+  fieldAccessAt(model, position) {
+    let prevDef;
+    const { globals } = this.groupedTags(model);
+    for (const d of globals) {
+      for (const [refIndex, ref] of d.references.entries()) {
+        if (!Position.isBefore(Range.getEndPosition(ref.range), position)) continue;
+        if (prevDef && Position.isBefore(Range.getEndPosition(ref.range), Range.getEndPosition(prevDef.range)))
+          continue;
+        prevDef = { def: d, ref: refIndex, range: ref.range };
+      }
+    }
+    this.scopes(model);
+    const { locals } = this.groupedTags(model);
+    for (const d of locals) {
+      for (const [refIndex, ref] of d.references.entries()) {
+        if (!Position.isBefore(Range.getEndPosition(ref.range), position)) continue;
+        if (prevDef && Position.isBefore(Range.getEndPosition(ref.range), Range.getEndPosition(prevDef.range)))
+          continue;
+        prevDef = { def: d, ref: refIndex, range: ref.range };
+      }
+    }
+    if (!prevDef) return void 0;
+    const chain = model.getValueInRange(Range.fromPositions(Range.getStartPosition(prevDef.range), position));
+    const chainParts = chain.split(/\s*(?:!\.|\.)\s*/);
+    if (
+      // 至少包含变量名和当前位置的字段名
+      chainParts.length < 2 || !chainParts.every(
+        (part, index) => (
+          // 如果是最后一个部分，则可以为空（表示当前位置的字段名），否则必须是合法的标识符
+          (index === chainParts.length - 1 ? !part : false) || REG_IDENTIFIER.test(part) || REG_ORDINAL.test(part)
+        )
+      )
+    ) {
+      return void 0;
+    }
+    return { def: prevDef, fields: chainParts.slice(1) };
+  }
+  /** 获取指定位置的字段访问信息 */
+  accessAt(model, position) {
+    const v = this.variableAccessAt(model, position);
+    if (v) return { def: v, fields: [] };
+    return this.fieldAccessAt(model, position);
+  }
+};
+
+// src/lsp/diagnostics.ts
+import { DiagnosticCode as DiagnosticCode3, getDiagnosticMessage } from "@mirascript/mirascript/subtle";
+var makeMarker = (model, modelVersionId, diagnostic, severity) => {
+  const { range, code } = diagnostic;
+  const { startLineNumber, startColumn, endLineNumber, endColumn } = range;
+  let unnecessary = false;
+  const deprecated = false;
+  if (code === DiagnosticCode3.UnusedLocalVariable || code === DiagnosticCode3.UnusedLocalFunction) {
+    unnecessary = true;
+    severity = MarkerSeverity.Hint;
+  }
+  let message = getDiagnosticMessage(code) ?? "Unknown error";
+  if (message.includes(`$0`)) {
+    message = message.replaceAll(`$0`, model.getValueInRange(range));
+  }
+  const marker = {
+    startLineNumber,
+    startColumn,
+    endLineNumber,
+    endColumn,
+    message,
+    severity,
+    modelVersionId,
+    source: "MiraScript"
+  };
+  const codeName = DiagnosticCode3[code];
+  if (codeName) {
+    marker.code = {
+      value: codeName,
+      target: Uri.parse(`https://mira.cloudpss.net/code/${codeName}`)
+    };
+  } else {
+    marker.code = `${code}`;
+  }
+  if (unnecessary) {
+    marker.tags ??= [];
+    marker.tags.push(MarkerTag.Unnecessary);
+  }
+  if (deprecated) {
+    marker.tags ??= [];
+    marker.tags.push(MarkerTag.Deprecated);
+  }
+  if (diagnostic.references.length) {
+    marker.relatedInformation = [];
+    for (const ref of diagnostic.references) {
+      const { range: range2, code: code2 } = ref;
+      const { startLineNumber: startLineNumber2, startColumn: startColumn2, endLineNumber: endLineNumber2, endColumn: endColumn2 } = range2;
+      const message2 = getDiagnosticMessage(code2) ?? "...here";
+      marker.relatedInformation.push({
+        message: message2,
+        resource: model.uri,
+        startLineNumber: startLineNumber2,
+        startColumn: startColumn2,
+        endLineNumber: endLineNumber2,
+        endColumn: endColumn2
+      });
+    }
+  }
+  return marker;
+};
+function setMarkers(model, result) {
+  const setModelMarkers = editor?.setModelMarkers;
+  if (typeof setModelMarkers != "function") return;
+  const { version } = result;
+  if (version !== model.getVersionId()) return;
+  const errors = result.errors.map((d) => makeMarker(model, version, d, MarkerSeverity.Error));
+  const warnings = result.warnings.map((d) => makeMarker(model, version, d, MarkerSeverity.Warning));
+  const infos = result.infos.map((d) => makeMarker(model, version, d, MarkerSeverity.Info));
+  const hints = result.hints.map((d) => makeMarker(model, version, d, MarkerSeverity.Hint));
+  const markers = [...errors, ...warnings, ...infos, ...hints];
+  setModelMarkers(model, "mirascript", markers);
+}
+
+// src/lsp/worker-helper.ts
+var cache = /* @__PURE__ */ new Map();
+var worker = void 0;
+var CACHE_MAX_AGE = 3e4;
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, { lastAccess }] of cache) {
+    if (now - lastAccess > CACHE_MAX_AGE) {
+      cache.delete(key);
+    }
+  }
+}, CACHE_MAX_AGE);
+async function compileWorker(req) {
+  if (!worker) {
+    const w = new Worker(new URL("#lsp/worker", import.meta.url), {
+      type: "module",
+      name: "@mirascript/lsp-server"
+    });
+    worker = new Promise((resolve, reject) => {
+      const onError = (e) => {
+        cleanUp();
+        reject(new Error(`Worker failed to start: ${e.message}`));
+      };
+      const onMessage = (e) => {
+        if (e.data === "mirascript lsp 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" }));
+      }, 3e4);
+    });
+  }
+  const instance = await worker;
+  instance.postMessage(req);
+  const [key, version, source] = req;
+  const [_key, _version, result] = await new Promise((resolve, reject) => {
+    const onMessage = (e) => {
+      if (e.data[0] === key && e.data[1] === version) {
+        instance.removeEventListener("message", onMessage);
+        if (e.data[2] instanceof Error) {
+          reject(e.data[2]);
+        } else {
+          resolve(e.data);
+        }
+      }
+    };
+    instance.addEventListener("message", onMessage);
+  });
+  return new CompileResult(key, version, source, result);
+}
+async function compileSync(req) {
+  const [key, version, script, mode] = req;
+  const { compile: compile2 } = await import("./worker.js");
+  const result = compile2(script, mode);
+  return new CompileResult(key, version, script, result);
+}
+var USE_WORKER = typeof Worker === "function";
+async function compile(model) {
+  const uri = model.uri.toString();
+  const version = model.getVersionId();
+  const mode = model.getLanguageId() === "mirascript-template" ? "Template" : "Script";
+  const cacheKey = `${model.id}\0${uri}\0${mode}`;
+  const cached = cache.get(cacheKey);
+  if (cached?.version === version) {
+    cached.lastAccess = Date.now();
+    return cached.result;
+  }
+  const value = model.getValue();
+  const req = [cacheKey, version, value, mode];
+  const res = USE_WORKER ? compileWorker(req) : compileSync(req);
+  void res.then((result) => {
+    setMarkers(model, result);
+  });
+  const item = {
+    version,
+    lastAccess: Date.now(),
+    result: res
+  };
+  cache.set(cacheKey, item);
+  res.catch(() => {
+    const current = cache.get(cacheKey);
+    if (current === item) {
+      cache.delete(cacheKey);
+    }
+  });
+  return res;
+}
+
+// src/lsp/providers/base.ts
+var contextProvider;
+function setContextProvider(provider) {
+  contextProvider = provider;
+}
+var Provider = class {
+  constructor() {
+    this.displayName = "MiraScript LSP";
+    this._debugDisplayName = "MiraScript LSP";
+    this._onDidChange = null;
+  }
+  /** 获取编译结果 */
+  async getCompileResult(model) {
+    if (model.uri.scheme === "mirascript") {
+      return void 0;
+    }
+    return await compile(model);
+  }
+  /** 获取执行上下文（全局变量） */
+  async getContext(model) {
+    return await contextProvider?.(model) ?? DefaultVmContext;
+  }
+  /** @inheritdoc */
+  get onDidChange() {
+    this._onDidChange ??= new Emitter();
+    return this._onDidChange.event;
+  }
+  /** 触发 onDidChange */
+  emitDidChange() {
+    this._onDidChange?.fire(this);
+  }
+};
+
+// src/lsp/providers/code-action-provider.ts
+var CodeActionProvider = class extends Provider {
+  /** @inheritdoc */
+  provideCodeActions(model, range, context, token) {
+    return {
+      actions: [],
+      dispose: () => void 0
+    };
+  }
+  /** @inheritdoc */
+  resolveCodeAction(codeAction, token) {
+    throw new Error("Method not implemented.");
+  }
+};
+
+// src/lsp/providers/color-provider.ts
+import { DiagnosticCode as DiagnosticCode4 } from "@mirascript/wasm";
+var REG_COLOR_STR = /^(@*)(['"`])(#(?:[0-9a-f]{6}|[0-9a-f]{3}|[0-9a-f]{8}|[0-9a-f]{4}))\2\1$/iu;
+function parseColorString(text) {
+  const colorMatch = REG_COLOR_STR.exec(text);
+  if (!colorMatch) {
+    return void 0;
+  }
+  const ats = colorMatch[1] || "";
+  const quote = colorMatch[2] || "";
+  const colorString = colorMatch[3];
+  let color;
+  if (colorString.startsWith("#")) {
+    const colorCode = colorString.slice(1);
+    if (colorCode.length === 3) {
+      color = {
+        red: Number.parseInt(colorCode[0] + colorCode[0], 16) / 255,
+        green: Number.parseInt(colorCode[1] + colorCode[1], 16) / 255,
+        blue: Number.parseInt(colorCode[2] + colorCode[2], 16) / 255,
+        alpha: 1
+      };
+    } else if (colorCode.length === 6) {
+      color = {
+        red: Number.parseInt(colorCode.slice(0, 2), 16) / 255,
+        green: Number.parseInt(colorCode.slice(2, 4), 16) / 255,
+        blue: Number.parseInt(colorCode.slice(4, 6), 16) / 255,
+        alpha: 1
+        // 假设不透明
+      };
+    } else if (colorCode.length === 8) {
+      color = {
+        red: Number.parseInt(colorCode.slice(0, 2), 16) / 255,
+        green: Number.parseInt(colorCode.slice(2, 4), 16) / 255,
+        blue: Number.parseInt(colorCode.slice(4, 6), 16) / 255,
+        alpha: Number.parseInt(colorCode.slice(6, 8), 16) / 255
+      };
+    } else if (colorCode.length === 4) {
+      color = {
+        red: Number.parseInt(colorCode[0] + colorCode[0], 16) / 255,
+        green: Number.parseInt(colorCode[1] + colorCode[1], 16) / 255,
+        blue: Number.parseInt(colorCode[2] + colorCode[2], 16) / 255,
+        alpha: Number.parseInt(colorCode[3] + colorCode[3], 16) / 255
+      };
+    } else {
+      return void 0;
+    }
+  } else {
+    return void 0;
+  }
+  return {
+    ats,
+    quote,
+    colorString,
+    color
+  };
+}
+var ColorProvider = class extends Provider {
+  /** @inheritdoc */
+  async provideDocumentColors(model, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const info = [];
+    for (const { range, code } of compiled.groupedTags(model).ranges) {
+      if (code !== DiagnosticCode4.String) continue;
+      if (range.startLineNumber !== range.endLineNumber) {
+        continue;
+      }
+      const text = model.getValueInRange(range);
+      const parsed = parseColorString(text);
+      if (!parsed) continue;
+      info.push({
+        range: {
+          startLineNumber: range.startLineNumber,
+          startColumn: range.startColumn + parsed.ats.length + parsed.quote.length,
+          endLineNumber: range.endLineNumber,
+          endColumn: range.endColumn - parsed.ats.length - parsed.quote.length
+        },
+        color: parsed.color
+      });
+    }
+    return info;
+  }
+  /** @inheritdoc */
+  provideColorPresentations(model, colorInfo, token) {
+    const { color } = colorInfo;
+    return [
+      {
+        label: `#${Math.round(color.red * 255).toString(16).padStart(2, "0")}${Math.round(color.green * 255).toString(16).padStart(2, "0")}${Math.round(color.blue * 255).toString(16).padStart(2, "0")}${color.alpha >= 1 ? "" : Math.round(color.alpha * 255).toString(16).padStart(2, "0")}`
+      }
+    ];
+  }
+};
+
+// src/lsp/providers/completion-item-provider.ts
+import {
+  getVmFunctionInfo as getVmFunctionInfo2,
+  isVmExtern as isVmExtern2,
+  isVmModule as isVmModule2
+} from "@mirascript/mirascript";
+import { DiagnosticCode as DiagnosticCode5, lib, operations as operations2 } from "@mirascript/mirascript/subtle";
+var DESC_GLOBAL = "(global)";
+var DESC_LOCAL = "(local)";
+var DESC_FIELD = "(field)";
+var SUGGEST_KEYWORDS = [];
+var loadSuggestKeywords = () => {
+  if (SUGGEST_KEYWORDS.length > 0) return SUGGEST_KEYWORDS;
+  const reserved = reservedKeywords();
+  for (const kw of keywords()) {
+    if (reserved.includes(kw)) continue;
+    SUGGEST_KEYWORDS.push(kw);
+  }
+  return SUGGEST_KEYWORDS;
+};
+var COMMON_GLOBAL_SUGGESTIONS = (range, extension) => {
+  const suggestions = [
+    {
+      label: "type",
+      kind: languages.CompletionItemKind.Keyword,
+      insertText: "type",
+      commitCharacters: ["("],
+      documentation: {
+        value: `使用 \`type()\` 调用获取表达式的类型。${codeblock("type(expression);\nexpression::type();")}`
+      },
+      range
+    },
+    {
+      label: "global",
+      kind: languages.CompletionItemKind.Keyword,
+      insertText: "global",
+      commitCharacters: [".", "["],
+      documentation: {
+        value: `使用 \`global\` 获取全局变量。${codeblock('global.variableName;\nglobal["variableName"];\n"variableName" in global;')}`
+      },
+      range
+    }
+  ];
+  if (!extension) {
+    suggestions.push(
+      {
+        label: { label: "if", description: "If 表达式" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "if ${1:condition} {\n	$0\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`if\` 表达式进行条件判断。${codeblock("if condition {\n	// code\n}")}`
+        },
+        range
+      },
+      {
+        label: { label: "ifelse", description: "If-Else 表达式" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "if ${1:condition} {\n	$0\n} else {\n	\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`ifelse\` 表达式进行条件判断。${codeblock("if condition {\n	// code\n} else {\n	// code\n}")}`
+        },
+        range
+      },
+      {
+        label: { label: "match", description: "Match 表达式" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "match ${1:value} {\n	case ${2:case1} {\n		$0\n	}\n	case ${3:case2} {\n		\n	}\n	case _ {\n		\n	}\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`match\` 表达式进行模式匹配。${codeblock("match value {\n	case case1 {\n		// code\n	}\n	case case2 {\n		// code\n	}\n	case _ {\n		// code\n	}\n}")}`
+        },
+        range
+      },
+      {
+        label: { label: "loop", description: "Loop 表达式" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "loop {\n	$0\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`loop\` 表达式进行无限循环。${codeblock("loop {\n	// code\n}")}`
+        },
+        range
+      },
+      {
+        label: { label: "while", description: "While 表达式" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "while ${1:condition} {\n	$0\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`while\` 表达式进行条件循环。${codeblock("while condition {\n	// code\n}")}`
+        },
+        range
+      },
+      {
+        label: { label: "whileelse", description: "While-Else 表达式" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "while ${1:condition} {\n	$0\n} else {\n	\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`whileelse\` 表达式进行条件循环。${codeblock("while condition {\n	// code\n} else {\n	// code\n}")}`
+        },
+        range
+      },
+      {
+        label: { label: "for", description: "For 表达式" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "for ${1:item} in ${2:collection} {\n	$0\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`for\` 表达式进行迭代循环。${codeblock("for item in collection {\n	// code\n}")}`
+        },
+        range
+      },
+      {
+        label: { label: "forelse", description: "For-Else 表达式" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "for ${1:item} in ${2:collection} {\n	$0\n} else {\n	\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`forelse\` 表达式进行迭代循环。${codeblock("for item in collection {\n	// code\n} else {\n	// code\n}")}`
+        },
+        range
+      },
+      {
+        label: { label: "fn", description: "Fn 语句" },
+        kind: languages.CompletionItemKind.Snippet,
+        insertText: "fn ${1:name}(${2:params}) {\n	$0\n}",
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        documentation: {
+          value: `使用 \`fn\` 语句进行函数声明。${codeblock("fn name(params) {\n	// code\n}")}`
+        },
+        range
+      }
+    );
+    for (const kw of loadSuggestKeywords()) {
+      const exist = suggestions.find(
+        (item) => item.label === kw && item.kind === languages.CompletionItemKind.Keyword
+      );
+      if (exist) continue;
+      suggestions.push(kwSuggestion(kw, range));
+    }
+  }
+  return suggestions;
+};
+function kwSuggestion(kw, range) {
+  return {
+    label: kw,
+    kind: languages.CompletionItemKind.Keyword,
+    insertText: kw,
+    range
+  };
+}
+function filterText(key, char) {
+  if (char == null || key.startsWith(char)) return key;
+  return key.startsWith("@") || key.startsWith("$") ? key.slice(1) : key;
+}
+function completion(model, description, key, value, fn, field) {
+  let detail = "";
+  let kind;
+  if (fn == null && typeof value == "function") {
+    fn = getVmFunctionInfo2(value);
+  }
+  if (fn != null) {
+    detail = paramsList(model, fn);
+    kind = field ? languages.CompletionItemKind.Function : languages.CompletionItemKind.Method;
+  } else if (isVmModule2(value)) {
+    kind = languages.CompletionItemKind.Module;
+  } else if (isVmExtern2(value) && typeof value.value == "function") {
+    if (value.value.prototype != null && (key[0] ?? "").toUpperCase() === key[0]) {
+      kind = languages.CompletionItemKind.Class;
+    } else {
+      detail = "(..)";
+      kind = value.caller ? languages.CompletionItemKind.Method : languages.CompletionItemKind.Function;
+    }
+  } else if (!field && key.startsWith("@")) {
+    kind = languages.CompletionItemKind.Constant;
+  } else {
+    kind = field ? languages.CompletionItemKind.Field : languages.CompletionItemKind.Variable;
+  }
+  return {
+    label: { label: key, description, detail },
+    kind,
+    commitCharacters: fn ? ["!", "("] : ["!", ".", "[", "("],
+    vmValue: value,
+    isField: field
+  };
+}
+function externKeys(value) {
+  const keys = /* @__PURE__ */ new Set();
+  let e = value.value;
+  while (e && (typeof e == "object" || typeof e == "function")) {
+    for (const key of Object.getOwnPropertyNames(e)) {
+      if (value.has(key)) {
+        keys.add(key);
+      }
+    }
+    e = Object.getPrototypeOf(e);
+  }
+  return Array.from(keys);
+}
+var CompletionItemProvider = class extends Provider {
+  constructor() {
+    super(...arguments);
+    this.triggerCharacters = [".", ":"];
+  }
+  /** 查找全局变量 */
+  async completeGlobal(model, char, locals, range) {
+    const global = await this.getContext(model);
+    const suggestions = [];
+    const localKeys = new Set(locals.map((item) => item.insertText));
+    for (const key of new Set(global.keys())) {
+      const element = global.get(key);
+      if (element === void 0) continue;
+      if (isVmModule2(element)) {
+        for (const f of element.keys()) {
+          if (char && !f.toLowerCase().includes(char)) {
+            continue;
+          }
+          const field = element.get(f);
+          if (field === void 0) continue;
+          suggestions.push({
+            insertText: localKeys.has(key) ? `global.${key}.${f}` : `${key}.${f}`,
+            filterText: filterText(f, char),
+            range,
+            ...completion(model, DESC_GLOBAL, `${key}.${f}`, field, void 0, true)
+          });
+        }
+      }
+      if (char && !key.toLowerCase().includes(char)) {
+        continue;
+      }
+      suggestions.push({
+        insertText: localKeys.has(key) ? `global.${key}` : key,
+        // 如果有同名局部变量，使用 global. 前缀
+        filterText: filterText(key, char),
+        range,
+        ...completion(model, DESC_GLOBAL, key, element, void 0, false)
+      });
+    }
+    return suggestions;
+  }
+  /** 查找局部变量 */
+  async completeLocal(model, position, char, range) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return [];
+    const suggestions = [];
+    let scope = compiled.scopeAt(model, position);
+    const locals = /* @__PURE__ */ new Set();
+    while (scope) {
+      for (const { definition, fn } of scope.locals) {
+        const name = model.getValueInRange(definition.range);
+        if (locals.has(name)) continue;
+        if (char && !name.toLowerCase().includes(char)) {
+          continue;
+        }
+        locals.add(name);
+        suggestions.push({
+          insertText: name,
+          filterText: filterText(name, char),
+          range,
+          ...completion(model, DESC_LOCAL, name, void 0, fn, false)
+        });
+      }
+      if (!scope.parent) break;
+      scope = scope.parent;
+    }
+    return suggestions;
+  }
+  /** 查找变量字段 */
+  async completeFields(model, position, char, range) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return [];
+    const access = compiled.fieldAccessAt(model, position);
+    if (!access || access.fields.length === 0) return [];
+    const { def, fields } = access;
+    if ("definition" in def.def) {
+      return [];
+    }
+    const vmGlobal = await this.getContext(model);
+    fields.pop();
+    const value = getDeep(vmGlobal.get(def.def.name), fields);
+    if (value == null || typeof value != "object") {
+      return [];
+    }
+    const keys = isVmExtern2(value) ? externKeys(value) : lib.keys(value);
+    const result = [];
+    for (const k of keys) {
+      const key = String(k);
+      if (char && !String(key).toLowerCase().includes(char)) {
+        continue;
+      }
+      const field = operations2.$Get(value, key);
+      result.push({
+        insertText: key,
+        range,
+        ...completion(model, DESC_FIELD, key, field, void 0, true)
+      });
+    }
+    return result;
+  }
+  /** 获取完成范围 */
+  toCompletionItemRanges(position, range) {
+    return {
+      replace: range,
+      insert: Range.fromPositions(Range.getStartPosition(range), position)
+    };
+  }
+  /** @inheritdoc */
+  async provideCompletionItems(model, position, context, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    if (context.triggerCharacter === ".") {
+      const prevWord = model.getWordAtPosition({
+        lineNumber: position.lineNumber,
+        column: position.column - 1
+      });
+      if (prevWord?.word === "global") {
+        const globals2 = await this.completeGlobal(
+          model,
+          void 0,
+          [],
+          void 0
+        );
+        return { suggestions: globals2 };
+      }
+    }
+    const word = wordAt(model, position);
+    const prev = model.getValueInRange({
+      startLineNumber: position.lineNumber,
+      startColumn: (word?.range.startColumn ?? position.column) - 2,
+      endLineNumber: position.lineNumber,
+      endColumn: word?.range.startColumn ?? position.column
+    });
+    if (context.triggerCharacter === ":" && prev !== "::") {
+      return void 0;
+    }
+    let char;
+    let range;
+    const def = compiled.variableAccessAt(model, position);
+    if (def) {
+      if (def.ref == null) {
+        const suggestions2 = [];
+        if (word && compiled.tags.some(
+          (t) => strictContainsPosition(t.range, position) && t.code === DiagnosticCode5.MatchExpression
+        )) {
+          suggestions2.push(
+            kwSuggestion("case", this.toCompletionItemRanges(position, word.range)),
+            kwSuggestion("if", this.toCompletionItemRanges(position, word.range))
+          );
+        }
+        return { suggestions: suggestions2 };
+      }
+      const d = def.def;
+      range = d.references[def.ref].range;
+      char = model.getValueInRange({
+        startLineNumber: range.startLineNumber,
+        startColumn: range.startColumn,
+        endLineNumber: range.startLineNumber,
+        endColumn: range.startColumn + 1
+      });
+    } else if (word) {
+      range = word.range;
+      char = word.word[0];
+    } else {
+      range = {
+        startLineNumber: position.lineNumber,
+        startColumn: position.column,
+        endLineNumber: position.lineNumber,
+        endColumn: position.column
+      };
+    }
+    char = char?.toLowerCase();
+    const completionRange = this.toCompletionItemRanges(position, range);
+    if (/[^.]\.$/u.test(prev)) {
+      const suggestions2 = await this.completeFields(model, position, char, completionRange);
+      return { suggestions: suggestions2 };
+    }
+    const suggestions = COMMON_GLOBAL_SUGGESTIONS(completionRange, prev === "::");
+    const locals = await this.completeLocal(model, position, char, completionRange);
+    const globals = await this.completeGlobal(model, char, locals, completionRange);
+    suggestions.push(...locals, ...globals);
+    return { suggestions };
+  }
+  /** @inheritdoc */
+  resolveCompletionItem(item, token) {
+    if (typeof item.label == "string") {
+      return item;
+    }
+    const { vmValue, isField } = item;
+    const { label } = item.label;
+    if (vmValue != null) {
+      if (item.documentation) return item;
+      const last = label.split(".").pop();
+      const def = valueDoc(last, vmValue, isField ? "field" : "hint");
+      item.documentation = {
+        value: `${codeblock("\0" + def.script)}
+${def.doc.join("\n")}`
+      };
+    }
+    return item;
+  }
+};
+
+// src/lsp/providers/definition-reference-provider.ts
+var DefinitionReferenceProvider = class extends Provider {
+  constructor(globalModel = editor.createModel(``, "mirascript", Uri.parse("mirascript:///lib/global.mira"))) {
+    super();
+    this.globalModel = globalModel;
+  }
+  /** 准备要显示的定义 */
+  prepareGlobal(name, value) {
+    const { globalModel } = this;
+    const { script, doc } = valueDoc(name, value, "declare");
+    const code = [
+      `/**${DOC_HEADER}**/`,
+      "",
+      `/**`,
+      ...doc.flatMap((sec) => sec.split("\n")).map((line) => ` * ${line}`),
+      ` */`,
+      script,
+      ""
+    ];
+    globalModel.setValue(code.join("\n"));
+    return {
+      uri: globalModel.uri,
+      range: {
+        startColumn: 1,
+        startLineNumber: code.length - 1,
+        endColumn: 1,
+        endLineNumber: code.length - 1
+      }
+    };
+  }
+  /** @inheritdoc */
+  async provideDefinition(model, position, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const globals = await this.getContext(model);
+    const d = compiled.variableAccessAt(model, position);
+    if (!d) return [];
+    const { def, ref } = d;
+    let originSelectionRange;
+    if (ref != null) {
+      originSelectionRange = def.references[ref]?.range;
+    } else if ("definition" in def) {
+      originSelectionRange = def.definition.range;
+    }
+    let link;
+    if ("name" in def) {
+      link = this.prepareGlobal(def.name, globals.get(def.name));
+    } else {
+      link = { uri: model.uri, range: def.definition.range };
+    }
+    link.originSelectionRange = originSelectionRange;
+    return [link];
+  }
+  /** @inheritdoc */
+  async provideReferences(model, position, context, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const globals = await this.getContext(model);
+    const d = compiled.variableAccessAt(model, position);
+    if (!d) return [];
+    const { def } = d;
+    const links = def.references.map((u) => ({
+      uri: model.uri,
+      range: u.range
+    }));
+    if (context.includeDeclaration) {
+      if ("name" in def) {
+        links.push(this.prepareGlobal(def.name, globals.get(def.name)));
+      } else if (!Range.isEmpty(def.definition.range)) {
+        links.push({
+          uri: model.uri,
+          range: def.definition.range
+        });
+      }
+    }
+    return links;
+  }
+};
+
+// src/lsp/providers/document-highlight-provider.ts
+import { DiagnosticCode as DiagnosticCode6 } from "@mirascript/mirascript/subtle";
+var DocumentHighlightProvider = class extends Provider {
+  /** @inheritdoc */
+  async provideDocumentHighlights(model, position, token) {
+    const word = model.getWordAtPosition(position);
+    if (word && keywords().includes(word.word)) {
+      const result = await this.highlightKeyword(model, position, word.word);
+      if (result) return result;
+    }
+    return this.getDocumentHighlightsFromDefinition(model, position);
+  }
+  /** 从 definition 生成 DocumentHighlight 列表 */
+  async getDocumentHighlightsFromDefinition(model, position) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const def = compiled.variableAccessAt(model, position)?.def;
+    if (!def) return void 0;
+    const links = def.references.map((u) => {
+      const { code, range } = u;
+      let kind = languages.DocumentHighlightKind.Read;
+      if (code === DiagnosticCode6.WriteLocal || code === DiagnosticCode6.ReadWriteLocal || code === DiagnosticCode6.RedeclareLocal) {
+        kind = languages.DocumentHighlightKind.Write;
+      }
+      return {
+        kind,
+        range
+      };
+    });
+    if ("definition" in def && !Range.isEmpty(def.definition.range)) {
+      links.push({
+        kind: languages.DocumentHighlightKind.Write,
+        range: def.definition.range
+      });
+    }
+    return links;
+  }
+  /** 高亮关键字 */
+  async highlightKeyword(model, position, word) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const kw = compiled.tagsReferences.find((kw2) => Range.containsPosition(kw2.range, position));
+    if (!kw) return void 0;
+    return kw.diagnostic.references.map((r) => ({
+      kind: languages.DocumentHighlightKind.Text,
+      range: r.range
+    }));
+  }
+};
+
+// src/lsp/providers/document-symbol-provider.ts
+import { DiagnosticCode as DiagnosticCode7 } from "@mirascript/wasm";
+var DocumentSymbolProvider = class extends Provider {
+  /** 构建树 */
+  handleScope(model, scope) {
+    const symbols = [];
+    const unhandledChildren = new Set(scope.children);
+    for (const { definition } of scope.locals) {
+      const { range } = definition;
+      let kind = languages.SymbolKind.Variable;
+      let name;
+      let children = [];
+      let allRange = range;
+      switch (definition.code) {
+        case DiagnosticCode7.ParameterIt:
+          if (definition.references.length === 0) {
+            continue;
+          }
+          name = `it`;
+          break;
+        case DiagnosticCode7.LocalFunction: {
+          kind = languages.SymbolKind.Function;
+          const funcScope = scope.children.find((s) => Range.compareRangesUsingStarts(s.range, range) > 0);
+          if (funcScope) {
+            allRange = Range.plusRange(range, funcScope.range);
+            children = this.handleScope(model, funcScope);
+            unhandledChildren.delete(funcScope);
+          }
+          break;
+        }
+      }
+      symbols.push({
+        name: name ?? model.getValueInRange(definition.range),
+        detail: "",
+        kind,
+        range: allRange,
+        tags: [],
+        selectionRange: range,
+        children
+      });
+    }
+    for (const child of unhandledChildren) {
+      symbols.push(...this.handleScope(model, child));
+    }
+    return symbols;
+  }
+  /** @inheritdoc */
+  async provideDocumentSymbols(model, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const root = compiled.scopes(model)[0];
+    if (!root) return void 0;
+    return this.handleScope(model, root);
+  }
+};
+
+// src/lsp/providers/formatter-provider.ts
+var FormatterProvider = class extends Provider {
+  constructor() {
+    super(...arguments);
+    /** @inheritdoc */
+    this.autoFormatTriggerCharacters = [";", "}", "]", ")"];
+  }
+  /** @inheritdoc */
+  async format(model, ranges, options, hint, token) {
+    if (hint !== "full") return [];
+    const compiled = await this.getCompileResult(model);
+    if (compiled?.result.formatted == null) return [];
+    return [
+      {
+        range: model.getFullModelRange(),
+        text: compiled.result.formatted
+      }
+    ];
+  }
+  /** @inheritdoc */
+  provideDocumentFormattingEdits(model, options, token) {
+    return this.format(model, [], options, "full", token);
+  }
+  /** @inheritdoc */
+  provideDocumentRangeFormattingEdits(model, range, options, token) {
+    return this.format(model, [range], options, "range", token);
+  }
+  /** @inheritdoc */
+  provideDocumentRangesFormattingEdits(model, ranges, options, token) {
+    return this.format(model, ranges, options, "range", token);
+  }
+  /** @inheritdoc */
+  provideOnTypeFormattingEdits(model, position, ch, options, token) {
+    return this.format(
+      model,
+      [Range.fromPositions(position, position)],
+      options,
+      ch === ";" ? "statement" : "expression",
+      token
+    );
+  }
+};
+
+// src/lsp/providers/hover-provider.ts
+import { DiagnosticCode as DiagnosticCode8 } from "@mirascript/wasm";
+var HoverProvider = class extends Provider {
+  /** 变量提示 */
+  async provideVariableHover(model, { def, ref }) {
+    const contents = [];
+    let range;
+    if ("name" in def) {
+      const globals = await this.getContext(model);
+      const value = globals.has(def.name) ? globals.get(def.name) : void 0;
+      const { script, doc } = valueDoc(def.name, value, "hint");
+      contents.push({ value: codeblock(`\0(global) ${script}`) });
+      for (const d of doc) {
+        contents.push({ value: d });
+      }
+      range = def.references[ref]?.range;
+    } else {
+      let content;
+      const tag = def.definition;
+      switch (tag.code) {
+        case DiagnosticCode8.ParameterSubPatternImmutable:
+          content = {
+            value: codeblock(`\0(parameter pattern) ${model.getValueInRange(tag.range)}`)
+          };
+          break;
+        case DiagnosticCode8.ParameterSubPatternMutable:
+          content = {
+            value: codeblock(`\0(parameter pattern) mut ${model.getValueInRange(tag.range)}`)
+          };
+          break;
+        case DiagnosticCode8.ParameterImmutable:
+          content = {
+            value: codeblock(`\0(parameter) ${model.getValueInRange(tag.range)}`)
+          };
+          break;
+        case DiagnosticCode8.ParameterMutable:
+          content = {
+            value: codeblock(`\0(parameter) mut ${model.getValueInRange(tag.range)}`)
+          };
+          break;
+        case DiagnosticCode8.ParameterIt:
+          content = {
+            value: codeblock(`\0(parameter) it`)
+          };
+          break;
+        case DiagnosticCode8.ParameterImmutableRest:
+          content = {
+            value: codeblock(`\0(parameter) ..${model.getValueInRange(tag.range)}`)
+          };
+          break;
+        case DiagnosticCode8.ParameterMutableRest:
+          content = {
+            value: codeblock(`\0(parameter) ..mut ${model.getValueInRange(tag.range)}`)
+          };
+          break;
+        case DiagnosticCode8.LocalFunction: {
+          const params = paramsList(model, def.fn);
+          content = {
+            value: codeblock(`\0fn ${model.getValueInRange(tag.range)}${params}`)
+          };
+          break;
+        }
+        case DiagnosticCode8.LocalImmutable:
+          content = {
+            value: codeblock(`\0let ${model.getValueInRange(tag.range)}`)
+          };
+          break;
+        case DiagnosticCode8.LocalConst:
+          content = {
+            value: codeblock(`\0const ${model.getValueInRange(tag.range)}`)
+          };
+          break;
+        case DiagnosticCode8.LocalMutable:
+          content = {
+            value: codeblock(`\0let mut ${model.getValueInRange(tag.range)}`)
+          };
+          break;
+      }
+      if (ref == null) {
+        range = tag.range;
+      } else {
+        range = def.references[ref]?.range;
+      }
+      if (content) {
+        contents.push(content);
+      }
+    }
+    if (!contents.length) return void 0;
+    return {
+      contents,
+      range
+    };
+  }
+  /** 字段提示 */
+  async provideFieldHover(model, range, { def: { def, ref }, fields }) {
+    if ("definition" in def) {
+      return void 0;
+    }
+    const vmGlobal = await this.getContext(model);
+    const value = getDeep(vmGlobal.get(def.name), fields);
+    if (value == null) return void 0;
+    const lastField = fields.pop();
+    const { script, doc } = valueDoc(lastField, value, "field");
+    return {
+      contents: [{ value: codeblock(`\0(field) ${script}`) }, ...doc.map((d) => ({ value: d }))],
+      range
+    };
+  }
+  /** @inheritdoc */
+  async provideHover(model, position, token, context) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) {
+      return void 0;
+    }
+    const d = compiled.variableAccessAt(model, position);
+    if (d) {
+      return this.provideVariableHover(model, d);
+    }
+    const word = wordAt(model, position);
+    if (word) {
+      const a = compiled.fieldAccessAt(model, {
+        lineNumber: position.lineNumber,
+        column: word.range.endColumn
+      });
+      if (a) {
+        return this.provideFieldHover(model, word.range, a);
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/lsp/providers/inlay-hints-provider.ts
+import { DiagnosticCode as DiagnosticCode9 } from "@mirascript/wasm";
+var InlayHintsProvider = class extends Provider {
+  /** @inheritdoc */
+  get onDidChangeInlayHints() {
+    return this.onDidChange;
+  }
+  /** @inheritdoc */
+  async provideInlayHints(model, range, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) {
+      return void 0;
+    }
+    const hints = [];
+    for (const tag of compiled.tags) {
+      if (!range.containsRange(tag.range)) {
+        continue;
+      }
+      let lineNumber = 0;
+      let column = 0;
+      let label = "";
+      const kind = languages.InlayHintKind.Parameter;
+      let paddingLeft = true;
+      let paddingRight = false;
+      const edits = [];
+      switch (tag.code) {
+        case DiagnosticCode9.ParameterIt: {
+          if (!tag.references.length) {
+            continue;
+          }
+          lineNumber = tag.range.endLineNumber;
+          column = tag.range.endColumn;
+          label = "(it)";
+          paddingLeft = /\bfn$/u.test(
+            model.getValueInRange(new Range(lineNumber, column - 3, lineNumber, column))
+          );
+          paddingRight = model.getValueInRange(new Range(lineNumber, column, lineNumber, column + 1)) === "{";
+          edits.push({
+            range: new Range(lineNumber, column, lineNumber, column),
+            text: `${paddingLeft ? " " : ""}${label}${paddingRight ? " " : ""}`
+          });
+          break;
+        }
+        case DiagnosticCode9.UnnamedRecordField0:
+        case DiagnosticCode9.UnnamedRecordField1:
+        case DiagnosticCode9.UnnamedRecordField2:
+        case DiagnosticCode9.UnnamedRecordField3:
+        case DiagnosticCode9.UnnamedRecordField4:
+        case DiagnosticCode9.UnnamedRecordField5:
+        case DiagnosticCode9.UnnamedRecordField6:
+        case DiagnosticCode9.UnnamedRecordField7:
+        case DiagnosticCode9.UnnamedRecordField8:
+        case DiagnosticCode9.UnnamedRecordField9:
+        case DiagnosticCode9.UnnamedRecordFieldN: {
+          const index = tag.code - DiagnosticCode9.UnnamedRecordField0;
+          if (index > 9) break;
+          lineNumber = tag.range.startLineNumber;
+          column = tag.range.startColumn;
+          label = `${index}:`;
+          paddingLeft = /[^\s(]/u.test(
+            model.getValueInRange(new Range(lineNumber, column - 1, lineNumber, column))
+          );
+          paddingRight = true;
+          break;
+        }
+        case DiagnosticCode9.OmitNamedRecordField: {
+          const ref = tag.references[0];
+          if (ref?.code !== DiagnosticCode9.OmitNamedRecordFieldName) continue;
+          lineNumber = tag.range.startLineNumber;
+          column = tag.range.startColumn;
+          label = model.getValueInRange(ref.range);
+          paddingLeft = /[^\s(]/u.test(
+            model.getValueInRange(new Range(lineNumber, column - 1, lineNumber, column))
+          );
+          paddingRight = false;
+          const insertRight = !/\s/u.test(
+            model.getValueInRange(
+              new Range(
+                tag.range.endLineNumber,
+                tag.range.endColumn,
+                tag.range.endLineNumber,
+                tag.range.endColumn + 1
+              )
+            )
+          );
+          edits.push({
+            range: tag.range,
+            text: `${paddingLeft ? " " : ""}${label}${model.getValueInRange(tag.range)}${insertRight ? " " : ""}`
+          });
+          break;
+        }
+      }
+      if (!label) continue;
+      const hint = {
+        position: { lineNumber, column },
+        label,
+        kind,
+        paddingLeft,
+        paddingRight,
+        textEdits: edits
+      };
+      hints.push(hint);
+    }
+    return {
+      hints,
+      dispose: () => {
+      }
+    };
+  }
+};
+
+// src/lsp/providers/range-provider.ts
+var RangeProvider = class extends Provider {
+  /** @inheritdoc */
+  async provideFoldingRanges(model, context, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    return void 0;
+  }
+  /** @inheritdoc */
+  async provideSelectionRanges(model, positions, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const { ranges } = compiled.groupedTags(model);
+    return positions.map((pos) => {
+      return ranges.filter((r) => Range.containsPosition(r.range, pos)).map((t) => ({
+        range: t.range
+      }));
+    });
+  }
+};
+
+// src/lsp/providers/rename-provider.ts
+import { DiagnosticCode as DiagnosticCode10 } from "@mirascript/wasm";
+var RenameProvider = class extends Provider {
+  /** 重命名推断字段 */
+  provideRenameEditsOmitNameFields(model, compiled, edits, ref, oldName) {
+    const { omitNameFields } = compiled.groupedTags(model);
+    for (const tag of omitNameFields) {
+      if (Range.equalsRange(tag.references[0]?.range, ref.range)) {
+        const current = model.getValueInRange(tag.range);
+        const paddingLeft = /[^\s(]/u.test(
+          model.getValueInRange({
+            startLineNumber: tag.range.startLineNumber,
+            startColumn: tag.range.startColumn - 1,
+            endLineNumber: tag.range.startLineNumber,
+            endColumn: tag.range.startColumn
+          })
+        );
+        const paddingRight = !/\s/u.test(
+          model.getValueInRange({
+            startLineNumber: tag.range.endLineNumber,
+            startColumn: tag.range.endColumn,
+            endLineNumber: tag.range.endLineNumber,
+            endColumn: tag.range.endColumn + 1
+          })
+        );
+        edits.push({
+          resource: model.uri,
+          versionId: compiled.version,
+          textEdit: {
+            range: tag.range,
+            text: `${paddingLeft ? " " : ""}${oldName}${current}${paddingRight ? " " : ""}`
+          }
+        });
+      }
+    }
+  }
+  /** @inheritdoc */
+  async provideRenameEdits(model, position, newName, token) {
+    newName = newName.trim();
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const d = compiled.variableAccessAt(model, position);
+    if (!d) return void 0;
+    const edits = [];
+    const { references } = d.def;
+    let oldName;
+    if ("definition" in d.def) {
+      edits.push({
+        resource: model.uri,
+        versionId: compiled.version,
+        textEdit: {
+          range: d.def.definition.range,
+          text: d.def.definition.code === DiagnosticCode10.ParameterIt ? `(${newName})` : newName
+        }
+      });
+      oldName = model.getValueInRange(d.def.definition.range);
+      this.provideRenameEditsOmitNameFields(model, compiled, edits, d.def.definition, oldName);
+    } else {
+      oldName = d.def.name;
+    }
+    for (const ref of references) {
+      edits.push({
+        resource: model.uri,
+        versionId: compiled.version,
+        textEdit: {
+          range: ref.range,
+          text: newName
+        }
+      });
+      this.provideRenameEditsOmitNameFields(model, compiled, edits, ref, oldName);
+    }
+    const { globals } = compiled.groupedTags(model);
+    const globalWithSameName = globals.find((g) => g.name === newName);
+    if (globalWithSameName) {
+      for (const ref of globalWithSameName.references) {
+        edits.push({
+          resource: model.uri,
+          versionId: compiled.version,
+          textEdit: {
+            range: ref.range,
+            text: `global.${newName}`
+          }
+        });
+        this.provideRenameEditsOmitNameFields(model, compiled, edits, ref, oldName);
+      }
+    }
+    return { edits };
+  }
+  /** @inheritdoc */
+  async resolveRenameLocation(model, position, token) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const d = compiled.variableAccessAt(model, position);
+    if (!d) {
+      return {
+        range: Range.fromPositions(position),
+        text: "",
+        rejectReason: "Cannot rename this element"
+      };
+    }
+    const { def, ref } = d;
+    if ("name" in def) {
+      return {
+        range: def.references[ref]?.range ?? Range.fromPositions(position),
+        text: def.name,
+        rejectReason: "Cannot rename global variables"
+      };
+    }
+    const tag = ref == null ? def.definition : def.references[ref];
+    return {
+      range: tag.range,
+      text: model.getValueInRange(tag.range) ?? ""
+    };
+  }
+};
+
+// src/lsp/providers/semantic-tokens-provider.ts
+import { isVmFunction as isVmFunction2, isVmModule as isVmModule3 } from "@mirascript/mirascript";
+import { DiagnosticCode as DiagnosticCode11 } from "@mirascript/wasm";
+var TOKEN_TYPES = {
+  [0 /* VARIABLE */]: "variable.other.constant",
+  [1 /* VARIABLE_MUTABLE */]: "variable",
+  [2 /* CONSTANT */]: "variable.other.constant",
+  [3 /* GLOBAL */]: "variable",
+  [4 /* FUNCTION */]: "entity.name.function",
+  [5 /* MODULE */]: "entity.name.namespace",
+  [6 /* PROPERTY */]: "support.type.property-name",
+  [7 /* KEYWORD_CONTROL */]: "keyword.control",
+  [8 /* PARAM */]: "variable.other.constant.emphasis",
+  [9 /* PARAM_MUTABLE */]: "variable.emphasis"
+};
+var DocumentSemanticTokensProvider = class extends Provider {
+  /** @inheritdoc */
+  getLegend() {
+    const tokenTypes = Object.values(TOKEN_TYPES);
+    return {
+      tokenTypes,
+      tokenModifiers: tokenTypes.map((_) => "")
+    };
+  }
+  /** @inheritdoc */
+  async provideDocumentSemanticTokens(model, lastResultId, token) {
+    const resultId = `${model.uri.toString()}?${model.getVersionId()}`;
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) {
+      return void 0;
+    }
+    const globals = await this.getContext(model);
+    const data = [];
+    for (const { code, range, references } of compiled.tags) {
+      if (Range.isEmpty(range)) continue;
+      let tokenType = -1;
+      let onlyReferences = false;
+      switch (code) {
+        case DiagnosticCode11.GlobalVariable: {
+          const id = model.getValueInRange(range);
+          if (id.startsWith("@")) {
+            tokenType = 2 /* CONSTANT */;
+          } else if (isVmFunction2(globals.get(id))) {
+            tokenType = 4 /* FUNCTION */;
+          } else if (isVmModule3(globals.get(id))) {
+            tokenType = 5 /* MODULE */;
+          } else {
+            tokenType = 3 /* GLOBAL */;
+          }
+          break;
+        }
+        case DiagnosticCode11.LocalFunction: {
+          tokenType = 4 /* FUNCTION */;
+          break;
+        }
+        case DiagnosticCode11.ParameterMutable:
+        case DiagnosticCode11.ParameterSubPatternMutable:
+        case DiagnosticCode11.ParameterMutableRest: {
+          tokenType = 9 /* PARAM_MUTABLE */;
+          break;
+        }
+        case DiagnosticCode11.LocalMutable: {
+          tokenType = 1 /* VARIABLE_MUTABLE */;
+          break;
+        }
+        case DiagnosticCode11.ParameterImmutable:
+        case DiagnosticCode11.ParameterSubPatternImmutable:
+        case DiagnosticCode11.ParameterImmutableRest: {
+          tokenType = 8 /* PARAM */;
+          break;
+        }
+        case DiagnosticCode11.LocalImmutable: {
+          tokenType = 0 /* VARIABLE */;
+          break;
+        }
+        case DiagnosticCode11.LocalConst: {
+          tokenType = 2 /* CONSTANT */;
+          break;
+        }
+        case DiagnosticCode11.RecordFieldIdName: {
+          tokenType = 6 /* PROPERTY */;
+          break;
+        }
+        case DiagnosticCode11.ForExpression: {
+          tokenType = 7 /* KEYWORD_CONTROL */;
+          onlyReferences = true;
+          break;
+        }
+      }
+      if (tokenType < 0) continue;
+      const { startLineNumber, startColumn, endColumn } = range;
+      const length = endColumn - startColumn;
+      if (!onlyReferences) {
+        data.push({
+          row: startLineNumber - 1,
+          // 从 0 开始
+          col: startColumn - 1,
+          length,
+          tokenType,
+          tokenModifiers: 1 << tokenType
+        });
+      }
+      for (const ref of references) {
+        data.push({
+          row: ref.range.startLineNumber - 1,
+          col: ref.range.startColumn - 1,
+          length: ref.range.endColumn - ref.range.startColumn,
+          tokenType,
+          tokenModifiers: 1 << tokenType
+        });
+      }
+    }
+    data.sort((a, b) => {
+      if (a.row !== b.row) {
+        return a.row - b.row;
+      }
+      return a.col - b.col;
+    });
+    const bin = new Uint32Array(data.length * 5);
+    for (let i = 0; i < data.length; i++) {
+      const current = data[i];
+      let { row, col } = current;
+      if (i > 0) {
+        const prev = data[i - 1];
+        row -= prev.row;
+        if (row === 0) {
+          col -= prev.col;
+        }
+      }
+      bin.set([row, col, current.length, current.tokenType, current.tokenModifiers], i * 5);
+    }
+    return {
+      resultId,
+      data: bin
+    };
+  }
+  /** @inheritdoc */
+  releaseDocumentSemanticTokens(resultId) {
+  }
+};
+
+// src/lsp/providers/signature-help-provider.ts
+import { DiagnosticCode as DiagnosticCode12 } from "@mirascript/wasm";
+import { getVmFunctionInfo as getVmFunctionInfo3 } from "@mirascript/mirascript";
+var SignatureHelpProvider = class extends Provider {
+  constructor() {
+    super(...arguments);
+    /** @inheritdoc */
+    this.signatureHelpTriggerCharacters = ["(", ","];
+    /** @inheritdoc */
+    this.signatureHelpRetriggerCharacters = [")"];
+  }
+  /** @inheritdoc */
+  async provideSignatureHelp(model, position, token, context) {
+    const compiled = await this.getCompileResult(model);
+    if (!compiled) return void 0;
+    const invokes = compiled.groupedTags(model).ranges.filter((r) => {
+      if (r.code !== DiagnosticCode12.FunctionCall && r.code !== DiagnosticCode12.ExtensionCall) {
+        return false;
+      }
+      if (!strictContainsPosition(r.range, position)) {
+        return false;
+      }
+      const argStart = r.references.find((ref) => ref.code === DiagnosticCode12.ArgumentStart);
+      const argEnd = r.references.find((ref) => ref.code === DiagnosticCode12.ArgumentEnd);
+      if (!argStart || !argEnd) {
+        return false;
+      }
+      return Range.containsPosition(
+        Range.fromPositions(Range.getEndPosition(argStart.range), Range.getStartPosition(argEnd.range)),
+        position
+      );
+    });
+    if (!invokes.length) return void 0;
+    invokes.sort((a, b) => Range.strictContainsRange(a.range, b.range) ? 1 : -1);
+    const invoke = invokes[0];
+    const callableRef = invoke.references.find((ref) => ref.code === DiagnosticCode12.Callable);
+    if (!callableRef) return void 0;
+    const callableInfo = compiled.accessAt(model, Range.getEndPosition(callableRef.range));
+    if (!callableInfo) return void 0;
+    let sig;
+    if ("name" in callableInfo.def.def) {
+      const { name } = callableInfo.def.def;
+      const globals = await this.getContext(model);
+      const callable = getDeep(globals.get(name), callableInfo.fields);
+      const info = getVmFunctionInfo3(callable);
+      if (!info) return void 0;
+      sig = { ...fnSignature(name, info), name, summary: info.summary };
+    } else if (callableInfo.def.def.fn) {
+      const { fn, definition } = callableInfo.def.def;
+      const params = localParamSignature(model, fn);
+      const name = model.getValueInRange(definition.range);
+      sig = { params, returns: "", name, summary: "" };
+    }
+    if (!sig) return void 0;
+    const signature = {
+      label: "",
+      parameters: []
+    };
+    if (invoke.code === DiagnosticCode12.ExtensionCall) {
+      const thisArg = sig.params[0];
+      if (thisArg && !thisArg[0].startsWith("..")) {
+        sig.params.shift();
+        const s = thisArg[1].includes(" ") ? `(${thisArg[1]})` : thisArg[1];
+        signature.label = `fn ${s}::${sig.name}(`;
+      } else {
+        signature.label = `fn ()::${sig.name}(`;
+      }
+    } else {
+      signature.label = `fn ${sig.name}(`;
+    }
+    signature.documentation = { value: sig.summary ?? "" };
+    for (let i = 0; i < sig.params.length; i++) {
+      const [_, p, doc] = sig.params[i];
+      const start = signature.label.length;
+      signature.parameters.push({
+        label: [start, start + p.length],
+        documentation: { value: doc }
+      });
+      if (i === sig.params.length - 1) {
+        signature.label += p;
+      } else {
+        signature.label += p + ", ";
+      }
+    }
+    signature.label += ")" + sig.returns;
+    let pos = 0;
+    for (const ref of invoke.references) {
+      if (ref.code === DiagnosticCode12.ArgumentSpread) pos = Number.NaN;
+      if (ref.code !== DiagnosticCode12.ArgumentComma || Range.isEmpty(ref.range)) continue;
+      if (Position.isBeforeOrEqual(Range.getEndPosition(ref.range), position) && !sig.params[pos]?.[0].startsWith("..")) {
+        pos++;
+      }
+    }
+    return {
+      dispose: () => void 0,
+      value: {
+        signatures: [signature],
+        activeSignature: 0,
+        activeParameter: pos
+      }
+    };
+  }
+};
+
+// src/lsp/index.ts
+import { ready } from "@mirascript/wasm";
+async function registerLSP(contextProvider2) {
+  setContextProvider(contextProvider2);
+  await ready;
+  const codeActionProvider = new CodeActionProvider();
+  const colorProvider = new ColorProvider();
+  const completionItemProvider = new CompletionItemProvider();
+  const definitionReferenceProvider = new DefinitionReferenceProvider();
+  const documentHighlightProvider = new DocumentHighlightProvider();
+  const documentSymbolProvider = new DocumentSymbolProvider();
+  const formatterProvider = new FormatterProvider();
+  const hoverProvider = new HoverProvider();
+  const inlayHintsProvider = new InlayHintsProvider();
+  const rangeProvider = new RangeProvider();
+  const renameProvider = new RenameProvider();
+  const documentSemanticTokensProvider = new DocumentSemanticTokensProvider();
+  const signatureHelpProvider = new SignatureHelpProvider();
+  const language = ["mirascript", "mirascript-template"];
+  return [
+    languages.registerCodeActionProvider(language, codeActionProvider),
+    languages.registerColorProvider(language, colorProvider),
+    languages.registerDefinitionProvider(language, definitionReferenceProvider),
+    languages.registerReferenceProvider(language, definitionReferenceProvider),
+    languages.registerDocumentHighlightProvider(language, documentHighlightProvider),
+    languages.registerDocumentSymbolProvider(language, documentSymbolProvider),
+    languages.registerDocumentFormattingEditProvider(language, formatterProvider),
+    // languages.registerDocumentRangeFormattingEditProvider(language, formatterProvider),
+    // languages.registerOnTypeFormattingEditProvider(language, formatterProvider),
+    languages.registerHoverProvider(language, hoverProvider),
+    languages.registerInlayHintsProvider(language, inlayHintsProvider),
+    languages.registerFoldingRangeProvider(language, rangeProvider),
+    languages.registerSelectionRangeProvider(language, rangeProvider),
+    languages.registerDocumentSemanticTokensProvider(language, documentSemanticTokensProvider),
+    languages.registerRenameProvider(language, renameProvider),
+    languages.registerCompletionItemProvider(language, completionItemProvider),
+    languages.registerSignatureHelpProvider(language, signatureHelpProvider)
+  ];
+}
+export {
+  CodeActionProvider,
+  ColorProvider,
+  CompletionItemProvider,
+  DefinitionReferenceProvider,
+  DocumentHighlightProvider,
+  DocumentSemanticTokensProvider,
+  DocumentSymbolProvider,
+  FormatterProvider,
+  HoverProvider,
+  InlayHintsProvider,
+  RangeProvider,
+  RenameProvider,
+  SignatureHelpProvider,
+  registerLSP,
+  setContextProvider
+};
+//# sourceMappingURL=index.js.map