monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/language/lspLanguageFeatures.js

@@ -0,0 +1,716 @@
+import { InsertTextFormat, CompletionItemKind, DocumentHighlightKind, SymbolKind, FoldingRangeKind, DiagnosticSeverity } from '../../../external/vscode-languageserver-types/lib/esm/main.js';
+import '../../editor/browser/coreCommands.js';
+import '../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import '../../editor/browser/widget/diffEditor/diffEditor.contribution.js';
+import '../../editor/contrib/anchorSelect/browser/anchorSelect.js';
+import '../../editor/contrib/bracketMatching/browser/bracketMatching.js';
+import '../../editor/contrib/caretOperations/browser/caretOperations.js';
+import '../../editor/contrib/caretOperations/browser/transpose.js';
+import '../../editor/contrib/clipboard/browser/clipboard.js';
+import '../../editor/contrib/codeAction/browser/codeActionContributions.js';
+import '../../editor/contrib/codelens/browser/codelensController.js';
+import '../../editor/contrib/colorPicker/browser/colorPickerContribution.js';
+import '../../editor/contrib/comment/browser/comment.js';
+import '../../editor/contrib/contextmenu/browser/contextmenu.js';
+import '../../editor/contrib/cursorUndo/browser/cursorUndo.js';
+import '../../editor/contrib/dnd/browser/dnd.js';
+import '../../editor/contrib/dropOrPasteInto/browser/copyPasteContribution.js';
+import '../../editor/contrib/dropOrPasteInto/browser/dropIntoEditorContribution.js';
+import '../../editor/contrib/find/browser/findController.js';
+import '../../editor/contrib/folding/browser/folding.js';
+import '../../editor/contrib/fontZoom/browser/fontZoom.js';
+import '../../editor/contrib/format/browser/formatActions.js';
+import '../../editor/contrib/documentSymbols/browser/documentSymbols.js';
+import '../../editor/contrib/inlineCompletions/browser/inlineCompletions.contribution.js';
+import '../../editor/contrib/inlineProgress/browser/inlineProgress.js';
+import '../../editor/contrib/gotoSymbol/browser/goToCommands.js';
+import '../../editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.js';
+import '../../editor/contrib/gotoError/browser/gotoError.js';
+import '../../editor/contrib/gpu/browser/gpuActions.js';
+import '../../editor/contrib/hover/browser/hoverContribution.js';
+import '../../editor/contrib/indentation/browser/indentation.js';
+import '../../editor/contrib/inlayHints/browser/inlayHintsContribution.js';
+import '../../editor/contrib/inPlaceReplace/browser/inPlaceReplace.js';
+import '../../editor/contrib/insertFinalNewLine/browser/insertFinalNewLine.js';
+import '../../editor/contrib/lineSelection/browser/lineSelection.js';
+import '../../editor/contrib/linesOperations/browser/linesOperations.js';
+import '../../editor/contrib/linkedEditing/browser/linkedEditing.js';
+import '../../editor/contrib/links/browser/links.js';
+import '../../editor/contrib/longLinesHelper/browser/longLinesHelper.js';
+import '../../editor/contrib/middleScroll/browser/middleScroll.contribution.js';
+import '../../editor/contrib/multicursor/browser/multicursor.js';
+import '../../editor/contrib/parameterHints/browser/parameterHints.js';
+import '../../editor/contrib/placeholderText/browser/placeholderText.contribution.js';
+import '../../editor/contrib/rename/browser/rename.js';
+import '../../editor/contrib/sectionHeaders/browser/sectionHeaders.js';
+import '../../editor/contrib/semanticTokens/browser/documentSemanticTokens.js';
+import '../../editor/contrib/semanticTokens/browser/viewportSemanticTokens.js';
+import '../../editor/contrib/smartSelect/browser/smartSelect.js';
+import '../../editor/contrib/snippet/browser/snippetController2.js';
+import '../../editor/contrib/stickyScroll/browser/stickyScrollContribution.js';
+import '../../editor/contrib/suggest/browser/suggestController.js';
+import '../../editor/contrib/suggest/browser/suggestInlineCompletions.js';
+import '../../editor/contrib/tokenization/browser/tokenization.js';
+import '../../editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+import '../../editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.js';
+import '../../editor/contrib/unusualLineTerminators/browser/unusualLineTerminators.js';
+import '../../editor/contrib/wordHighlighter/browser/wordHighlighter.js';
+import '../../editor/contrib/wordOperations/browser/wordOperations.js';
+import '../../editor/contrib/wordPartOperations/browser/wordPartOperations.js';
+import '../../editor/contrib/readOnlyMessage/browser/contribution.js';
+import '../../editor/contrib/diffEditorBreadcrumbs/browser/contribution.js';
+import '../../editor/contrib/floatingMenu/browser/floatingMenu.contribution.js';
+import '../../editor/common/standaloneStrings.js';
+import '../../base/browser/ui/codicons/codicon/codicon.css';
+import '../../base/browser/ui/codicons/codicon/codicon-modifiers.css';
+import '../../editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.js';
+import '../../editor/standalone/browser/inspectTokens/inspectTokens.js';
+import '../../editor/standalone/browser/quickAccess/standaloneHelpQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneGotoLineQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneGotoSymbolQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
+import '../../editor/standalone/browser/referenceSearch/standaloneReferenceSearch.js';
+import '../../editor/standalone/browser/toggleHighContrast/toggleHighContrast.js';
+import { editor, Range, languages, Uri, MarkerSeverity } from '../../editor/editor.api2.js';
+
+class DiagnosticsAdapter {
+  constructor(_languageId, _worker, configChangeEvent) {
+    this._languageId = _languageId;
+    this._worker = _worker;
+    this._disposables = [];
+    this._listener = /* @__PURE__ */ Object.create(null);
+    const onModelAdd = (model) => {
+      let modeId = model.getLanguageId();
+      if (modeId !== this._languageId) {
+        return;
+      }
+      let handle;
+      this._listener[model.uri.toString()] = model.onDidChangeContent(() => {
+        window.clearTimeout(handle);
+        handle = window.setTimeout(() => this._doValidate(model.uri, modeId), 500);
+      });
+      this._doValidate(model.uri, modeId);
+    };
+    const onModelRemoved = (model) => {
+      editor.setModelMarkers(model, this._languageId, []);
+      let uriStr = model.uri.toString();
+      let listener = this._listener[uriStr];
+      if (listener) {
+        listener.dispose();
+        delete this._listener[uriStr];
+      }
+    };
+    this._disposables.push(editor.onDidCreateModel(onModelAdd));
+    this._disposables.push(editor.onWillDisposeModel(onModelRemoved));
+    this._disposables.push(
+      editor.onDidChangeModelLanguage((event) => {
+        onModelRemoved(event.model);
+        onModelAdd(event.model);
+      })
+    );
+    this._disposables.push(
+      configChangeEvent((_) => {
+        editor.getModels().forEach((model) => {
+          if (model.getLanguageId() === this._languageId) {
+            onModelRemoved(model);
+            onModelAdd(model);
+          }
+        });
+      })
+    );
+    this._disposables.push({
+      dispose: () => {
+        editor.getModels().forEach(onModelRemoved);
+        for (let key in this._listener) {
+          this._listener[key].dispose();
+        }
+      }
+    });
+    editor.getModels().forEach(onModelAdd);
+  }
+  dispose() {
+    this._disposables.forEach((d) => d && d.dispose());
+    this._disposables.length = 0;
+  }
+  _doValidate(resource, languageId) {
+    this._worker(resource).then((worker) => {
+      return worker.doValidation(resource.toString());
+    }).then((diagnostics) => {
+      const markers = diagnostics.map((d) => toDiagnostics(resource, d));
+      let model = editor.getModel(resource);
+      if (model && model.getLanguageId() === languageId) {
+        editor.setModelMarkers(model, languageId, markers);
+      }
+    }).then(void 0, (err) => {
+      console.error(err);
+    });
+  }
+}
+function toSeverity(lsSeverity) {
+  switch (lsSeverity) {
+    case DiagnosticSeverity.Error:
+      return MarkerSeverity.Error;
+    case DiagnosticSeverity.Warning:
+      return MarkerSeverity.Warning;
+    case DiagnosticSeverity.Information:
+      return MarkerSeverity.Info;
+    case DiagnosticSeverity.Hint:
+      return MarkerSeverity.Hint;
+    default:
+      return MarkerSeverity.Info;
+  }
+}
+function toDiagnostics(resource, diag) {
+  let code = typeof diag.code === "number" ? String(diag.code) : diag.code;
+  return {
+    severity: toSeverity(diag.severity),
+    startLineNumber: diag.range.start.line + 1,
+    startColumn: diag.range.start.character + 1,
+    endLineNumber: diag.range.end.line + 1,
+    endColumn: diag.range.end.character + 1,
+    message: diag.message,
+    code,
+    source: diag.source
+  };
+}
+class CompletionAdapter {
+  constructor(_worker, _triggerCharacters) {
+    this._worker = _worker;
+    this._triggerCharacters = _triggerCharacters;
+  }
+  get triggerCharacters() {
+    return this._triggerCharacters;
+  }
+  provideCompletionItems(model, position, context, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => {
+      return worker.doComplete(resource.toString(), fromPosition(position));
+    }).then((info) => {
+      if (!info) {
+        return;
+      }
+      const wordInfo = model.getWordUntilPosition(position);
+      const wordRange = new Range(
+        position.lineNumber,
+        wordInfo.startColumn,
+        position.lineNumber,
+        wordInfo.endColumn
+      );
+      const items = info.items.map((entry) => {
+        const item = {
+          label: entry.label,
+          insertText: entry.insertText || entry.label,
+          sortText: entry.sortText,
+          filterText: entry.filterText,
+          documentation: entry.documentation,
+          detail: entry.detail,
+          command: toCommand(entry.command),
+          range: wordRange,
+          kind: toCompletionItemKind(entry.kind)
+        };
+        if (entry.textEdit) {
+          if (isInsertReplaceEdit(entry.textEdit)) {
+            item.range = {
+              insert: toRange(entry.textEdit.insert),
+              replace: toRange(entry.textEdit.replace)
+            };
+          } else {
+            item.range = toRange(entry.textEdit.range);
+          }
+          item.insertText = entry.textEdit.newText;
+        }
+        if (entry.additionalTextEdits) {
+          item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
+        }
+        if (entry.insertTextFormat === InsertTextFormat.Snippet) {
+          item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
+        }
+        return item;
+      });
+      return {
+        isIncomplete: info.isIncomplete,
+        suggestions: items
+      };
+    });
+  }
+}
+function fromPosition(position) {
+  if (!position) {
+    return void 0;
+  }
+  return { character: position.column - 1, line: position.lineNumber - 1 };
+}
+function fromRange(range) {
+  if (!range) {
+    return void 0;
+  }
+  return {
+    start: {
+      line: range.startLineNumber - 1,
+      character: range.startColumn - 1
+    },
+    end: { line: range.endLineNumber - 1, character: range.endColumn - 1 }
+  };
+}
+function toRange(range) {
+  if (!range) {
+    return void 0;
+  }
+  return new Range(
+    range.start.line + 1,
+    range.start.character + 1,
+    range.end.line + 1,
+    range.end.character + 1
+  );
+}
+function isInsertReplaceEdit(edit) {
+  return typeof edit.insert !== "undefined" && typeof edit.replace !== "undefined";
+}
+function toCompletionItemKind(kind) {
+  const mItemKind = languages.CompletionItemKind;
+  switch (kind) {
+    case CompletionItemKind.Text:
+      return mItemKind.Text;
+    case CompletionItemKind.Method:
+      return mItemKind.Method;
+    case CompletionItemKind.Function:
+      return mItemKind.Function;
+    case CompletionItemKind.Constructor:
+      return mItemKind.Constructor;
+    case CompletionItemKind.Field:
+      return mItemKind.Field;
+    case CompletionItemKind.Variable:
+      return mItemKind.Variable;
+    case CompletionItemKind.Class:
+      return mItemKind.Class;
+    case CompletionItemKind.Interface:
+      return mItemKind.Interface;
+    case CompletionItemKind.Module:
+      return mItemKind.Module;
+    case CompletionItemKind.Property:
+      return mItemKind.Property;
+    case CompletionItemKind.Unit:
+      return mItemKind.Unit;
+    case CompletionItemKind.Value:
+      return mItemKind.Value;
+    case CompletionItemKind.Enum:
+      return mItemKind.Enum;
+    case CompletionItemKind.Keyword:
+      return mItemKind.Keyword;
+    case CompletionItemKind.Snippet:
+      return mItemKind.Snippet;
+    case CompletionItemKind.Color:
+      return mItemKind.Color;
+    case CompletionItemKind.File:
+      return mItemKind.File;
+    case CompletionItemKind.Reference:
+      return mItemKind.Reference;
+  }
+  return mItemKind.Property;
+}
+function toTextEdit(textEdit) {
+  if (!textEdit) {
+    return void 0;
+  }
+  return {
+    range: toRange(textEdit.range),
+    text: textEdit.newText
+  };
+}
+function toCommand(c) {
+  return c && c.command === "editor.action.triggerSuggest" ? { id: c.command, title: c.title, arguments: c.arguments } : void 0;
+}
+class HoverAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideHover(model, position, token) {
+    let resource = model.uri;
+    return this._worker(resource).then((worker) => {
+      return worker.doHover(resource.toString(), fromPosition(position));
+    }).then((info) => {
+      if (!info) {
+        return;
+      }
+      return {
+        range: toRange(info.range),
+        contents: toMarkedStringArray(info.contents)
+      };
+    });
+  }
+}
+function isMarkupContent(thing) {
+  return thing && typeof thing === "object" && typeof thing.kind === "string";
+}
+function toMarkdownString(entry) {
+  if (typeof entry === "string") {
+    return {
+      value: entry
+    };
+  }
+  if (isMarkupContent(entry)) {
+    if (entry.kind === "plaintext") {
+      return {
+        value: entry.value.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&")
+      };
+    }
+    return {
+      value: entry.value
+    };
+  }
+  return { value: "```" + entry.language + "\n" + entry.value + "\n```\n" };
+}
+function toMarkedStringArray(contents) {
+  if (!contents) {
+    return void 0;
+  }
+  if (Array.isArray(contents)) {
+    return contents.map(toMarkdownString);
+  }
+  return [toMarkdownString(contents)];
+}
+class DocumentHighlightAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideDocumentHighlights(model, position, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => worker.findDocumentHighlights(resource.toString(), fromPosition(position))).then((entries) => {
+      if (!entries) {
+        return;
+      }
+      return entries.map((entry) => {
+        return {
+          range: toRange(entry.range),
+          kind: toDocumentHighlightKind(entry.kind)
+        };
+      });
+    });
+  }
+}
+function toDocumentHighlightKind(kind) {
+  switch (kind) {
+    case DocumentHighlightKind.Read:
+      return languages.DocumentHighlightKind.Read;
+    case DocumentHighlightKind.Write:
+      return languages.DocumentHighlightKind.Write;
+    case DocumentHighlightKind.Text:
+      return languages.DocumentHighlightKind.Text;
+  }
+  return languages.DocumentHighlightKind.Text;
+}
+class DefinitionAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideDefinition(model, position, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => {
+      return worker.findDefinition(resource.toString(), fromPosition(position));
+    }).then((definition) => {
+      if (!definition) {
+        return;
+      }
+      return [toLocation(definition)];
+    });
+  }
+}
+function toLocation(location) {
+  return {
+    uri: Uri.parse(location.uri),
+    range: toRange(location.range)
+  };
+}
+class ReferenceAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideReferences(model, position, context, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => {
+      return worker.findReferences(resource.toString(), fromPosition(position));
+    }).then((entries) => {
+      if (!entries) {
+        return;
+      }
+      return entries.map(toLocation);
+    });
+  }
+}
+class RenameAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideRenameEdits(model, position, newName, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => {
+      return worker.doRename(resource.toString(), fromPosition(position), newName);
+    }).then((edit) => {
+      return toWorkspaceEdit(edit);
+    });
+  }
+}
+function toWorkspaceEdit(edit) {
+  if (!edit || !edit.changes) {
+    return void 0;
+  }
+  let resourceEdits = [];
+  for (let uri in edit.changes) {
+    const _uri = Uri.parse(uri);
+    for (let e of edit.changes[uri]) {
+      resourceEdits.push({
+        resource: _uri,
+        versionId: void 0,
+        textEdit: {
+          range: toRange(e.range),
+          text: e.newText
+        }
+      });
+    }
+  }
+  return {
+    edits: resourceEdits
+  };
+}
+class DocumentSymbolAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideDocumentSymbols(model, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => worker.findDocumentSymbols(resource.toString())).then((items) => {
+      if (!items) {
+        return;
+      }
+      return items.map((item) => {
+        if (isDocumentSymbol(item)) {
+          return toDocumentSymbol(item);
+        }
+        return {
+          name: item.name,
+          detail: "",
+          containerName: item.containerName,
+          kind: toSymbolKind(item.kind),
+          range: toRange(item.location.range),
+          selectionRange: toRange(item.location.range),
+          tags: []
+        };
+      });
+    });
+  }
+}
+function isDocumentSymbol(symbol) {
+  return "children" in symbol;
+}
+function toDocumentSymbol(symbol) {
+  return {
+    name: symbol.name,
+    detail: symbol.detail ?? "",
+    kind: toSymbolKind(symbol.kind),
+    range: toRange(symbol.range),
+    selectionRange: toRange(symbol.selectionRange),
+    tags: symbol.tags ?? [],
+    children: (symbol.children ?? []).map((item) => toDocumentSymbol(item))
+  };
+}
+function toSymbolKind(kind) {
+  let mKind = languages.SymbolKind;
+  switch (kind) {
+    case SymbolKind.File:
+      return mKind.File;
+    case SymbolKind.Module:
+      return mKind.Module;
+    case SymbolKind.Namespace:
+      return mKind.Namespace;
+    case SymbolKind.Package:
+      return mKind.Package;
+    case SymbolKind.Class:
+      return mKind.Class;
+    case SymbolKind.Method:
+      return mKind.Method;
+    case SymbolKind.Property:
+      return mKind.Property;
+    case SymbolKind.Field:
+      return mKind.Field;
+    case SymbolKind.Constructor:
+      return mKind.Constructor;
+    case SymbolKind.Enum:
+      return mKind.Enum;
+    case SymbolKind.Interface:
+      return mKind.Interface;
+    case SymbolKind.Function:
+      return mKind.Function;
+    case SymbolKind.Variable:
+      return mKind.Variable;
+    case SymbolKind.Constant:
+      return mKind.Constant;
+    case SymbolKind.String:
+      return mKind.String;
+    case SymbolKind.Number:
+      return mKind.Number;
+    case SymbolKind.Boolean:
+      return mKind.Boolean;
+    case SymbolKind.Array:
+      return mKind.Array;
+  }
+  return mKind.Function;
+}
+class DocumentLinkAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideLinks(model, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => worker.findDocumentLinks(resource.toString())).then((items) => {
+      if (!items) {
+        return;
+      }
+      return {
+        links: items.map((item) => ({
+          range: toRange(item.range),
+          url: item.target
+        }))
+      };
+    });
+  }
+}
+class DocumentFormattingEditProvider {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideDocumentFormattingEdits(model, options, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => {
+      return worker.format(resource.toString(), null, fromFormattingOptions(options)).then((edits) => {
+        if (!edits || edits.length === 0) {
+          return;
+        }
+        return edits.map(toTextEdit);
+      });
+    });
+  }
+}
+class DocumentRangeFormattingEditProvider {
+  constructor(_worker) {
+    this._worker = _worker;
+    this.canFormatMultipleRanges = false;
+  }
+  provideDocumentRangeFormattingEdits(model, range, options, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => {
+      return worker.format(resource.toString(), fromRange(range), fromFormattingOptions(options)).then((edits) => {
+        if (!edits || edits.length === 0) {
+          return;
+        }
+        return edits.map(toTextEdit);
+      });
+    });
+  }
+}
+function fromFormattingOptions(options) {
+  return {
+    tabSize: options.tabSize,
+    insertSpaces: options.insertSpaces
+  };
+}
+class DocumentColorAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideDocumentColors(model, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => worker.findDocumentColors(resource.toString())).then((infos) => {
+      if (!infos) {
+        return;
+      }
+      return infos.map((item) => ({
+        color: item.color,
+        range: toRange(item.range)
+      }));
+    });
+  }
+  provideColorPresentations(model, info, token) {
+    const resource = model.uri;
+    return this._worker(resource).then(
+      (worker) => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))
+    ).then((presentations) => {
+      if (!presentations) {
+        return;
+      }
+      return presentations.map((presentation) => {
+        let item = {
+          label: presentation.label
+        };
+        if (presentation.textEdit) {
+          item.textEdit = toTextEdit(presentation.textEdit);
+        }
+        if (presentation.additionalTextEdits) {
+          item.additionalTextEdits = presentation.additionalTextEdits.map(toTextEdit);
+        }
+        return item;
+      });
+    });
+  }
+}
+class FoldingRangeAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideFoldingRanges(model, context, token) {
+    const resource = model.uri;
+    return this._worker(resource).then((worker) => worker.getFoldingRanges(resource.toString(), context)).then((ranges) => {
+      if (!ranges) {
+        return;
+      }
+      return ranges.map((range) => {
+        const result = {
+          start: range.startLine + 1,
+          end: range.endLine + 1
+        };
+        if (typeof range.kind !== "undefined") {
+          result.kind = toFoldingRangeKind(range.kind);
+        }
+        return result;
+      });
+    });
+  }
+}
+function toFoldingRangeKind(kind) {
+  switch (kind) {
+    case FoldingRangeKind.Comment:
+      return languages.FoldingRangeKind.Comment;
+    case FoldingRangeKind.Imports:
+      return languages.FoldingRangeKind.Imports;
+    case FoldingRangeKind.Region:
+      return languages.FoldingRangeKind.Region;
+  }
+  return void 0;
+}
+class SelectionRangeAdapter {
+  constructor(_worker) {
+    this._worker = _worker;
+  }
+  provideSelectionRanges(model, positions, token) {
+    const resource = model.uri;
+    return this._worker(resource).then(
+      (worker) => worker.getSelectionRanges(
+        resource.toString(),
+        positions.map(fromPosition)
+      )
+    ).then((selectionRanges) => {
+      if (!selectionRanges) {
+        return;
+      }
+      return selectionRanges.map((selectionRange) => {
+        const result = [];
+        while (selectionRange) {
+          result.push({ range: toRange(selectionRange.range) });
+          selectionRange = selectionRange.parent;
+        }
+        return result;
+      });
+    });
+  }
+}
+
+export { CompletionAdapter, DefinitionAdapter, DiagnosticsAdapter, DocumentColorAdapter, DocumentFormattingEditProvider, DocumentHighlightAdapter, DocumentLinkAdapter, DocumentRangeFormattingEditProvider, DocumentSymbolAdapter, FoldingRangeAdapter, HoverAdapter, ReferenceAdapter, RenameAdapter, SelectionRangeAdapter, fromPosition, fromRange, toRange, toTextEdit };