monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/cssMode.js

@@ -0,0 +1,198 @@
+import { WorkerManager } from './workerManager.js';
+import { CompletionAdapter, HoverAdapter, DocumentHighlightAdapter, DefinitionAdapter, ReferenceAdapter, DocumentSymbolAdapter, RenameAdapter, DocumentColorAdapter, FoldingRangeAdapter, DiagnosticsAdapter, SelectionRangeAdapter, DocumentFormattingEditProvider, DocumentRangeFormattingEditProvider } from '../common/lspLanguageFeatures.js';
+export { DocumentLinkAdapter, fromPosition, fromRange, toRange, toTextEdit } from '../common/lspLanguageFeatures.js';
+import '../../editor/browser/coreCommands.js';
+import '../../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import '../../editor/browser/widget/diffEditor/diffEditor.contribution.js';
+import '../../editor/contrib/anchorSelect/browser/anchorSelect.js';
+import '../../editor/contrib/bracketMatching/browser/bracketMatching.js';
+import '../../editor/contrib/caretOperations/browser/caretOperations.js';
+import '../../editor/contrib/caretOperations/browser/transpose.js';
+import '../../editor/contrib/clipboard/browser/clipboard.js';
+import '../../editor/contrib/codeAction/browser/codeActionContributions.js';
+import '../../editor/contrib/codelens/browser/codelensController.js';
+import '../../editor/contrib/colorPicker/browser/colorPickerContribution.js';
+import '../../editor/contrib/comment/browser/comment.js';
+import '../../editor/contrib/contextmenu/browser/contextmenu.js';
+import '../../editor/contrib/cursorUndo/browser/cursorUndo.js';
+import '../../editor/contrib/dnd/browser/dnd.js';
+import '../../editor/contrib/dropOrPasteInto/browser/copyPasteContribution.js';
+import '../../editor/contrib/dropOrPasteInto/browser/dropIntoEditorContribution.js';
+import '../../editor/contrib/find/browser/findController.js';
+import '../../editor/contrib/folding/browser/folding.js';
+import '../../editor/contrib/fontZoom/browser/fontZoom.js';
+import '../../editor/contrib/format/browser/formatActions.js';
+import '../../editor/contrib/documentSymbols/browser/documentSymbols.js';
+import '../../editor/contrib/inlineCompletions/browser/inlineCompletions.contribution.js';
+import '../../editor/contrib/inlineProgress/browser/inlineProgress.js';
+import '../../editor/contrib/gotoSymbol/browser/goToCommands.js';
+import '../../editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.js';
+import '../../editor/contrib/gotoError/browser/gotoError.js';
+import '../../editor/contrib/gpu/browser/gpuActions.js';
+import '../../editor/contrib/hover/browser/hoverContribution.js';
+import '../../editor/contrib/indentation/browser/indentation.js';
+import '../../editor/contrib/inlayHints/browser/inlayHintsContribution.js';
+import '../../editor/contrib/inPlaceReplace/browser/inPlaceReplace.js';
+import '../../editor/contrib/insertFinalNewLine/browser/insertFinalNewLine.js';
+import '../../editor/contrib/lineSelection/browser/lineSelection.js';
+import '../../editor/contrib/linesOperations/browser/linesOperations.js';
+import '../../editor/contrib/linkedEditing/browser/linkedEditing.js';
+import '../../editor/contrib/links/browser/links.js';
+import '../../editor/contrib/longLinesHelper/browser/longLinesHelper.js';
+import '../../editor/contrib/middleScroll/browser/middleScroll.contribution.js';
+import '../../editor/contrib/multicursor/browser/multicursor.js';
+import '../../editor/contrib/parameterHints/browser/parameterHints.js';
+import '../../editor/contrib/placeholderText/browser/placeholderText.contribution.js';
+import '../../editor/contrib/rename/browser/rename.js';
+import '../../editor/contrib/sectionHeaders/browser/sectionHeaders.js';
+import '../../editor/contrib/semanticTokens/browser/documentSemanticTokens.js';
+import '../../editor/contrib/semanticTokens/browser/viewportSemanticTokens.js';
+import '../../editor/contrib/smartSelect/browser/smartSelect.js';
+import '../../editor/contrib/snippet/browser/snippetController2.js';
+import '../../editor/contrib/stickyScroll/browser/stickyScrollContribution.js';
+import '../../editor/contrib/suggest/browser/suggestController.js';
+import '../../editor/contrib/suggest/browser/suggestInlineCompletions.js';
+import '../../editor/contrib/tokenization/browser/tokenization.js';
+import '../../editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+import '../../editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.js';
+import '../../editor/contrib/unusualLineTerminators/browser/unusualLineTerminators.js';
+import '../../editor/contrib/wordHighlighter/browser/wordHighlighter.js';
+import '../../editor/contrib/wordOperations/browser/wordOperations.js';
+import '../../editor/contrib/wordPartOperations/browser/wordPartOperations.js';
+import '../../editor/contrib/readOnlyMessage/browser/contribution.js';
+import '../../editor/contrib/diffEditorBreadcrumbs/browser/contribution.js';
+import '../../editor/contrib/floatingMenu/browser/floatingMenu.contribution.js';
+import '../../editor/common/standaloneStrings.js';
+import '../../base/browser/ui/codicons/codicon/codicon.css';
+import '../../base/browser/ui/codicons/codicon/codicon-modifiers.css';
+import '../../editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.js';
+import '../../editor/standalone/browser/inspectTokens/inspectTokens.js';
+import '../../editor/standalone/browser/quickAccess/standaloneHelpQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneGotoLineQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneGotoSymbolQuickAccess.js';
+import '../../editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
+import '../../editor/standalone/browser/referenceSearch/standaloneReferenceSearch.js';
+import '../../editor/standalone/browser/toggleHighContrast/toggleHighContrast.js';
+import { languages } from '../../editor/editor.api2.js';
+
+function setupMode(defaults) {
+  const disposables = [];
+  const providers = [];
+  const client = new WorkerManager(defaults);
+  disposables.push(client);
+  const worker = (...uris) => {
+    return client.getLanguageServiceWorker(...uris);
+  };
+  function registerProviders() {
+    const { languageId, modeConfiguration } = defaults;
+    disposeAll(providers);
+    if (modeConfiguration.completionItems) {
+      providers.push(
+        languages.registerCompletionItemProvider(
+          languageId,
+          new CompletionAdapter(worker, ["/", "-", ":"])
+        )
+      );
+    }
+    if (modeConfiguration.hovers) {
+      providers.push(
+        languages.registerHoverProvider(languageId, new HoverAdapter(worker))
+      );
+    }
+    if (modeConfiguration.documentHighlights) {
+      providers.push(
+        languages.registerDocumentHighlightProvider(
+          languageId,
+          new DocumentHighlightAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.definitions) {
+      providers.push(
+        languages.registerDefinitionProvider(
+          languageId,
+          new DefinitionAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.references) {
+      providers.push(
+        languages.registerReferenceProvider(
+          languageId,
+          new ReferenceAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.documentSymbols) {
+      providers.push(
+        languages.registerDocumentSymbolProvider(
+          languageId,
+          new DocumentSymbolAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.rename) {
+      providers.push(
+        languages.registerRenameProvider(languageId, new RenameAdapter(worker))
+      );
+    }
+    if (modeConfiguration.colors) {
+      providers.push(
+        languages.registerColorProvider(
+          languageId,
+          new DocumentColorAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.foldingRanges) {
+      providers.push(
+        languages.registerFoldingRangeProvider(
+          languageId,
+          new FoldingRangeAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.diagnostics) {
+      providers.push(
+        new DiagnosticsAdapter(languageId, worker, defaults.onDidChange)
+      );
+    }
+    if (modeConfiguration.selectionRanges) {
+      providers.push(
+        languages.registerSelectionRangeProvider(
+          languageId,
+          new SelectionRangeAdapter(worker)
+        )
+      );
+    }
+    if (modeConfiguration.documentFormattingEdits) {
+      providers.push(
+        languages.registerDocumentFormattingEditProvider(
+          languageId,
+          new DocumentFormattingEditProvider(worker)
+        )
+      );
+    }
+    if (modeConfiguration.documentRangeFormattingEdits) {
+      providers.push(
+        languages.registerDocumentRangeFormattingEditProvider(
+          languageId,
+          new DocumentRangeFormattingEditProvider(worker)
+        )
+      );
+    }
+  }
+  registerProviders();
+  disposables.push(asDisposable(providers));
+  return asDisposable(disposables);
+}
+function asDisposable(disposables) {
+  return { dispose: () => disposeAll(disposables) };
+}
+function disposeAll(disposables) {
+  while (disposables.length) {
+    disposables.pop().dispose();
+  }
+}
+
+export { CompletionAdapter, DefinitionAdapter, DiagnosticsAdapter, DocumentColorAdapter, DocumentFormattingEditProvider, DocumentHighlightAdapter, DocumentRangeFormattingEditProvider, DocumentSymbolAdapter, FoldingRangeAdapter, HoverAdapter, ReferenceAdapter, RenameAdapter, SelectionRangeAdapter, WorkerManager, setupMode };

package/dist/workers/cssValue.js

@@ -0,0 +1,69 @@
+import { FileAccess } from '../common/network.js';
+
+function asFragment(raw) {
+    return raw;
+}
+function asCssValueWithDefault(cssPropertyValue, dflt) {
+    if (cssPropertyValue !== undefined) {
+        const variableMatch = cssPropertyValue.match(/^\s*var\((.+)\)$/);
+        if (variableMatch) {
+            const varArguments = variableMatch[1].split(',', 2);
+            if (varArguments.length === 2) {
+                dflt = asCssValueWithDefault(varArguments[1].trim(), dflt);
+            }
+            return `var(${varArguments[0]}, ${dflt})`;
+        }
+        return cssPropertyValue;
+    }
+    return dflt;
+}
+function identValue(value) {
+    const out = value.replaceAll(/[^_\-a-z0-9]/gi, '');
+    if (out !== value) {
+        console.warn(`CSS ident value ${value} modified to ${out} to be safe for CSS`);
+    }
+    return asFragment(out);
+}
+function stringValue(value) {
+    return asFragment(`'${value.replaceAll(/'/g, '\\000027')}'`);
+}
+/**
+ * returns url('...')
+ */
+function asCSSUrl(uri) {
+    if (!uri) {
+        return asFragment(`url('')`);
+    }
+    return inline `url('${asFragment(CSS.escape(FileAccess.uriToBrowserUri(uri).toString(true)))}')`;
+}
+function className(value, escapingExpected = false) {
+    const out = CSS.escape(value);
+    if (!escapingExpected && out !== value) {
+        console.warn(`CSS class name ${value} modified to ${out} to be safe for CSS`);
+    }
+    return asFragment(out);
+}
+/**
+ * Template string tag that that constructs a CSS fragment.
+ *
+ * All expressions in the template must be css safe values.
+ */
+function inline(strings, ...values) {
+    return asFragment(strings.reduce((result, str, i) => {
+        const value = values[i] || '';
+        return result + str + value;
+    }, ''));
+}
+class Builder {
+    constructor() {
+        this._parts = [];
+    }
+    push(...parts) {
+        this._parts.push(...parts);
+    }
+    join(joiner = '\n') {
+        return asFragment(this._parts.join(joiner));
+    }
+}
+
+export { Builder, asCSSUrl, asCssValueWithDefault, className, identValue, inline, stringValue };

package/dist/workers/cssWorker.js

@@ -0,0 +1,183 @@
+import { newCSSDataProvider, getSCSSLanguageService, getLESSLanguageService, getCSSLanguageService } from '../../../external/vscode-css-languageservice/lib/esm/cssLanguageService.js';
+import { TextDocument } from '../../../external/vscode-languageserver-textdocument/lib/esm/main.js';
+
+class CSSWorker {
+  constructor(ctx, createData) {
+    this._ctx = ctx;
+    this._languageSettings = createData.options;
+    this._languageId = createData.languageId;
+    const data = createData.options.data;
+    const useDefaultDataProvider = data?.useDefaultDataProvider;
+    const customDataProviders = [];
+    if (data?.dataProviders) {
+      for (const id in data.dataProviders) {
+        customDataProviders.push(newCSSDataProvider(data.dataProviders[id]));
+      }
+    }
+    const lsOptions = {
+      customDataProviders,
+      useDefaultDataProvider
+    };
+    switch (this._languageId) {
+      case "css":
+        this._languageService = getCSSLanguageService(lsOptions);
+        break;
+      case "less":
+        this._languageService = getLESSLanguageService(lsOptions);
+        break;
+      case "scss":
+        this._languageService = getSCSSLanguageService(lsOptions);
+        break;
+      default:
+        throw new Error("Invalid language id: " + this._languageId);
+    }
+    this._languageService.configure(this._languageSettings);
+  }
+  // --- language service host ---------------
+  async doValidation(uri) {
+    const document = this._getTextDocument(uri);
+    if (document) {
+      const stylesheet = this._languageService.parseStylesheet(document);
+      const diagnostics = this._languageService.doValidation(document, stylesheet);
+      return Promise.resolve(diagnostics);
+    }
+    return Promise.resolve([]);
+  }
+  async doComplete(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const completions = this._languageService.doComplete(document, position, stylesheet);
+    return Promise.resolve(completions);
+  }
+  async doHover(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const hover = this._languageService.doHover(document, position, stylesheet);
+    return Promise.resolve(hover);
+  }
+  async findDefinition(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const definition = this._languageService.findDefinition(document, position, stylesheet);
+    return Promise.resolve(definition);
+  }
+  async findReferences(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const references = this._languageService.findReferences(document, position, stylesheet);
+    return Promise.resolve(references);
+  }
+  async findDocumentHighlights(uri, position) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const highlights = this._languageService.findDocumentHighlights(document, position, stylesheet);
+    return Promise.resolve(highlights);
+  }
+  async findDocumentSymbols(uri) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const symbols = this._languageService.findDocumentSymbols(document, stylesheet);
+    return Promise.resolve(symbols);
+  }
+  async doCodeActions(uri, range, context) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const actions = this._languageService.doCodeActions(document, range, context, stylesheet);
+    return Promise.resolve(actions);
+  }
+  async findDocumentColors(uri) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const colorSymbols = this._languageService.findDocumentColors(document, stylesheet);
+    return Promise.resolve(colorSymbols);
+  }
+  async getColorPresentations(uri, color, range) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const colorPresentations = this._languageService.getColorPresentations(
+      document,
+      stylesheet,
+      color,
+      range
+    );
+    return Promise.resolve(colorPresentations);
+  }
+  async getFoldingRanges(uri, context) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const ranges = this._languageService.getFoldingRanges(document, context);
+    return Promise.resolve(ranges);
+  }
+  async getSelectionRanges(uri, positions) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const ranges = this._languageService.getSelectionRanges(document, positions, stylesheet);
+    return Promise.resolve(ranges);
+  }
+  async doRename(uri, position, newName) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return null;
+    }
+    const stylesheet = this._languageService.parseStylesheet(document);
+    const renames = this._languageService.doRename(document, position, newName, stylesheet);
+    return Promise.resolve(renames);
+  }
+  async format(uri, range, options) {
+    const document = this._getTextDocument(uri);
+    if (!document) {
+      return [];
+    }
+    const settings = { ...this._languageSettings.format, ...options };
+    const textEdits = this._languageService.format(document, range, settings);
+    return Promise.resolve(textEdits);
+  }
+  _getTextDocument(uri) {
+    const models = this._ctx.getMirrorModels();
+    for (const model of models) {
+      if (model.uri.toString() === uri) {
+        return TextDocument.create(
+          uri,
+          this._languageId,
+          model.version,
+          model.getValue()
+        );
+      }
+    }
+    return null;
+  }
+}
+
+export { CSSWorker };

package/dist/workers/currentLineHighlight.js

@@ -0,0 +1,205 @@
+import './currentLineHighlight.css';
+import { DynamicViewOverlay } from '../../view/dynamicViewOverlay.js';
+import { editorLineHighlight, editorLineHighlightBorder } from '../../../common/core/editorColorRegistry.js';
+import { equals } from '../../../../base/common/arrays.js';
+import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
+import { Selection } from '../../../common/core/selection.js';
+import { isHighContrast } from '../../../../platform/theme/common/theme.js';
+import { Position } from '../../../common/core/position.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class AbstractLineHighlightOverlay extends DynamicViewOverlay {
+    constructor(context) {
+        super();
+        this._context = context;
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        this._renderLineHighlight = options.get(110 /* EditorOption.renderLineHighlight */);
+        this._renderLineHighlightOnlyWhenFocus = options.get(111 /* EditorOption.renderLineHighlightOnlyWhenFocus */);
+        this._wordWrap = layoutInfo.isViewportWrapping;
+        this._contentLeft = layoutInfo.contentLeft;
+        this._contentWidth = layoutInfo.contentWidth;
+        this._selectionIsEmpty = true;
+        this._focused = false;
+        this._cursorLineNumbers = [1];
+        this._selections = [new Selection(1, 1, 1, 1)];
+        this._renderData = null;
+        this._context.addEventHandler(this);
+    }
+    dispose() {
+        this._context.removeEventHandler(this);
+        super.dispose();
+    }
+    _readFromSelections() {
+        let hasChanged = false;
+        const lineNumbers = new Set();
+        for (const selection of this._selections) {
+            lineNumbers.add(selection.positionLineNumber);
+        }
+        const cursorsLineNumbers = Array.from(lineNumbers);
+        cursorsLineNumbers.sort((a, b) => a - b);
+        if (!equals(this._cursorLineNumbers, cursorsLineNumbers)) {
+            this._cursorLineNumbers = cursorsLineNumbers;
+            hasChanged = true;
+        }
+        const selectionIsEmpty = this._selections.every(s => s.isEmpty());
+        if (this._selectionIsEmpty !== selectionIsEmpty) {
+            this._selectionIsEmpty = selectionIsEmpty;
+            hasChanged = true;
+        }
+        return hasChanged;
+    }
+    // --- begin event handlers
+    onThemeChanged(e) {
+        return this._readFromSelections();
+    }
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        this._renderLineHighlight = options.get(110 /* EditorOption.renderLineHighlight */);
+        this._renderLineHighlightOnlyWhenFocus = options.get(111 /* EditorOption.renderLineHighlightOnlyWhenFocus */);
+        this._wordWrap = layoutInfo.isViewportWrapping;
+        this._contentLeft = layoutInfo.contentLeft;
+        this._contentWidth = layoutInfo.contentWidth;
+        return true;
+    }
+    onCursorStateChanged(e) {
+        this._selections = e.selections;
+        return this._readFromSelections();
+    }
+    onFlushed(e) {
+        return true;
+    }
+    onLinesDeleted(e) {
+        return true;
+    }
+    onLinesInserted(e) {
+        return true;
+    }
+    onScrollChanged(e) {
+        return e.scrollWidthChanged || e.scrollTopChanged;
+    }
+    onZonesChanged(e) {
+        return true;
+    }
+    onFocusChanged(e) {
+        if (!this._renderLineHighlightOnlyWhenFocus) {
+            return false;
+        }
+        this._focused = e.isFocused;
+        return true;
+    }
+    // --- end event handlers
+    prepareRender(ctx) {
+        if (!this._shouldRenderThis()) {
+            this._renderData = null;
+            return;
+        }
+        const visibleStartLineNumber = ctx.visibleRange.startLineNumber;
+        const visibleEndLineNumber = ctx.visibleRange.endLineNumber;
+        // initialize renderData
+        const renderData = [];
+        for (let lineNumber = visibleStartLineNumber; lineNumber <= visibleEndLineNumber; lineNumber++) {
+            const lineIndex = lineNumber - visibleStartLineNumber;
+            renderData[lineIndex] = '';
+        }
+        if (this._wordWrap) {
+            // do a first pass to render wrapped lines
+            const renderedLineWrapped = this._renderOne(ctx, false);
+            for (const cursorLineNumber of this._cursorLineNumbers) {
+                const coordinatesConverter = this._context.viewModel.coordinatesConverter;
+                const modelLineNumber = coordinatesConverter.convertViewPositionToModelPosition(new Position(cursorLineNumber, 1)).lineNumber;
+                const firstViewLineNumber = coordinatesConverter.convertModelPositionToViewPosition(new Position(modelLineNumber, 1)).lineNumber;
+                const lastViewLineNumber = coordinatesConverter.convertModelPositionToViewPosition(new Position(modelLineNumber, this._context.viewModel.model.getLineMaxColumn(modelLineNumber))).lineNumber;
+                const firstLine = Math.max(firstViewLineNumber, visibleStartLineNumber);
+                const lastLine = Math.min(lastViewLineNumber, visibleEndLineNumber);
+                for (let lineNumber = firstLine; lineNumber <= lastLine; lineNumber++) {
+                    const lineIndex = lineNumber - visibleStartLineNumber;
+                    renderData[lineIndex] = renderedLineWrapped;
+                }
+            }
+        }
+        // do a second pass to render exact lines
+        const renderedLineExact = this._renderOne(ctx, true);
+        for (const cursorLineNumber of this._cursorLineNumbers) {
+            if (cursorLineNumber < visibleStartLineNumber || cursorLineNumber > visibleEndLineNumber) {
+                continue;
+            }
+            const lineIndex = cursorLineNumber - visibleStartLineNumber;
+            renderData[lineIndex] = renderedLineExact;
+        }
+        this._renderData = renderData;
+    }
+    render(startLineNumber, lineNumber) {
+        if (!this._renderData) {
+            return '';
+        }
+        const lineIndex = lineNumber - startLineNumber;
+        if (lineIndex >= this._renderData.length) {
+            return '';
+        }
+        return this._renderData[lineIndex];
+    }
+    _shouldRenderInMargin() {
+        return ((this._renderLineHighlight === 'gutter' || this._renderLineHighlight === 'all')
+            && (!this._renderLineHighlightOnlyWhenFocus || this._focused));
+    }
+    _shouldRenderInContent() {
+        return ((this._renderLineHighlight === 'line' || this._renderLineHighlight === 'all')
+            && this._selectionIsEmpty
+            && (!this._renderLineHighlightOnlyWhenFocus || this._focused));
+    }
+}
+/**
+ * Emphasizes the current line by drawing a border around it.
+ */
+class CurrentLineHighlightOverlay extends AbstractLineHighlightOverlay {
+    _renderOne(ctx, exact) {
+        const className = 'current-line' + (this._shouldRenderInMargin() ? ' current-line-both' : '') + (exact ? ' current-line-exact' : '');
+        return `<div class="${className}" style="width:${Math.max(ctx.scrollWidth, this._contentWidth)}px;"></div>`;
+    }
+    _shouldRenderThis() {
+        return this._shouldRenderInContent();
+    }
+    _shouldRenderOther() {
+        return this._shouldRenderInMargin();
+    }
+}
+/**
+ * Emphasizes the current line margin/gutter by drawing a border around it.
+ */
+class CurrentLineMarginHighlightOverlay extends AbstractLineHighlightOverlay {
+    _renderOne(ctx, exact) {
+        const className = 'current-line' + (this._shouldRenderInMargin() ? ' current-line-margin' : '') + (this._shouldRenderOther() ? ' current-line-margin-both' : '') + (this._shouldRenderInMargin() && exact ? ' current-line-exact-margin' : '');
+        return `<div class="${className}" style="width:${this._contentLeft}px"></div>`;
+    }
+    _shouldRenderThis() {
+        return true;
+    }
+    _shouldRenderOther() {
+        return this._shouldRenderInContent();
+    }
+}
+registerThemingParticipant((theme, collector) => {
+    const lineHighlight = theme.getColor(editorLineHighlight);
+    if (lineHighlight) {
+        collector.addRule(`.monaco-editor .view-overlays .current-line { background-color: ${lineHighlight}; }`);
+        collector.addRule(`.monaco-editor .margin-view-overlays .current-line-margin { background-color: ${lineHighlight}; border: none; }`);
+    }
+    if (!lineHighlight || lineHighlight.isTransparent() || theme.defines(editorLineHighlightBorder)) {
+        const lineHighlightBorder = theme.getColor(editorLineHighlightBorder);
+        if (lineHighlightBorder) {
+            collector.addRule(`.monaco-editor .view-overlays .current-line-exact { border: 2px solid ${lineHighlightBorder}; }`);
+            collector.addRule(`.monaco-editor .margin-view-overlays .current-line-exact-margin { border: 2px solid ${lineHighlightBorder}; }`);
+            if (isHighContrast(theme.type)) {
+                collector.addRule(`.monaco-editor .view-overlays .current-line-exact { border-width: 1px; }`);
+                collector.addRule(`.monaco-editor .margin-view-overlays .current-line-exact-margin { border-width: 1px; }`);
+            }
+        }
+    }
+});
+
+export { AbstractLineHighlightOverlay, CurrentLineHighlightOverlay, CurrentLineMarginHighlightOverlay };