@umbraco-cms/backoffice 16.1.0 → 16.2.0-rc

package/dist-cms/monaco-editor/vs/editor/common/config/editorZoom.js

@@ -1,23 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { Emitter } from '../../../base/common/event.js';
-export const EditorZoom = new class {
-    constructor() {
-        this._zoomLevel = 0;
-        this._onDidChangeZoomLevel = new Emitter();
-        this.onDidChangeZoomLevel = this._onDidChangeZoomLevel.event;
-    }
-    getZoomLevel() {
-        return this._zoomLevel;
-    }
-    setZoomLevel(zoomLevel) {
-        zoomLevel = Math.min(Math.max(-5, zoomLevel), 20);
-        if (this._zoomLevel === zoomLevel) {
-            return;
-        }
-        this._zoomLevel = zoomLevel;
-        this._onDidChangeZoomLevel.fire(this._zoomLevel);
-    }
-};

package/dist-cms/monaco-editor/vs/editor/common/config/fontInfo.js

@@ -1,153 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import * as platform from '../../../base/common/platform.js';
-import { EditorFontVariations, EDITOR_FONT_DEFAULTS } from './editorOptions.js';
-import { EditorZoom } from './editorZoom.js';
-/**
- * Determined from empirical observations.
- * @internal
- */
-const GOLDEN_LINE_HEIGHT_RATIO = platform.isMacintosh ? 1.5 : 1.35;
-/**
- * @internal
- */
-const MINIMUM_LINE_HEIGHT = 8;
-export class BareFontInfo {
-    /**
-     * @internal
-     */
-    static createFromValidatedSettings(options, pixelRatio, ignoreEditorZoom) {
-        const fontFamily = options.get(49 /* EditorOption.fontFamily */);
-        const fontWeight = options.get(53 /* EditorOption.fontWeight */);
-        const fontSize = options.get(52 /* EditorOption.fontSize */);
-        const fontFeatureSettings = options.get(51 /* EditorOption.fontLigatures */);
-        const fontVariationSettings = options.get(54 /* EditorOption.fontVariations */);
-        const lineHeight = options.get(67 /* EditorOption.lineHeight */);
-        const letterSpacing = options.get(64 /* EditorOption.letterSpacing */);
-        return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
-    }
-    /**
-     * @internal
-     */
-    static _create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom) {
-        if (lineHeight === 0) {
-            lineHeight = GOLDEN_LINE_HEIGHT_RATIO * fontSize;
-        }
-        else if (lineHeight < MINIMUM_LINE_HEIGHT) {
-            // Values too small to be line heights in pixels are in ems.
-            lineHeight = lineHeight * fontSize;
-        }
-        // Enforce integer, minimum constraints
-        lineHeight = Math.round(lineHeight);
-        if (lineHeight < MINIMUM_LINE_HEIGHT) {
-            lineHeight = MINIMUM_LINE_HEIGHT;
-        }
-        const editorZoomLevelMultiplier = 1 + (ignoreEditorZoom ? 0 : EditorZoom.getZoomLevel() * 0.1);
-        fontSize *= editorZoomLevelMultiplier;
-        lineHeight *= editorZoomLevelMultiplier;
-        if (fontVariationSettings === EditorFontVariations.TRANSLATE) {
-            if (fontWeight === 'normal' || fontWeight === 'bold') {
-                fontVariationSettings = EditorFontVariations.OFF;
-            }
-            else {
-                const fontWeightAsNumber = parseInt(fontWeight, 10);
-                fontVariationSettings = `'wght' ${fontWeightAsNumber}`;
-                fontWeight = 'normal';
-            }
-        }
-        return new BareFontInfo({
-            pixelRatio: pixelRatio,
-            fontFamily: fontFamily,
-            fontWeight: fontWeight,
-            fontSize: fontSize,
-            fontFeatureSettings: fontFeatureSettings,
-            fontVariationSettings,
-            lineHeight: lineHeight,
-            letterSpacing: letterSpacing
-        });
-    }
-    /**
-     * @internal
-     */
-    constructor(opts) {
-        this._bareFontInfoBrand = undefined;
-        this.pixelRatio = opts.pixelRatio;
-        this.fontFamily = String(opts.fontFamily);
-        this.fontWeight = String(opts.fontWeight);
-        this.fontSize = opts.fontSize;
-        this.fontFeatureSettings = opts.fontFeatureSettings;
-        this.fontVariationSettings = opts.fontVariationSettings;
-        this.lineHeight = opts.lineHeight | 0;
-        this.letterSpacing = opts.letterSpacing;
-    }
-    /**
-     * @internal
-     */
-    getId() {
-        return `${this.pixelRatio}-${this.fontFamily}-${this.fontWeight}-${this.fontSize}-${this.fontFeatureSettings}-${this.fontVariationSettings}-${this.lineHeight}-${this.letterSpacing}`;
-    }
-    /**
-     * @internal
-     */
-    getMassagedFontFamily() {
-        const fallbackFontFamily = EDITOR_FONT_DEFAULTS.fontFamily;
-        const fontFamily = BareFontInfo._wrapInQuotes(this.fontFamily);
-        if (fallbackFontFamily && this.fontFamily !== fallbackFontFamily) {
-            return `${fontFamily}, ${fallbackFontFamily}`;
-        }
-        return fontFamily;
-    }
-    static _wrapInQuotes(fontFamily) {
-        if (/[,"']/.test(fontFamily)) {
-            // Looks like the font family might be already escaped
-            return fontFamily;
-        }
-        if (/[+ ]/.test(fontFamily)) {
-            // Wrap a font family using + or <space> with quotes
-            return `"${fontFamily}"`;
-        }
-        return fontFamily;
-    }
-}
-// change this whenever `FontInfo` members are changed
-export const SERIALIZED_FONT_INFO_VERSION = 2;
-export class FontInfo extends BareFontInfo {
-    /**
-     * @internal
-     */
-    constructor(opts, isTrusted) {
-        super(opts);
-        this._editorStylingBrand = undefined;
-        this.version = SERIALIZED_FONT_INFO_VERSION;
-        this.isTrusted = isTrusted;
-        this.isMonospace = opts.isMonospace;
-        this.typicalHalfwidthCharacterWidth = opts.typicalHalfwidthCharacterWidth;
-        this.typicalFullwidthCharacterWidth = opts.typicalFullwidthCharacterWidth;
-        this.canUseHalfwidthRightwardsArrow = opts.canUseHalfwidthRightwardsArrow;
-        this.spaceWidth = opts.spaceWidth;
-        this.middotWidth = opts.middotWidth;
-        this.wsmiddotWidth = opts.wsmiddotWidth;
-        this.maxDigitWidth = opts.maxDigitWidth;
-    }
-    /**
-     * @internal
-     */
-    equals(other) {
-        return (this.fontFamily === other.fontFamily
-            && this.fontWeight === other.fontWeight
-            && this.fontSize === other.fontSize
-            && this.fontFeatureSettings === other.fontFeatureSettings
-            && this.fontVariationSettings === other.fontVariationSettings
-            && this.lineHeight === other.lineHeight
-            && this.letterSpacing === other.letterSpacing
-            && this.typicalHalfwidthCharacterWidth === other.typicalHalfwidthCharacterWidth
-            && this.typicalFullwidthCharacterWidth === other.typicalFullwidthCharacterWidth
-            && this.canUseHalfwidthRightwardsArrow === other.canUseHalfwidthRightwardsArrow
-            && this.spaceWidth === other.spaceWidth
-            && this.middotWidth === other.middotWidth
-            && this.wsmiddotWidth === other.wsmiddotWidth
-            && this.maxDigitWidth === other.maxDigitWidth);
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/core/characterClassifier.js

@@ -1,56 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { toUint8 } from '../../../base/common/uint.js';
-/**
- * A fast character classifier that uses a compact array for ASCII values.
- */
-export class CharacterClassifier {
-    constructor(_defaultValue) {
-        const defaultValue = toUint8(_defaultValue);
-        this._defaultValue = defaultValue;
-        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);
-        this._map = new Map();
-    }
-    static _createAsciiMap(defaultValue) {
-        const asciiMap = new Uint8Array(256);
-        asciiMap.fill(defaultValue);
-        return asciiMap;
-    }
-    set(charCode, _value) {
-        const value = toUint8(_value);
-        if (charCode >= 0 && charCode < 256) {
-            this._asciiMap[charCode] = value;
-        }
-        else {
-            this._map.set(charCode, value);
-        }
-    }
-    get(charCode) {
-        if (charCode >= 0 && charCode < 256) {
-            return this._asciiMap[charCode];
-        }
-        else {
-            return (this._map.get(charCode) || this._defaultValue);
-        }
-    }
-    clear() {
-        this._asciiMap.fill(this._defaultValue);
-        this._map.clear();
-    }
-}
-export class CharacterSet {
-    constructor() {
-        this._actual = new CharacterClassifier(0 /* Boolean.False */);
-    }
-    add(charCode) {
-        this._actual.set(charCode, 1 /* Boolean.True */);
-    }
-    has(charCode) {
-        return (this._actual.get(charCode) === 1 /* Boolean.True */);
-    }
-    clear() {
-        return this._actual.clear();
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/core/cursorColumns.js

@@ -1,109 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import * as strings from '../../../base/common/strings.js';
-/**
- * A column in a position is the gap between two adjacent characters. The methods here
- * work with a concept called "visible column". A visible column is a very rough approximation
- * of the horizontal screen position of a column. For example, using a tab size of 4:
- * ```txt
- * |<TAB>|<TAB>|T|ext
- * |     |     | \---- column = 4, visible column = 9
- * |     |     \------ column = 3, visible column = 8
- * |     \------------ column = 2, visible column = 4
- * \------------------ column = 1, visible column = 0
- * ```
- *
- * **NOTE**: Visual columns do not work well for RTL text or variable-width fonts or characters.
- *
- * **NOTE**: These methods work and make sense both on the model and on the view model.
- */
-export class CursorColumns {
-    static _nextVisibleColumn(codePoint, visibleColumn, tabSize) {
-        if (codePoint === 9 /* CharCode.Tab */) {
-            return CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
-        }
-        if (strings.isFullWidthCharacter(codePoint) || strings.isEmojiImprecise(codePoint)) {
-            return visibleColumn + 2;
-        }
-        return visibleColumn + 1;
-    }
-    /**
-     * Returns a visible column from a column.
-     * @see {@link CursorColumns}
-     */
-    static visibleColumnFromColumn(lineContent, column, tabSize) {
-        const textLen = Math.min(column - 1, lineContent.length);
-        const text = lineContent.substring(0, textLen);
-        const iterator = new strings.GraphemeIterator(text);
-        let result = 0;
-        while (!iterator.eol()) {
-            const codePoint = strings.getNextCodePoint(text, textLen, iterator.offset);
-            iterator.nextGraphemeLength();
-            result = this._nextVisibleColumn(codePoint, result, tabSize);
-        }
-        return result;
-    }
-    /**
-     * Returns a column from a visible column.
-     * @see {@link CursorColumns}
-     */
-    static columnFromVisibleColumn(lineContent, visibleColumn, tabSize) {
-        if (visibleColumn <= 0) {
-            return 1;
-        }
-        const lineContentLength = lineContent.length;
-        const iterator = new strings.GraphemeIterator(lineContent);
-        let beforeVisibleColumn = 0;
-        let beforeColumn = 1;
-        while (!iterator.eol()) {
-            const codePoint = strings.getNextCodePoint(lineContent, lineContentLength, iterator.offset);
-            iterator.nextGraphemeLength();
-            const afterVisibleColumn = this._nextVisibleColumn(codePoint, beforeVisibleColumn, tabSize);
-            const afterColumn = iterator.offset + 1;
-            if (afterVisibleColumn >= visibleColumn) {
-                const beforeDelta = visibleColumn - beforeVisibleColumn;
-                const afterDelta = afterVisibleColumn - visibleColumn;
-                if (afterDelta < beforeDelta) {
-                    return afterColumn;
-                }
-                else {
-                    return beforeColumn;
-                }
-            }
-            beforeVisibleColumn = afterVisibleColumn;
-            beforeColumn = afterColumn;
-        }
-        // walked the entire string
-        return lineContentLength + 1;
-    }
-    /**
-     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
-     * @see {@link CursorColumns}
-     */
-    static nextRenderTabStop(visibleColumn, tabSize) {
-        return visibleColumn + tabSize - visibleColumn % tabSize;
-    }
-    /**
-     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
-     * @see {@link CursorColumns}
-     */
-    static nextIndentTabStop(visibleColumn, indentSize) {
-        return visibleColumn + indentSize - visibleColumn % indentSize;
-    }
-    /**
-     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
-     * @see {@link CursorColumns}
-     */
-    static prevRenderTabStop(column, tabSize) {
-        return Math.max(0, column - 1 - (column - 1) % tabSize);
-    }
-    /**
-     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)
-     * @see {@link CursorColumns}
-     */
-    static prevIndentTabStop(column, indentSize) {
-        return Math.max(0, column - 1 - (column - 1) % indentSize);
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/core/dimension.js

@@ -1,5 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-export {};

package/dist-cms/monaco-editor/vs/editor/common/core/editOperation.js

@@ -1,33 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { Range } from './range.js';
-export class EditOperation {
-    static insert(position, text) {
-        return {
-            range: new Range(position.lineNumber, position.column, position.lineNumber, position.column),
-            text: text,
-            forceMoveMarkers: true
-        };
-    }
-    static delete(range) {
-        return {
-            range: range,
-            text: null
-        };
-    }
-    static replace(range, text) {
-        return {
-            range: range,
-            text: text
-        };
-    }
-    static replaceMove(range, text) {
-        return {
-            range: range,
-            text: text,
-            forceMoveMarkers: true
-        };
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/core/editorColorRegistry.js

@@ -1,89 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import * as nls from '../../../nls.js';
-import { Color, RGBA } from '../../../base/common/color.js';
-import { activeContrastBorder, editorBackground, registerColor, editorWarningForeground, editorInfoForeground, editorWarningBorder, editorInfoBorder, contrastBorder, editorFindMatchHighlight, editorWarningBackground } from '../../../platform/theme/common/colorRegistry.js';
-import { registerThemingParticipant } from '../../../platform/theme/common/themeService.js';
-/**
- * Definition of the editor colors
- */
-export const editorLineHighlight = registerColor('editor.lineHighlightBackground', null, nls.localize('lineHighlight', 'Background color for the highlight of line at the cursor position.'));
-export const editorLineHighlightBorder = registerColor('editor.lineHighlightBorder', { dark: '#282828', light: '#eeeeee', hcDark: '#f38518', hcLight: contrastBorder }, nls.localize('lineHighlightBorderBox', 'Background color for the border around the line at the cursor position.'));
-export const editorRangeHighlight = registerColor('editor.rangeHighlightBackground', { dark: '#ffffff0b', light: '#fdff0033', hcDark: null, hcLight: null }, nls.localize('rangeHighlight', 'Background color of highlighted ranges, like by quick open and find features. The color must not be opaque so as not to hide underlying decorations.'), true);
-export const editorRangeHighlightBorder = registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize('rangeHighlightBorder', 'Background color of the border around highlighted ranges.'));
-export const editorSymbolHighlight = registerColor('editor.symbolHighlightBackground', { dark: editorFindMatchHighlight, light: editorFindMatchHighlight, hcDark: null, hcLight: null }, nls.localize('symbolHighlight', 'Background color of highlighted symbol, like for go to definition or go next/previous symbol. The color must not be opaque so as not to hide underlying decorations.'), true);
-export const editorSymbolHighlightBorder = registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize('symbolHighlightBorder', 'Background color of the border around highlighted symbols.'));
-export const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, nls.localize('caret', 'Color of the editor cursor.'));
-export const editorCursorBackground = registerColor('editorCursor.background', null, nls.localize('editorCursorBackground', 'The background color of the editor cursor. Allows customizing the color of a character overlapped by a block cursor.'));
-export const editorMultiCursorPrimaryForeground = registerColor('editorMultiCursor.primary.foreground', editorCursorForeground, nls.localize('editorMultiCursorPrimaryForeground', 'Color of the primary editor cursor when multiple cursors are present.'));
-export const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', editorCursorBackground, nls.localize('editorMultiCursorPrimaryBackground', 'The background color of the primary editor cursor when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor.'));
-export const editorMultiCursorSecondaryForeground = registerColor('editorMultiCursor.secondary.foreground', editorCursorForeground, nls.localize('editorMultiCursorSecondaryForeground', 'Color of secondary editor cursors when multiple cursors are present.'));
-export const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', editorCursorBackground, nls.localize('editorMultiCursorSecondaryBackground', 'The background color of secondary editor cursors when multiple cursors are present. Allows customizing the color of a character overlapped by a block cursor.'));
-export const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, nls.localize('editorWhitespaces', 'Color of whitespace characters in the editor.'));
-export const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, nls.localize('editorLineNumbers', 'Color of editor line numbers.'));
-export const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', editorWhitespaces, nls.localize('editorIndentGuides', 'Color of the editor indentation guides.'), false, nls.localize('deprecatedEditorIndentGuides', '\'editorIndentGuide.background\' is deprecated. Use \'editorIndentGuide.background1\' instead.'));
-export const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', editorWhitespaces, nls.localize('editorActiveIndentGuide', 'Color of the active editor indentation guides.'), false, nls.localize('deprecatedEditorActiveIndentGuide', '\'editorIndentGuide.activeBackground\' is deprecated. Use \'editorIndentGuide.activeBackground1\' instead.'));
-export const editorIndentGuide1 = registerColor('editorIndentGuide.background1', deprecatedEditorIndentGuides, nls.localize('editorIndentGuides1', 'Color of the editor indentation guides (1).'));
-export const editorIndentGuide2 = registerColor('editorIndentGuide.background2', '#00000000', nls.localize('editorIndentGuides2', 'Color of the editor indentation guides (2).'));
-export const editorIndentGuide3 = registerColor('editorIndentGuide.background3', '#00000000', nls.localize('editorIndentGuides3', 'Color of the editor indentation guides (3).'));
-export const editorIndentGuide4 = registerColor('editorIndentGuide.background4', '#00000000', nls.localize('editorIndentGuides4', 'Color of the editor indentation guides (4).'));
-export const editorIndentGuide5 = registerColor('editorIndentGuide.background5', '#00000000', nls.localize('editorIndentGuides5', 'Color of the editor indentation guides (5).'));
-export const editorIndentGuide6 = registerColor('editorIndentGuide.background6', '#00000000', nls.localize('editorIndentGuides6', 'Color of the editor indentation guides (6).'));
-export const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', deprecatedEditorActiveIndentGuides, nls.localize('editorActiveIndentGuide1', 'Color of the active editor indentation guides (1).'));
-export const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', '#00000000', nls.localize('editorActiveIndentGuide2', 'Color of the active editor indentation guides (2).'));
-export const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', '#00000000', nls.localize('editorActiveIndentGuide3', 'Color of the active editor indentation guides (3).'));
-export const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', '#00000000', nls.localize('editorActiveIndentGuide4', 'Color of the active editor indentation guides (4).'));
-export const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', '#00000000', nls.localize('editorActiveIndentGuide5', 'Color of the active editor indentation guides (5).'));
-export const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', '#00000000', nls.localize('editorActiveIndentGuide6', 'Color of the active editor indentation guides (6).'));
-const deprecatedEditorActiveLineNumber = registerColor('editorActiveLineNumber.foreground', { dark: '#c6c6c6', light: '#0B216F', hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize('editorActiveLineNumber', 'Color of editor active line number'), false, nls.localize('deprecatedEditorActiveLineNumber', 'Id is deprecated. Use \'editorLineNumber.activeForeground\' instead.'));
-export const editorActiveLineNumber = registerColor('editorLineNumber.activeForeground', deprecatedEditorActiveLineNumber, nls.localize('editorActiveLineNumber', 'Color of editor active line number'));
-export const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', null, nls.localize('editorDimmedLineNumber', 'Color of the final editor line when editor.renderFinalNewline is set to dimmed.'));
-export const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, nls.localize('editorRuler', 'Color of the editor rulers.'));
-export const editorCodeLensForeground = registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, nls.localize('editorCodeLensForeground', 'Foreground color of editor CodeLens'));
-export const editorBracketMatchBackground = registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, nls.localize('editorBracketMatchBackground', 'Background color behind matching brackets'));
-export const editorBracketMatchBorder = registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize('editorBracketMatchBorder', 'Color for matching brackets boxes'));
-export const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, nls.localize('editorOverviewRulerBorder', 'Color of the overview ruler border.'));
-export const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, nls.localize('editorOverviewRulerBackground', 'Background color of the editor overview ruler.'));
-export const editorGutter = registerColor('editorGutter.background', editorBackground, nls.localize('editorGutter', 'Background color of the editor gutter. The gutter contains the glyph margins and the line numbers.'));
-export const editorUnnecessaryCodeBorder = registerColor('editorUnnecessaryCode.border', { dark: null, light: null, hcDark: Color.fromHex('#fff').transparent(0.8), hcLight: contrastBorder }, nls.localize('unnecessaryCodeBorder', 'Border color of unnecessary (unused) source code in the editor.'));
-export const editorUnnecessaryCodeOpacity = registerColor('editorUnnecessaryCode.opacity', { dark: Color.fromHex('#000a'), light: Color.fromHex('#0007'), hcDark: null, hcLight: null }, nls.localize('unnecessaryCodeOpacity', 'Opacity of unnecessary (unused) source code in the editor. For example, "#000000c0" will render the code with 75% opacity. For high contrast themes, use the  \'editorUnnecessaryCode.border\' theme color to underline unnecessary code instead of fading it out.'));
-export const ghostTextBorder = registerColor('editorGhostText.border', { dark: null, light: null, hcDark: Color.fromHex('#fff').transparent(0.8), hcLight: Color.fromHex('#292929').transparent(0.8) }, nls.localize('editorGhostTextBorder', 'Border color of ghost text in the editor.'));
-export const ghostTextForeground = registerColor('editorGhostText.foreground', { dark: Color.fromHex('#ffffff56'), light: Color.fromHex('#0007'), hcDark: null, hcLight: null }, nls.localize('editorGhostTextForeground', 'Foreground color of the ghost text in the editor.'));
-export const ghostTextBackground = registerColor('editorGhostText.background', null, nls.localize('editorGhostTextBackground', 'Background color of the ghost text in the editor.'));
-const rulerRangeDefault = new Color(new RGBA(0, 122, 204, 0.6));
-export const overviewRulerRangeHighlight = registerColor('editorOverviewRuler.rangeHighlightForeground', rulerRangeDefault, nls.localize('overviewRulerRangeHighlight', 'Overview ruler marker color for range highlights. The color must not be opaque so as not to hide underlying decorations.'), true);
-export const overviewRulerError = registerColor('editorOverviewRuler.errorForeground', { dark: new Color(new RGBA(255, 18, 18, 0.7)), light: new Color(new RGBA(255, 18, 18, 0.7)), hcDark: new Color(new RGBA(255, 50, 50, 1)), hcLight: '#B5200D' }, nls.localize('overviewRuleError', 'Overview ruler marker color for errors.'));
-export const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, nls.localize('overviewRuleWarning', 'Overview ruler marker color for warnings.'));
-export const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, nls.localize('overviewRuleInfo', 'Overview ruler marker color for infos.'));
-export const editorBracketHighlightingForeground1 = registerColor('editorBracketHighlight.foreground1', { dark: '#FFD700', light: '#0431FAFF', hcDark: '#FFD700', hcLight: '#0431FAFF' }, nls.localize('editorBracketHighlightForeground1', 'Foreground color of brackets (1). Requires enabling bracket pair colorization.'));
-export const editorBracketHighlightingForeground2 = registerColor('editorBracketHighlight.foreground2', { dark: '#DA70D6', light: '#319331FF', hcDark: '#DA70D6', hcLight: '#319331FF' }, nls.localize('editorBracketHighlightForeground2', 'Foreground color of brackets (2). Requires enabling bracket pair colorization.'));
-export const editorBracketHighlightingForeground3 = registerColor('editorBracketHighlight.foreground3', { dark: '#179FFF', light: '#7B3814FF', hcDark: '#87CEFA', hcLight: '#7B3814FF' }, nls.localize('editorBracketHighlightForeground3', 'Foreground color of brackets (3). Requires enabling bracket pair colorization.'));
-export const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', '#00000000', nls.localize('editorBracketHighlightForeground4', 'Foreground color of brackets (4). Requires enabling bracket pair colorization.'));
-export const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', '#00000000', nls.localize('editorBracketHighlightForeground5', 'Foreground color of brackets (5). Requires enabling bracket pair colorization.'));
-export const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', '#00000000', nls.localize('editorBracketHighlightForeground6', 'Foreground color of brackets (6). Requires enabling bracket pair colorization.'));
-export const editorBracketHighlightingUnexpectedBracketForeground = registerColor('editorBracketHighlight.unexpectedBracket.foreground', { dark: new Color(new RGBA(255, 18, 18, 0.8)), light: new Color(new RGBA(255, 18, 18, 0.8)), hcDark: 'new Color(new RGBA(255, 50, 50, 1))', hcLight: '#B5200D' }, nls.localize('editorBracketHighlightUnexpectedBracketForeground', 'Foreground color of unexpected brackets.'));
-export const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', '#00000000', nls.localize('editorBracketPairGuide.background1', 'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', '#00000000', nls.localize('editorBracketPairGuide.background2', 'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', '#00000000', nls.localize('editorBracketPairGuide.background3', 'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', '#00000000', nls.localize('editorBracketPairGuide.background4', 'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', '#00000000', nls.localize('editorBracketPairGuide.background5', 'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', '#00000000', nls.localize('editorBracketPairGuide.background6', 'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', '#00000000', nls.localize('editorBracketPairGuide.activeBackground1', 'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', '#00000000', nls.localize('editorBracketPairGuide.activeBackground2', 'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', '#00000000', nls.localize('editorBracketPairGuide.activeBackground3', 'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', '#00000000', nls.localize('editorBracketPairGuide.activeBackground4', 'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', '#00000000', nls.localize('editorBracketPairGuide.activeBackground5', 'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'));
-export const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', '#00000000', nls.localize('editorBracketPairGuide.activeBackground6', 'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'));
-export const editorUnicodeHighlightBorder = registerColor('editorUnicodeHighlight.border', editorWarningForeground, nls.localize('editorUnicodeHighlight.border', 'Border color used to highlight unicode characters.'));
-export const editorUnicodeHighlightBackground = registerColor('editorUnicodeHighlight.background', editorWarningBackground, nls.localize('editorUnicodeHighlight.background', 'Background color used to highlight unicode characters.'));
-// contains all color rules that used to defined in editor/browser/widget/editor.css
-registerThemingParticipant((theme, collector) => {
-    const background = theme.getColor(editorBackground);
-    const lineHighlight = theme.getColor(editorLineHighlight);
-    const imeBackground = (lineHighlight && !lineHighlight.isTransparent() ? lineHighlight : background);
-    if (imeBackground) {
-        collector.addRule(`.monaco-editor .inputarea.ime-input { background-color: ${imeBackground}; }`);
-    }
-});

