@jxsuite/studio 4.0.0 → 5.0.0

package/dist/chunks/{studio-685s0ytq.js → studio-nqgawfks.js}

@@ -1,241 +1,241 @@
 import {
-  AbstractEditorNavigationQuickAccessProvider,
-  AnimationFrameScheduler,
-  ColorDetector,
-  ColorPickerWidget,
-  ColorPresentationsCollector,
-  ContentHoverController,
-  CopyPasteController,
-  DefaultDocumentColorProvider,
-  DefaultDocumentColorProviderFeature,
-  DefaultDropProvidersFeature,
-  DefaultPasteProvidersFeature,
-  DefaultTextPasteOrDropEditProvider,
-  EditorHoverStatusBar,
-  ExtColorDataCollector,
-  HierarchicalKind,
-  HoverColorPickerParticipant,
-  HoverParticipantRegistry,
-  IFileService,
-  IOutlineModelService,
-  InlayHintsController,
-  InlayHintsHover,
-  InlineProgressManager,
-  PostEditWidgetManager,
-  ReferencesController,
-  StickyScrollController,
-  _findColorData,
-  _setupColorCommand,
-  changePasteTypeCommandId,
-  createColorHover,
-  getColors,
-  getHighlightDecorationOptions,
-  isOnColorDecorator,
-  pasteWidgetVisibleCtx,
-  sortEditsByYieldTo,
-  toErrorMessage,
-  updateColorPresentations,
-  updateEditorModel
-} from "./studio-ynxwkrzd.js";
-import {
-  $,
-  Action2,
-  CancellationToken,
-  CancellationTokenSource,
-  Codicon,
-  Color,
-  CommandsRegistry,
-  ContextKeyEqualsExpr,
-  ContextKeyExpr,
-  DeferredPromise,
-  Delayer,
-  DiffEditorWidget,
-  Dimension,
-  Disposable,
-  DisposableCancellationTokenSource,
+  coalesce,
+  isNonEmptyArray,
+  compareBy,
+  numberComparator,
+  reverseOrder,
+  onUnexpectedError,
+  onUnexpectedExternalError,
+  isCancellationError,
+  illegalArgument,
+  assertType,
+  isFunction,
+  localize,
+  localize2,
+  isWindows,
+  isIOS,
+  isLittleEndian,
+  createSingleCallFunction,
+  isDisposable,
+  dispose,
+  toDisposable,
   DisposableStore,
-  DocumentHighlightKind,
-  EDITOR_FONT_DEFAULTS,
-  EditOperation,
-  EditorAction,
-  EditorAction2,
-  EditorCommand,
-  EditorContextKeys,
-  EditorState,
-  EditorStateCancellationTokenSource,
-  EditorZoom,
-  Emitter,
-  Event,
-  Extensions1 as Extensions,
-  GlyphRasterizer,
-  HC_BLACK_THEME_NAME,
-  HC_LIGHT_THEME_NAME,
-  HideUnchangedRegionsFeature,
-  ICodeEditorService,
-  ICommandService,
-  IConfigurationService,
-  IContextKeyService,
-  IDialogService,
-  IEditorWorkerService,
-  IHoverService,
-  IInstantiationService,
-  IKeybindingService,
-  ILanguageConfigurationService,
-  ILanguageFeatureDebounceService,
-  ILanguageFeaturesService,
-  ILanguageService,
-  ILogService,
-  IMarkerService,
-  IMenuService,
-  IModelService,
-  INotificationService,
-  IQuickInputService,
-  ISemanticTokensStylingService,
-  IStandaloneThemeService,
-  IStorageService,
-  ITelemetryService,
-  ITextModelService,
-  IThemeService,
-  IWorkspaceContextService,
-  InspectTokensNLS,
-  ItemActivation,
-  KeyChord,
-  LRUCache,
-  LineRange,
-  LocalSelectionTransfer,
-  MarkdownString,
-  MarkerSeverity,
-  MenuEntryActionViewItem,
-  MenuId,
-  MenuItemAction,
-  MenuRegistry,
-  MenuWorkbenchToolBar,
-  ModelDecorationOptions,
-  MoveOperations,
+  Disposable,
   MutableDisposable,
-  NullState,
-  Point,
-  Position,
-  QuickCommandNLS,
-  QuickHelpNLS,
-  QuickOutlineNLS,
-  Range,
-  RawContextKey,
-  Registry,
-  ReplaceCommand,
-  ResourceMap,
-  RunOnceScheduler,
-  Schemas,
-  Selection,
-  Separator,
-  StableEditorScrollState,
   StopWatch,
+  Event2,
+  Emitter2,
+  EditorZoom,
+  EDITOR_FONT_DEFAULTS,
+  USUAL_WORD_SEPARATORS,
+  CancellationToken,
+  CancellationTokenSource2,
+  KeyChord,
+  sep,
+  URI,
+  Position2,
+  Range2,
+  Selection2,
+  Codicon,
+  DocumentHighlightKind,
+  getAriaLabelForSymbol,
   SymbolKinds,
-  ThemeIcon,
-  ToggleHighContrastNLS,
-  TokenMetadata,
   TokenizationRegistry,
-  URI,
-  USUAL_WORD_SEPARATORS,
-  VSBuffer,
-  VSDataTransfer,
-  VS_DARK_THEME_NAME,
-  VS_LIGHT_THEME_NAME,
-  ViewGpuContext,
-  WillSaveStateReason,
-  addDisposableListener,
-  alert,
-  append,
-  appendRemoveOnDispose,
-  assertType,
-  autorun,
-  autorunWithStore,
-  basename1 as basename,
-  coalesce,
+  mainWindow,
+  format,
+  trim,
+  lastNonWhitespaceIndex,
   commonPrefixLength,
   commonSuffixLength,
-  compareBy,
-  constObservable,
   createCancelablePromise,
-  createDecorator,
-  createMatches,
-  createSingleCallFunction,
+  raceCancellation,
+  Delayer,
+  timeout,
+  disposableTimeout,
+  first,
+  RunOnceScheduler,
+  DeferredPromise,
+  Schemas,
+  matchesScheme,
+  VSBuffer,
+  structuralEquals,
   derived,
-  derivedObservableWithCache,
   derivedOpts,
+  autorun,
+  autorunWithStore,
+  observableValue,
   disposableObservableValue,
-  disposableTimeout,
-  dispose,
-  editor,
-  ensureNonNullable,
-  findLast,
-  first,
-  format,
-  fuzzyScore,
-  getActionBarActions,
+  observableFromEvent,
+  derivedObservableWithCache,
+  getWindow,
+  addDisposableListener,
+  runWhenWindowIdle,
+  Dimension,
   getActiveElement,
   getActiveWindow,
-  getAriaLabelForSymbol,
-  getWindow,
-  ghostTextForeground,
+  trackFocus,
+  append,
+  reset,
+  $,
   h,
-  illegalArgument,
-  isCancellationError,
-  isDark,
-  isDiffEditor,
-  isDisposable,
-  isEqual,
-  isFunction,
-  isHighContrast,
-  isIOS,
-  isKeyModified,
-  isLittleEndian,
-  isLocalizedString,
-  isNonEmptyArray,
-  isWindows,
-  lastNonWhitespaceIndex,
-  localize,
-  localize2,
-  mainWindow,
-  matchesBaseContiguousSubString,
-  matchesScheme,
-  matchesWords,
   n,
-  nullTokenize,
-  nullTokenizeEncoded,
-  numberComparator,
-  observableCodeEditor,
-  observableFromEvent,
-  observableSignalFromEvent,
-  observableValue,
-  onUnexpectedError,
-  onUnexpectedExternalError,
-  or,
-  raceCancellation,
+  IInstantiationService,
+  createDecorator,
+  ICodeEditorService,
+  IModelService,
+  ITextModelService,
+  Separator,
+  ThemeIcon,
+  ICommandService,
+  CommandsRegistry,
+  ContextKeyExpr,
+  ContextKeyEqualsExpr,
+  RawContextKey,
+  IContextKeyService,
+  Registry,
+  MenuId,
+  IMenuService,
+  MenuRegistry,
+  MenuItemAction,
+  Action2,
   registerAction2,
-  registerColor,
-  registerEditorAction,
+  ITelemetryService,
+  ResourceMap,
+  LRUCache,
+  isEqual,
+  basename2,
+  ILogService,
+  EditorCommand,
+  EditorAction,
+  EditorAction2,
+  registerModelAndPositionCommand,
   registerEditorCommand,
+  registerEditorAction,
   registerEditorContribution,
-  registerEditorFeature,
-  registerModelAndPositionCommand,
+  IConfigurationService,
+  ILanguageService,
   registerSingleton,
-  renderLabelWithIcons,
-  reset,
-  reverseOrder,
-  runWhenWindowIdle,
-  score,
-  sep,
+  ILanguageConfigurationService,
   shouldSynchronizeModel,
-  stripIcons,
-  structuralEquals,
-  timeout,
-  toDisposable,
+  findLast,
+  LineRange,
+  Color,
+  ILanguageFeaturesService,
+  NullState,
+  nullTokenize,
+  nullTokenizeEncoded,
+  TokenMetadata,
+  alert,
+  IEditorWorkerService,
+  registerColor,
+  isHighContrast,
+  isDark,
+  VSDataTransfer,
+  LocalSelectionTransfer,
   toExternalVSDataTransfer,
+  ReplaceCommand,
+  MoveOperations,
+  EditorContextKeys,
+  IThemeService,
+  ghostTextForeground,
+  ensureNonNullable,
+  GlyphRasterizer,
+  INotificationService,
+  ViewGpuContext,
+  IKeybindingService,
+  ModelDecorationOptions,
+  IHoverService,
+  or,
+  matchesBaseContiguousSubString,
+  matchesWords,
+  createMatches,
+  fuzzyScore,
+  stripIcons,
+  MarkdownString,
+  renderLabelWithIcons,
+  IDialogService,
+  isKeyModified,
+  ItemActivation,
+  IQuickInputService,
+  IStorageService,
+  WillSaveStateReason,
+  ILanguageFeatureDebounceService,
+  score,
   toMultilineTokens2,
-  trackFocus,
-  trim
-} from "./studio-b9b6t1dg.js";
+  ISemanticTokensStylingService,
+  constObservable,
+  isLocalizedString,
+  getActionBarActions,
+  MenuEntryActionViewItem,
+  MarkerSeverity2,
+  IMarkerService,
+  IWorkspaceContextService,
+  EditOperation,
+  registerEditorFeature,
+  InspectTokensNLS,
+  QuickHelpNLS,
+  QuickCommandNLS,
+  QuickOutlineNLS,
+  ToggleHighContrastNLS,
+  IStandaloneThemeService,
+  Extensions2,
+  VS_LIGHT_THEME_NAME,
+  VS_DARK_THEME_NAME,
+  HC_BLACK_THEME_NAME,
+  HC_LIGHT_THEME_NAME,
+  StableEditorScrollState,
+  appendRemoveOnDispose,
+  DisposableCancellationTokenSource,
+  observableSignalFromEvent,
+  Point,
+  observableCodeEditor,
+  MenuWorkbenchToolBar,
+  HideUnchangedRegionsFeature,
+  DiffEditorWidget,
+  isDiffEditor,
+  EditorState,
+  EditorStateCancellationTokenSource,
+  editor2
+} from "./studio-e1f24eff.js";
+import {
+  HierarchicalKind,
+  InlineProgressManager,
+  DefaultTextPasteOrDropEditProvider,
+  DefaultDropProvidersFeature,
+  DefaultPasteProvidersFeature,
+  sortEditsByYieldTo,
+  toErrorMessage,
+  PostEditWidgetManager,
+  changePasteTypeCommandId,
+  pasteWidgetVisibleCtx,
+  CopyPasteController,
+  getHighlightDecorationOptions,
+  AbstractEditorNavigationQuickAccessProvider,
+  ReferencesController,
+  HoverParticipantRegistry,
+  EditorHoverStatusBar,
+  DefaultDocumentColorProvider,
+  DefaultDocumentColorProviderFeature,
+  getColors,
+  ExtColorDataCollector,
+  ColorPresentationsCollector,
+  _findColorData,
+  _setupColorCommand,
+  ColorDetector,
+  ColorPickerWidget,
+  createColorHover,
+  updateEditorModel,
+  updateColorPresentations,
+  HoverColorPickerParticipant,
+  InlayHintsController,
+  InlayHintsHover,
+  isOnColorDecorator,
+  ContentHoverController,
+  AnimationFrameScheduler,
+  IFileService,
+  IOutlineModelService,
+  StickyScrollController
+} from "./studio-4wbb9ct0.js";
 
 // ../../node_modules/monaco-editor/esm/vs/editor/browser/widget/diffEditor/commands.js
 class ToggleCollapseUnchangedRegions extends Action2 {
@@ -303,7 +303,7 @@ class SwitchSide extends EditorAction2 {
       category: diffEditorCategory
     });
   }
