@easyv/biz-components 0.0.52-beta.0 → 0.0.52-beta.1

package/dist/node_modules/.pnpm/monaco-editor@0.52.2/node_modules/monaco-editor/esm/vs/editor/contrib/wordHighlighter/browser/wordHighlighter.es.js

@@ -0,0 +1,712 @@
+var _a, _b;
+import { localize } from "../../../../nls.es.js";
+import { alert } from "../../../../base/browser/ui/aria/aria.es.js";
+import { Delayer, first, createCancelablePromise } from "../../../../base/common/async.es.js";
+import { CancellationToken } from "../../../../base/common/cancellation.es.js";
+import { onUnexpectedError, onUnexpectedExternalError } from "../../../../base/common/errors.es.js";
+import { DisposableStore, Disposable } from "../../../../base/common/lifecycle.es.js";
+import { isDiffEditor } from "../../../browser/editorBrowser.es.js";
+import { registerModelAndPositionCommand, registerEditorContribution, registerEditorAction, EditorAction } from "../../../browser/editorExtensions.es.js";
+import { ICodeEditorService } from "../../../browser/services/codeEditorService.es.js";
+import { Range } from "../../../common/core/range.es.js";
+import { EditorContextKeys } from "../../../common/editorContextKeys.es.js";
+import { shouldSynchronizeModel } from "../../../common/model.es.js";
+import { ILanguageFeaturesService } from "../../../common/services/languageFeatures.es.js";
+import { getHighlightDecorationOptions } from "./highlightDecorations.es.js";
+import { RawContextKey, IContextKeyService } from "../../../../platform/contextkey/common/contextkey.es.js";
+import { matchesScheme, Schemas } from "../../../../base/common/network.es.js";
+import { ResourceMap } from "../../../../base/common/map.es.js";
+import { score } from "../../../common/languageSelector.es.js";
+import { isEqual } from "../../../../base/common/resources.es.js";
+import { TextualMultiDocumentHighlightFeature } from "./textualHighlightProvider.es.js";
+import { registerEditorFeature } from "../../../common/editorFeatures.es.js";
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+var WordHighlighter_1, WordHighlighterContribution_1;
+const ctxHasWordHighlights = new RawContextKey("hasWordHighlights", false);
+function getOccurrencesAtPosition(registry, model, position, token) {
+  const orderedByScore = registry.ordered(model);
+  return first(orderedByScore.map((provider) => () => {
+    return Promise.resolve(provider.provideDocumentHighlights(model, position, token)).then(void 0, onUnexpectedExternalError);
+  }), (result) => result !== void 0 && result !== null).then((result) => {
+    if (result) {
+      const map = new ResourceMap();
+      map.set(model.uri, result);
+      return map;
+    }
+    return new ResourceMap();
+  });
+}
+function getOccurrencesAcrossMultipleModels(registry, model, position, wordSeparators, token, otherModels) {
+  const orderedByScore = registry.ordered(model);
+  return first(orderedByScore.map((provider) => () => {
+    const filteredModels = otherModels.filter((otherModel) => {
+      return shouldSynchronizeModel(otherModel);
+    }).filter((otherModel) => {
+      return score(provider.selector, otherModel.uri, otherModel.getLanguageId(), true, void 0, void 0) > 0;
+    });
+    return Promise.resolve(provider.provideMultiDocumentHighlights(model, position, filteredModels, token)).then(void 0, onUnexpectedExternalError);
+  }), (result) => result !== void 0 && result !== null);
+}
+class OccurenceAtPositionRequest {
+  constructor(_model, _selection, _wordSeparators) {
+    this._model = _model;
+    this._selection = _selection;
+    this._wordSeparators = _wordSeparators;
+    this._wordRange = this._getCurrentWordRange(_model, _selection);
+    this._result = null;
+  }
+  get result() {
+    if (!this._result) {
+      this._result = createCancelablePromise((token) => this._compute(this._model, this._selection, this._wordSeparators, token));
+    }
+    return this._result;
+  }
+  _getCurrentWordRange(model, selection) {
+    const word = model.getWordAtPosition(selection.getPosition());
+    if (word) {
+      return new Range(selection.startLineNumber, word.startColumn, selection.startLineNumber, word.endColumn);
+    }
+    return null;
+  }
+  isValid(model, selection, decorations) {
+    const lineNumber = selection.startLineNumber;
+    const startColumn = selection.startColumn;
+    const endColumn = selection.endColumn;
+    const currentWordRange = this._getCurrentWordRange(model, selection);
+    let requestIsValid = Boolean(this._wordRange && this._wordRange.equalsRange(currentWordRange));
+    for (let i = 0, len = decorations.length; !requestIsValid && i < len; i++) {
+      const range = decorations.getRange(i);
+      if (range && range.startLineNumber === lineNumber) {
+        if (range.startColumn <= startColumn && range.endColumn >= endColumn) {
+          requestIsValid = true;
+        }
+      }
+    }
+    return requestIsValid;
+  }
+  cancel() {
+    this.result.cancel();
+  }
+}
+class SemanticOccurenceAtPositionRequest extends OccurenceAtPositionRequest {
+  constructor(model, selection, wordSeparators, providers) {
+    super(model, selection, wordSeparators);
+    this._providers = providers;
+  }
+  _compute(model, selection, wordSeparators, token) {
+    return getOccurrencesAtPosition(this._providers, model, selection.getPosition(), token).then((value) => {
+      if (!value) {
+        return new ResourceMap();
+      }
+      return value;
+    });
+  }
+}
+class MultiModelOccurenceRequest extends OccurenceAtPositionRequest {
+  constructor(model, selection, wordSeparators, providers, otherModels) {
+    super(model, selection, wordSeparators);
+    this._providers = providers;
+    this._otherModels = otherModels;
+  }
+  _compute(model, selection, wordSeparators, token) {
+    return getOccurrencesAcrossMultipleModels(this._providers, model, selection.getPosition(), wordSeparators, token, this._otherModels).then((value) => {
+      if (!value) {
+        return new ResourceMap();
+      }
+      return value;
+    });
+  }
+}
+function computeOccurencesAtPosition(registry, model, selection, word, wordSeparators) {
+  return new SemanticOccurenceAtPositionRequest(model, selection, wordSeparators, registry);
+}
+function computeOccurencesMultiModel(registry, model, selection, word, wordSeparators, otherModels) {
+  return new MultiModelOccurenceRequest(model, selection, wordSeparators, registry, otherModels);
+}
+registerModelAndPositionCommand("_executeDocumentHighlights", async (accessor, model, position) => {
+  const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+  const map = await getOccurrencesAtPosition(languageFeaturesService.documentHighlightProvider, model, position, CancellationToken.None);
+  return map == null ? void 0 : map.get(model.uri);
+});
+let WordHighlighter = (_a = class {
+  constructor(editor, providers, multiProviders, contextKeyService, codeEditorService) {
+    this.toUnhook = new DisposableStore();
+    this.workerRequestTokenId = 0;
+    this.workerRequestCompleted = false;
+    this.workerRequestValue = new ResourceMap();
+    this.lastCursorPositionChangeTime = 0;
+    this.renderDecorationsTimer = -1;
+    this.runDelayer = this.toUnhook.add(new Delayer(50));
+    this.editor = editor;
+    this.providers = providers;
+    this.multiDocumentProviders = multiProviders;
+    this.codeEditorService = codeEditorService;
+    this._hasWordHighlights = ctxHasWordHighlights.bindTo(contextKeyService);
+    this._ignorePositionChangeEvent = false;
+    this.occurrencesHighlight = this.editor.getOption(
+      81
+      /* EditorOption.occurrencesHighlight */
+    );
+    this.model = this.editor.getModel();
+    this.toUnhook.add(editor.onDidChangeCursorPosition((e) => {
+      if (this._ignorePositionChangeEvent) {
+        return;
+      }
+      if (this.occurrencesHighlight === "off") {
+        return;
+      }
+      this.runDelayer.trigger(() => {
+        this._onPositionChanged(e);
+      });
+    }));
+    this.toUnhook.add(editor.onDidFocusEditorText((e) => {
+      if (this.occurrencesHighlight === "off") {
+        return;
+      }
+      if (!this.workerRequest) {
+        this.runDelayer.trigger(() => {
+          this._run();
+        });
+      }
+    }));
+    this.toUnhook.add(editor.onDidChangeModelContent((e) => {
+      if (!matchesScheme(this.model.uri, "output")) {
+        this._stopAll();
+      }
+    }));
+    this.toUnhook.add(editor.onDidChangeModel((e) => {
+      if (!e.newModelUrl && e.oldModelUrl) {
+        this._stopSingular();
+      } else {
+        if (WordHighlighter_1.query) {
+          this._run();
+        }
+      }
+    }));
+    this.toUnhook.add(editor.onDidChangeConfiguration((e) => {
+      var _a2, _b2;
+      const newValue = this.editor.getOption(
+        81
+        /* EditorOption.occurrencesHighlight */
+      );
+      if (this.occurrencesHighlight !== newValue) {
+        this.occurrencesHighlight = newValue;
+        switch (newValue) {
+          case "off":
+            this._stopAll();
+            break;
+          case "singleFile":
+            this._stopAll((_b2 = (_a2 = WordHighlighter_1.query) == null ? void 0 : _a2.modelInfo) == null ? void 0 : _b2.model);
+            break;
+          case "multiFile":
+            if (WordHighlighter_1.query) {
+              this._run(true);
+            }
+            break;
+          default:
+            console.warn("Unknown occurrencesHighlight setting value:", newValue);
+            break;
+        }
+      }
+    }));
+    this.decorations = this.editor.createDecorationsCollection();
+    this.workerRequestTokenId = 0;
+    this.workerRequest = null;
+    this.workerRequestCompleted = false;
+    this.lastCursorPositionChangeTime = 0;
+    this.renderDecorationsTimer = -1;
+    if (WordHighlighter_1.query) {
+      this._run();
+    }
+  }
+  hasDecorations() {
+    return this.decorations.length > 0;
+  }
+  restore() {
+    if (this.occurrencesHighlight === "off") {
+      return;
+    }
+    this.runDelayer.cancel();
+    this._run();
+  }
+  _getSortedHighlights() {
+    return this.decorations.getRanges().sort(Range.compareRangesUsingStarts);
+  }
+  moveNext() {
+    const highlights = this._getSortedHighlights();
+    const index = highlights.findIndex((range) => range.containsPosition(this.editor.getPosition()));
+    const newIndex = (index + 1) % highlights.length;
+    const dest = highlights[newIndex];
+    try {
+      this._ignorePositionChangeEvent = true;
+      this.editor.setPosition(dest.getStartPosition());
+      this.editor.revealRangeInCenterIfOutsideViewport(dest);
+      const word = this._getWord();
+      if (word) {
+        const lineContent = this.editor.getModel().getLineContent(dest.startLineNumber);
+        alert(`${lineContent}, ${newIndex + 1} of ${highlights.length} for '${word.word}'`);
+      }
+    } finally {
+      this._ignorePositionChangeEvent = false;
+    }
+  }
+  moveBack() {
+    const highlights = this._getSortedHighlights();
+    const index = highlights.findIndex((range) => range.containsPosition(this.editor.getPosition()));
+    const newIndex = (index - 1 + highlights.length) % highlights.length;
+    const dest = highlights[newIndex];
+    try {
+      this._ignorePositionChangeEvent = true;
+      this.editor.setPosition(dest.getStartPosition());
+      this.editor.revealRangeInCenterIfOutsideViewport(dest);
+      const word = this._getWord();
+      if (word) {
+        const lineContent = this.editor.getModel().getLineContent(dest.startLineNumber);
+        alert(`${lineContent}, ${newIndex + 1} of ${highlights.length} for '${word.word}'`);
+      }
+    } finally {
+      this._ignorePositionChangeEvent = false;
+    }
+  }
+  _removeSingleDecorations() {
+    if (!this.editor.hasModel()) {
+      return;
+    }
+    const currentDecorationIDs = WordHighlighter_1.storedDecorationIDs.get(this.editor.getModel().uri);
+    if (!currentDecorationIDs) {
+      return;
+    }
+    this.editor.removeDecorations(currentDecorationIDs);
+    WordHighlighter_1.storedDecorationIDs.delete(this.editor.getModel().uri);
+    if (this.decorations.length > 0) {
+      this.decorations.clear();
+      this._hasWordHighlights.set(false);
+    }
+  }
+  _removeAllDecorations(preservedModel) {
+    const currentEditors = this.codeEditorService.listCodeEditors();
+    const deleteURI = [];
+    for (const editor of currentEditors) {
+      if (!editor.hasModel() || isEqual(editor.getModel().uri, preservedModel == null ? void 0 : preservedModel.uri)) {
+        continue;
+      }
+      const currentDecorationIDs = WordHighlighter_1.storedDecorationIDs.get(editor.getModel().uri);
+      if (!currentDecorationIDs) {
+        continue;
+      }
+      editor.removeDecorations(currentDecorationIDs);
+      deleteURI.push(editor.getModel().uri);
+      const editorHighlighterContrib = WordHighlighterContribution.get(editor);
+      if (!(editorHighlighterContrib == null ? void 0 : editorHighlighterContrib.wordHighlighter)) {
+        continue;
+      }
+      if (editorHighlighterContrib.wordHighlighter.decorations.length > 0) {
+        editorHighlighterContrib.wordHighlighter.decorations.clear();
+        editorHighlighterContrib.wordHighlighter.workerRequest = null;
+        editorHighlighterContrib.wordHighlighter._hasWordHighlights.set(false);
+      }
+    }
+    for (const uri of deleteURI) {
+      WordHighlighter_1.storedDecorationIDs.delete(uri);
+    }
+  }
+  _stopSingular() {
+    var _a2, _b2, _c, _d;
+    this._removeSingleDecorations();
+    if (this.editor.hasTextFocus()) {
+      if (((_a2 = this.editor.getModel()) == null ? void 0 : _a2.uri.scheme) !== Schemas.vscodeNotebookCell && ((_c = (_b2 = WordHighlighter_1.query) == null ? void 0 : _b2.modelInfo) == null ? void 0 : _c.model.uri.scheme) !== Schemas.vscodeNotebookCell) {
+        WordHighlighter_1.query = null;
+        this._run();
+      } else {
+        if ((_d = WordHighlighter_1.query) == null ? void 0 : _d.modelInfo) {
+          WordHighlighter_1.query.modelInfo = null;
+        }
+      }
+    }
+    if (this.renderDecorationsTimer !== -1) {
+      clearTimeout(this.renderDecorationsTimer);
+      this.renderDecorationsTimer = -1;
+    }
+    if (this.workerRequest !== null) {
+      this.workerRequest.cancel();
+      this.workerRequest = null;
+    }
+    if (!this.workerRequestCompleted) {
+      this.workerRequestTokenId++;
+      this.workerRequestCompleted = true;
+    }
+  }
+  _stopAll(preservedModel) {
+    this._removeAllDecorations(preservedModel);
+    if (this.renderDecorationsTimer !== -1) {
+      clearTimeout(this.renderDecorationsTimer);
+      this.renderDecorationsTimer = -1;
+    }
+    if (this.workerRequest !== null) {
+      this.workerRequest.cancel();
+      this.workerRequest = null;
+    }
+    if (!this.workerRequestCompleted) {
+      this.workerRequestTokenId++;
+      this.workerRequestCompleted = true;
+    }
+  }
+  _onPositionChanged(e) {
+    var _a2;
+    if (this.occurrencesHighlight === "off") {
+      this._stopAll();
+      return;
+    }
+    if (e.reason !== 3 && ((_a2 = this.editor.getModel()) == null ? void 0 : _a2.uri.scheme) !== Schemas.vscodeNotebookCell) {
+      this._stopAll();
+      return;
+    }
+    this._run();
+  }
+  _getWord() {
+    const editorSelection = this.editor.getSelection();
+    const lineNumber = editorSelection.startLineNumber;
+    const startColumn = editorSelection.startColumn;
+    if (this.model.isDisposed()) {
+      return null;
+    }
+    return this.model.getWordAtPosition({
+      lineNumber,
+      column: startColumn
+    });
+  }
+  getOtherModelsToHighlight(model) {
+    if (!model) {
+      return [];
+    }
+    const isNotebookEditor = model.uri.scheme === Schemas.vscodeNotebookCell;
+    if (isNotebookEditor) {
+      const currentModels2 = [];
+      const currentEditors2 = this.codeEditorService.listCodeEditors();
+      for (const editor of currentEditors2) {
+        const tempModel = editor.getModel();
+        if (tempModel && tempModel !== model && tempModel.uri.scheme === Schemas.vscodeNotebookCell) {
+          currentModels2.push(tempModel);
+        }
+      }
+      return currentModels2;
+    }
+    const currentModels = [];
+    const currentEditors = this.codeEditorService.listCodeEditors();
+    for (const editor of currentEditors) {
+      if (!isDiffEditor(editor)) {
+        continue;
+      }
+      const diffModel = editor.getModel();
+      if (!diffModel) {
+        continue;
+      }
+      if (model === diffModel.modified) {
+        currentModels.push(diffModel.modified);
+      }
+    }
+    if (currentModels.length) {
+      return currentModels;
+    }
+    if (this.occurrencesHighlight === "singleFile") {
+      return [];
+    }
+    for (const editor of currentEditors) {
+      const tempModel = editor.getModel();
+      const isValidModel = tempModel && tempModel !== model;
+      if (isValidModel) {
+        currentModels.push(tempModel);
+      }
+    }
+    return currentModels;
+  }
+  _run(multiFileConfigChange) {
+    var _a2, _b2;
+    let workerRequestIsValid;
+    const hasTextFocus = this.editor.hasTextFocus();
+    if (!hasTextFocus) {
+      if (!WordHighlighter_1.query) {
+        this._stopAll();
+        return;
+      }
+    } else {
+      const editorSelection = this.editor.getSelection();
+      if (!editorSelection || editorSelection.startLineNumber !== editorSelection.endLineNumber) {
+        WordHighlighter_1.query = null;
+        this._stopAll();
+        return;
+      }
+      const startColumn = editorSelection.startColumn;
+      const endColumn = editorSelection.endColumn;
+      const word = this._getWord();
+      if (!word || word.startColumn > startColumn || word.endColumn < endColumn) {
+        WordHighlighter_1.query = null;
+        this._stopAll();
+        return;
+      }
+      workerRequestIsValid = this.workerRequest && this.workerRequest.isValid(this.model, editorSelection, this.decorations);
+      WordHighlighter_1.query = {
+        modelInfo: {
+          model: this.model,
+          selection: editorSelection
+        },
+        word
+      };
+    }
+    this.lastCursorPositionChangeTime = (/* @__PURE__ */ new Date()).getTime();
+    if (workerRequestIsValid) {
+      if (this.workerRequestCompleted && this.renderDecorationsTimer !== -1) {
+        clearTimeout(this.renderDecorationsTimer);
+        this.renderDecorationsTimer = -1;
+        this._beginRenderDecorations();
+      }
+    } else if (isEqual(this.editor.getModel().uri, (_a2 = WordHighlighter_1.query.modelInfo) == null ? void 0 : _a2.model.uri)) {
+      if (!multiFileConfigChange) {
+        const currentModelDecorationRanges = this.decorations.getRanges();
+        for (const storedRange of currentModelDecorationRanges) {
+          if (storedRange.containsPosition(this.editor.getPosition())) {
+            return;
+          }
+        }
+      }
+      this._stopAll(multiFileConfigChange ? this.model : void 0);
+      const myRequestId = ++this.workerRequestTokenId;
+      this.workerRequestCompleted = false;
+      const otherModelsToHighlight = this.getOtherModelsToHighlight(this.editor.getModel());
+      if (!WordHighlighter_1.query || !WordHighlighter_1.query.modelInfo || WordHighlighter_1.query.modelInfo.model.isDisposed()) {
+        return;
+      }
+      this.workerRequest = this.computeWithModel(WordHighlighter_1.query.modelInfo.model, WordHighlighter_1.query.modelInfo.selection, WordHighlighter_1.query.word, otherModelsToHighlight);
+      (_b2 = this.workerRequest) == null ? void 0 : _b2.result.then((data) => {
+        if (myRequestId === this.workerRequestTokenId) {
+          this.workerRequestCompleted = true;
+          this.workerRequestValue = data || [];
+          this._beginRenderDecorations();
+        }
+      }, onUnexpectedError);
+    }
+  }
+  computeWithModel(model, selection, word, otherModels) {
+    if (!otherModels.length) {
+      return computeOccurencesAtPosition(this.providers, model, selection, word, this.editor.getOption(
+        132
+        /* EditorOption.wordSeparators */
+      ));
+    } else {
+      return computeOccurencesMultiModel(this.multiDocumentProviders, model, selection, word, this.editor.getOption(
+        132
+        /* EditorOption.wordSeparators */
+      ), otherModels);
+    }
+  }
+  _beginRenderDecorations() {
+    const currentTime = (/* @__PURE__ */ new Date()).getTime();
+    const minimumRenderTime = this.lastCursorPositionChangeTime + 250;
+    if (currentTime >= minimumRenderTime) {
+      this.renderDecorationsTimer = -1;
+      this.renderDecorations();
+    } else {
+      this.renderDecorationsTimer = setTimeout(() => {
+        this.renderDecorations();
+      }, minimumRenderTime - currentTime);
+    }
+  }
+  renderDecorations() {
+    var _a2, _b2, _c;
+    this.renderDecorationsTimer = -1;
+    const currentEditors = this.codeEditorService.listCodeEditors();
+    for (const editor of currentEditors) {
+      const editorHighlighterContrib = WordHighlighterContribution.get(editor);
+      if (!editorHighlighterContrib) {
+        continue;
+      }
+      const newDecorations = [];
+      const uri = (_a2 = editor.getModel()) == null ? void 0 : _a2.uri;
+      if (uri && this.workerRequestValue.has(uri)) {
+        const oldDecorationIDs = WordHighlighter_1.storedDecorationIDs.get(uri);
+        const newDocumentHighlights = this.workerRequestValue.get(uri);
+        if (newDocumentHighlights) {
+          for (const highlight of newDocumentHighlights) {
+            if (!highlight.range) {
+              continue;
+            }
+            newDecorations.push({
+              range: highlight.range,
+              options: getHighlightDecorationOptions(highlight.kind)
+            });
+          }
+        }
+        let newDecorationIDs = [];
+        editor.changeDecorations((changeAccessor) => {
+          newDecorationIDs = changeAccessor.deltaDecorations(oldDecorationIDs ?? [], newDecorations);
+        });
+        WordHighlighter_1.storedDecorationIDs = WordHighlighter_1.storedDecorationIDs.set(uri, newDecorationIDs);
+        if (newDecorations.length > 0) {
+          (_b2 = editorHighlighterContrib.wordHighlighter) == null ? void 0 : _b2.decorations.set(newDecorations);
+          (_c = editorHighlighterContrib.wordHighlighter) == null ? void 0 : _c._hasWordHighlights.set(true);
+        }
+      }
+    }
+  }
+  dispose() {
+    this._stopSingular();
+    this.toUnhook.dispose();
+  }
+}, WordHighlighter_1 = _a, _a.storedDecorationIDs = new ResourceMap(), _a.query = null, _a);
+WordHighlighter = WordHighlighter_1 = __decorate([
+  __param(4, ICodeEditorService)
+], WordHighlighter);
+let WordHighlighterContribution = (_b = class extends Disposable {
+  static get(editor) {
+    return editor.getContribution(WordHighlighterContribution_1.ID);
+  }
+  constructor(editor, contextKeyService, languageFeaturesService, codeEditorService) {
+    super();
+    this._wordHighlighter = null;
+    const createWordHighlighterIfPossible = () => {
+      if (editor.hasModel() && !editor.getModel().isTooLargeForTokenization()) {
+        this._wordHighlighter = new WordHighlighter(editor, languageFeaturesService.documentHighlightProvider, languageFeaturesService.multiDocumentHighlightProvider, contextKeyService, codeEditorService);
+      }
+    };
+    this._register(editor.onDidChangeModel((e) => {
+      if (this._wordHighlighter) {
+        this._wordHighlighter.dispose();
+        this._wordHighlighter = null;
+      }
+      createWordHighlighterIfPossible();
+    }));
+    createWordHighlighterIfPossible();
+  }
+  get wordHighlighter() {
+    return this._wordHighlighter;
+  }
+  saveViewState() {
+    if (this._wordHighlighter && this._wordHighlighter.hasDecorations()) {
+      return true;
+    }
+    return false;
+  }
+  moveNext() {
+    var _a2;
+    (_a2 = this._wordHighlighter) == null ? void 0 : _a2.moveNext();
+  }
+  moveBack() {
+    var _a2;
+    (_a2 = this._wordHighlighter) == null ? void 0 : _a2.moveBack();
+  }
+  restoreViewState(state) {
+    if (this._wordHighlighter && state) {
+      this._wordHighlighter.restore();
+    }
+  }
+  dispose() {
+    if (this._wordHighlighter) {
+      this._wordHighlighter.dispose();
+      this._wordHighlighter = null;
+    }
+    super.dispose();
+  }
+}, WordHighlighterContribution_1 = _b, _b.ID = "editor.contrib.wordHighlighter", _b);
+WordHighlighterContribution = WordHighlighterContribution_1 = __decorate([
+  __param(1, IContextKeyService),
+  __param(2, ILanguageFeaturesService),
+  __param(3, ICodeEditorService)
+], WordHighlighterContribution);
+class WordHighlightNavigationAction extends EditorAction {
+  constructor(next, opts) {
+    super(opts);
+    this._isNext = next;
+  }
+  run(accessor, editor) {
+    const controller = WordHighlighterContribution.get(editor);
+    if (!controller) {
+      return;
+    }
+    if (this._isNext) {
+      controller.moveNext();
+    } else {
+      controller.moveBack();
+    }
+  }
+}
+class NextWordHighlightAction extends WordHighlightNavigationAction {
+  constructor() {
+    super(true, {
+      id: "editor.action.wordHighlight.next",
+      label: localize("wordHighlight.next.label", "Go to Next Symbol Highlight"),
+      alias: "Go to Next Symbol Highlight",
+      precondition: ctxHasWordHighlights,
+      kbOpts: {
+        kbExpr: EditorContextKeys.editorTextFocus,
+        primary: 65,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      }
+    });
+  }
+}
+class PrevWordHighlightAction extends WordHighlightNavigationAction {
+  constructor() {
+    super(false, {
+      id: "editor.action.wordHighlight.prev",
+      label: localize("wordHighlight.previous.label", "Go to Previous Symbol Highlight"),
+      alias: "Go to Previous Symbol Highlight",
+      precondition: ctxHasWordHighlights,
+      kbOpts: {
+        kbExpr: EditorContextKeys.editorTextFocus,
+        primary: 1024 | 65,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      }
+    });
+  }
+}
+class TriggerWordHighlightAction extends EditorAction {
+  constructor() {
+    super({
+      id: "editor.action.wordHighlight.trigger",
+      label: localize("wordHighlight.trigger.label", "Trigger Symbol Highlight"),
+      alias: "Trigger Symbol Highlight",
+      precondition: void 0,
+      kbOpts: {
+        kbExpr: EditorContextKeys.editorTextFocus,
+        primary: 0,
+        weight: 100
+        /* KeybindingWeight.EditorContrib */
+      }
+    });
+  }
+  run(accessor, editor, args) {
+    const controller = WordHighlighterContribution.get(editor);
+    if (!controller) {
+      return;
+    }
+    controller.restoreViewState(true);
+  }
+}
+registerEditorContribution(
+  WordHighlighterContribution.ID,
+  WordHighlighterContribution,
+  0
+  /* EditorContributionInstantiation.Eager */
+);
+registerEditorAction(NextWordHighlightAction);
+registerEditorAction(PrevWordHighlightAction);
+registerEditorAction(TriggerWordHighlightAction);
+registerEditorFeature(TextualMultiDocumentHighlightFeature);
+export {
+  WordHighlighterContribution,
+  getOccurrencesAcrossMultipleModels,
+  getOccurrencesAtPosition
+};
+//# sourceMappingURL=wordHighlighter.es.js.map