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

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

@@ -1,702 +0,0 @@
-var _a;
-import { RunOnceScheduler } from "../../../../base/common/async.es.js";
-import { Codicon } from "../../../../base/common/codicons.es.js";
-import { MarkdownString } from "../../../../base/common/htmlContent.es.js";
-import { Disposable } from "../../../../base/common/lifecycle.es.js";
-import { language } from "../../../../base/common/platform.es.js";
-import { isBasicASCII, InvisibleCharacters } from "../../../../base/common/strings.es.js";
-/* empty css                          */
-import { EditorAction, registerEditorAction, registerEditorContribution } from "../../../browser/editorExtensions.es.js";
-import { inUntrustedWorkspace, unicodeHighlightConfigKeys } from "../../../common/config/editorOptions.es.js";
-import { ModelDecorationOptions } from "../../../common/model/textModel.es.js";
-import { UnicodeTextModelHighlighter } from "../../../common/services/unicodeTextModelHighlighter.es.js";
-import { IEditorWorkerService } from "../../../common/services/editorWorker.es.js";
-import { ILanguageService } from "../../../common/languages/language.es.js";
-import { isModelDecorationVisible, isModelDecorationInString, isModelDecorationInComment } from "../../../common/viewModel/viewModelDecorations.es.js";
-import { HoverParticipantRegistry } from "../../hover/browser/hoverTypes.es.js";
-import { MarkdownHover, renderMarkdownHovers } from "../../hover/browser/markdownHoverParticipant.es.js";
-import { BannerController } from "./bannerController.es.js";
-import { localize } from "../../../../nls.es.js";
-import { IConfigurationService } from "../../../../platform/configuration/common/configuration.es.js";
-import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.es.js";
-import { IOpenerService } from "../../../../platform/opener/common/opener.es.js";
-import { IQuickInputService } from "../../../../platform/quickinput/common/quickInput.es.js";
-import { registerIcon } from "../../../../platform/theme/common/iconRegistry.es.js";
-import { IWorkspaceTrustManagementService } from "../../../../platform/workspace/common/workspaceTrust.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);
-  };
-};
-const warningIcon = registerIcon("extensions-warning-message", Codicon.warning, localize("warningIcon", "Icon shown with a warning message in the extensions editor."));
-let UnicodeHighlighter = (_a = class extends Disposable {
-  constructor(_editor, _editorWorkerService, _workspaceTrustService, instantiationService) {
-    super();
-    this._editor = _editor;
-    this._editorWorkerService = _editorWorkerService;
-    this._workspaceTrustService = _workspaceTrustService;
-    this._highlighter = null;
-    this._bannerClosed = false;
-    this._updateState = (state) => {
-      if (state && state.hasMore) {
-        if (this._bannerClosed) {
-          return;
-        }
-        const max = Math.max(state.ambiguousCharacterCount, state.nonBasicAsciiCharacterCount, state.invisibleCharacterCount);
-        let data;
-        if (state.nonBasicAsciiCharacterCount >= max) {
-          data = {
-            message: localize("unicodeHighlighting.thisDocumentHasManyNonBasicAsciiUnicodeCharacters", "This document contains many non-basic ASCII unicode characters"),
-            command: new DisableHighlightingOfNonBasicAsciiCharactersAction()
-          };
-        } else if (state.ambiguousCharacterCount >= max) {
-          data = {
-            message: localize("unicodeHighlighting.thisDocumentHasManyAmbiguousUnicodeCharacters", "This document contains many ambiguous unicode characters"),
-            command: new DisableHighlightingOfAmbiguousCharactersAction()
-          };
-        } else if (state.invisibleCharacterCount >= max) {
-          data = {
-            message: localize("unicodeHighlighting.thisDocumentHasManyInvisibleUnicodeCharacters", "This document contains many invisible unicode characters"),
-            command: new DisableHighlightingOfInvisibleCharactersAction()
-          };
-        } else {
-          throw new Error("Unreachable");
-        }
-        this._bannerController.show({
-          id: "unicodeHighlightBanner",
-          message: data.message,
-          icon: warningIcon,
-          actions: [
-            {
-              label: data.command.shortLabel,
-              href: `command:${data.command.id}`
-            }
-          ],
-          onClose: () => {
-            this._bannerClosed = true;
-          }
-        });
-      } else {
-        this._bannerController.hide();
-      }
-    };
-    this._bannerController = this._register(instantiationService.createInstance(BannerController, _editor));
-    this._register(this._editor.onDidChangeModel(() => {
-      this._bannerClosed = false;
-      this._updateHighlighter();
-    }));
-    this._options = _editor.getOption(
-      126
-      /* EditorOption.unicodeHighlighting */
-    );
-    this._register(_workspaceTrustService.onDidChangeTrust((e) => {
-      this._updateHighlighter();
-    }));
-    this._register(_editor.onDidChangeConfiguration((e) => {
-      if (e.hasChanged(
-        126
-        /* EditorOption.unicodeHighlighting */
-      )) {
-        this._options = _editor.getOption(
-          126
-          /* EditorOption.unicodeHighlighting */
-        );
-        this._updateHighlighter();
-      }
-    }));
-    this._updateHighlighter();
-  }
-  dispose() {
-    if (this._highlighter) {
-      this._highlighter.dispose();
-      this._highlighter = null;
-    }
-    super.dispose();
-  }
-  _updateHighlighter() {
-    this._updateState(null);
-    if (this._highlighter) {
-      this._highlighter.dispose();
-      this._highlighter = null;
-    }
-    if (!this._editor.hasModel()) {
-      return;
-    }
-    const options = resolveOptions(this._workspaceTrustService.isWorkspaceTrusted(), this._options);
-    if ([
-      options.nonBasicASCII,
-      options.ambiguousCharacters,
-      options.invisibleCharacters
-    ].every((option) => option === false)) {
-      return;
-    }
-    const highlightOptions = {
-      nonBasicASCII: options.nonBasicASCII,
-      ambiguousCharacters: options.ambiguousCharacters,
-      invisibleCharacters: options.invisibleCharacters,
-      includeComments: options.includeComments,
-      includeStrings: options.includeStrings,
-      allowedCodePoints: Object.keys(options.allowedCharacters).map((c) => c.codePointAt(0)),
-      allowedLocales: Object.keys(options.allowedLocales).map((locale) => {
-        if (locale === "_os") {
-          const osLocale = new Intl.NumberFormat().resolvedOptions().locale;
-          return osLocale;
-        } else if (locale === "_vscode") {
-          return language;
-        }
-        return locale;
-      })
-    };
-    if (this._editorWorkerService.canComputeUnicodeHighlights(this._editor.getModel().uri)) {
-      this._highlighter = new DocumentUnicodeHighlighter(this._editor, highlightOptions, this._updateState, this._editorWorkerService);
-    } else {
-      this._highlighter = new ViewportUnicodeHighlighter(this._editor, highlightOptions, this._updateState);
-    }
-  }
-  getDecorationInfo(decoration) {
-    if (this._highlighter) {
-      return this._highlighter.getDecorationInfo(decoration);
-    }
-    return null;
-  }
-}, _a.ID = "editor.contrib.unicodeHighlighter", _a);
-UnicodeHighlighter = __decorate([
-  __param(1, IEditorWorkerService),
-  __param(2, IWorkspaceTrustManagementService),
-  __param(3, IInstantiationService)
-], UnicodeHighlighter);
-function resolveOptions(trusted, options) {
-  return {
-    nonBasicASCII: options.nonBasicASCII === inUntrustedWorkspace ? !trusted : options.nonBasicASCII,
-    ambiguousCharacters: options.ambiguousCharacters,
-    invisibleCharacters: options.invisibleCharacters,
-    includeComments: options.includeComments === inUntrustedWorkspace ? !trusted : options.includeComments,
-    includeStrings: options.includeStrings === inUntrustedWorkspace ? !trusted : options.includeStrings,
-    allowedCharacters: options.allowedCharacters,
-    allowedLocales: options.allowedLocales
-  };
-}
-let DocumentUnicodeHighlighter = class DocumentUnicodeHighlighter2 extends Disposable {
-  constructor(_editor, _options, _updateState, _editorWorkerService) {
-    super();
-    this._editor = _editor;
-    this._options = _options;
-    this._updateState = _updateState;
-    this._editorWorkerService = _editorWorkerService;
-    this._model = this._editor.getModel();
-    this._decorations = this._editor.createDecorationsCollection();
-    this._updateSoon = this._register(new RunOnceScheduler(() => this._update(), 250));
-    this._register(this._editor.onDidChangeModelContent(() => {
-      this._updateSoon.schedule();
-    }));
-    this._updateSoon.schedule();
-  }
-  dispose() {
-    this._decorations.clear();
-    super.dispose();
-  }
-  _update() {
-    if (this._model.isDisposed()) {
-      return;
-    }
-    if (!this._model.mightContainNonBasicASCII()) {
-      this._decorations.clear();
-      return;
-    }
-    const modelVersionId = this._model.getVersionId();
-    this._editorWorkerService.computedUnicodeHighlights(this._model.uri, this._options).then((info) => {
-      if (this._model.isDisposed()) {
-        return;
-      }
-      if (this._model.getVersionId() !== modelVersionId) {
-        return;
-      }
-      this._updateState(info);
-      const decorations = [];
-      if (!info.hasMore) {
-        for (const range of info.ranges) {
-          decorations.push({
-            range,
-            options: Decorations.instance.getDecorationFromOptions(this._options)
-          });
-        }
-      }
-      this._decorations.set(decorations);
-    });
-  }
-  getDecorationInfo(decoration) {
-    if (!this._decorations.has(decoration)) {
-      return null;
-    }
-    const model = this._editor.getModel();
-    if (!isModelDecorationVisible(model, decoration)) {
-      return null;
-    }
-    const text = model.getValueInRange(decoration.range);
-    return {
-      reason: computeReason(text, this._options),
-      inComment: isModelDecorationInComment(model, decoration),
-      inString: isModelDecorationInString(model, decoration)
-    };
-  }
-};
-DocumentUnicodeHighlighter = __decorate([
-  __param(3, IEditorWorkerService)
-], DocumentUnicodeHighlighter);
-class ViewportUnicodeHighlighter extends Disposable {
-  constructor(_editor, _options, _updateState) {
-    super();
-    this._editor = _editor;
-    this._options = _options;
-    this._updateState = _updateState;
-    this._model = this._editor.getModel();
-    this._decorations = this._editor.createDecorationsCollection();
-    this._updateSoon = this._register(new RunOnceScheduler(() => this._update(), 250));
-    this._register(this._editor.onDidLayoutChange(() => {
-      this._updateSoon.schedule();
-    }));
-    this._register(this._editor.onDidScrollChange(() => {
-      this._updateSoon.schedule();
-    }));
-    this._register(this._editor.onDidChangeHiddenAreas(() => {
-      this._updateSoon.schedule();
-    }));
-    this._register(this._editor.onDidChangeModelContent(() => {
-      this._updateSoon.schedule();
-    }));
-    this._updateSoon.schedule();
-  }
-  dispose() {
-    this._decorations.clear();
-    super.dispose();
-  }
-  _update() {
-    if (this._model.isDisposed()) {
-      return;
-    }
-    if (!this._model.mightContainNonBasicASCII()) {
-      this._decorations.clear();
-      return;
-    }
-    const ranges = this._editor.getVisibleRanges();
-    const decorations = [];
-    const totalResult = {
-      ranges: [],
-      ambiguousCharacterCount: 0,
-      invisibleCharacterCount: 0,
-      nonBasicAsciiCharacterCount: 0,
-      hasMore: false
-    };
-    for (const range of ranges) {
-      const result = UnicodeTextModelHighlighter.computeUnicodeHighlights(this._model, this._options, range);
-      for (const r of result.ranges) {
-        totalResult.ranges.push(r);
-      }
-      totalResult.ambiguousCharacterCount += totalResult.ambiguousCharacterCount;
-      totalResult.invisibleCharacterCount += totalResult.invisibleCharacterCount;
-      totalResult.nonBasicAsciiCharacterCount += totalResult.nonBasicAsciiCharacterCount;
-      totalResult.hasMore = totalResult.hasMore || result.hasMore;
-    }
-    if (!totalResult.hasMore) {
-      for (const range of totalResult.ranges) {
-        decorations.push({ range, options: Decorations.instance.getDecorationFromOptions(this._options) });
-      }
-    }
-    this._updateState(totalResult);
-    this._decorations.set(decorations);
-  }
-  getDecorationInfo(decoration) {
-    if (!this._decorations.has(decoration)) {
-      return null;
-    }
-    const model = this._editor.getModel();
-    const text = model.getValueInRange(decoration.range);
-    if (!isModelDecorationVisible(model, decoration)) {
-      return null;
-    }
-    return {
-      reason: computeReason(text, this._options),
-      inComment: isModelDecorationInComment(model, decoration),
-      inString: isModelDecorationInString(model, decoration)
-    };
-  }
-}
-const configureUnicodeHighlightOptionsStr = localize("unicodeHighlight.configureUnicodeHighlightOptions", "Configure Unicode Highlight Options");
-let UnicodeHighlighterHoverParticipant = class UnicodeHighlighterHoverParticipant2 {
-  constructor(_editor, _languageService, _openerService) {
-    this._editor = _editor;
-    this._languageService = _languageService;
-    this._openerService = _openerService;
-    this.hoverOrdinal = 5;
-  }
-  computeSync(anchor, lineDecorations) {
-    if (!this._editor.hasModel() || anchor.type !== 1) {
-      return [];
-    }
-    const model = this._editor.getModel();
-    const unicodeHighlighter = this._editor.getContribution(UnicodeHighlighter.ID);
-    if (!unicodeHighlighter) {
-      return [];
-    }
-    const result = [];
-    const existedReason = /* @__PURE__ */ new Set();
-    let index = 300;
-    for (const d of lineDecorations) {
-      const highlightInfo = unicodeHighlighter.getDecorationInfo(d);
-      if (!highlightInfo) {
-        continue;
-      }
-      const char = model.getValueInRange(d.range);
-      const codePoint = char.codePointAt(0);
-      const codePointStr = formatCodePointMarkdown(codePoint);
-      let reason;
-      switch (highlightInfo.reason.kind) {
-        case 0: {
-          if (isBasicASCII(highlightInfo.reason.confusableWith)) {
-            reason = localize("unicodeHighlight.characterIsAmbiguousASCII", "The character {0} could be confused with the ASCII character {1}, which is more common in source code.", codePointStr, formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0)));
-          } else {
-            reason = localize("unicodeHighlight.characterIsAmbiguous", "The character {0} could be confused with the character {1}, which is more common in source code.", codePointStr, formatCodePointMarkdown(highlightInfo.reason.confusableWith.codePointAt(0)));
-          }
-          break;
-        }
-        case 1:
-          reason = localize("unicodeHighlight.characterIsInvisible", "The character {0} is invisible.", codePointStr);
-          break;
-        case 2:
-          reason = localize("unicodeHighlight.characterIsNonBasicAscii", "The character {0} is not a basic ASCII character.", codePointStr);
-          break;
-      }
-      if (existedReason.has(reason)) {
-        continue;
-      }
-      existedReason.add(reason);
-      const adjustSettingsArgs = {
-        codePoint,
-        reason: highlightInfo.reason,
-        inComment: highlightInfo.inComment,
-        inString: highlightInfo.inString
-      };
-      const adjustSettings = localize("unicodeHighlight.adjustSettings", "Adjust settings");
-      const uri = `command:${ShowExcludeOptions.ID}?${encodeURIComponent(JSON.stringify(adjustSettingsArgs))}`;
-      const markdown = new MarkdownString("", true).appendMarkdown(reason).appendText(" ").appendLink(uri, adjustSettings, configureUnicodeHighlightOptionsStr);
-      result.push(new MarkdownHover(this, d.range, [markdown], false, index++));
-    }
-    return result;
-  }
-  renderHoverParts(context, hoverParts) {
-    return renderMarkdownHovers(context, hoverParts, this._editor, this._languageService, this._openerService);
-  }
-};
-UnicodeHighlighterHoverParticipant = __decorate([
-  __param(1, ILanguageService),
-  __param(2, IOpenerService)
-], UnicodeHighlighterHoverParticipant);
-function codePointToHex(codePoint) {
-  return `U+${codePoint.toString(16).padStart(4, "0")}`;
-}
-function formatCodePointMarkdown(codePoint) {
-  let value = `\`${codePointToHex(codePoint)}\``;
-  if (!InvisibleCharacters.isInvisibleCharacter(codePoint)) {
-    value += ` "${`${renderCodePointAsInlineCode(codePoint)}`}"`;
-  }
-  return value;
-}
-function renderCodePointAsInlineCode(codePoint) {
-  if (codePoint === 96) {
-    return "`` ` ``";
-  }
-  return "`" + String.fromCodePoint(codePoint) + "`";
-}
-function computeReason(char, options) {
-  return UnicodeTextModelHighlighter.computeUnicodeHighlightReason(char, options);
-}
-const _Decorations = class _Decorations {
-  constructor() {
-    this.map = /* @__PURE__ */ new Map();
-  }
-  getDecorationFromOptions(options) {
-    return this.getDecoration(!options.includeComments, !options.includeStrings);
-  }
-  getDecoration(hideInComments, hideInStrings) {
-    const key = `${hideInComments}${hideInStrings}`;
-    let options = this.map.get(key);
-    if (!options) {
-      options = ModelDecorationOptions.createDynamic({
-        description: "unicode-highlight",
-        stickiness: 1,
-        className: "unicode-highlight",
-        showIfCollapsed: true,
-        overviewRuler: null,
-        minimap: null,
-        hideInCommentTokens: hideInComments,
-        hideInStringTokens: hideInStrings
-      });
-      this.map.set(key, options);
-    }
-    return options;
-  }
-};
-_Decorations.instance = new _Decorations();
-let Decorations = _Decorations;
-class DisableHighlightingInCommentsAction extends EditorAction {
-  constructor() {
-    super({
-      id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-      label: localize("action.unicodeHighlight.disableHighlightingInComments", "Disable highlighting of characters in comments"),
-      alias: "Disable highlighting of characters in comments",
-      precondition: void 0
-    });
-    this.shortLabel = localize("unicodeHighlight.disableHighlightingInComments.shortLabel", "Disable Highlight In Comments");
-  }
-  async run(accessor, editor, args) {
-    const configurationService = accessor == null ? void 0 : accessor.get(IConfigurationService);
-    if (configurationService) {
-      this.runAction(configurationService);
-    }
-  }
-  async runAction(configurationService) {
-    await configurationService.updateValue(
-      unicodeHighlightConfigKeys.includeComments,
-      false,
-      2
-      /* ConfigurationTarget.USER */
-    );
-  }
-}
-class DisableHighlightingInStringsAction extends EditorAction {
-  constructor() {
-    super({
-      id: DisableHighlightingOfAmbiguousCharactersAction.ID,
-      label: localize("action.unicodeHighlight.disableHighlightingInStrings", "Disable highlighting of characters in strings"),
-      alias: "Disable highlighting of characters in strings",
-      precondition: void 0
-    });
-    this.shortLabel = localize("unicodeHighlight.disableHighlightingInStrings.shortLabel", "Disable Highlight In Strings");
-  }
-  async run(accessor, editor, args) {
-    const configurationService = accessor == null ? void 0 : accessor.get(IConfigurationService);
-    if (configurationService) {
-      this.runAction(configurationService);
-    }
-  }
-  async runAction(configurationService) {
-    await configurationService.updateValue(
-      unicodeHighlightConfigKeys.includeStrings,
-      false,
-      2
-      /* ConfigurationTarget.USER */
-    );
-  }
-}
-const _DisableHighlightingOfAmbiguousCharactersAction = class _DisableHighlightingOfAmbiguousCharactersAction extends EditorAction {
-  constructor() {
-    super({
-      id: _DisableHighlightingOfAmbiguousCharactersAction.ID,
-      label: localize("action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters", "Disable highlighting of ambiguous characters"),
-      alias: "Disable highlighting of ambiguous characters",
-      precondition: void 0
-    });
-    this.shortLabel = localize("unicodeHighlight.disableHighlightingOfAmbiguousCharacters.shortLabel", "Disable Ambiguous Highlight");
-  }
-  async run(accessor, editor, args) {
-    const configurationService = accessor == null ? void 0 : accessor.get(IConfigurationService);
-    if (configurationService) {
-      this.runAction(configurationService);
-    }
-  }
-  async runAction(configurationService) {
-    await configurationService.updateValue(
-      unicodeHighlightConfigKeys.ambiguousCharacters,
-      false,
-      2
-      /* ConfigurationTarget.USER */
-    );
-  }
-};
-_DisableHighlightingOfAmbiguousCharactersAction.ID = "editor.action.unicodeHighlight.disableHighlightingOfAmbiguousCharacters";
-let DisableHighlightingOfAmbiguousCharactersAction = _DisableHighlightingOfAmbiguousCharactersAction;
-const _DisableHighlightingOfInvisibleCharactersAction = class _DisableHighlightingOfInvisibleCharactersAction extends EditorAction {
-  constructor() {
-    super({
-      id: _DisableHighlightingOfInvisibleCharactersAction.ID,
-      label: localize("action.unicodeHighlight.disableHighlightingOfInvisibleCharacters", "Disable highlighting of invisible characters"),
-      alias: "Disable highlighting of invisible characters",
-      precondition: void 0
-    });
-    this.shortLabel = localize("unicodeHighlight.disableHighlightingOfInvisibleCharacters.shortLabel", "Disable Invisible Highlight");
-  }
-  async run(accessor, editor, args) {
-    const configurationService = accessor == null ? void 0 : accessor.get(IConfigurationService);
-    if (configurationService) {
-      this.runAction(configurationService);
-    }
-  }
-  async runAction(configurationService) {
-    await configurationService.updateValue(
-      unicodeHighlightConfigKeys.invisibleCharacters,
-      false,
-      2
-      /* ConfigurationTarget.USER */
-    );
-  }
-};
-_DisableHighlightingOfInvisibleCharactersAction.ID = "editor.action.unicodeHighlight.disableHighlightingOfInvisibleCharacters";
-let DisableHighlightingOfInvisibleCharactersAction = _DisableHighlightingOfInvisibleCharactersAction;
-const _DisableHighlightingOfNonBasicAsciiCharactersAction = class _DisableHighlightingOfNonBasicAsciiCharactersAction extends EditorAction {
-  constructor() {
-    super({
-      id: _DisableHighlightingOfNonBasicAsciiCharactersAction.ID,
-      label: localize("action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters", "Disable highlighting of non basic ASCII characters"),
-      alias: "Disable highlighting of non basic ASCII characters",
-      precondition: void 0
-    });
-    this.shortLabel = localize("unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters.shortLabel", "Disable Non ASCII Highlight");
-  }
-  async run(accessor, editor, args) {
-    const configurationService = accessor == null ? void 0 : accessor.get(IConfigurationService);
-    if (configurationService) {
-      this.runAction(configurationService);
-    }
-  }
-  async runAction(configurationService) {
-    await configurationService.updateValue(
-      unicodeHighlightConfigKeys.nonBasicASCII,
-      false,
-      2
-      /* ConfigurationTarget.USER */
-    );
-  }
-};
-_DisableHighlightingOfNonBasicAsciiCharactersAction.ID = "editor.action.unicodeHighlight.disableHighlightingOfNonBasicAsciiCharacters";
-let DisableHighlightingOfNonBasicAsciiCharactersAction = _DisableHighlightingOfNonBasicAsciiCharactersAction;
-const _ShowExcludeOptions = class _ShowExcludeOptions extends EditorAction {
-  constructor() {
-    super({
-      id: _ShowExcludeOptions.ID,
-      label: localize("action.unicodeHighlight.showExcludeOptions", "Show Exclude Options"),
-      alias: "Show Exclude Options",
-      precondition: void 0
-    });
-  }
-  async run(accessor, editor, args) {
-    const { codePoint, reason, inString, inComment } = args;
-    const char = String.fromCodePoint(codePoint);
-    const quickPickService = accessor.get(IQuickInputService);
-    const configurationService = accessor.get(IConfigurationService);
-    function getExcludeCharFromBeingHighlightedLabel(codePoint2) {
-      if (InvisibleCharacters.isInvisibleCharacter(codePoint2)) {
-        return localize("unicodeHighlight.excludeInvisibleCharFromBeingHighlighted", "Exclude {0} (invisible character) from being highlighted", codePointToHex(codePoint2));
-      }
-      return localize("unicodeHighlight.excludeCharFromBeingHighlighted", "Exclude {0} from being highlighted", `${codePointToHex(codePoint2)} "${char}"`);
-    }
-    const options = [];
-    if (reason.kind === 0) {
-      for (const locale of reason.notAmbiguousInLocales) {
-        options.push({
-          label: localize("unicodeHighlight.allowCommonCharactersInLanguage", 'Allow unicode characters that are more common in the language "{0}".', locale),
-          run: async () => {
-            excludeLocaleFromBeingHighlighted(configurationService, [locale]);
-          }
-        });
-      }
-    }
-    options.push({
-      label: getExcludeCharFromBeingHighlightedLabel(codePoint),
-      run: () => excludeCharFromBeingHighlighted(configurationService, [codePoint])
-    });
-    if (inComment) {
-      const action = new DisableHighlightingInCommentsAction();
-      options.push({ label: action.label, run: async () => action.runAction(configurationService) });
-    } else if (inString) {
-      const action = new DisableHighlightingInStringsAction();
-      options.push({ label: action.label, run: async () => action.runAction(configurationService) });
-    }
-    if (reason.kind === 0) {
-      const action = new DisableHighlightingOfAmbiguousCharactersAction();
-      options.push({ label: action.label, run: async () => action.runAction(configurationService) });
-    } else if (reason.kind === 1) {
-      const action = new DisableHighlightingOfInvisibleCharactersAction();
-      options.push({ label: action.label, run: async () => action.runAction(configurationService) });
-    } else if (reason.kind === 2) {
-      const action = new DisableHighlightingOfNonBasicAsciiCharactersAction();
-      options.push({ label: action.label, run: async () => action.runAction(configurationService) });
-    } else {
-      expectNever(reason);
-    }
-    const result = await quickPickService.pick(options, { title: configureUnicodeHighlightOptionsStr });
-    if (result) {
-      await result.run();
-    }
-  }
-};
-_ShowExcludeOptions.ID = "editor.action.unicodeHighlight.showExcludeOptions";
-let ShowExcludeOptions = _ShowExcludeOptions;
-async function excludeCharFromBeingHighlighted(configurationService, charCodes) {
-  const existingValue = configurationService.getValue(unicodeHighlightConfigKeys.allowedCharacters);
-  let value;
-  if (typeof existingValue === "object" && existingValue) {
-    value = existingValue;
-  } else {
-    value = {};
-  }
-  for (const charCode of charCodes) {
-    value[String.fromCodePoint(charCode)] = true;
-  }
-  await configurationService.updateValue(
-    unicodeHighlightConfigKeys.allowedCharacters,
-    value,
-    2
-    /* ConfigurationTarget.USER */
-  );
-}
-async function excludeLocaleFromBeingHighlighted(configurationService, locales) {
-  var _a2;
-  const existingValue = (_a2 = configurationService.inspect(unicodeHighlightConfigKeys.allowedLocales).user) == null ? void 0 : _a2.value;
-  let value;
-  if (typeof existingValue === "object" && existingValue) {
-    value = Object.assign({}, existingValue);
-  } else {
-    value = {};
-  }
-  for (const locale of locales) {
-    value[locale] = true;
-  }
-  await configurationService.updateValue(
-    unicodeHighlightConfigKeys.allowedLocales,
-    value,
-    2
-    /* ConfigurationTarget.USER */
-  );
-}
-function expectNever(value) {
-  throw new Error(`Unexpected value: ${value}`);
-}
-registerEditorAction(DisableHighlightingOfAmbiguousCharactersAction);
-registerEditorAction(DisableHighlightingOfInvisibleCharactersAction);
-registerEditorAction(DisableHighlightingOfNonBasicAsciiCharactersAction);
-registerEditorAction(ShowExcludeOptions);
-registerEditorContribution(
-  UnicodeHighlighter.ID,
-  UnicodeHighlighter,
-  1
-  /* EditorContributionInstantiation.AfterFirstRender */
-);
-HoverParticipantRegistry.register(UnicodeHighlighterHoverParticipant);
-export {
-  DisableHighlightingInCommentsAction,
-  DisableHighlightingInStringsAction,
-  DisableHighlightingOfAmbiguousCharactersAction,
-  DisableHighlightingOfInvisibleCharactersAction,
-  DisableHighlightingOfNonBasicAsciiCharactersAction,
-  ShowExcludeOptions,
-  UnicodeHighlighter,
-  UnicodeHighlighterHoverParticipant,
-  warningIcon
-};
-//# sourceMappingURL=unicodeHighlighter.es.js.map