-  runEditorCommand(accessor, editor2, arg) {
+  runEditorCommand(accessor, editor, arg) {
     const diffEditor = findFocusedDiffEditor(accessor);
     if (diffEditor instanceof DiffEditorWidget) {
       if (arg && arg.dryRun) {
@@ -331,7 +331,7 @@ class ExitCompareMove extends EditorAction2 {
       }
     });
   }
-  runEditorCommand(accessor, editor2, ...args) {
+  runEditorCommand(accessor, editor, ...args) {
     const diffEditor = findFocusedDiffEditor(accessor);
     if (diffEditor instanceof DiffEditorWidget) {
       diffEditor.exitCompareMove();
@@ -350,7 +350,7 @@ class CollapseAllUnchangedRegions extends EditorAction2 {
       category: diffEditorCategory
     });
   }
-  runEditorCommand(accessor, editor2, ...args) {
+  runEditorCommand(accessor, editor, ...args) {
     const diffEditor = findFocusedDiffEditor(accessor);
     if (diffEditor instanceof DiffEditorWidget) {
       diffEditor.collapseAllUnchangedRegions();
@@ -369,7 +369,7 @@ class ShowAllUnchangedRegions extends EditorAction2 {
       category: diffEditorCategory
     });
   }
-  runEditorCommand(accessor, editor2, ...args) {
+  runEditorCommand(accessor, editor, ...args) {
     const diffEditor = findFocusedDiffEditor(accessor);
     if (diffEditor instanceof DiffEditorWidget) {
       diffEditor.showAllUnchangedRegions();
@@ -566,20 +566,20 @@ var __param = function(paramIndex, decorator) {
 };
 var SelectionAnchorController_1;
 var SelectionAnchorSet = new RawContextKey("selectionAnchorSet", false);
-var SelectionAnchorController = class SelectionAnchorController2 {
+var SelectionAnchorController = class SelectionAnchorController {
   static {
     SelectionAnchorController_1 = this;
   }
   static {
     this.ID = "editor.contrib.selectionAnchorController";
   }
-  static get(editor2) {
-    return editor2.getContribution(SelectionAnchorController_1.ID);
+  static get(editor) {
+    return editor.getContribution(SelectionAnchorController_1.ID);
   }
-  constructor(editor2, contextKeyService) {
-    this.editor = editor2;
+  constructor(editor, contextKeyService) {
+    this.editor = editor;
     this.selectionAnchorSetContextKey = SelectionAnchorSet.bindTo(contextKeyService);
-    this.modelChangeListener = editor2.onDidChangeModel(() => this.selectionAnchorSetContextKey.reset());
+    this.modelChangeListener = editor.onDidChangeModel(() => this.selectionAnchorSetContextKey.reset());
   }
   setSelectionAnchor() {
     if (this.editor.hasModel()) {
@@ -588,7 +588,7 @@ var SelectionAnchorController = class SelectionAnchorController2 {
         if (this.decorationId) {
           accessor.removeDecoration(this.decorationId);
         }
-        this.decorationId = accessor.addDecoration(Selection.fromPositions(position, position), {
+        this.decorationId = accessor.addDecoration(Selection2.fromPositions(position, position), {
           description: "selection-anchor",
           stickiness: 1,
           hoverMessage: new MarkdownString().appendText(localize(834, "Selection Anchor")),
@@ -612,7 +612,7 @@ var SelectionAnchorController = class SelectionAnchorController2 {
       const start = this.editor.getModel().getDecorationRange(this.decorationId);
       if (start) {
         const end = this.editor.getPosition();
-        this.editor.setSelection(Selection.fromPositions(start.getStartPosition(), end));
+        this.editor.setSelection(Selection2.fromPositions(start.getStartPosition(), end));
         this.cancelSelectionAnchor();
       }
     }
@@ -649,8 +649,8 @@ class SetSelectionAnchor extends EditorAction {
       }
     });
   }
-  async run(_accessor, editor2) {
-    SelectionAnchorController.get(editor2)?.setSelectionAnchor();
+  async run(_accessor, editor) {
+    SelectionAnchorController.get(editor)?.setSelectionAnchor();
   }
 }
 
@@ -662,8 +662,8 @@ class GoToSelectionAnchor extends EditorAction {
       precondition: SelectionAnchorSet
     });
   }
-  async run(_accessor, editor2) {
-    SelectionAnchorController.get(editor2)?.goToSelectionAnchor();
+  async run(_accessor, editor) {
+    SelectionAnchorController.get(editor)?.goToSelectionAnchor();
   }
 }
 
@@ -680,8 +680,8 @@ class SelectFromAnchorToCursor extends EditorAction {
       }
     });
   }
-  async run(_accessor, editor2) {
-    SelectionAnchorController.get(editor2)?.selectFromAnchorToCursor();
+  async run(_accessor, editor) {
+    SelectionAnchorController.get(editor)?.selectFromAnchorToCursor();
   }
 }
 
@@ -698,8 +698,8 @@ class CancelSelectionAnchor extends EditorAction {
       }
     });
   }
-  async run(_accessor, editor2) {
-    SelectionAnchorController.get(editor2)?.cancelSelectionAnchor();
+  async run(_accessor, editor) {
+    SelectionAnchorController.get(editor)?.cancelSelectionAnchor();
   }
 }
 registerEditorContribution(SelectionAnchorController.ID, SelectionAnchorController, 4);
@@ -728,22 +728,22 @@ class MoveCaretCommand {
       return;
     }
     if (this._isMovingLeft) {
-      const rangeBefore = new Range(lineNumber, startColumn - 1, lineNumber, startColumn);
+      const rangeBefore = new Range2(lineNumber, startColumn - 1, lineNumber, startColumn);
       const charBefore = model.getValueInRange(rangeBefore);
       builder.addEditOperation(rangeBefore, null);
-      builder.addEditOperation(new Range(lineNumber, endColumn, lineNumber, endColumn), charBefore);
+      builder.addEditOperation(new Range2(lineNumber, endColumn, lineNumber, endColumn), charBefore);
     } else {
-      const rangeAfter = new Range(lineNumber, endColumn, lineNumber, endColumn + 1);
+      const rangeAfter = new Range2(lineNumber, endColumn, lineNumber, endColumn + 1);
       const charAfter = model.getValueInRange(rangeAfter);
       builder.addEditOperation(rangeAfter, null);
-      builder.addEditOperation(new Range(lineNumber, startColumn, lineNumber, startColumn), charAfter);
+      builder.addEditOperation(new Range2(lineNumber, startColumn, lineNumber, startColumn), charAfter);
     }
   }
   computeCursorState(model, helper) {
     if (this._isMovingLeft) {
-      return new Selection(this._selection.startLineNumber, this._selection.startColumn - 1, this._selection.endLineNumber, this._selection.endColumn - 1);
+      return new Selection2(this._selection.startLineNumber, this._selection.startColumn - 1, this._selection.endLineNumber, this._selection.endColumn - 1);
     } else {
-      return new Selection(this._selection.startLineNumber, this._selection.startColumn + 1, this._selection.endLineNumber, this._selection.endColumn + 1);
+      return new Selection2(this._selection.startLineNumber, this._selection.startColumn + 1, this._selection.endLineNumber, this._selection.endColumn + 1);
     }
   }
 }
@@ -754,18 +754,18 @@ class MoveCaretAction extends EditorAction {
     super(opts);
     this.left = left;
   }
-  run(accessor, editor2) {
-    if (!editor2.hasModel()) {
+  run(accessor, editor) {
+    if (!editor.hasModel()) {
       return;
     }
     const commands = [];
-    const selections = editor2.getSelections();
+    const selections = editor.getSelections();
     for (const selection of selections) {
       commands.push(new MoveCaretCommand(selection, this.left));
     }
-    editor2.pushUndoStop();
-    editor2.executeCommands(this.id, commands);
-    editor2.pushUndoStop();
+    editor.pushUndoStop();
+    editor.executeCommands(this.id, commands);
+    editor.pushUndoStop();
   }
 }
 
@@ -808,13 +808,13 @@ class TransposeLettersAction extends EditorAction {
       }
     });
   }
-  run(accessor, editor2) {
-    if (!editor2.hasModel()) {
+  run(accessor, editor) {
+    if (!editor.hasModel()) {
       return;
     }
-    const model = editor2.getModel();
+    const model = editor.getModel();
     const commands = [];
-    const selections = editor2.getSelections();
+    const selections = editor.getSelections();
     for (const selection of selections) {
       if (!selection.isEmpty()) {
         continue;
@@ -828,15 +828,15 @@ class TransposeLettersAction extends EditorAction {
       const endPosition = column === lastColumn ? selection.getPosition() : MoveOperations.rightPosition(model, selection.getPosition().lineNumber, selection.getPosition().column);
       const middlePosition = MoveOperations.leftPosition(model, endPosition);
       const beginPosition = MoveOperations.leftPosition(model, middlePosition);
-      const leftChar = model.getValueInRange(Range.fromPositions(beginPosition, middlePosition));
-      const rightChar = model.getValueInRange(Range.fromPositions(middlePosition, endPosition));
-      const replaceRange = Range.fromPositions(beginPosition, endPosition);
+      const leftChar = model.getValueInRange(Range2.fromPositions(beginPosition, middlePosition));
+      const rightChar = model.getValueInRange(Range2.fromPositions(middlePosition, endPosition));
+      const replaceRange = Range2.fromPositions(beginPosition, endPosition);
       commands.push(new ReplaceCommand(replaceRange, rightChar + leftChar));
     }
     if (commands.length > 0) {
-      editor2.pushUndoStop();
-      editor2.executeCommands(this.id, commands);
-      editor2.pushUndoStop();
+      editor.pushUndoStop();
+      editor.executeCommands(this.id, commands);
+      editor.pushUndoStop();
     }
   }
 }
@@ -870,12 +870,12 @@ async function getCodeLensModel(registry, model, token) {
   const provider = registry.ordered(model);
   const providerRanks = new Map;
   const result = new CodeLensModel;
-  const promises = provider.map(async (provider2, i) => {
-    providerRanks.set(provider2, i);
+  const promises = provider.map(async (provider, i) => {
+    providerRanks.set(provider, i);
     try {
-      const list = await Promise.resolve(provider2.provideCodeLenses(model, token));
+      const list = await Promise.resolve(provider.provideCodeLenses(model, token));
       if (list) {
-        result.add(list, provider2);
+        result.add(list, provider);
       }
     } catch (err) {
       onUnexpectedExternalError(err);
@@ -958,7 +958,7 @@ class CacheItem {
     this.data = data;
   }
 }
-var CodeLensCache = class CodeLensCache2 {
+var CodeLensCache = class CodeLensCache {
   constructor(storageService) {
     this._fakeProvider = new class {
       provideCodeLenses() {
@@ -971,16 +971,16 @@ var CodeLensCache = class CodeLensCache2 {
     const key = "codelens/cache2";
     const raw = storageService.get(key, 1, "{}");
     this._deserialize(raw);
-    const onWillSaveStateBecauseOfShutdown = Event.filter(storageService.onWillSaveState, (e) => e.reason === WillSaveStateReason.SHUTDOWN);
-    Event.once(onWillSaveStateBecauseOfShutdown)((e) => {
+    const onWillSaveStateBecauseOfShutdown = Event2.filter(storageService.onWillSaveState, (e) => e.reason === WillSaveStateReason.SHUTDOWN);
+    Event2.once(onWillSaveStateBecauseOfShutdown)((e) => {
       storageService.store(key, this._serialize(), 1, 1);
     });
   }
   put(model, data) {
-    const copyItems = data.lenses.map((item2) => {
+    const copyItems = data.lenses.map((item) => {
       return {
-        range: item2.symbol.range,
-        command: item2.symbol.command && { id: "", title: item2.symbol.command?.title }
+        range: item.symbol.range,
+        command: item.symbol.command && { id: "", title: item.symbol.command?.title }
       };
     });
     const copyModel = new CodeLensModel;
@@ -1016,7 +1016,7 @@ var CodeLensCache = class CodeLensCache2 {
         const element = data[key];
         const lenses = [];
         for (const line of element.lines) {
-          lenses.push({ range: new Range(line, 1, line, 11) });
+          lenses.push({ range: new Range2(line, 1, line, 11) });
         }
         const model = new CodeLensModel;
         model.add({ lenses }, this._fakeProvider);
@@ -1057,12 +1057,12 @@ class CodeLensContentWidget {
   static {
     this._idPool = 0;
   }
-  constructor(editor2, line) {
+  constructor(editor, line) {
     this.allowEditorOverflow = false;
     this.suppressMouseDown = true;
     this._commands = new Map;
     this._isEmpty = true;
-    this._editor = editor2;
+    this._editor = editor;
     this._id = `codelens.widget-${CodeLensContentWidget._idPool++}`;
     this.updatePosition(line);
     this._domNode = document.createElement("span");
@@ -1149,9 +1149,9 @@ var codeLensDecorationOptions = ModelDecorationOptions.register({
 });
 
 class CodeLensWidget {
-  constructor(data, editor2, helper, viewZoneChangeAccessor, heightInPx, updateCallback) {
+  constructor(data, editor, helper, viewZoneChangeAccessor, heightInPx, updateCallback) {
     this._isDisposed = false;
-    this._editor = editor2;
+    this._editor = editor;
     this._data = data;
     this._decorationIds = [];
     let range;
@@ -1165,9 +1165,9 @@ class CodeLensWidget {
         options: codeLensDecorationOptions
       }, (id) => this._decorationIds[i] = id);
       if (!range) {
-        range = Range.lift(codeLensData.symbol.range);
+        range = Range2.lift(codeLensData.symbol.range);
       } else {
-        range = Range.plusRange(range, codeLensData.symbol.range);
+        range = Range2.plusRange(range, codeLensData.symbol.range);
       }
     });
     this._viewZone = new CodeLensViewZone(range.startLineNumber - 1, heightInPx, updateCallback);
@@ -1202,7 +1202,7 @@ class CodeLensWidget {
     return this._decorationIds.some((id, i) => {
       const range = this._editor.getModel().getDecorationRange(id);
       const symbol = this._data[i].symbol;
-      return !!(range && Range.isEmpty(symbol.range) === range.isEmpty());
+      return !!(range && Range2.isEmpty(symbol.range) === range.isEmpty());
     });
   }
   updateCodeLensSymbols(data, helper) {
@@ -1287,7 +1287,7 @@ var __param3 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var CodeLensContribution = class CodeLensContribution2 {
+var CodeLensContribution = class CodeLensContribution {
   static {
     this.ID = "css.editor.codeLens";
   }
@@ -1583,17 +1583,17 @@ var CodeLensContribution = class CodeLensContribution2 {
     const resolvePromise = createCancelablePromise((token) => {
       const promises = toResolve.map((request, i) => {
         const resolvedSymbols = new Array(request.length);
-        const promises2 = request.map((request2, i2) => {
-          if (!request2.symbol.command && typeof request2.provider.resolveCodeLens === "function") {
-            return Promise.resolve(request2.provider.resolveCodeLens(model, request2.symbol, token)).then((symbol) => {
-              resolvedSymbols[i2] = symbol;
+        const promises = request.map((request, i) => {
+          if (!request.symbol.command && typeof request.provider.resolveCodeLens === "function") {
+            return Promise.resolve(request.provider.resolveCodeLens(model, request.symbol, token)).then((symbol) => {
+              resolvedSymbols[i] = symbol;
             }, onUnexpectedExternalError);
           } else {
-            resolvedSymbols[i2] = request2.symbol;
+            resolvedSymbols[i] = request.symbol;
             return Promise.resolve(undefined);
           }
         });
-        return Promise.all(promises2).then(() => {
+        return Promise.all(promises).then(() => {
           if (!token.isCancellationRequested && !lenses[i].isDisposed()) {
             lenses[i].updateCommands(resolvedSymbols);
           }
@@ -1641,15 +1641,15 @@ registerEditorAction(class ShowLensesInCurrentLine extends EditorAction {
       label: localize2(920, "Show CodeLens Commands for Current Line")
     });
   }
-  async run(accessor, editor2) {
-    if (!editor2.hasModel()) {
+  async run(accessor, editor) {
+    if (!editor.hasModel()) {
       return;
     }
     const quickInputService = accessor.get(IQuickInputService);
     const commandService = accessor.get(ICommandService);
     const notificationService = accessor.get(INotificationService);
-    const lineNumber = editor2.getSelection().positionLineNumber;
-    const codelensController = editor2.getContribution(CodeLensContribution.ID);
+    const lineNumber = editor.getSelection().positionLineNumber;
+    const codelensController = editor.getContribution(CodeLensContribution.ID);
     if (!codelensController) {
       return;
     }
@@ -1725,7 +1725,7 @@ class HoverColorPickerContribution extends Disposable {
     if (!targetRange) {
       return;
     }
-    const range = new Range(targetRange.startLineNumber, targetRange.startColumn + 1, targetRange.endLineNumber, targetRange.endColumn + 1);
+    const range = new Range2(targetRange.startLineNumber, targetRange.startColumn + 1, targetRange.endLineNumber, targetRange.endColumn + 1);
     hoverController.showContentHover(range, 1, 1, false);
   }
 }
@@ -1760,28 +1760,28 @@ class StandaloneColorPickerHover {
 }
 
 class StandaloneColorPickerRenderedParts extends Disposable {
-  constructor(editor2, context, colorHover, themeService) {
+  constructor(editor, context, colorHover, themeService) {
     super();
-    const editorModel = editor2.getModel();
+    const editorModel = editor.getModel();
     const colorPickerModel = colorHover.model;
     this.color = colorHover.model.color;
-    this.colorPicker = this._register(new ColorPickerWidget(context.fragment, colorPickerModel, editor2.getOption(163), themeService, "standalone"));
+    this.colorPicker = this._register(new ColorPickerWidget(context.fragment, colorPickerModel, editor.getOption(163), themeService, "standalone"));
     this._register(colorPickerModel.onColorFlushed((color) => {
       this.color = color;
     }));
     this._register(colorPickerModel.onDidChangeColor((color) => {
       updateColorPresentations(editorModel, colorPickerModel, color, colorHover.range, colorHover);
     }));
-    this._register(editor2.onDidChangeModelContent((e) => {
+    this._register(editor.onDidChangeModelContent((e) => {
       {
         context.hide();
-        editor2.focus();
+        editor.focus();
       }
     }));
     updateColorPresentations(editorModel, colorPickerModel, this.color, colorHover.range, colorHover);
   }
 }
-var StandaloneColorPickerParticipant = class StandaloneColorPickerParticipant2 {
+var StandaloneColorPickerParticipant = class StandaloneColorPickerParticipant {
   constructor(_editor, _themeService) {
     this._editor = _editor;
     this._themeService = _themeService;
@@ -1798,9 +1798,9 @@ var StandaloneColorPickerParticipant = class StandaloneColorPickerParticipant2 {
     let foundColorInfo = null;
     let foundColorProvider = null;
     for (const colorData of colors) {
-      const colorInfo2 = colorData.colorInfo;
-      if (Range.containsRange(colorInfo2.range, defaultColorInfo.range)) {
-        foundColorInfo = colorInfo2;
+      const colorInfo = colorData.colorInfo;
+      if (Range2.containsRange(colorInfo.range, defaultColorInfo.range)) {
+        foundColorInfo = colorInfo;
         foundColorProvider = colorData.provider;
       }
     }
@@ -1815,7 +1815,7 @@ var StandaloneColorPickerParticipant = class StandaloneColorPickerParticipant2 {
       return;
     }
     const colorPickerModel = colorHoverData.model;
-    let range = new Range(colorHoverData.range.startLineNumber, colorHoverData.range.startColumn, colorHoverData.range.endLineNumber, colorHoverData.range.endColumn);
+    let range = new Range2(colorHoverData.range.startLineNumber, colorHoverData.range.startColumn, colorHoverData.range.endLineNumber, colorHoverData.range.endColumn);
     if (this._color) {
       await updateColorPresentations(this._editor.getModel(), colorPickerModel, this._color, range, colorHoverData);
       range = updateEditorModel(this._editor, range, colorPickerModel);
@@ -1867,7 +1867,7 @@ class StandaloneColorPickerResult {
 }
 var PADDING = 8;
 var CLOSE_BUTTON_WIDTH = 22;
-var StandaloneColorPickerWidget = class StandaloneColorPickerWidget2 extends Disposable {
+var StandaloneColorPickerWidget = class StandaloneColorPickerWidget extends Disposable {
   static {
     StandaloneColorPickerWidget_1 = this;
   }
@@ -1888,7 +1888,7 @@ var StandaloneColorPickerWidget = class StandaloneColorPickerWidget2 extends Dis
     this._body = document.createElement("div");
     this._colorHover = null;
     this._selectionSetInEditor = false;
-    this._onResult = this._register(new Emitter);
+    this._onResult = this._register(new Emitter2);
     this.onResult = this._onResult.event;
     this._renderedHoverParts = this._register(new MutableDisposable);
     this._renderedStatusBar = this._register(new MutableDisposable);
@@ -2061,7 +2061,7 @@ var __param6 = function(paramIndex, decorator) {
   };
 };
 var StandaloneColorPickerController_1;
-var StandaloneColorPickerController = class StandaloneColorPickerController2 extends Disposable {
+var StandaloneColorPickerController = class StandaloneColorPickerController extends Disposable {
   static {
     StandaloneColorPickerController_1 = this;
   }
@@ -2096,8 +2096,8 @@ var StandaloneColorPickerController = class StandaloneColorPickerController2 ext
     this._standaloneColorPickerWidget?.updateEditor();
     this.hide();
   }
-  static get(editor2) {
-    return editor2.getContribution(StandaloneColorPickerController_1.ID);
+  static get(editor) {
+    return editor.getContribution(StandaloneColorPickerController_1.ID);
   }
 };
 StandaloneColorPickerController = StandaloneColorPickerController_1 = __decorate6([
@@ -2123,8 +2123,8 @@ class ShowOrFocusStandaloneColorPicker extends EditorAction2 {
       }
     });
   }
-  runEditorCommand(_accessor, editor2) {
-    StandaloneColorPickerController.get(editor2)?.showOrFocus();
+  runEditorCommand(_accessor, editor) {
+    StandaloneColorPickerController.get(editor)?.showOrFocus();
   }
 }
 
@@ -2143,8 +2143,8 @@ class HideStandaloneColorPicker extends EditorAction {
       }
     });
   }
-  run(_accessor, editor2) {
-    StandaloneColorPickerController.get(editor2)?.hide();
+  run(_accessor, editor) {
+    StandaloneColorPickerController.get(editor)?.hide();
   }
 }
 
@@ -2163,8 +2163,8 @@ class InsertColorWithStandaloneColorPicker extends EditorAction {
       }
     });
   }
-  run(_accessor, editor2) {
-    StandaloneColorPickerController.get(editor2)?.insertColor();
+  run(_accessor, editor) {
+    StandaloneColorPickerController.get(editor)?.insertColor();
   }
 }
 
@@ -2191,7 +2191,7 @@ CommandsRegistry.registerCommand("_executeColorPresentationProvider", function(a
     return;
   }
   const { uri, range } = context;
-  if (!(uri instanceof URI) || !Array.isArray(color) || color.length !== 4 || !Range.isIRange(range)) {
+  if (!(uri instanceof URI) || !Array.isArray(color) || color.length !== 4 || !Range2.isIRange(range)) {
     throw illegalArgument();
   }
   const { model, colorProviderRegistry, defaultColorDecoratorsEnablement } = _setupColorCommand(accessor, uri);
@@ -2214,8 +2214,8 @@ registerEditorCommand(new class extends EditorCommand {
       }
     });
   }
-  runEditorCommand(_accessor, editor2) {
-    return CopyPasteController.get(editor2)?.changePasteType();
+  runEditorCommand(_accessor, editor) {
+    return CopyPasteController.get(editor)?.changePasteType();
   }
 });
 registerEditorCommand(new class extends EditorCommand {
@@ -2229,8 +2229,8 @@ registerEditorCommand(new class extends EditorCommand {
       }
     });
   }
-  runEditorCommand(_accessor, editor2) {
-    CopyPasteController.get(editor2)?.clearWidgets();
+  runEditorCommand(_accessor, editor) {
+    CopyPasteController.get(editor)?.clearWidgets();
   }
 });
 registerEditorAction(class PasteAsAction extends EditorAction {
@@ -2278,7 +2278,7 @@ The first edit matching the preferences will be applied.`),
       canTriggerInlineEdits: true
     });
   }
-  run(_accessor, editor2, args) {
+  run(_accessor, editor, args) {
     let preference;
     if (args) {
       if ("kind" in args) {
@@ -2287,7 +2287,7 @@ The first edit matching the preferences will be applied.`),
         preference = { preferences: args.preferences.map((kind) => new HierarchicalKind(kind)) };
       }
     }
-    return CopyPasteController.get(editor2)?.pasteAs(preference);
+    return CopyPasteController.get(editor)?.pasteAs(preference);
   }
 });
 registerEditorAction(class extends EditorAction {
@@ -2299,8 +2299,8 @@ registerEditorAction(class extends EditorAction {
       canTriggerInlineEdits: true
     });
   }
-  run(_accessor, editor2) {
-    return CopyPasteController.get(editor2)?.pasteAs({ providerId: DefaultTextPasteOrDropEditProvider.id });
+  run(_accessor, editor) {
+    return CopyPasteController.get(editor)?.pasteAs({ providerId: DefaultTextPasteOrDropEditProvider.id });
   }
 });
 
@@ -2349,25 +2349,25 @@ var DropIntoEditorController_1;
 var dropAsPreferenceConfig = "editor.dropIntoEditor.preferences";
 var changeDropTypeCommandId = "editor.changeDropType";
 var dropWidgetVisibleCtx = new RawContextKey("dropWidgetVisible", false, localize(973, "Whether the drop widget is showing"));
-var DropIntoEditorController = class DropIntoEditorController2 extends Disposable {
+var DropIntoEditorController = class DropIntoEditorController extends Disposable {
   static {
     DropIntoEditorController_1 = this;
   }
   static {
     this.ID = "editor.contrib.dropIntoEditorController";
   }
-  static get(editor2) {
-    return editor2.getContribution(DropIntoEditorController_1.ID);
+  static get(editor) {
+    return editor.getContribution(DropIntoEditorController_1.ID);
   }
-  constructor(editor2, instantiationService, _configService, _languageFeaturesService, _treeViewsDragAndDropService) {
+  constructor(editor, instantiationService, _configService, _languageFeaturesService, _treeViewsDragAndDropService) {
     super();
     this._configService = _configService;
     this._languageFeaturesService = _languageFeaturesService;
     this._treeViewsDragAndDropService = _treeViewsDragAndDropService;
     this.treeItemsTransfer = LocalSelectionTransfer.getInstance();
-    this._dropProgressManager = this._register(instantiationService.createInstance(InlineProgressManager, "dropIntoEditor", editor2));
-    this._postDropWidgetManager = this._register(instantiationService.createInstance(PostEditWidgetManager, "dropIntoEditor", editor2, dropWidgetVisibleCtx, { id: changeDropTypeCommandId, label: localize(974, "Show drop options...") }, () => DropIntoEditorController_1._configureDefaultAction ? [DropIntoEditorController_1._configureDefaultAction] : []));
-    this._register(editor2.onDropIntoEditor((e) => this.onDropIntoEditor(editor2, e.position, e.event)));
+    this._dropProgressManager = this._register(instantiationService.createInstance(InlineProgressManager, "dropIntoEditor", editor));
+    this._postDropWidgetManager = this._register(instantiationService.createInstance(PostEditWidgetManager, "dropIntoEditor", editor, dropWidgetVisibleCtx, { id: changeDropTypeCommandId, label: localize(974, "Show drop options...") }, () => DropIntoEditorController_1._configureDefaultAction ? [DropIntoEditorController_1._configureDefaultAction] : []));
+    this._register(editor.onDropIntoEditor((e) => this.onDropIntoEditor(editor, e.position, e.event)));
   }
   clearWidgets() {
     this._postDropWidgetManager.clear();
@@ -2375,22 +2375,22 @@ var DropIntoEditorController = class DropIntoEditorController2 extends Disposabl
   changeDropType() {
     this._postDropWidgetManager.tryShowSelector();
   }
-  async onDropIntoEditor(editor2, position, dragEvent) {
-    if (!dragEvent.dataTransfer || !editor2.hasModel()) {
+  async onDropIntoEditor(editor, position, dragEvent) {
+    if (!dragEvent.dataTransfer || !editor.hasModel()) {
       return;
     }
     DropIntoEditorController_1._currentDropOperation?.cancel();
-    editor2.focus();
-    editor2.setPosition(position);
+    editor.focus();
+    editor.setPosition(position);
     const p = createCancelablePromise(async (token) => {
       const disposables = new DisposableStore;
-      const tokenSource = disposables.add(new EditorStateCancellationTokenSource(editor2, 1, undefined, token));
+      const tokenSource = disposables.add(new EditorStateCancellationTokenSource(editor, 1, undefined, token));
       try {
         const ourDataTransfer = await this.extractDataTransferData(dragEvent);
         if (ourDataTransfer.size === 0 || tokenSource.token.isCancellationRequested) {
           return;
         }
-        const model = editor2.getModel();
+        const model = editor.getModel();
         if (!model) {
           return;
         }
@@ -2406,8 +2406,8 @@ var DropIntoEditorController = class DropIntoEditorController2 extends Disposabl
         }
         if (editSession.edits.length) {
           const activeEditIndex = this.getInitialActiveEditIndex(model, editSession.edits);
-          const canShowWidget = editor2.getOption(43).showDropSelector === "afterDrop";
-          await this._postDropWidgetManager.applyEditAndShowIfNeeded([Range.fromPositions(position)], { activeEditIndex, allEdits: editSession.edits }, canShowWidget, async (edit) => edit, token);
+          const canShowWidget = editor.getOption(43).showDropSelector === "afterDrop";
+          await this._postDropWidgetManager.applyEditAndShowIfNeeded([Range2.fromPositions(position)], { activeEditIndex, allEdits: editSession.edits }, canShowWidget, async (edit) => edit, token);
         }
       } finally {
         disposables.dispose();
@@ -2423,11 +2423,11 @@ var DropIntoEditorController = class DropIntoEditorController2 extends Disposabl
     const disposables = new DisposableStore;
     const results = await raceCancellation(Promise.all(providers.map(async (provider) => {
       try {
-        const edits2 = await provider.provideDocumentDropEdits(model, position, dataTransfer, token);
-        if (edits2) {
-          disposables.add(edits2);
+        const edits = await provider.provideDocumentDropEdits(model, position, dataTransfer, token);
+        if (edits) {
+          disposables.add(edits);
         }
-        return edits2?.edits.map((edit) => ({ ...edit, providerId: provider.id }));
+        return edits?.edits.map((edit) => ({ ...edit, providerId: provider.id }));
       } catch (err) {
         if (!isCancellationError(err)) {
           console.error(err);
@@ -2495,8 +2495,8 @@ registerEditorCommand(new class extends EditorCommand {
       }
     });
   }
-  runEditorCommand(_accessor, editor2, _args) {
-    DropIntoEditorController.get(editor2)?.changeDropType();
+  runEditorCommand(_accessor, editor, _args) {
+    DropIntoEditorController.get(editor)?.changeDropType();
   }
 });
 registerEditorCommand(new class extends EditorCommand {
@@ -2510,8 +2510,8 @@ registerEditorCommand(new class extends EditorCommand {
       }
     });
   }
-  runEditorCommand(_accessor, editor2, _args) {
-    DropIntoEditorController.get(editor2)?.clearWidgets();
+  runEditorCommand(_accessor, editor, _args) {
+    DropIntoEditorController.get(editor)?.clearWidgets();
   }
 });
 
@@ -2524,7 +2524,7 @@ class EditorFontZoomIn extends EditorAction {
       precondition: undefined
     });
   }
-  run(accessor, editor2) {
+  run(accessor, editor) {
     EditorZoom.setZoomLevel(EditorZoom.getZoomLevel() + 1);
   }
 }
@@ -2537,7 +2537,7 @@ class EditorFontZoomOut extends EditorAction {
       precondition: undefined
     });
   }
-  run(accessor, editor2) {
+  run(accessor, editor) {
     EditorZoom.setZoomLevel(EditorZoom.getZoomLevel() - 1);
   }
 }
@@ -2550,7 +2550,7 @@ class EditorFontZoomReset extends EditorAction {
       precondition: undefined
     });
   }
-  run(accessor, editor2) {
+  run(accessor, editor) {
     EditorZoom.setZoomLevel(0);
   }
 }
@@ -2588,7 +2588,7 @@ var __param8 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var MarkerSelectionStatus = class MarkerSelectionStatus2 extends Disposable {
+var MarkerSelectionStatus = class MarkerSelectionStatus extends Disposable {
   static {
     this.ID = "editor.contrib.markerSelectionStatus";
   }
@@ -2620,9 +2620,9 @@ var MarkerSelectionStatus = class MarkerSelectionStatus2 extends Disposable {
     }
     const markers = this._markerService.read({
       resource: model.uri,
-      severities: MarkerSeverity.Error | MarkerSeverity.Warning | MarkerSeverity.Info
+      severities: MarkerSeverity2.Error | MarkerSeverity2.Warning | MarkerSeverity2.Info
     });
-    const hasIntersecting = markers.some((marker) => Range.areIntersecting({ startLineNumber: marker.startLineNumber, startColumn: marker.startColumn, endLineNumber: marker.endLineNumber, endColumn: marker.endColumn }, selection));
+    const hasIntersecting = markers.some((marker) => Range2.areIntersecting({ startLineNumber: marker.startLineNumber, startColumn: marker.startColumn, endLineNumber: marker.endLineNumber, endColumn: marker.endColumn }, selection));
     this._ctxHasDiagnostics.set(hasIntersecting);
   }
 };
@@ -2641,7 +2641,7 @@ class DebugEditorGpuRendererAction extends EditorAction {
       precondition: ContextKeyExpr.true()
     });
   }
-  async run(accessor, editor2) {
+  async run(accessor, editor) {
     const instantiationService = accessor.get(IInstantiationService);
     const quickInputService = accessor.get(IQuickInputService);
     const choice = await quickInputService.pick([
@@ -2663,8 +2663,8 @@ class DebugEditorGpuRendererAction extends EditorAction {
     }
     switch (choice.id) {
       case "logTextureAtlasStats":
-        instantiationService.invokeFunction((accessor2) => {
-          const logService = accessor2.get(ILogService);
+        instantiationService.invokeFunction((accessor) => {
+          const logService = accessor.get(ILogService);
           const atlas = ViewGpuContext.atlas;
           if (!ViewGpuContext.atlas) {
             logService.error("No texture atlas found");
@@ -2677,9 +2677,9 @@ class DebugEditorGpuRendererAction extends EditorAction {
         });
         break;
       case "saveTextureAtlas":
-        instantiationService.invokeFunction(async (accessor2) => {
-          const workspaceContextService = accessor2.get(IWorkspaceContextService);
-          const fileService = accessor2.get(IFileService);
+        instantiationService.invokeFunction(async (accessor) => {
+          const workspaceContextService = accessor.get(IWorkspaceContextService);
+          const fileService = accessor.get(IFileService);
           const folders = workspaceContextService.getWorkspace().folders;
           if (folders.length > 0) {
             const atlas = ViewGpuContext.atlas;
@@ -2695,11 +2695,11 @@ class DebugEditorGpuRendererAction extends EditorAction {
         });
         break;
       case "drawGlyph":
-        instantiationService.invokeFunction(async (accessor2) => {
-          const configurationService = accessor2.get(IConfigurationService);
-          const fileService = accessor2.get(IFileService);
-          const quickInputService2 = accessor2.get(IQuickInputService);
-          const workspaceContextService = accessor2.get(IWorkspaceContextService);
+        instantiationService.invokeFunction(async (accessor) => {
+          const configurationService = accessor.get(IConfigurationService);
+          const fileService = accessor.get(IFileService);
+          const quickInputService = accessor.get(IQuickInputService);
+          const workspaceContextService = accessor.get(IWorkspaceContextService);
           const folders = workspaceContextService.getWorkspace().folders;
           if (folders.length === 0) {
             return;
@@ -2708,7 +2708,7 @@ class DebugEditorGpuRendererAction extends EditorAction {
           const fontFamily = configurationService.getValue("editor.fontFamily");
           const fontSize = configurationService.getValue("editor.fontSize");
           const rasterizer = new GlyphRasterizer(fontSize, fontFamily, getActiveWindow().devicePixelRatio, ViewGpuContext.decorationStyleCache);
-          let chars = await quickInputService2.input({
+          let chars = await quickInputService.input({
             prompt: "Enter a character to draw (prefix with 0x for code point))"
           });
           if (!chars) {
@@ -2759,9 +2759,9 @@ class InPlaceReplaceCommand {
     const inverseEditOperations = helper.getInverseEditOperations();
     const srcRange = inverseEditOperations[0].range;
     if (!this._originalSelection.isEmpty()) {
-      return new Selection(srcRange.endLineNumber, srcRange.endColumn - this._text.length, srcRange.endLineNumber, srcRange.endColumn);
+      return new Selection2(srcRange.endLineNumber, srcRange.endColumn - this._text.length, srcRange.endLineNumber, srcRange.endColumn);
     }
-    return new Selection(srcRange.endLineNumber, Math.min(this._originalSelection.positionColumn, srcRange.endColumn), srcRange.endLineNumber, Math.min(this._originalSelection.positionColumn, srcRange.endColumn));
+    return new Selection2(srcRange.endLineNumber, Math.min(this._originalSelection.positionColumn, srcRange.endColumn), srcRange.endLineNumber, Math.min(this._originalSelection.positionColumn, srcRange.endColumn));
   }
 }
 
@@ -2782,15 +2782,15 @@ var __param9 = function(paramIndex, decorator) {
   };
 };
 var InPlaceReplaceController_1;
-var InPlaceReplaceController = class InPlaceReplaceController2 {
+var InPlaceReplaceController = class InPlaceReplaceController {
   static {
     InPlaceReplaceController_1 = this;
   }
   static {
     this.ID = "editor.contrib.inPlaceReplaceController";
   }
-  static get(editor2) {
-    return editor2.getContribution(InPlaceReplaceController_1.ID);
+  static get(editor) {
+    return editor.getContribution(InPlaceReplaceController_1.ID);
   }
   static {
     this.DECORATION = ModelDecorationOptions.register({
@@ -2798,8 +2798,8 @@ var InPlaceReplaceController = class InPlaceReplaceController2 {
       className: "valueSetReplacement"
     });
   }
-  constructor(editor2, editorWorkerService) {
-    this.editor = editor2;
+  constructor(editor, editorWorkerService) {
+    this.editor = editor;
     this.editorWorkerService = editorWorkerService;
     this.decorations = this.editor.createDecorationsCollection();
   }
@@ -2828,7 +2828,7 @@ var InPlaceReplaceController = class InPlaceReplaceController2 {
       if (!state.validate(this.editor)) {
         return;
       }
-      const editRange = Range.lift(result.range);
+      const editRange = Range2.lift(result.range);
       let highlightRange = result.range;
       const diff = result.value.length - (selection.endColumn - selection.startColumn);
       highlightRange = {
@@ -2838,7 +2838,7 @@ var InPlaceReplaceController = class InPlaceReplaceController2 {
         endColumn: highlightRange.startColumn + result.value.length
       };
       if (diff > 1) {
-        selection = new Selection(selection.startLineNumber, selection.startColumn, selection.endLineNumber, selection.endColumn + diff - 1);
+        selection = new Selection2(selection.startLineNumber, selection.startColumn, selection.endLineNumber, selection.endColumn + diff - 1);
       }
       const command = new InPlaceReplaceCommand(editRange, selection, result.value);
       this.editor.pushUndoStop();
@@ -2871,8 +2871,8 @@ class InPlaceReplaceUp extends EditorAction {
       }
     });
   }
-  run(accessor, editor2) {
-    const controller = InPlaceReplaceController.get(editor2);
+  run(accessor, editor) {
+    const controller = InPlaceReplaceController.get(editor);
     if (!controller) {
       return Promise.resolve(undefined);
     }
@@ -2893,8 +2893,8 @@ class InPlaceReplaceDown extends EditorAction {
       }
     });
   }
-  run(accessor, editor2) {
-    const controller = InPlaceReplaceController.get(editor2);
+  run(accessor, editor) {
+    const controller = InPlaceReplaceController.get(editor);
     if (!controller) {
       return Promise.resolve(undefined);
     }
@@ -2929,7 +2929,7 @@ function insertFinalNewLine(model) {
   if (!lineCount || lastLineIsEmptyOrWhitespace) {
     return;
   }
-  return EditOperation.insert(new Position(lineCount, model.getLineMaxColumn(lineCount)), model.getEOL());
+  return EditOperation.insert(new Position2(lineCount, model.getLineMaxColumn(lineCount)), model.getEOL());
 }
 
 // ../../node_modules/monaco-editor/esm/vs/editor/contrib/insertFinalNewLine/browser/insertFinalNewLine.js
@@ -2944,15 +2944,15 @@ class InsertFinalNewLineAction extends EditorAction {
       precondition: EditorContextKeys.writable
     });
   }
-  run(_accessor, editor2, args) {
-    const selection = editor2.getSelection();
+  run(_accessor, editor, args) {
+    const selection = editor.getSelection();
     if (selection === null) {
       return;
     }
     const command = new InsertFinalNewLineCommand(selection);
-    editor2.pushUndoStop();
-    editor2.executeCommands(this.id, [command]);
-    editor2.pushUndoStop();
+    editor.pushUndoStop();
+    editor.executeCommands(this.id, [command]);
+    editor.pushUndoStop();
   }
 }
 registerEditorAction(InsertFinalNewLineAction);
@@ -2976,7 +2976,7 @@ var __param10 = function(paramIndex, decorator) {
 var LinkedEditingContribution_1;
 var CONTEXT_ONTYPE_RENAME_INPUT_VISIBLE = new RawContextKey("LinkedEditingInputVisible", false);
 var DECORATION_CLASS_NAME = "linked-editing-decoration";
-var LinkedEditingContribution = class LinkedEditingContribution2 extends Disposable {
+var LinkedEditingContribution = class LinkedEditingContribution extends Disposable {
   static {
     LinkedEditingContribution_1 = this;
   }
@@ -2990,15 +2990,15 @@ var LinkedEditingContribution = class LinkedEditingContribution2 extends Disposa
       className: DECORATION_CLASS_NAME
     });
   }
-  static get(editor2) {
-    return editor2.getContribution(LinkedEditingContribution_1.ID);
+  static get(editor) {
+    return editor.getContribution(LinkedEditingContribution_1.ID);
   }
-  constructor(editor2, contextKeyService, languageFeaturesService, languageConfigurationService, languageFeatureDebounceService) {
+  constructor(editor, contextKeyService, languageFeaturesService, languageConfigurationService, languageFeatureDebounceService) {
     super();
     this.languageConfigurationService = languageConfigurationService;
     this._syncRangesToken = 0;
     this._localToDispose = this._register(new DisposableStore);
-    this._editor = editor2;
+    this._editor = editor;
     this._providers = languageFeaturesService.linkedEditingRangeProvider;
     this._enabled = false;
     this._visibleContextKey = CONTEXT_ONTYPE_RENAME_INPUT_VISIBLE.bindTo(contextKeyService);
@@ -3035,7 +3035,7 @@ var LinkedEditingContribution = class LinkedEditingContribution2 extends Disposa
     if (!isEnabled || model === null) {
       return;
     }
-    this._localToDispose.add(Event.runAndSubscribe(model.onDidChangeLanguageConfiguration, () => {
+    this._localToDispose.add(Event2.runAndSubscribe(model.onDidChangeLanguageConfiguration, () => {
       this._languageWordPattern = this.languageConfigurationService.getLanguageConfiguration(model.getLanguageId()).getWordDefinition();
     }));
     const rangeUpdateScheduler = new Delayer(this._debounceInformation.get(model));
@@ -3112,7 +3112,7 @@ var LinkedEditingContribution = class LinkedEditingContribution2 extends Disposa
         newValue = newValue.substr(0, newValue.length - commonSuffixLength$1);
         if (rangeStartColumn !== rangeEndColumn || newValue.length !== 0) {
           edits.push({
-            range: new Range(mirrorRange.startLineNumber, rangeStartColumn, mirrorRange.endLineNumber, rangeEndColumn),
+            range: new Range2(mirrorRange.startLineNumber, rangeStartColumn, mirrorRange.endLineNumber, rangeEndColumn),
             text: newValue
           });
         }
@@ -3175,7 +3175,7 @@ var LinkedEditingContribution = class LinkedEditingContribution2 extends Disposa
     }
     this._currentRequestPosition = position;
     this._currentRequestModelVersion = modelVersionId;
-    const currentRequestCts = this._currentRequestCts = new CancellationTokenSource;
+    const currentRequestCts = this._currentRequestCts = new CancellationTokenSource2;
     try {
       const sw = new StopWatch(false);
       const response = await getLinkedEditingRanges(this._providers, model, position, currentRequestCts.token);
@@ -3194,7 +3194,7 @@ var LinkedEditingContribution = class LinkedEditingContribution2 extends Disposa
       this._currentWordPattern = response?.wordPattern || this._languageWordPattern;
       let foundReferenceRange = false;
       for (let i = 0, len = ranges.length;i < len; i++) {
-        if (Range.containsPosition(ranges[i], position)) {
+        if (Range2.containsPosition(ranges[i], position)) {
           foundReferenceRange = true;
           if (i !== 0) {
             const referenceRange = ranges[i];
@@ -3245,22 +3245,22 @@ class LinkedEditingAction extends EditorAction {
   runCommand(accessor, args) {
     const editorService = accessor.get(ICodeEditorService);
     const [uri, pos] = Array.isArray(args) && args || [undefined, undefined];
-    if (URI.isUri(uri) && Position.isIPosition(pos)) {
-      return editorService.openCodeEditor({ resource: uri }, editorService.getActiveCodeEditor()).then((editor2) => {
-        if (!editor2) {
+    if (URI.isUri(uri) && Position2.isIPosition(pos)) {
+      return editorService.openCodeEditor({ resource: uri }, editorService.getActiveCodeEditor()).then((editor) => {
+        if (!editor) {
           return;
         }
-        editor2.setPosition(pos);
-        editor2.invokeWithinContext((accessor2) => {
-          this.reportTelemetry(accessor2, editor2);
-          return this.run(accessor2, editor2);
+        editor.setPosition(pos);
+        editor.invokeWithinContext((accessor) => {
+          this.reportTelemetry(accessor, editor);
+          return this.run(accessor, editor);
         });
       }, onUnexpectedError);
     }
     return super.runCommand(accessor, args);
   }
-  run(_accessor, editor2) {
-    const controller = LinkedEditingContribution.get(editor2);
+  run(_accessor, editor) {
+    const controller = LinkedEditingContribution.get(editor);
     if (controller) {
       return Promise.resolve(controller.updateRanges(true));
     }
@@ -3360,24 +3360,24 @@ class MiddleScrollController extends Disposable {
           didScroll: false,
           dispose: () => store.dispose()
         }, undefined);
-        store.add(this._editor.onMouseUp((e2) => {
-          const session2 = scrollingSession.read(undefined);
-          if (session2 && session2.didScroll) {
+        store.add(this._editor.onMouseUp((e) => {
+          const session = scrollingSession.read(undefined);
+          if (session && session.didScroll) {
             scrollingSession.set(undefined, undefined);
           }
         }));
-        store.add(this._editor.onKeyDown((e2) => {
+        store.add(this._editor.onKeyDown((e) => {
           scrollingSession.set(undefined, undefined);
         }));
       }));
-      reader.store.add(autorun((reader2) => {
-        const session = scrollingSession.read(reader2);
+      reader.store.add(autorun((reader) => {
+        const session = scrollingSession.read(reader);
         if (!session) {
           return;
         }
         let lastTime = Date.now();
-        reader2.store.add(autorun((reader3) => {
-          AnimationFrameScheduler.instance.invalidateOnNextAnimationFrame(reader3);
+        reader.store.add(autorun((reader) => {
+          AnimationFrameScheduler.instance.invalidateOnNextAnimationFrame(reader);
           const curTime = Date.now();
           const frameDurationMs = curTime - lastTime;
           lastTime = curTime;
@@ -3390,15 +3390,15 @@ class MiddleScrollController extends Disposable {
             session.didScroll = true;
           }
         }));
-        const directionAttr = derived((reader3) => {
-          const delta = session.mouseDeltaAfterThreshold.read(reader3);
+        const directionAttr = derived((reader) => {
+          const delta = session.mouseDeltaAfterThreshold.read(reader);
           let direction = "";
           direction += delta.y < 0 ? "n" : delta.y > 0 ? "s" : "";
           direction += delta.x < 0 ? "w" : delta.x > 0 ? "e" : "";
           return direction;
         });
-        reader2.store.add(autorun((reader3) => {
-          editorDomNode.setAttribute("data-scroll-direction", directionAttr.read(reader3));
+        reader.store.add(autorun((reader) => {
+          editorDomNode.setAttribute("data-scroll-direction", directionAttr.read(reader));
         }));
       }));
       const dotDomElem = reader.store.add(n.div({
@@ -3409,8 +3409,8 @@ class MiddleScrollController extends Disposable {
         }
       }).toDisposableLiveElement());
       reader.store.add(appendRemoveOnDispose(editorDomNode, dotDomElem.element));
-      reader.store.add(autorun((reader2) => {
-        const session = scrollingSession.read(reader2);
+      reader.store.add(autorun((reader) => {
+        const session = scrollingSession.read(reader);
         editorDomNode.classList.toggle("scroll-editor-on-middle-click-editor", !!session);
       }));
     }));
@@ -3459,22 +3459,22 @@ class PlaceholderTextContribution extends Disposable {
         return;
       }
       const element = h("div.editorPlaceholder");
-      reader.store.add(autorun((reader2) => {
-        const data = this._state.read(reader2);
+      reader.store.add(autorun((reader) => {
+        const data = this._state.read(reader);
         const shouldBeVisibile = data?.placeholder !== undefined;
         element.root.style.display = shouldBeVisibile ? "block" : "none";
         element.root.innerText = data?.placeholder ?? "";
       }));
-      reader.store.add(autorun((reader2) => {
-        const info = this._editorObs.layoutInfo.read(reader2);
+      reader.store.add(autorun((reader) => {
+        const info = this._editorObs.layoutInfo.read(reader);
         element.root.style.left = `${info.contentLeft}px`;
         element.root.style.width = info.contentWidth - info.verticalScrollbarWidth + "px";
         element.root.style.top = `${this._editor.getTopForLineNumber(0)}px`;
       }));
-      reader.store.add(autorun((reader2) => {
-        element.root.style.fontFamily = this._editorObs.getOption(58).read(reader2);
-        element.root.style.fontSize = this._editorObs.getOption(61).read(reader2) + "px";
-        element.root.style.lineHeight = this._editorObs.getOption(75).read(reader2) + "px";
+      reader.store.add(autorun((reader) => {
+        element.root.style.fontFamily = this._editorObs.getOption(58).read(reader);
+        element.root.style.fontSize = this._editorObs.getOption(61).read(reader) + "px";
+        element.root.style.lineHeight = this._editorObs.getOption(75).read(reader) + "px";
       }));
       reader.store.add(this._editorObs.createOverlayWidget({
         allowEditorOverflow: false,
@@ -3521,7 +3521,7 @@ class BaseClass {
 function wrapInReloadableClass1(getClass) {
   return getClass();
 }
-var BaseClass1 = class BaseClass12 extends BaseClass {
+var BaseClass1 = class BaseClass1 extends BaseClass {
   constructor(param1, i) {
     super(i);
     this.init(param1);
@@ -3551,28 +3551,28 @@ var __param12 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var SectionHeaderDetector = class SectionHeaderDetector2 extends Disposable {
+var SectionHeaderDetector = class SectionHeaderDetector extends Disposable {
   static {
     this.ID = "editor.sectionHeaderDetector";
   }
-  constructor(editor2, languageConfigurationService, editorWorkerService) {
+  constructor(editor, languageConfigurationService, editorWorkerService) {
     super();
-    this.editor = editor2;
+    this.editor = editor;
     this.languageConfigurationService = languageConfigurationService;
     this.editorWorkerService = editorWorkerService;
     this.decorations = this.editor.createDecorationsCollection();
-    this.options = this.createOptions(editor2.getOption(81));
+    this.options = this.createOptions(editor.getOption(81));
     this.computePromise = null;
     this.currentOccurrences = {};
-    this._register(editor2.onDidChangeModel((e) => {
+    this._register(editor.onDidChangeModel((e) => {
       this.currentOccurrences = {};
-      this.options = this.createOptions(editor2.getOption(81));
+      this.options = this.createOptions(editor.getOption(81));
       this.stop();
       this.computeSectionHeaders.schedule(0);
     }));
-    this._register(editor2.onDidChangeModelLanguage((e) => {
+    this._register(editor.onDidChangeModelLanguage((e) => {
       this.currentOccurrences = {};
-      this.options = this.createOptions(editor2.getOption(81));
+      this.options = this.createOptions(editor.getOption(81));
       this.stop();
       this.computeSectionHeaders.schedule(0);
     }));
@@ -3580,16 +3580,16 @@ var SectionHeaderDetector = class SectionHeaderDetector2 extends Disposable {
       const editorLanguageId = this.editor.getModel()?.getLanguageId();
       if (editorLanguageId && e.affects(editorLanguageId)) {
         this.currentOccurrences = {};
-        this.options = this.createOptions(editor2.getOption(81));
+        this.options = this.createOptions(editor.getOption(81));
         this.stop();
         this.computeSectionHeaders.schedule(0);
       }
     }));
-    this._register(editor2.onDidChangeConfiguration((e) => {
+    this._register(editor.onDidChangeConfiguration((e) => {
       if (this.options && !e.hasChanged(81)) {
         return;
       }
-      this.options = this.createOptions(editor2.getOption(81));
+      this.options = this.createOptions(editor.getOption(81));
       this.updateDecorations([]);
       this.stop();
       this.computeSectionHeaders.schedule(0);
@@ -3597,7 +3597,7 @@ var SectionHeaderDetector = class SectionHeaderDetector2 extends Disposable {
     this._register(this.editor.onDidChangeModelContent((e) => {
       this.computeSectionHeaders.schedule();
     }));
-    this._register(editor2.onDidChangeModelTokens((e) => {
+    this._register(editor.onDidChangeModelTokens((e) => {
       if (!this.computeSectionHeaders.isScheduled()) {
         this.computeSectionHeaders.schedule(1000);
       }
@@ -3920,11 +3920,11 @@ CommandsRegistry.registerCommand("_provideDocumentRangeSemanticTokensLegend", as
   if (providers.length === 1) {
     return providers[0].getLegend();
   }
-  if (!range || !Range.isIRange(range)) {
+  if (!range || !Range2.isIRange(range)) {
     console.warn(`provideDocumentRangeSemanticTokensLegend might be out-of-sync with provideDocumentRangeSemanticTokens unless a range argument is passed in`);
     return providers[0].getLegend();
   }
-  const result = await getDocumentRangeSemanticTokens(documentRangeSemanticTokensProvider, model, Range.lift(range), CancellationToken.None);
+  const result = await getDocumentRangeSemanticTokens(documentRangeSemanticTokensProvider, model, Range2.lift(range), CancellationToken.None);
   if (!result) {
     return;
   }
@@ -3933,13 +3933,13 @@ CommandsRegistry.registerCommand("_provideDocumentRangeSemanticTokensLegend", as
 CommandsRegistry.registerCommand("_provideDocumentRangeSemanticTokens", async (accessor, ...args) => {
   const [uri, range] = args;
   assertType(uri instanceof URI);
-  assertType(Range.isIRange(range));
+  assertType(Range2.isIRange(range));
   const model = accessor.get(IModelService).getModel(uri);
   if (!model) {
     return;
   }
   const { documentRangeSemanticTokensProvider } = accessor.get(ILanguageFeaturesService);
-  const result = await getDocumentRangeSemanticTokens(documentRangeSemanticTokensProvider, model, Range.lift(range), CancellationToken.None);
+  const result = await getDocumentRangeSemanticTokens(documentRangeSemanticTokensProvider, model, Range2.lift(range), CancellationToken.None);
   if (!result || !result.tokens) {
     return;
   }
@@ -3977,7 +3977,7 @@ var __param13 = function(paramIndex, decorator) {
   };
 };
 var ModelSemanticColoring_1;
-var DocumentSemanticTokensFeature = class DocumentSemanticTokensFeature2 extends Disposable {
+var DocumentSemanticTokensFeature = class DocumentSemanticTokensFeature extends Disposable {
   constructor(semanticTokensStylingService, modelService, themeService, configurationService, languageFeatureDebounceService, languageFeaturesService) {
     super();
     this._watchers = new ResourceMap;
@@ -4061,7 +4061,7 @@ DocumentSemanticTokensFeature = __decorate13([
   __param13(4, ILanguageFeatureDebounceService),
   __param13(5, ILanguageFeaturesService)
 ], DocumentSemanticTokensFeature);
-var ModelSemanticColoring = class ModelSemanticColoring2 extends Disposable {
+var ModelSemanticColoring = class ModelSemanticColoring extends Disposable {
   static {
     ModelSemanticColoring_1 = this;
   }
@@ -4156,7 +4156,7 @@ var ModelSemanticColoring = class ModelSemanticColoring2 extends Disposable {
     if (!this._model.isAttachedToEditor()) {
       return;
     }
-    const cancellationTokenSource = new CancellationTokenSource;
+    const cancellationTokenSource = new CancellationTokenSource2;
     const lastProvider = this._currentDocumentResponse ? this._currentDocumentResponse.provider : null;
     const lastResultId = this._currentDocumentResponse ? this._currentDocumentResponse.resultId || null : null;
     const request = getDocumentSemanticTokens(this._provider, this._model, lastProvider, lastResultId, cancellationTokenSource.token);
@@ -4324,16 +4324,16 @@ var __param14 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var ViewportSemanticTokensContribution = class ViewportSemanticTokensContribution2 extends Disposable {
+var ViewportSemanticTokensContribution = class ViewportSemanticTokensContribution extends Disposable {
   static {
     this.ID = "editor.contrib.viewportSemanticTokens";
   }
-  constructor(editor2, _semanticTokensStylingService, _themeService, _configurationService, languageFeatureDebounceService, languageFeaturesService) {
+  constructor(editor, _semanticTokensStylingService, _themeService, _configurationService, languageFeatureDebounceService, languageFeaturesService) {
     super();
     this._semanticTokensStylingService = _semanticTokensStylingService;
     this._themeService = _themeService;
     this._configurationService = _configurationService;
-    this._editor = editor2;
+    this._editor = editor;
     this._provider = languageFeaturesService.documentRangeSemanticTokensProvider;
     this._debounceInformation = languageFeatureDebounceService.for(this._provider, "DocumentRangeSemanticTokens", { min: 100, max: 500 });
     this._tokenizeViewport = this._register(new RunOnceScheduler(() => this._tokenizeViewportNow(), 100));
@@ -4499,13 +4499,13 @@ class ToggleStickyScroll extends EditorAction2 {
       ]
     });
   }
-  async runEditorCommand(accessor, editor2) {
+  async runEditorCommand(accessor, editor) {
     const configurationService = accessor.get(IConfigurationService);
     const newValue = !configurationService.getValue("editor.stickyScroll.enabled");
-    const isFocused = StickyScrollController.get(editor2)?.isFocused();
+    const isFocused = StickyScrollController.get(editor)?.isFocused();
     configurationService.updateValue("editor.stickyScroll.enabled", newValue);
     if (isFocused) {
-      editor2.focus();
+      editor.focus();
     }
   }
 }
@@ -4525,8 +4525,8 @@ class FocusStickyScroll extends EditorAction2 {
       ]
     });
   }
-  runEditorCommand(_accessor, editor2) {
-    StickyScrollController.get(editor2)?.focus();
+  runEditorCommand(_accessor, editor) {
+    StickyScrollController.get(editor)?.focus();
   }
 }
 
@@ -4542,8 +4542,8 @@ class SelectNextStickyScrollLine extends EditorAction2 {
       }
     });
   }
-  runEditorCommand(_accessor, editor2) {
-    StickyScrollController.get(editor2)?.focusNext();
+  runEditorCommand(_accessor, editor) {
+    StickyScrollController.get(editor)?.focusNext();
   }
 }
 
@@ -4559,8 +4559,8 @@ class SelectPreviousStickyScrollLine extends EditorAction2 {
       }
     });
   }
-  runEditorCommand(_accessor, editor2) {
-    StickyScrollController.get(editor2)?.focusPrevious();
+  runEditorCommand(_accessor, editor) {
+    StickyScrollController.get(editor)?.focusPrevious();
   }
 }
 
@@ -4576,8 +4576,8 @@ class GoToStickyScrollLine extends EditorAction2 {
       }
     });
   }
-  runEditorCommand(_accessor, editor2) {
-    StickyScrollController.get(editor2)?.goToFocused();
+  runEditorCommand(_accessor, editor) {
+    StickyScrollController.get(editor)?.goToFocused();
   }
 }
 
@@ -4593,8 +4593,8 @@ class SelectEditor extends EditorAction2 {
       }
     });
   }
-  runEditorCommand(_accessor, editor2) {
-    StickyScrollController.get(editor2)?.selectEditor();
+  runEditorCommand(_accessor, editor) {
+    StickyScrollController.get(editor)?.selectEditor();
   }
 }
 
@@ -4630,7 +4630,7 @@ function writeIgnoreState(codeEditorService, model, state) {
 function readIgnoreState(codeEditorService, model) {
   return codeEditorService.getModelProperty(model.uri, ignoreUnusualLineTerminators);
 }
-var UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector2 extends Disposable {
+var UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector extends Disposable {
   static {
     this.ID = "editor.contrib.unusualLineTerminatorsDetector";
   }
@@ -4689,7 +4689,7 @@ var UnusualLineTerminatorsDetector = class UnusualLineTerminatorsDetector2 exten
       result = await this._dialogService.confirm({
         title: localize(1610, "Unusual Line Terminators"),
         message: localize(1611, "Detected unusual line terminators"),
-        detail: localize(1612, "The file '{0}' contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).\n\nIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`.", basename(model.uri)),
+        detail: localize(1612, "The file '{0}' contains one or more unusual line terminator characters, like Line Separator (LS) or Paragraph Separator (PS).\n\nIt is recommended to remove them from the file. This can be configured via `editor.unusualLineTerminators`.", basename2(model.uri)),
         primaryButton: localize(1613, "&&Remove Unusual Line Terminators"),
         cancelButton: localize(1614, "Ignore")
       });
@@ -4776,7 +4776,7 @@ class TextualDocumentHighlightProvider {
     return result;
   }
 }
-var TextualMultiDocumentHighlightFeature = class TextualMultiDocumentHighlightFeature2 extends Disposable {
+var TextualMultiDocumentHighlightFeature = class TextualMultiDocumentHighlightFeature extends Disposable {
   constructor(languageFeaturesService) {
     super();
     this._register(languageFeaturesService.documentHighlightProvider.register("*", new TextualDocumentHighlightProvider));
@@ -4848,7 +4848,7 @@ class OccurenceAtPositionRequest {
   _getCurrentWordRange(model, selection) {
     const word = model.getWordAtPosition(selection.getPosition());
     if (word) {
-      return new Range(selection.startLineNumber, word.startColumn, selection.startLineNumber, word.endColumn);
+      return new Range2(selection.startLineNumber, word.startColumn, selection.startLineNumber, word.endColumn);
     }
     return null;
   }
@@ -4898,7 +4898,7 @@ registerModelAndPositionCommand("_executeDocumentHighlights", async (accessor, m
   const map = await getOccurrencesAtPosition(languageFeaturesService.documentHighlightProvider, model, position, CancellationToken.None);
   return map?.get(model.uri);
 });
-var WordHighlighter = class WordHighlighter2 {
+var WordHighlighter = class WordHighlighter {
   static {
     WordHighlighter_1 = this;
   }
@@ -4908,7 +4908,7 @@ var WordHighlighter = class WordHighlighter2 {
   static {
     this.query = null;
   }
-  constructor(editor2, providers, multiProviders, contextKeyService, textModelService, codeEditorService, configurationService, logService) {
+  constructor(editor, providers, multiProviders, contextKeyService, textModelService, codeEditorService, configurationService, logService) {
     this.toUnhook = new DisposableStore;
     this.workerRequestTokenId = 0;
     this.workerRequestCompleted = false;
@@ -4916,7 +4916,7 @@ var WordHighlighter = class WordHighlighter2 {
     this.lastCursorPositionChangeTime = 0;
     this.renderDecorationsTimer = undefined;
     this.runDelayer = this.toUnhook.add(new Delayer(50));
-    this.editor = editor2;
+    this.editor = editor;
     this.providers = providers;
     this.multiDocumentProviders = multiProviders;
     this.codeEditorService = codeEditorService;
@@ -4928,7 +4928,7 @@ var WordHighlighter = class WordHighlighter2 {
     this.occurrencesHighlightEnablement = this.editor.getOption(90);
     this.occurrencesHighlightDelay = this.configurationService.getValue("editor.occurrencesHighlightDelay");
     this.model = this.editor.getModel();
-    this.toUnhook.add(editor2.onDidChangeCursorPosition((e) => {
+    this.toUnhook.add(editor.onDidChangeCursorPosition((e) => {
       if (this._ignorePositionChangeEvent) {
         return;
       }
@@ -4939,7 +4939,7 @@ var WordHighlighter = class WordHighlighter2 {
         this._onPositionChanged(e);
       }).catch(onUnexpectedError);
     }));
-    this.toUnhook.add(editor2.onDidFocusEditorText((e) => {
+    this.toUnhook.add(editor.onDidFocusEditorText((e) => {
       if (this.occurrencesHighlightEnablement === "off") {
         return;
       }
@@ -4949,19 +4949,19 @@ var WordHighlighter = class WordHighlighter2 {
         }).catch(onUnexpectedError);
       }
     }));
-    this.toUnhook.add(editor2.onDidChangeModelContent((e) => {
+    this.toUnhook.add(editor.onDidChangeModelContent((e) => {
       if (!matchesScheme(this.model.uri, "output")) {
         this._stopAll();
       }
     }));
-    this.toUnhook.add(editor2.onDidChangeModel((e) => {
+    this.toUnhook.add(editor.onDidChangeModel((e) => {
       if (!e.newModelUrl && e.oldModelUrl) {
         this._stopSingular();
       } else if (WordHighlighter_1.query) {
         this._run();
       }
     }));
-    this.toUnhook.add(editor2.onDidChangeConfiguration((e) => {
+    this.toUnhook.add(editor.onDidChangeConfiguration((e) => {
       const newEnablement = this.editor.getOption(90);
       if (this.occurrencesHighlightEnablement !== newEnablement) {
         this.occurrencesHighlightEnablement = newEnablement;
@@ -4991,7 +4991,7 @@ var WordHighlighter = class WordHighlighter2 {
         }
       }
     }));
-    this.toUnhook.add(editor2.onDidBlurEditorWidget(() => {
+    this.toUnhook.add(editor.onDidBlurEditorWidget(() => {
       const activeEditor = this.codeEditorService.getFocusedCodeEditor();
       if (!activeEditor) {
         this._stopAll();
@@ -5028,7 +5028,7 @@ var WordHighlighter = class WordHighlighter2 {
     this._stopAll();
   }
   _getSortedHighlights() {
-    return this.decorations.getRanges().sort(Range.compareRangesUsingStarts);
+    return this.decorations.getRanges().sort(Range2.compareRangesUsingStarts);
   }
   moveNext() {
     const highlights = this._getSortedHighlights();
@@ -5084,17 +5084,17 @@ var WordHighlighter = class WordHighlighter2 {
   _removeAllDecorations(preservedModel) {
     const currentEditors = this.codeEditorService.listCodeEditors();
     const deleteURI = [];
-    for (const editor2 of currentEditors) {
-      if (!editor2.hasModel() || isEqual(editor2.getModel().uri, preservedModel)) {
+    for (const editor of currentEditors) {
+      if (!editor.hasModel() || isEqual(editor.getModel().uri, preservedModel)) {
         continue;
       }
-      const currentDecorationIDs = WordHighlighter_1.storedDecorationIDs.get(editor2.getModel().uri);
+      const currentDecorationIDs = WordHighlighter_1.storedDecorationIDs.get(editor.getModel().uri);
       if (!currentDecorationIDs) {
         continue;
       }
-      editor2.removeDecorations(currentDecorationIDs);
-      deleteURI.push(editor2.getModel().uri);
-      const editorHighlighterContrib = WordHighlighterContribution.get(editor2);
+      editor.removeDecorations(currentDecorationIDs);
+      deleteURI.push(editor.getModel().uri);
+      const editorHighlighterContrib = WordHighlighterContribution.get(editor);
       if (!editorHighlighterContrib?.wordHighlighter) {
         continue;
       }
@@ -5177,23 +5177,23 @@ var WordHighlighter = class WordHighlighter2 {
     }
     const isNotebookEditor = model.uri.scheme === Schemas.vscodeNotebookCell;
     if (isNotebookEditor) {
-      const currentModels2 = [];
-      const currentEditors2 = this.codeEditorService.listCodeEditors();
-      for (const editor2 of currentEditors2) {
-        const tempModel = editor2.getModel();
+      const currentModels = [];
+      const currentEditors = this.codeEditorService.listCodeEditors();
+      for (const editor of currentEditors) {
+        const tempModel = editor.getModel();
         if (tempModel && tempModel !== model && tempModel.uri.scheme === Schemas.vscodeNotebookCell) {
-          currentModels2.push(tempModel);
+          currentModels.push(tempModel);
         }
       }
-      return currentModels2;
+      return currentModels;
     }
     const currentModels = [];
     const currentEditors = this.codeEditorService.listCodeEditors();
-    for (const editor2 of currentEditors) {
-      if (!isDiffEditor(editor2)) {
+    for (const editor of currentEditors) {
+      if (!isDiffEditor(editor)) {
         continue;
       }
-      const diffModel = editor2.getModel();
+      const diffModel = editor.getModel();
       if (!diffModel) {
         continue;
       }
@@ -5207,8 +5207,8 @@ var WordHighlighter = class WordHighlighter2 {
     if (this.occurrencesHighlightEnablement === "singleFile") {
       return [];
     }
-    for (const editor2 of currentEditors) {
-      const tempModel = editor2.getModel();
+    for (const editor of currentEditors) {
+      const tempModel = editor.getModel();
       const isValidModel = tempModel && tempModel !== model;
       if (isValidModel) {
         currentModels.push(tempModel);
@@ -5322,13 +5322,13 @@ var WordHighlighter = class WordHighlighter2 {
   renderDecorations() {
     this.renderDecorationsTimer = undefined;
     const currentEditors = this.codeEditorService.listCodeEditors();
-    for (const editor2 of currentEditors) {
-      const editorHighlighterContrib = WordHighlighterContribution.get(editor2);
+    for (const editor of currentEditors) {
+      const editorHighlighterContrib = WordHighlighterContribution.get(editor);
       if (!editorHighlighterContrib) {
         continue;
       }
       const newDecorations = [];
-      const uri = editor2.getModel()?.uri;
+      const uri = editor.getModel()?.uri;
       if (uri && this.workerRequestValue.has(uri)) {
         const oldDecorationIDs = WordHighlighter_1.storedDecorationIDs.get(uri);
         const newDocumentHighlights = this.workerRequestValue.get(uri);
@@ -5344,7 +5344,7 @@ var WordHighlighter = class WordHighlighter2 {
           }
         }
         let newDecorationIDs = [];
-        editor2.changeDecorations((changeAccessor) => {
+        editor.changeDecorations((changeAccessor) => {
           newDecorationIDs = changeAccessor.deltaDecorations(oldDecorationIDs ?? [], newDecorations);
         });
         WordHighlighter_1.storedDecorationIDs = WordHighlighter_1.storedDecorationIDs.set(uri, newDecorationIDs);
@@ -5367,25 +5367,25 @@ WordHighlighter = WordHighlighter_1 = __decorate17([
   __param17(6, IConfigurationService),
   __param17(7, ILogService)
 ], WordHighlighter);
-var WordHighlighterContribution = class WordHighlighterContribution2 extends Disposable {
+var WordHighlighterContribution = class WordHighlighterContribution extends Disposable {
   static {
     WordHighlighterContribution_1 = this;
   }
   static {
     this.ID = "editor.contrib.wordHighlighter";
   }
-  static get(editor2) {
-    return editor2.getContribution(WordHighlighterContribution_1.ID);
+  static get(editor) {
+    return editor.getContribution(WordHighlighterContribution_1.ID);
   }
-  constructor(editor2, contextKeyService, languageFeaturesService, codeEditorService, textModelService, configurationService, logService) {
+  constructor(editor, contextKeyService, languageFeaturesService, codeEditorService, textModelService, configurationService, logService) {
     super();
     this._wordHighlighter = null;
     const createWordHighlighterIfPossible = () => {
-      if (editor2.hasModel() && !editor2.getModel().isTooLargeForTokenization() && editor2.getModel().uri.scheme !== Schemas.accessibleView) {
-        this._wordHighlighter = new WordHighlighter(editor2, languageFeaturesService.documentHighlightProvider, languageFeaturesService.multiDocumentHighlightProvider, contextKeyService, textModelService, codeEditorService, configurationService, logService);
+      if (editor.hasModel() && !editor.getModel().isTooLargeForTokenization() && editor.getModel().uri.scheme !== Schemas.accessibleView) {
+        this._wordHighlighter = new WordHighlighter(editor, languageFeaturesService.documentHighlightProvider, languageFeaturesService.multiDocumentHighlightProvider, contextKeyService, textModelService, codeEditorService, configurationService, logService);
       }
     };
-    this._register(editor2.onDidChangeModel((e) => {
+    this._register(editor.onDidChangeModel((e) => {
       if (this._wordHighlighter) {
         if (!e.newModelUrl && e.oldModelUrl?.scheme !== Schemas.vscodeNotebookCell) {
           this.wordHighlighter?.stop();
@@ -5439,8 +5439,8 @@ class WordHighlightNavigationAction extends EditorAction {
     super(opts);
     this._isNext = next;
   }
-  run(accessor, editor2) {
-    const controller = WordHighlighterContribution.get(editor2);
+  run(accessor, editor) {
+    const controller = WordHighlighterContribution.get(editor);
     if (!controller) {
       return;
     }
@@ -5495,8 +5495,8 @@ class TriggerWordHighlightAction extends EditorAction {
       }
     });
   }
-  run(accessor, editor2) {
-    const controller = WordHighlighterContribution.get(editor2);
+  run(accessor, editor) {
+    const controller = WordHighlighterContribution.get(editor);
     if (!controller) {
       return;
     }
@@ -5525,7 +5525,7 @@ var __param18 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var DiffEditorBreadcrumbsSource = class DiffEditorBreadcrumbsSource2 extends Disposable {
+var DiffEditorBreadcrumbsSource = class DiffEditorBreadcrumbsSource extends Disposable {
   constructor(_textModel, _languageFeaturesService, _outlineModelService) {
     super();
     this._textModel = _textModel;
@@ -5533,7 +5533,7 @@ var DiffEditorBreadcrumbsSource = class DiffEditorBreadcrumbsSource2 extends Dis
     this._outlineModelService = _outlineModelService;
     this._currentModel = observableValue(this, undefined);
     const documentSymbolProviderChanged = observableSignalFromEvent("documentSymbolProvider.onDidChange", this._languageFeaturesService.documentSymbolProvider.onDidChange);
-    const textModelChanged = observableSignalFromEvent("_textModel.onDidChangeContent", Event.debounce((e) => this._textModel.onDidChangeContent(e), () => {
+    const textModelChanged = observableSignalFromEvent("_textModel.onDidChangeContent", Event2.debounce((e) => this._textModel.onDidChangeContent(e), () => {
       return;
     }, 100));
     this._register(autorunWithStore(async (reader, store) => {
@@ -5593,15 +5593,15 @@ var __param19 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var FloatingEditorToolbar = class FloatingEditorToolbar2 extends Disposable {
+var FloatingEditorToolbar = class FloatingEditorToolbar extends Disposable {
   static {
     this.ID = "editor.contrib.floatingToolbar";
   }
-  constructor(editor2, instantiationService, keybindingService, menuService) {
+  constructor(editor, instantiationService, keybindingService, menuService) {
     super();
-    const editorObs = this._register(observableCodeEditor(editor2));
+    const editorObs = this._register(observableCodeEditor(editor));
     const editorUriObs = derived((reader) => editorObs.model.read(reader)?.uri);
-    const widget = this._register(instantiationService.createInstance(FloatingEditorToolbarWidget, MenuId.EditorContent, editor2.contextKeyService, editorUriObs));
+    const widget = this._register(instantiationService.createInstance(FloatingEditorToolbarWidget, MenuId.EditorContent, editor.contextKeyService, editorUriObs));
     this._register(autorun((reader) => {
       const hasActions = widget.hasActions.read(reader);
       if (!hasActions) {
@@ -5623,7 +5623,7 @@ FloatingEditorToolbar = __decorate19([
   __param19(2, IKeybindingService),
   __param19(3, IMenuService)
 ], FloatingEditorToolbar);
-var FloatingEditorToolbarWidget = class FloatingEditorToolbarWidget2 extends Disposable {
+var FloatingEditorToolbarWidget = class FloatingEditorToolbarWidget extends Disposable {
   constructor(_menuId, _scopedContextKeyService, _toolbarContext, instantiationService, keybindingService, menuService) {
     super();
     const menu = this._register(menuService.createMenu(_menuId, _scopedContextKeyService));
@@ -5678,8 +5678,8 @@ var FloatingEditorToolbarWidget = class FloatingEditorToolbarWidget2 extends Dis
         }
       });
       reader.store.add(toolbar);
-      reader.store.add(autorun((reader2) => {
-        const context = _toolbarContext.read(reader2);
+      reader.store.add(autorun((reader) => {
+        const context = _toolbarContext.read(reader);
         toolbar.context = context;
       }));
     }));
@@ -5699,12 +5699,12 @@ class IPadShowKeyboard extends Disposable {
   static {
     this.ID = "editor.contrib.iPadShowKeyboard";
   }
-  constructor(editor2) {
+  constructor(editor) {
     super();
-    this.editor = editor2;
+    this.editor = editor;
     this.widget = null;
     if (isIOS) {
-      this._register(editor2.onDidChangeConfiguration(() => this.update()));
+      this._register(editor.onDidChangeConfiguration(() => this.update()));
       this.update();
     }
   }
@@ -5730,9 +5730,9 @@ class ShowKeyboardWidget extends Disposable {
   static {
     this.ID = "editor.contrib.ShowKeyboardWidget";
   }
-  constructor(editor2) {
+  constructor(editor) {
     super();
-    this.editor = editor2;
+    this.editor = editor;
     this._domNode = document.createElement("textarea");
     this._domNode.className = "iPadShowKeyboard";
     this._register(addDisposableListener(this._domNode, "touchstart", (e) => {
@@ -5778,19 +5778,19 @@ var __param20 = function(paramIndex, decorator) {
   };
 };
 var InspectTokensController_1;
-var InspectTokensController = class InspectTokensController2 extends Disposable {
+var InspectTokensController = class InspectTokensController extends Disposable {
   static {
     InspectTokensController_1 = this;
   }
   static {
     this.ID = "editor.contrib.inspectTokens";
   }
-  static get(editor2) {
-    return editor2.getContribution(InspectTokensController_1.ID);
+  static get(editor) {
+    return editor.getContribution(InspectTokensController_1.ID);
   }
-  constructor(editor2, standaloneColorService, languageService) {
+  constructor(editor, standaloneColorService, languageService) {
     super();
-    this._editor = editor2;
+    this._editor = editor;
     this._languageService = languageService;
     this._widget = null;
     this._register(this._editor.onDidChangeModel((e) => this.stop()));
@@ -5832,8 +5832,8 @@ class InspectTokens extends EditorAction {
       precondition: undefined
     });
   }
-  run(accessor, editor2) {
-    const controller = InspectTokensController.get(editor2);
+  run(accessor, editor) {
+    const controller = InspectTokensController.get(editor);
     controller?.launch();
   }
 }
@@ -5871,10 +5871,10 @@ class InspectTokensWidget extends Disposable {
   static {
     this._ID = "editor.contrib.inspectTokensWidget";
   }
-  constructor(editor2, languageService) {
+  constructor(editor, languageService) {
     super();
     this.allowEditorOverflow = true;
-    this._editor = editor2;
+    this._editor = editor;
     this._languageService = languageService;
     this._model = this._editor.getModel();
     this._domNode = document.createElement("div");
@@ -6022,7 +6022,7 @@ var __param21 = function(paramIndex, decorator) {
   };
 };
 var HelpQuickAccessProvider_1;
-var HelpQuickAccessProvider = class HelpQuickAccessProvider2 {
+var HelpQuickAccessProvider = class HelpQuickAccessProvider {
   static {
     HelpQuickAccessProvider_1 = this;
   }
@@ -6033,7 +6033,7 @@ var HelpQuickAccessProvider = class HelpQuickAccessProvider2 {
     this.quickInputService = quickInputService;
     this.keybindingService = keybindingService;
     this.contextKeyService = contextKeyService;
-    this.registry = Registry.as(Extensions.Quickaccess);
+    this.registry = Registry.as(Extensions2.Quickaccess);
   }
   provide(picker) {
     const disposables = new DisposableStore;
@@ -6077,7 +6077,7 @@ HelpQuickAccessProvider = HelpQuickAccessProvider_1 = __decorate21([
 ], HelpQuickAccessProvider);
 
 // ../../node_modules/monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneHelpQuickAccess.js
-Registry.as(Extensions.Quickaccess).registerQuickAccessProvider({
+Registry.as(Extensions2.Quickaccess).registerQuickAccessProvider({
   ctor: HelpQuickAccessProvider,
   prefix: "",
   helpEntries: [{ description: QuickHelpNLS.helpQuickAccessActionLabel }]
@@ -6096,21 +6096,21 @@ function doScoreFuzzy2Multiple(target, query, patternStart, wordStart) {
   let totalScore = 0;
   const totalMatches = [];
   for (const queryPiece of query) {
-    const [score2, matches] = doScoreFuzzy2Single(target, queryPiece, patternStart, wordStart);
-    if (typeof score2 !== "number") {
+    const [score, matches] = doScoreFuzzy2Single(target, queryPiece, patternStart, wordStart);
+    if (typeof score !== "number") {
       return NO_SCORE2;
     }
-    totalScore += score2;
+    totalScore += score;
     totalMatches.push(...matches);
   }
   return [totalScore, normalizeMatches(totalMatches)];
 }
 function doScoreFuzzy2Single(target, query, patternStart, wordStart) {
-  const score2 = fuzzyScore(query.normalized, query.normalizedLowercase, patternStart, target, target.toLowerCase(), wordStart, { firstMatchCanBeWeak: true, boostFullMatch: true });
-  if (!score2) {
+  const score = fuzzyScore(query.normalized, query.normalizedLowercase, patternStart, target, target.toLowerCase(), wordStart, { firstMatchCanBeWeak: true, boostFullMatch: true });
+  if (!score) {
     return NO_SCORE2;
   }
-  return [score2[0], createMatches(score2)];
+  return [score[0], createMatches(score)];
 }
 function normalizeMatches(matches) {
   const sortedMatches = matches.sort((matchA, matchB) => {
@@ -6211,7 +6211,7 @@ var __param22 = function(paramIndex, decorator) {
   };
 };
 var AbstractGotoSymbolQuickAccessProvider_1;
-var AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessProvider2 extends AbstractEditorNavigationQuickAccessProvider {
+var AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessProvider extends AbstractEditorNavigationQuickAccessProvider {
   static {
     AbstractGotoSymbolQuickAccessProvider_1 = this;
   }
@@ -6236,8 +6236,8 @@ var AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
     return Disposable.None;
   }
   provideWithTextEditor(context, picker, token, runOptions) {
-    const editor2 = context.editor;
-    const model = this.getModel(editor2);
+    const editor = context.editor;
+    const model = this.getModel(editor);
     if (!model) {
       return Disposable.None;
     }
@@ -6277,7 +6277,7 @@ var AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
     return symbolProviderRegistryPromise.p;
   }
   doProvideWithEditorSymbols(context, model, picker, token, runOptions) {
-    const editor2 = context.editor;
+    const editor = context.editor;
     const disposables = new DisposableStore;
     disposables.add(picker.onDidAccept((event) => {
       const [item] = picker.selectedItems;
@@ -6304,7 +6304,7 @@ var AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
     const updatePickerItems = async (positionToEnclose) => {
       picksCts?.value?.cancel();
       picker.busy = false;
-      picksCts.value = new CancellationTokenSource;
+      picksCts.value = new CancellationTokenSource2;
       picker.busy = true;
       try {
         const query = prepareQuery(picker.value.substr(AbstractGotoSymbolQuickAccessProvider_1.PREFIX.length).trim());
@@ -6315,7 +6315,7 @@ var AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
         if (items.length > 0) {
           picker.items = items;
           if (positionToEnclose && query.original.length === 0) {
-            const candidate = findLast(items, (item) => Boolean(item.type !== "separator" && item.range && Range.containsPosition(item.range.decoration, positionToEnclose)));
+            const candidate = findLast(items, (item) => Boolean(item.type !== "separator" && item.range && Range2.containsPosition(item.range.decoration, positionToEnclose)));
             if (candidate) {
               picker.activeItems = [candidate];
             }
@@ -6334,12 +6334,12 @@ var AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
       }
     };
     disposables.add(picker.onDidChangeValue(() => updatePickerItems(undefined)));
-    updatePickerItems(editor2.getSelection()?.getPosition());
+    updatePickerItems(editor.getSelection()?.getPosition());
     disposables.add(picker.onDidChangeActive(() => {
       const [item] = picker.activeItems;
       if (item && item.range) {
-        editor2.revealRangeInCenter(item.range.selection, 0);
-        this.addDecorations(editor2, item.range.decoration);
+        editor.revealRangeInCenter(item.range.selection, 0);
+        this.addDecorations(editor, item.range.decoration);
       }
     }));
     return disposables;
@@ -6424,7 +6424,7 @@ var AbstractGotoSymbolQuickAccessProvider = class AbstractGotoSymbolQuickAccessP
           description: containerMatches
         },
         range: {
-          selection: Range.collapseToStart(symbol.selectionRange),
+          selection: Range2.collapseToStart(symbol.selectionRange),
           decoration: symbol.range
         },
         uri: model.uri,
@@ -6548,11 +6548,11 @@ var __param23 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var StandaloneGotoSymbolQuickAccessProvider = class StandaloneGotoSymbolQuickAccessProvider2 extends AbstractGotoSymbolQuickAccessProvider {
+var StandaloneGotoSymbolQuickAccessProvider = class StandaloneGotoSymbolQuickAccessProvider extends AbstractGotoSymbolQuickAccessProvider {
   constructor(editorService, languageFeaturesService, outlineModelService) {
     super(languageFeaturesService, outlineModelService);
     this.editorService = editorService;
-    this.onDidActiveTextEditorControlChange = Event.None;
+    this.onDidActiveTextEditorControlChange = Event2.None;
   }
   get activeTextEditorControl() {
     return this.editorService.getFocusedCodeEditor() ?? undefined;
@@ -6590,7 +6590,7 @@ class GotoSymbolAction extends EditorAction {
   }
 }
 registerEditorAction(GotoSymbolAction);
-Registry.as(Extensions.Quickaccess).registerQuickAccessProvider({
+Registry.as(Extensions2.Quickaccess).registerQuickAccessProvider({
   ctor: StandaloneGotoSymbolQuickAccessProvider,
   prefix: AbstractGotoSymbolQuickAccessProvider.PREFIX,
   helpEntries: [
@@ -6623,9 +6623,9 @@ class TfIdfCalculator {
         return [];
       }
       for (const chunk of doc.chunks) {
-        const score2 = this.computeSimilarityScore(chunk, embedding, idfCache);
-        if (score2 > 0) {
-          scores.push({ key, score: score2 });
+        const score = this.computeSimilarityScore(chunk, embedding, idfCache);
+        if (score > 0) {
+          scores.push({ key, score });
         }
       }
     }
@@ -6728,8 +6728,8 @@ function normalizeTfIdfScores(scores) {
   result.sort((a, b) => b.score - a.score);
   const max = result[0]?.score ?? 0;
   if (max > 0) {
-    for (const score2 of result) {
-      score2.score /= max;
+    for (const score of result) {
+      score.score /= max;
     }
   }
   return result;
@@ -6737,11 +6737,11 @@ function normalizeTfIdfScores(scores) {
 
 // ../../node_modules/monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js
 var TriggerAction;
-(function(TriggerAction2) {
-  TriggerAction2[TriggerAction2["NO_ACTION"] = 0] = "NO_ACTION";
-  TriggerAction2[TriggerAction2["CLOSE_PICKER"] = 1] = "CLOSE_PICKER";
-  TriggerAction2[TriggerAction2["REFRESH_PICKER"] = 2] = "REFRESH_PICKER";
-  TriggerAction2[TriggerAction2["REMOVE_ITEM"] = 3] = "REMOVE_ITEM";
+(function(TriggerAction) {
+  TriggerAction[TriggerAction["NO_ACTION"] = 0] = "NO_ACTION";
+  TriggerAction[TriggerAction["CLOSE_PICKER"] = 1] = "CLOSE_PICKER";
+  TriggerAction[TriggerAction["REFRESH_PICKER"] = 2] = "REFRESH_PICKER";
+  TriggerAction[TriggerAction["REMOVE_ITEM"] = 3] = "REMOVE_ITEM";
 })(TriggerAction || (TriggerAction = {}));
 function isPicksWithActive(obj) {
   const candidate = obj;
@@ -6768,7 +6768,7 @@ class PickerQuickAccessProvider extends Disposable {
       picksCts?.dispose(true);
       picker.busy = false;
       const picksDisposables = picksDisposable.value = new DisposableStore;
-      picksCts = picksDisposables.add(new CancellationTokenSource(token));
+      picksCts = picksDisposables.add(new CancellationTokenSource2(token));
       const picksToken = picksCts.token;
       let picksFilter = picker.value.substring(this.prefix.length);
       if (!this.options?.shouldSkipTrimPickFilter) {
@@ -6973,7 +6973,7 @@ var __param24 = function(paramIndex, decorator) {
 };
 var AbstractCommandsQuickAccessProvider_1;
 var CommandsHistory_1;
-var AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvider2 extends PickerQuickAccessProvider {
+var AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvider extends PickerQuickAccessProvider {
   static {
     AbstractCommandsQuickAccessProvider_1 = this;
   }
@@ -7010,7 +7010,7 @@ var AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvi
         textChunks: [this.getTfIdfChunk(commandPick)]
       })));
       const result = tfidf.calculateScores(filter, token);
-      return normalizeTfIdfScores(result).filter((score2) => score2.score > AbstractCommandsQuickAccessProvider_1.TFIDF_THRESHOLD).slice(0, AbstractCommandsQuickAccessProvider_1.TFIDF_MAX_RESULTS);
+      return normalizeTfIdfScores(result).filter((score) => score.score > AbstractCommandsQuickAccessProvider_1.TFIDF_THRESHOLD).slice(0, AbstractCommandsQuickAccessProvider_1.TFIDF_MAX_RESULTS);
     });
     const filteredCommandPicks = [];
     for (const commandPick of allCommandPicks) {
@@ -7032,7 +7032,7 @@ var AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvi
         if (token.isCancellationRequested) {
           return [];
         }
-        const tfidfScore = tfidf.find((score2) => score2.key === commandPick.commandId);
+        const tfidfScore = tfidf.find((score) => score.key === commandPick.commandId);
         if (tfidfScore) {
           commandPick.tfIdfScore = tfidfScore.score;
           filteredCommandPicks.push(commandPick);
@@ -7130,11 +7130,11 @@ var AbstractCommandsQuickAccessProvider = class AbstractCommandsQuickAccessProvi
         if (token.isCancellationRequested) {
           return [];
         }
-        const commandPicks2 = additionalCommandPicks.map((commandPick) => this.toCommandPick(commandPick, runOptions));
-        if (addSuggestedSeparator && commandPicks2[0]?.type !== "separator") {
-          commandPicks2.unshift({ type: "separator", label: localize(1807, "similar commands") });
+        const commandPicks = additionalCommandPicks.map((commandPick) => this.toCommandPick(commandPick, runOptions));
+        if (addSuggestedSeparator && commandPicks[0]?.type !== "separator") {
+          commandPicks.unshift({ type: "separator", label: localize(1807, "similar commands") });
         }
-        return commandPicks2;
+        return commandPicks;
       })()
     };
   }
@@ -7205,7 +7205,7 @@ AbstractCommandsQuickAccessProvider = AbstractCommandsQuickAccessProvider_1 = __
   __param24(4, ITelemetryService),
   __param24(5, IDialogService)
 ], AbstractCommandsQuickAccessProvider);
-var CommandsHistory = class CommandsHistory2 extends Disposable {
+var CommandsHistory = class CommandsHistory extends Disposable {
   static {
     CommandsHistory_1 = this;
   }
@@ -7366,7 +7366,7 @@ var __param25 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var StandaloneCommandsQuickAccessProvider = class StandaloneCommandsQuickAccessProvider2 extends AbstractEditorCommandsQuickAccessProvider {
+var StandaloneCommandsQuickAccessProvider = class StandaloneCommandsQuickAccessProvider extends AbstractEditorCommandsQuickAccessProvider {
   get activeTextEditorControl() {
     return this.codeEditorService.getFocusedCodeEditor() ?? undefined;
   }
@@ -7419,7 +7419,7 @@ class GotoLineAction extends EditorAction {
   }
 }
 registerEditorAction(GotoLineAction);
-Registry.as(Extensions.Quickaccess).registerQuickAccessProvider({
+Registry.as(Extensions2.Quickaccess).registerQuickAccessProvider({
   ctor: StandaloneCommandsQuickAccessProvider,
   prefix: StandaloneCommandsQuickAccessProvider.PREFIX,
   helpEntries: [{ description: QuickCommandNLS.quickCommandHelp, commandId: GotoLineAction.ID }]
@@ -7441,9 +7441,9 @@ var __param26 = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var StandaloneReferencesController = class StandaloneReferencesController2 extends ReferencesController {
-  constructor(editor2, contextKeyService, editorService, notificationService, instantiationService, storageService, configurationService) {
-    super(true, editor2, contextKeyService, editorService, notificationService, instantiationService, storageService, configurationService);
+var StandaloneReferencesController = class StandaloneReferencesController extends ReferencesController {
+  constructor(editor, contextKeyService, editorService, notificationService, instantiationService, storageService, configurationService) {
+    super(true, editor, contextKeyService, editorService, notificationService, instantiationService, storageService, configurationService);
   }
 };
 StandaloneReferencesController = __decorate26([
@@ -7467,7 +7467,7 @@ class ToggleHighContrast extends EditorAction {
     });
     this._originalThemeName = null;
   }
-  run(accessor, editor2) {
+  run(accessor, editor) {
     const standaloneThemeService = accessor.get(IStandaloneThemeService);
     const currentTheme = standaloneThemeService.getColorTheme();
     if (isHighContrast(currentTheme.type)) {
@@ -7534,7 +7534,7 @@ function createWebWorker(opts) {
     w.postMessage(opts.createData);
     return w;
   });
-  return editor.createWebWorker({
+  return editor2.createWebWorker({
     worker,
     host: opts.host,
     keepIdleModels: opts.keepIdleModels
@@ -7543,5 +7543,5 @@ function createWebWorker(opts) {
 
 export { createWebWorker };
 
-//# debugId=2EE01D553D5D47C264756E2164756E21
-//# sourceMappingURL=studio-685s0ytq.js.map
+//# debugId=D8DDF918ED1620D364756E2164756E21
+//# sourceMappingURL=studio-nqgawfks.js.map