{"version":3,"file":"static/js/8845_7abbd574bb2c6bf461ec.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/characterClassifier.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/cursorColumns.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/editOperation.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/editorColorRegistry.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/eolCounter.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/indentation.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/lineRange.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/offsetRange.js"],"sourcesContent":["/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { toUint8 } from '../../../base/common/uint.js';\n/**\n * A fast character classifier that uses a compact array for ASCII values.\n */\nexport class CharacterClassifier {\n    constructor(_defaultValue) {\n        const defaultValue = toUint8(_defaultValue);\n        this._defaultValue = defaultValue;\n        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);\n        this._map = new Map();\n    }\n    static _createAsciiMap(defaultValue) {\n        const asciiMap = new Uint8Array(256);\n        asciiMap.fill(defaultValue);\n        return asciiMap;\n    }\n    set(charCode, _value) {\n        const value = toUint8(_value);\n        if (charCode >= 0 && charCode < 256) {\n            this._asciiMap[charCode] = value;\n        }\n        else {\n            this._map.set(charCode, value);\n        }\n    }\n    get(charCode) {\n        if (charCode >= 0 && charCode < 256) {\n            return this._asciiMap[charCode];\n        }\n        else {\n            return (this._map.get(charCode) || this._defaultValue);\n        }\n    }\n    clear() {\n        this._asciiMap.fill(this._defaultValue);\n        this._map.clear();\n    }\n}\nexport class CharacterSet {\n    constructor() {\n        this._actual = new CharacterClassifier(0 /* Boolean.False */);\n    }\n    add(charCode) {\n        this._actual.set(charCode, 1 /* Boolean.True */);\n    }\n    has(charCode) {\n        return (this._actual.get(charCode) === 1 /* Boolean.True */);\n    }\n    clear() {\n        return this._actual.clear();\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../base/common/strings.js';\n/**\n * A column in a position is the gap between two adjacent characters. The methods here\n * work with a concept called \"visible column\". A visible column is a very rough approximation\n * of the horizontal screen position of a column. For example, using a tab size of 4:\n * ```txt\n * |<TAB>|<TAB>|T|ext\n * |     |     | \\---- column = 4, visible column = 9\n * |     |     \\------ column = 3, visible column = 8\n * |     \\------------ column = 2, visible column = 4\n * \\------------------ column = 1, visible column = 0\n * ```\n *\n * **NOTE**: Visual columns do not work well for RTL text or variable-width fonts or characters.\n *\n * **NOTE**: These methods work and make sense both on the model and on the view model.\n */\nexport class CursorColumns {\n    static _nextVisibleColumn(codePoint, visibleColumn, tabSize) {\n        if (codePoint === 9 /* CharCode.Tab */) {\n            return CursorColumns.nextRenderTabStop(visibleColumn, tabSize);\n        }\n        if (strings.isFullWidthCharacter(codePoint) || strings.isEmojiImprecise(codePoint)) {\n            return visibleColumn + 2;\n        }\n        return visibleColumn + 1;\n    }\n    /**\n     * Returns a visible column from a column.\n     * @see {@link CursorColumns}\n     */\n    static visibleColumnFromColumn(lineContent, column, tabSize) {\n        const textLen = Math.min(column - 1, lineContent.length);\n        const text = lineContent.substring(0, textLen);\n        const iterator = new strings.GraphemeIterator(text);\n        let result = 0;\n        while (!iterator.eol()) {\n            const codePoint = strings.getNextCodePoint(text, textLen, iterator.offset);\n            iterator.nextGraphemeLength();\n            result = this._nextVisibleColumn(codePoint, result, tabSize);\n        }\n        return result;\n    }\n    /**\n     * Returns a column from a visible column.\n     * @see {@link CursorColumns}\n     */\n    static columnFromVisibleColumn(lineContent, visibleColumn, tabSize) {\n        if (visibleColumn <= 0) {\n            return 1;\n        }\n        const lineContentLength = lineContent.length;\n        const iterator = new strings.GraphemeIterator(lineContent);\n        let beforeVisibleColumn = 0;\n        let beforeColumn = 1;\n        while (!iterator.eol()) {\n            const codePoint = strings.getNextCodePoint(lineContent, lineContentLength, iterator.offset);\n            iterator.nextGraphemeLength();\n            const afterVisibleColumn = this._nextVisibleColumn(codePoint, beforeVisibleColumn, tabSize);\n            const afterColumn = iterator.offset + 1;\n            if (afterVisibleColumn >= visibleColumn) {\n                const beforeDelta = visibleColumn - beforeVisibleColumn;\n                const afterDelta = afterVisibleColumn - visibleColumn;\n                if (afterDelta < beforeDelta) {\n                    return afterColumn;\n                }\n                else {\n                    return beforeColumn;\n                }\n            }\n            beforeVisibleColumn = afterVisibleColumn;\n            beforeColumn = afterColumn;\n        }\n        // walked the entire string\n        return lineContentLength + 1;\n    }\n    /**\n     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)\n     * @see {@link CursorColumns}\n     */\n    static nextRenderTabStop(visibleColumn, tabSize) {\n        return visibleColumn + tabSize - visibleColumn % tabSize;\n    }\n    /**\n     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)\n     * @see {@link CursorColumns}\n     */\n    static nextIndentTabStop(visibleColumn, indentSize) {\n        return visibleColumn + indentSize - visibleColumn % indentSize;\n    }\n    /**\n     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)\n     * @see {@link CursorColumns}\n     */\n    static prevRenderTabStop(column, tabSize) {\n        return Math.max(0, column - 1 - (column - 1) % tabSize);\n    }\n    /**\n     * ATTENTION: This works with 0-based columns (as opposed to the regular 1-based columns)\n     * @see {@link CursorColumns}\n     */\n    static prevIndentTabStop(column, indentSize) {\n        return Math.max(0, column - 1 - (column - 1) % indentSize);\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Range } from './range.js';\nexport class EditOperation {\n    static insert(position, text) {\n        return {\n            range: new Range(position.lineNumber, position.column, position.lineNumber, position.column),\n            text: text,\n            forceMoveMarkers: true\n        };\n    }\n    static delete(range) {\n        return {\n            range: range,\n            text: null\n        };\n    }\n    static replace(range, text) {\n        return {\n            range: range,\n            text: text\n        };\n    }\n    static replaceMove(range, text) {\n        return {\n            range: range,\n            text: text,\n            forceMoveMarkers: true\n        };\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as nls from '../../../nls.js';\nimport { Color, RGBA } from '../../../base/common/color.js';\nimport { activeContrastBorder, editorBackground, registerColor, editorWarningForeground, editorInfoForeground, editorWarningBorder, editorInfoBorder, contrastBorder, editorFindMatchHighlight, editorWarningBackground } from '../../../platform/theme/common/colorRegistry.js';\nimport { registerThemingParticipant } from '../../../platform/theme/common/themeService.js';\n/**\n * Definition of the editor colors\n */\nexport const editorLineHighlight = registerColor('editor.lineHighlightBackground', { dark: null, light: null, hcDark: null, hcLight: null }, nls.localize('lineHighlight', 'Background color for the highlight of line at the cursor position.'));\nexport 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.'));\nexport 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);\nexport const editorRangeHighlightBorder = registerColor('editor.rangeHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize('rangeHighlightBorder', 'Background color of the border around highlighted ranges.'));\nexport 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);\nexport const editorSymbolHighlightBorder = registerColor('editor.symbolHighlightBorder', { dark: null, light: null, hcDark: activeContrastBorder, hcLight: activeContrastBorder }, nls.localize('symbolHighlightBorder', 'Background color of the border around highlighted symbols.'));\nexport const editorCursorForeground = registerColor('editorCursor.foreground', { dark: '#AEAFAD', light: Color.black, hcDark: Color.white, hcLight: '#0F4A85' }, nls.localize('caret', 'Color of the editor cursor.'));\nexport 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.'));\nexport const editorMultiCursorPrimaryForeground = registerColor('editorMultiCursor.primary.foreground', { dark: editorCursorForeground, light: editorCursorForeground, hcDark: editorCursorForeground, hcLight: editorCursorForeground }, nls.localize('editorMultiCursorPrimaryForeground', 'Color of the primary editor cursor when multiple cursors are present.'));\nexport const editorMultiCursorPrimaryBackground = registerColor('editorMultiCursor.primary.background', { dark: editorCursorBackground, light: editorCursorBackground, hcDark: editorCursorBackground, hcLight: 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.'));\nexport const editorMultiCursorSecondaryForeground = registerColor('editorMultiCursor.secondary.foreground', { dark: editorCursorForeground, light: editorCursorForeground, hcDark: editorCursorForeground, hcLight: editorCursorForeground }, nls.localize('editorMultiCursorSecondaryForeground', 'Color of secondary editor cursors when multiple cursors are present.'));\nexport const editorMultiCursorSecondaryBackground = registerColor('editorMultiCursor.secondary.background', { dark: editorCursorBackground, light: editorCursorBackground, hcDark: editorCursorBackground, hcLight: 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.'));\nexport const editorWhitespaces = registerColor('editorWhitespace.foreground', { dark: '#e3e4e229', light: '#33333333', hcDark: '#e3e4e229', hcLight: '#CCCCCC' }, nls.localize('editorWhitespaces', 'Color of whitespace characters in the editor.'));\nexport const editorLineNumbers = registerColor('editorLineNumber.foreground', { dark: '#858585', light: '#237893', hcDark: Color.white, hcLight: '#292929' }, nls.localize('editorLineNumbers', 'Color of editor line numbers.'));\nexport const deprecatedEditorIndentGuides = registerColor('editorIndentGuide.background', { dark: editorWhitespaces, light: editorWhitespaces, hcDark: editorWhitespaces, hcLight: editorWhitespaces }, nls.localize('editorIndentGuides', 'Color of the editor indentation guides.'), false, nls.localize('deprecatedEditorIndentGuides', '\\'editorIndentGuide.background\\' is deprecated. Use \\'editorIndentGuide.background1\\' instead.'));\nexport const deprecatedEditorActiveIndentGuides = registerColor('editorIndentGuide.activeBackground', { dark: editorWhitespaces, light: editorWhitespaces, hcDark: editorWhitespaces, hcLight: editorWhitespaces }, nls.localize('editorActiveIndentGuide', 'Color of the active editor indentation guides.'), false, nls.localize('deprecatedEditorActiveIndentGuide', '\\'editorIndentGuide.activeBackground\\' is deprecated. Use \\'editorIndentGuide.activeBackground1\\' instead.'));\nexport const editorIndentGuide1 = registerColor('editorIndentGuide.background1', { dark: deprecatedEditorIndentGuides, light: deprecatedEditorIndentGuides, hcDark: deprecatedEditorIndentGuides, hcLight: deprecatedEditorIndentGuides }, nls.localize('editorIndentGuides1', 'Color of the editor indentation guides (1).'));\nexport const editorIndentGuide2 = registerColor('editorIndentGuide.background2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorIndentGuides2', 'Color of the editor indentation guides (2).'));\nexport const editorIndentGuide3 = registerColor('editorIndentGuide.background3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorIndentGuides3', 'Color of the editor indentation guides (3).'));\nexport const editorIndentGuide4 = registerColor('editorIndentGuide.background4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorIndentGuides4', 'Color of the editor indentation guides (4).'));\nexport const editorIndentGuide5 = registerColor('editorIndentGuide.background5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorIndentGuides5', 'Color of the editor indentation guides (5).'));\nexport const editorIndentGuide6 = registerColor('editorIndentGuide.background6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorIndentGuides6', 'Color of the editor indentation guides (6).'));\nexport const editorActiveIndentGuide1 = registerColor('editorIndentGuide.activeBackground1', { dark: deprecatedEditorActiveIndentGuides, light: deprecatedEditorActiveIndentGuides, hcDark: deprecatedEditorActiveIndentGuides, hcLight: deprecatedEditorActiveIndentGuides }, nls.localize('editorActiveIndentGuide1', 'Color of the active editor indentation guides (1).'));\nexport const editorActiveIndentGuide2 = registerColor('editorIndentGuide.activeBackground2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorActiveIndentGuide2', 'Color of the active editor indentation guides (2).'));\nexport const editorActiveIndentGuide3 = registerColor('editorIndentGuide.activeBackground3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorActiveIndentGuide3', 'Color of the active editor indentation guides (3).'));\nexport const editorActiveIndentGuide4 = registerColor('editorIndentGuide.activeBackground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorActiveIndentGuide4', 'Color of the active editor indentation guides (4).'));\nexport const editorActiveIndentGuide5 = registerColor('editorIndentGuide.activeBackground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorActiveIndentGuide5', 'Color of the active editor indentation guides (5).'));\nexport const editorActiveIndentGuide6 = registerColor('editorIndentGuide.activeBackground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorActiveIndentGuide6', 'Color of the active editor indentation guides (6).'));\nconst 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.'));\nexport const editorActiveLineNumber = registerColor('editorLineNumber.activeForeground', { dark: deprecatedEditorActiveLineNumber, light: deprecatedEditorActiveLineNumber, hcDark: deprecatedEditorActiveLineNumber, hcLight: deprecatedEditorActiveLineNumber }, nls.localize('editorActiveLineNumber', 'Color of editor active line number'));\nexport const editorDimmedLineNumber = registerColor('editorLineNumber.dimmedForeground', { dark: null, light: null, hcDark: null, hcLight: null }, nls.localize('editorDimmedLineNumber', 'Color of the final editor line when editor.renderFinalNewline is set to dimmed.'));\nexport const editorRuler = registerColor('editorRuler.foreground', { dark: '#5A5A5A', light: Color.lightgrey, hcDark: Color.white, hcLight: '#292929' }, nls.localize('editorRuler', 'Color of the editor rulers.'));\nexport const editorCodeLensForeground = registerColor('editorCodeLens.foreground', { dark: '#999999', light: '#919191', hcDark: '#999999', hcLight: '#292929' }, nls.localize('editorCodeLensForeground', 'Foreground color of editor CodeLens'));\nexport const editorBracketMatchBackground = registerColor('editorBracketMatch.background', { dark: '#0064001a', light: '#0064001a', hcDark: '#0064001a', hcLight: '#0000' }, nls.localize('editorBracketMatchBackground', 'Background color behind matching brackets'));\nexport const editorBracketMatchBorder = registerColor('editorBracketMatch.border', { dark: '#888', light: '#B9B9B9', hcDark: contrastBorder, hcLight: contrastBorder }, nls.localize('editorBracketMatchBorder', 'Color for matching brackets boxes'));\nexport const editorOverviewRulerBorder = registerColor('editorOverviewRuler.border', { dark: '#7f7f7f4d', light: '#7f7f7f4d', hcDark: '#7f7f7f4d', hcLight: '#666666' }, nls.localize('editorOverviewRulerBorder', 'Color of the overview ruler border.'));\nexport const editorOverviewRulerBackground = registerColor('editorOverviewRuler.background', null, nls.localize('editorOverviewRulerBackground', 'Background color of the editor overview ruler.'));\nexport const editorGutter = registerColor('editorGutter.background', { dark: editorBackground, light: editorBackground, hcDark: editorBackground, hcLight: editorBackground }, nls.localize('editorGutter', 'Background color of the editor gutter. The gutter contains the glyph margins and the line numbers.'));\nexport 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.'));\nexport 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.'));\nexport 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.'));\nexport 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.'));\nexport const ghostTextBackground = registerColor('editorGhostText.background', { dark: null, light: null, hcDark: null, hcLight: null }, nls.localize('editorGhostTextBackground', 'Background color of the ghost text in the editor.'));\nconst rulerRangeDefault = new Color(new RGBA(0, 122, 204, 0.6));\nexport const overviewRulerRangeHighlight = registerColor('editorOverviewRuler.rangeHighlightForeground', { dark: rulerRangeDefault, light: rulerRangeDefault, hcDark: rulerRangeDefault, hcLight: 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);\nexport 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.'));\nexport const overviewRulerWarning = registerColor('editorOverviewRuler.warningForeground', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningBorder, hcLight: editorWarningBorder }, nls.localize('overviewRuleWarning', 'Overview ruler marker color for warnings.'));\nexport const overviewRulerInfo = registerColor('editorOverviewRuler.infoForeground', { dark: editorInfoForeground, light: editorInfoForeground, hcDark: editorInfoBorder, hcLight: editorInfoBorder }, nls.localize('overviewRuleInfo', 'Overview ruler marker color for infos.'));\nexport 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.'));\nexport 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.'));\nexport 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.'));\nexport const editorBracketHighlightingForeground4 = registerColor('editorBracketHighlight.foreground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketHighlightForeground4', 'Foreground color of brackets (4). Requires enabling bracket pair colorization.'));\nexport const editorBracketHighlightingForeground5 = registerColor('editorBracketHighlight.foreground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketHighlightForeground5', 'Foreground color of brackets (5). Requires enabling bracket pair colorization.'));\nexport const editorBracketHighlightingForeground6 = registerColor('editorBracketHighlight.foreground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketHighlightForeground6', 'Foreground color of brackets (6). Requires enabling bracket pair colorization.'));\nexport 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: '' }, nls.localize('editorBracketHighlightUnexpectedBracketForeground', 'Foreground color of unexpected brackets.'));\nexport const editorBracketPairGuideBackground1 = registerColor('editorBracketPairGuide.background1', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background1', 'Background color of inactive bracket pair guides (1). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideBackground2 = registerColor('editorBracketPairGuide.background2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background2', 'Background color of inactive bracket pair guides (2). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideBackground3 = registerColor('editorBracketPairGuide.background3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background3', 'Background color of inactive bracket pair guides (3). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideBackground4 = registerColor('editorBracketPairGuide.background4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background4', 'Background color of inactive bracket pair guides (4). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideBackground5 = registerColor('editorBracketPairGuide.background5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background5', 'Background color of inactive bracket pair guides (5). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideBackground6 = registerColor('editorBracketPairGuide.background6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.background6', 'Background color of inactive bracket pair guides (6). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideActiveBackground1 = registerColor('editorBracketPairGuide.activeBackground1', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground1', 'Background color of active bracket pair guides (1). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideActiveBackground2 = registerColor('editorBracketPairGuide.activeBackground2', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground2', 'Background color of active bracket pair guides (2). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideActiveBackground3 = registerColor('editorBracketPairGuide.activeBackground3', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground3', 'Background color of active bracket pair guides (3). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideActiveBackground4 = registerColor('editorBracketPairGuide.activeBackground4', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground4', 'Background color of active bracket pair guides (4). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideActiveBackground5 = registerColor('editorBracketPairGuide.activeBackground5', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground5', 'Background color of active bracket pair guides (5). Requires enabling bracket pair guides.'));\nexport const editorBracketPairGuideActiveBackground6 = registerColor('editorBracketPairGuide.activeBackground6', { dark: '#00000000', light: '#00000000', hcDark: '#00000000', hcLight: '#00000000' }, nls.localize('editorBracketPairGuide.activeBackground6', 'Background color of active bracket pair guides (6). Requires enabling bracket pair guides.'));\nexport const editorUnicodeHighlightBorder = registerColor('editorUnicodeHighlight.border', { dark: editorWarningForeground, light: editorWarningForeground, hcDark: editorWarningForeground, hcLight: editorWarningForeground }, nls.localize('editorUnicodeHighlight.border', 'Border color used to highlight unicode characters.'));\nexport const editorUnicodeHighlightBackground = registerColor('editorUnicodeHighlight.background', { dark: editorWarningBackground, light: editorWarningBackground, hcDark: editorWarningBackground, hcLight: editorWarningBackground }, nls.localize('editorUnicodeHighlight.background', 'Background color used to highlight unicode characters.'));\n// contains all color rules that used to defined in editor/browser/widget/editor.css\nregisterThemingParticipant((theme, collector) => {\n    const background = theme.getColor(editorBackground);\n    const lineHighlight = theme.getColor(editorLineHighlight);\n    const imeBackground = (lineHighlight && !lineHighlight.isTransparent() ? lineHighlight : background);\n    if (imeBackground) {\n        collector.addRule(`.monaco-editor .inputarea.ime-input { background-color: ${imeBackground}; }`);\n    }\n});\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nexport function countEOL(text) {\n    let eolCount = 0;\n    let firstLineLength = 0;\n    let lastLineStart = 0;\n    let eol = 0 /* StringEOL.Unknown */;\n    for (let i = 0, len = text.length; i < len; i++) {\n        const chr = text.charCodeAt(i);\n        if (chr === 13 /* CharCode.CarriageReturn */) {\n            if (eolCount === 0) {\n                firstLineLength = i;\n            }\n            eolCount++;\n            if (i + 1 < len && text.charCodeAt(i + 1) === 10 /* CharCode.LineFeed */) {\n                // \\r\\n... case\n                eol |= 2 /* StringEOL.CRLF */;\n                i++; // skip \\n\n            }\n            else {\n                // \\r... case\n                eol |= 3 /* StringEOL.Invalid */;\n            }\n            lastLineStart = i + 1;\n        }\n        else if (chr === 10 /* CharCode.LineFeed */) {\n            // \\n... case\n            eol |= 1 /* StringEOL.LF */;\n            if (eolCount === 0) {\n                firstLineLength = i;\n            }\n            eolCount++;\n            lastLineStart = i + 1;\n        }\n    }\n    if (eolCount === 0) {\n        firstLineLength = text.length;\n    }\n    return [eolCount, firstLineLength, text.length - lastLineStart, eol];\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as strings from '../../../base/common/strings.js';\nimport { CursorColumns } from './cursorColumns.js';\nfunction _normalizeIndentationFromWhitespace(str, indentSize, insertSpaces) {\n    let spacesCnt = 0;\n    for (let i = 0; i < str.length; i++) {\n        if (str.charAt(i) === '\\t') {\n            spacesCnt = CursorColumns.nextIndentTabStop(spacesCnt, indentSize);\n        }\n        else {\n            spacesCnt++;\n        }\n    }\n    let result = '';\n    if (!insertSpaces) {\n        const tabsCnt = Math.floor(spacesCnt / indentSize);\n        spacesCnt = spacesCnt % indentSize;\n        for (let i = 0; i < tabsCnt; i++) {\n            result += '\\t';\n        }\n    }\n    for (let i = 0; i < spacesCnt; i++) {\n        result += ' ';\n    }\n    return result;\n}\nexport function normalizeIndentation(str, indentSize, insertSpaces) {\n    let firstNonWhitespaceIndex = strings.firstNonWhitespaceIndex(str);\n    if (firstNonWhitespaceIndex === -1) {\n        firstNonWhitespaceIndex = str.length;\n    }\n    return _normalizeIndentationFromWhitespace(str.substring(0, firstNonWhitespaceIndex), indentSize, insertSpaces) + str.substring(firstNonWhitespaceIndex);\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { BugIndicatingError } from '../../../base/common/errors.js';\nimport { OffsetRange } from './offsetRange.js';\nimport { Range } from './range.js';\nimport { findFirstIdxMonotonousOrArrLen, findLastIdxMonotonous, findLastMonotonous } from '../../../base/common/arraysFind.js';\n/**\n * A range of lines (1-based).\n */\nexport class LineRange {\n    static fromRangeInclusive(range) {\n        return new LineRange(range.startLineNumber, range.endLineNumber + 1);\n    }\n    /**\n     * @param lineRanges An array of sorted line ranges.\n     */\n    static joinMany(lineRanges) {\n        if (lineRanges.length === 0) {\n            return [];\n        }\n        let result = new LineRangeSet(lineRanges[0].slice());\n        for (let i = 1; i < lineRanges.length; i++) {\n            result = result.getUnion(new LineRangeSet(lineRanges[i].slice()));\n        }\n        return result.ranges;\n    }\n    static join(lineRanges) {\n        if (lineRanges.length === 0) {\n            throw new BugIndicatingError('lineRanges cannot be empty');\n        }\n        let startLineNumber = lineRanges[0].startLineNumber;\n        let endLineNumberExclusive = lineRanges[0].endLineNumberExclusive;\n        for (let i = 1; i < lineRanges.length; i++) {\n            startLineNumber = Math.min(startLineNumber, lineRanges[i].startLineNumber);\n            endLineNumberExclusive = Math.max(endLineNumberExclusive, lineRanges[i].endLineNumberExclusive);\n        }\n        return new LineRange(startLineNumber, endLineNumberExclusive);\n    }\n    static ofLength(startLineNumber, length) {\n        return new LineRange(startLineNumber, startLineNumber + length);\n    }\n    /**\n     * @internal\n     */\n    static deserialize(lineRange) {\n        return new LineRange(lineRange[0], lineRange[1]);\n    }\n    constructor(startLineNumber, endLineNumberExclusive) {\n        if (startLineNumber > endLineNumberExclusive) {\n            throw new BugIndicatingError(`startLineNumber ${startLineNumber} cannot be after endLineNumberExclusive ${endLineNumberExclusive}`);\n        }\n        this.startLineNumber = startLineNumber;\n        this.endLineNumberExclusive = endLineNumberExclusive;\n    }\n    /**\n     * Indicates if this line range contains the given line number.\n     */\n    contains(lineNumber) {\n        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;\n    }\n    /**\n     * Indicates if this line range is empty.\n     */\n    get isEmpty() {\n        return this.startLineNumber === this.endLineNumberExclusive;\n    }\n    /**\n     * Moves this line range by the given offset of line numbers.\n     */\n    delta(offset) {\n        return new LineRange(this.startLineNumber + offset, this.endLineNumberExclusive + offset);\n    }\n    deltaLength(offset) {\n        return new LineRange(this.startLineNumber, this.endLineNumberExclusive + offset);\n    }\n    /**\n     * The number of lines this line range spans.\n     */\n    get length() {\n        return this.endLineNumberExclusive - this.startLineNumber;\n    }\n    /**\n     * Creates a line range that combines this and the given line range.\n     */\n    join(other) {\n        return new LineRange(Math.min(this.startLineNumber, other.startLineNumber), Math.max(this.endLineNumberExclusive, other.endLineNumberExclusive));\n    }\n    toString() {\n        return `[${this.startLineNumber},${this.endLineNumberExclusive})`;\n    }\n    /**\n     * The resulting range is empty if the ranges do not intersect, but touch.\n     * If the ranges don't even touch, the result is undefined.\n     */\n    intersect(other) {\n        const startLineNumber = Math.max(this.startLineNumber, other.startLineNumber);\n        const endLineNumberExclusive = Math.min(this.endLineNumberExclusive, other.endLineNumberExclusive);\n        if (startLineNumber <= endLineNumberExclusive) {\n            return new LineRange(startLineNumber, endLineNumberExclusive);\n        }\n        return undefined;\n    }\n    intersectsStrict(other) {\n        return this.startLineNumber < other.endLineNumberExclusive && other.startLineNumber < this.endLineNumberExclusive;\n    }\n    overlapOrTouch(other) {\n        return this.startLineNumber <= other.endLineNumberExclusive && other.startLineNumber <= this.endLineNumberExclusive;\n    }\n    equals(b) {\n        return this.startLineNumber === b.startLineNumber && this.endLineNumberExclusive === b.endLineNumberExclusive;\n    }\n    toInclusiveRange() {\n        if (this.isEmpty) {\n            return null;\n        }\n        return new Range(this.startLineNumber, 1, this.endLineNumberExclusive - 1, Number.MAX_SAFE_INTEGER);\n    }\n    /**\n     * @deprecated Using this function is discouraged because it might lead to bugs: The end position is not guaranteed to be a valid position!\n    */\n    toExclusiveRange() {\n        return new Range(this.startLineNumber, 1, this.endLineNumberExclusive, 1);\n    }\n    mapToLineArray(f) {\n        const result = [];\n        for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) {\n            result.push(f(lineNumber));\n        }\n        return result;\n    }\n    forEach(f) {\n        for (let lineNumber = this.startLineNumber; lineNumber < this.endLineNumberExclusive; lineNumber++) {\n            f(lineNumber);\n        }\n    }\n    /**\n     * @internal\n     */\n    serialize() {\n        return [this.startLineNumber, this.endLineNumberExclusive];\n    }\n    includes(lineNumber) {\n        return this.startLineNumber <= lineNumber && lineNumber < this.endLineNumberExclusive;\n    }\n    /**\n     * Converts this 1-based line range to a 0-based offset range (subtracts 1!).\n     * @internal\n     */\n    toOffsetRange() {\n        return new OffsetRange(this.startLineNumber - 1, this.endLineNumberExclusive - 1);\n    }\n}\nexport class LineRangeSet {\n    constructor(\n    /**\n     * Sorted by start line number.\n     * No two line ranges are touching or intersecting.\n     */\n    _normalizedRanges = []) {\n        this._normalizedRanges = _normalizedRanges;\n    }\n    get ranges() {\n        return this._normalizedRanges;\n    }\n    addRange(range) {\n        if (range.length === 0) {\n            return;\n        }\n        // Idea: Find joinRange such that:\n        // replaceRange = _normalizedRanges.replaceRange(joinRange, range.joinAll(joinRange.map(idx => this._normalizedRanges[idx])))\n        // idx of first element that touches range or that is after range\n        const joinRangeStartIdx = findFirstIdxMonotonousOrArrLen(this._normalizedRanges, r => r.endLineNumberExclusive >= range.startLineNumber);\n        // idx of element after { last element that touches range or that is before range }\n        const joinRangeEndIdxExclusive = findLastIdxMonotonous(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1;\n        if (joinRangeStartIdx === joinRangeEndIdxExclusive) {\n            // If there is no element that touches range, then joinRangeStartIdx === joinRangeEndIdxExclusive and that value is the index of the element after range\n            this._normalizedRanges.splice(joinRangeStartIdx, 0, range);\n        }\n        else if (joinRangeStartIdx === joinRangeEndIdxExclusive - 1) {\n            // Else, there is an element that touches range and in this case it is both the first and last element. Thus we can replace it\n            const joinRange = this._normalizedRanges[joinRangeStartIdx];\n            this._normalizedRanges[joinRangeStartIdx] = joinRange.join(range);\n        }\n        else {\n            // First and last element are different - we need to replace the entire range\n            const joinRange = this._normalizedRanges[joinRangeStartIdx].join(this._normalizedRanges[joinRangeEndIdxExclusive - 1]).join(range);\n            this._normalizedRanges.splice(joinRangeStartIdx, joinRangeEndIdxExclusive - joinRangeStartIdx, joinRange);\n        }\n    }\n    contains(lineNumber) {\n        const rangeThatStartsBeforeEnd = findLastMonotonous(this._normalizedRanges, r => r.startLineNumber <= lineNumber);\n        return !!rangeThatStartsBeforeEnd && rangeThatStartsBeforeEnd.endLineNumberExclusive > lineNumber;\n    }\n    intersects(range) {\n        const rangeThatStartsBeforeEnd = findLastMonotonous(this._normalizedRanges, r => r.startLineNumber < range.endLineNumberExclusive);\n        return !!rangeThatStartsBeforeEnd && rangeThatStartsBeforeEnd.endLineNumberExclusive > range.startLineNumber;\n    }\n    getUnion(other) {\n        if (this._normalizedRanges.length === 0) {\n            return other;\n        }\n        if (other._normalizedRanges.length === 0) {\n            return this;\n        }\n        const result = [];\n        let i1 = 0;\n        let i2 = 0;\n        let current = null;\n        while (i1 < this._normalizedRanges.length || i2 < other._normalizedRanges.length) {\n            let next = null;\n            if (i1 < this._normalizedRanges.length && i2 < other._normalizedRanges.length) {\n                const lineRange1 = this._normalizedRanges[i1];\n                const lineRange2 = other._normalizedRanges[i2];\n                if (lineRange1.startLineNumber < lineRange2.startLineNumber) {\n                    next = lineRange1;\n                    i1++;\n                }\n                else {\n                    next = lineRange2;\n                    i2++;\n                }\n            }\n            else if (i1 < this._normalizedRanges.length) {\n                next = this._normalizedRanges[i1];\n                i1++;\n            }\n            else {\n                next = other._normalizedRanges[i2];\n                i2++;\n            }\n            if (current === null) {\n                current = next;\n            }\n            else {\n                if (current.endLineNumberExclusive >= next.startLineNumber) {\n                    // merge\n                    current = new LineRange(current.startLineNumber, Math.max(current.endLineNumberExclusive, next.endLineNumberExclusive));\n                }\n                else {\n                    // push\n                    result.push(current);\n                    current = next;\n                }\n            }\n        }\n        if (current !== null) {\n            result.push(current);\n        }\n        return new LineRangeSet(result);\n    }\n    /**\n     * Subtracts all ranges in this set from `range` and returns the result.\n     */\n    subtractFrom(range) {\n        // idx of first element that touches range or that is after range\n        const joinRangeStartIdx = findFirstIdxMonotonousOrArrLen(this._normalizedRanges, r => r.endLineNumberExclusive >= range.startLineNumber);\n        // idx of element after { last element that touches range or that is before range }\n        const joinRangeEndIdxExclusive = findLastIdxMonotonous(this._normalizedRanges, r => r.startLineNumber <= range.endLineNumberExclusive) + 1;\n        if (joinRangeStartIdx === joinRangeEndIdxExclusive) {\n            return new LineRangeSet([range]);\n        }\n        const result = [];\n        let startLineNumber = range.startLineNumber;\n        for (let i = joinRangeStartIdx; i < joinRangeEndIdxExclusive; i++) {\n            const r = this._normalizedRanges[i];\n            if (r.startLineNumber > startLineNumber) {\n                result.push(new LineRange(startLineNumber, r.startLineNumber));\n            }\n            startLineNumber = r.endLineNumberExclusive;\n        }\n        if (startLineNumber < range.endLineNumberExclusive) {\n            result.push(new LineRange(startLineNumber, range.endLineNumberExclusive));\n        }\n        return new LineRangeSet(result);\n    }\n    toString() {\n        return this._normalizedRanges.map(r => r.toString()).join(', ');\n    }\n    getIntersection(other) {\n        const result = [];\n        let i1 = 0;\n        let i2 = 0;\n        while (i1 < this._normalizedRanges.length && i2 < other._normalizedRanges.length) {\n            const r1 = this._normalizedRanges[i1];\n            const r2 = other._normalizedRanges[i2];\n            const i = r1.intersect(r2);\n            if (i && !i.isEmpty) {\n                result.push(i);\n            }\n            if (r1.endLineNumberExclusive < r2.endLineNumberExclusive) {\n                i1++;\n            }\n            else {\n                i2++;\n            }\n        }\n        return new LineRangeSet(result);\n    }\n    getWithDelta(value) {\n        return new LineRangeSet(this._normalizedRanges.map(r => r.delta(value)));\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { BugIndicatingError } from '../../../base/common/errors.js';\n/**\n * A range of offsets (0-based).\n*/\nexport class OffsetRange {\n    static addRange(range, sortedRanges) {\n        let i = 0;\n        while (i < sortedRanges.length && sortedRanges[i].endExclusive < range.start) {\n            i++;\n        }\n        let j = i;\n        while (j < sortedRanges.length && sortedRanges[j].start <= range.endExclusive) {\n            j++;\n        }\n        if (i === j) {\n            sortedRanges.splice(i, 0, range);\n        }\n        else {\n            const start = Math.min(range.start, sortedRanges[i].start);\n            const end = Math.max(range.endExclusive, sortedRanges[j - 1].endExclusive);\n            sortedRanges.splice(i, j - i, new OffsetRange(start, end));\n        }\n    }\n    static tryCreate(start, endExclusive) {\n        if (start > endExclusive) {\n            return undefined;\n        }\n        return new OffsetRange(start, endExclusive);\n    }\n    static ofLength(length) {\n        return new OffsetRange(0, length);\n    }\n    static ofStartAndLength(start, length) {\n        return new OffsetRange(start, start + length);\n    }\n    constructor(start, endExclusive) {\n        this.start = start;\n        this.endExclusive = endExclusive;\n        if (start > endExclusive) {\n            throw new BugIndicatingError(`Invalid range: ${this.toString()}`);\n        }\n    }\n    get isEmpty() {\n        return this.start === this.endExclusive;\n    }\n    delta(offset) {\n        return new OffsetRange(this.start + offset, this.endExclusive + offset);\n    }\n    deltaStart(offset) {\n        return new OffsetRange(this.start + offset, this.endExclusive);\n    }\n    deltaEnd(offset) {\n        return new OffsetRange(this.start, this.endExclusive + offset);\n    }\n    get length() {\n        return this.endExclusive - this.start;\n    }\n    toString() {\n        return `[${this.start}, ${this.endExclusive})`;\n    }\n    contains(offset) {\n        return this.start <= offset && offset < this.endExclusive;\n    }\n    /**\n     * for all numbers n: range1.contains(n) or range2.contains(n) => range1.join(range2).contains(n)\n     * The joined range is the smallest range that contains both ranges.\n     */\n    join(other) {\n        return new OffsetRange(Math.min(this.start, other.start), Math.max(this.endExclusive, other.endExclusive));\n    }\n    /**\n     * for all numbers n: range1.contains(n) and range2.contains(n) <=> range1.intersect(range2).contains(n)\n     *\n     * The resulting range is empty if the ranges do not intersect, but touch.\n     * If the ranges don't even touch, the result is undefined.\n     */\n    intersect(other) {\n        const start = Math.max(this.start, other.start);\n        const end = Math.min(this.endExclusive, other.endExclusive);\n        if (start <= end) {\n            return new OffsetRange(start, end);\n        }\n        return undefined;\n    }\n    intersects(other) {\n        const start = Math.max(this.start, other.start);\n        const end = Math.min(this.endExclusive, other.endExclusive);\n        return start < end;\n    }\n    isBefore(other) {\n        return this.endExclusive <= other.start;\n    }\n    isAfter(other) {\n        return this.start >= other.endExclusive;\n    }\n    slice(arr) {\n        return arr.slice(this.start, this.endExclusive);\n    }\n    substring(str) {\n        return str.substring(this.start, this.endExclusive);\n    }\n    /**\n     * Returns the given value if it is contained in this instance, otherwise the closest value that is contained.\n     * The range must not be empty.\n     */\n    clip(value) {\n        if (this.isEmpty) {\n            throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);\n        }\n        return Math.max(this.start, Math.min(this.endExclusive - 1, value));\n    }\n    /**\n     * Returns `r := value + k * length` such that `r` is contained in this range.\n     * The range must not be empty.\n     *\n     * E.g. `[5, 10).clipCyclic(10) === 5`, `[5, 10).clipCyclic(11) === 6` and `[5, 10).clipCyclic(4) === 9`.\n     */\n    clipCyclic(value) {\n        if (this.isEmpty) {\n            throw new BugIndicatingError(`Invalid clipping range: ${this.toString()}`);\n        }\n        if (value < this.start) {\n            return this.endExclusive - ((this.start - value) % this.length);\n        }\n        if (value >= this.endExclusive) {\n            return this.start + ((value - this.start) % this.length);\n        }\n        return value;\n    }\n    forEach(f) {\n        for (let i = this.start; i < this.endExclusive; i++) {\n            f(i);\n        }\n    }\n}\nexport class OffsetRangeSet {\n    constructor() {\n        this._sortedRanges = [];\n    }\n    addRange(range) {\n        let i = 0;\n        while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive < range.start) {\n            i++;\n        }\n        let j = i;\n        while (j < this._sortedRanges.length && this._sortedRanges[j].start <= range.endExclusive) {\n            j++;\n        }\n        if (i === j) {\n            this._sortedRanges.splice(i, 0, range);\n        }\n        else {\n            const start = Math.min(range.start, this._sortedRanges[i].start);\n            const end = Math.max(range.endExclusive, this._sortedRanges[j - 1].endExclusive);\n            this._sortedRanges.splice(i, j - i, new OffsetRange(start, end));\n        }\n    }\n    toString() {\n        return this._sortedRanges.map(r => r.toString()).join(', ');\n    }\n    /**\n     * Returns of there is a value that is contained in this instance and the given range.\n     */\n    intersectsStrict(other) {\n        // TODO use binary search\n        let i = 0;\n        while (i < this._sortedRanges.length && this._sortedRanges[i].endExclusive <= other.start) {\n            i++;\n        }\n        return i < this._sortedRanges.length && this._sortedRanges[i].start < other.endExclusive;\n    }\n    intersectWithRange(other) {\n        // TODO use binary search + slice\n        const result = new OffsetRangeSet();\n        for (const range of this._sortedRanges) {\n            const intersection = range.intersect(other);\n            if (intersection) {\n                result.addRange(intersection);\n            }\n        }\n        return result;\n    }\n    intersectWithRangeLength(other) {\n        return this.intersectWithRange(other).length;\n    }\n    get length() {\n        return this._sortedRanges.reduce((prev, cur) => prev + cur.length, 0);\n    }\n}\n"],"names":["CharacterClassifier","constructor","_defaultValue","defaultValue","this","_asciiMap","_createAsciiMap","_map","Map","asciiMap","Uint8Array","fill","set","charCode","_value","value","get","clear","CharacterSet","_actual","add","has","CursorColumns","_nextVisibleColumn","codePoint","visibleColumn","tabSize","nextRenderTabStop","visibleColumnFromColumn","lineContent","column","textLen","Math","min","length","text","substring","iterator","result","eol","offset","nextGraphemeLength","columnFromVisibleColumn","lineContentLength","beforeVisibleColumn","beforeColumn","afterVisibleColumn","afterColumn","nextIndentTabStop","indentSize","prevRenderTabStop","max","prevIndentTabStop","EditOperation","insert","position","range","lineNumber","forceMoveMarkers","replace","replaceMove","editorLineHighlight","dark","light","hcDark","hcLight","editorLineHighlightBorder","editorCursorForeground","editorCursorBackground","editorMultiCursorPrimaryForeground","editorMultiCursorPrimaryBackground","editorMultiCursorSecondaryForeground","editorMultiCursorSecondaryBackground","editorWhitespaces","editorLineNumbers","deprecatedEditorIndentGuides","deprecatedEditorActiveIndentGuides","editorIndentGuide1","editorIndentGuide2","editorIndentGuide3","editorIndentGuide4","editorIndentGuide5","editorIndentGuide6","editorActiveIndentGuide1","editorActiveIndentGuide2","editorActiveIndentGuide3","editorActiveIndentGuide4","editorActiveIndentGuide5","editorActiveIndentGuide6","deprecatedEditorActiveLineNumber","editorDimmedLineNumber","editorOverviewRulerBorder","editorOverviewRulerBackground","editorUnnecessaryCodeOpacity","transparent","rulerRangeDefault","overviewRulerRangeHighlight","overviewRulerError","overviewRulerWarning","overviewRulerInfo","editorBracketHighlightingForeground1","editorBracketHighlightingForeground2","editorBracketHighlightingForeground3","editorBracketHighlightingForeground4","editorBracketHighlightingForeground5","editorBracketHighlightingForeground6","editorBracketHighlightingUnexpectedBracketForeground","editorBracketPairGuideBackground1","editorBracketPairGuideBackground2","editorBracketPairGuideBackground3","editorBracketPairGuideBackground4","editorBracketPairGuideBackground5","editorBracketPairGuideBackground6","editorBracketPairGuideActiveBackground1","editorBracketPairGuideActiveBackground2","editorBracketPairGuideActiveBackground3","editorBracketPairGuideActiveBackground4","editorBracketPairGuideActiveBackground5","editorBracketPairGuideActiveBackground6","theme","collector","background","getColor","lineHighlight","imeBackground","isTransparent","addRule","countEOL","eolCount","firstLineLength","lastLineStart","i","len","chr","charCodeAt","normalizeIndentation","str","insertSpaces","firstNonWhitespaceIndex","spacesCnt","charAt","tabsCnt","floor","_normalizeIndentationFromWhitespace","LineRange","fromRangeInclusive","startLineNumber","endLineNumber","joinMany","lineRanges","LineRangeSet","slice","getUnion","ranges","join","endLineNumberExclusive","ofLength","deserialize","lineRange","contains","isEmpty","delta","deltaLength","other","toString","intersect","intersectsStrict","overlapOrTouch","equals","b","toInclusiveRange","Number","MAX_SAFE_INTEGER","toExclusiveRange","mapToLineArray","f","push","forEach","serialize","includes","toOffsetRange","_normalizedRanges","addRange","joinRangeStartIdx","r","joinRangeEndIdxExclusive","splice","joinRange","rangeThatStartsBeforeEnd","intersects","i1","i2","current","next","lineRange1","lineRange2","subtractFrom","map","getIntersection","r1","r2","getWithDelta","OffsetRange","sortedRanges","endExclusive","start","j","end","tryCreate","ofStartAndLength","deltaStart","deltaEnd","isBefore","isAfter","arr","clip","clipCyclic","OffsetRangeSet","_sortedRanges","intersectWithRange","intersection","intersectWithRangeLength","reduce","prev","cur"],"sourceRoot":""}