package/dist-cms/monaco-editor/vs/editor/common/core/eolCounter.js

@@ -1,42 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-export function countEOL(text) {
-    let eolCount = 0;
-    let firstLineLength = 0;
-    let lastLineStart = 0;
-    let eol = 0 /* StringEOL.Unknown */;
-    for (let i = 0, len = text.length; i < len; i++) {
-        const chr = text.charCodeAt(i);
-        if (chr === 13 /* CharCode.CarriageReturn */) {
-            if (eolCount === 0) {
-                firstLineLength = i;
-            }
-            eolCount++;
-            if (i + 1 < len && text.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {
-                // \r\n... case
-                eol |= 2 /* StringEOL.CRLF */;
-                i++; // skip \n
-            }
-            else {
-                // \r... case
-                eol |= 3 /* StringEOL.Invalid */;
-            }
-            lastLineStart = i + 1;
-        }
-        else if (chr === 10 /* CharCode.LineFeed */) {
-            // \n... case
-            eol |= 1 /* StringEOL.LF */;
-            if (eolCount === 0) {
-                firstLineLength = i;
-            }
-            eolCount++;
-            lastLineStart = i + 1;
-        }
-    }
-    if (eolCount === 0) {
-        firstLineLength = text.length;
-    }
-    return [eolCount, firstLineLength, text.length - lastLineStart, eol];
-}

package/dist-cms/monaco-editor/vs/editor/common/core/indentation.js

@@ -1,36 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import * as strings from '../../../base/common/strings.js';
-import { CursorColumns } from './cursorColumns.js';
-function _normalizeIndentationFromWhitespace(str, indentSize, insertSpaces) {
-    let spacesCnt = 0;
-    for (let i = 0; i < str.length; i++) {
-        if (str.charAt(i) === '\t') {
-            spacesCnt = CursorColumns.nextIndentTabStop(spacesCnt, indentSize);
-        }
-        else {
-            spacesCnt++;
-        }
-    }
-    let result = '';
-    if (!insertSpaces) {
-        const tabsCnt = Math.floor(spacesCnt / indentSize);
-        spacesCnt = spacesCnt % indentSize;
-        for (let i = 0; i < tabsCnt; i++) {
-            result += '\t';
-        }
-    }
-    for (let i = 0; i < spacesCnt; i++) {
-        result += ' ';
-    }
-    return result;
-}
-export function normalizeIndentation(str, indentSize, insertSpaces) {
-    let firstNonWhitespaceIndex = strings.firstNonWhitespaceIndex(str);
-    if (firstNonWhitespaceIndex === -1) {
-        firstNonWhitespaceIndex = str.length;
-    }
-    return _normalizeIndentationFromWhitespace(str.substring(0, firstNonWhitespaceIndex), indentSize, insertSpaces) + str.substring(firstNonWhitespaceIndex);
-}