{"version":3,"file":"static/js/1380_35a111c21d0676be2632.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/viewEventHandler.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/viewEvents.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/viewLayout/lineDecorations.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/viewLayout/linesLayout.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/viewLayout/viewLayout.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/viewLayout/linePart.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/viewLayout/viewLineRenderer.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/viewLayout/viewLinesViewportData.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/viewModel/glyphLanesModel.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/viewModelEventDispatcher.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 { Disposable } from '../../base/common/lifecycle.js';\nexport class ViewEventHandler extends Disposable {\n    constructor() {\n        super();\n        this._shouldRender = true;\n    }\n    shouldRender() {\n        return this._shouldRender;\n    }\n    forceShouldRender() {\n        this._shouldRender = true;\n    }\n    setShouldRender() {\n        this._shouldRender = true;\n    }\n    onDidRender() {\n        this._shouldRender = false;\n    }\n    // --- begin event handlers\n    onCompositionStart(e) {\n        return false;\n    }\n    onCompositionEnd(e) {\n        return false;\n    }\n    onConfigurationChanged(e) {\n        return false;\n    }\n    onCursorStateChanged(e) {\n        return false;\n    }\n    onDecorationsChanged(e) {\n        return false;\n    }\n    onFlushed(e) {\n        return false;\n    }\n    onFocusChanged(e) {\n        return false;\n    }\n    onLanguageConfigurationChanged(e) {\n        return false;\n    }\n    onLineMappingChanged(e) {\n        return false;\n    }\n    onLinesChanged(e) {\n        return false;\n    }\n    onLinesDeleted(e) {\n        return false;\n    }\n    onLinesInserted(e) {\n        return false;\n    }\n    onRevealRangeRequest(e) {\n        return false;\n    }\n    onScrollChanged(e) {\n        return false;\n    }\n    onThemeChanged(e) {\n        return false;\n    }\n    onTokensChanged(e) {\n        return false;\n    }\n    onTokensColorsChanged(e) {\n        return false;\n    }\n    onZonesChanged(e) {\n        return false;\n    }\n    // --- end event handlers\n    handleEvents(events) {\n        let shouldRender = false;\n        for (let i = 0, len = events.length; i < len; i++) {\n            const e = events[i];\n            switch (e.type) {\n                case 0 /* viewEvents.ViewEventType.ViewCompositionStart */:\n                    if (this.onCompositionStart(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 1 /* viewEvents.ViewEventType.ViewCompositionEnd */:\n                    if (this.onCompositionEnd(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 2 /* viewEvents.ViewEventType.ViewConfigurationChanged */:\n                    if (this.onConfigurationChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 3 /* viewEvents.ViewEventType.ViewCursorStateChanged */:\n                    if (this.onCursorStateChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 4 /* viewEvents.ViewEventType.ViewDecorationsChanged */:\n                    if (this.onDecorationsChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 5 /* viewEvents.ViewEventType.ViewFlushed */:\n                    if (this.onFlushed(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 6 /* viewEvents.ViewEventType.ViewFocusChanged */:\n                    if (this.onFocusChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 7 /* viewEvents.ViewEventType.ViewLanguageConfigurationChanged */:\n                    if (this.onLanguageConfigurationChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 8 /* viewEvents.ViewEventType.ViewLineMappingChanged */:\n                    if (this.onLineMappingChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 9 /* viewEvents.ViewEventType.ViewLinesChanged */:\n                    if (this.onLinesChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 10 /* viewEvents.ViewEventType.ViewLinesDeleted */:\n                    if (this.onLinesDeleted(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 11 /* viewEvents.ViewEventType.ViewLinesInserted */:\n                    if (this.onLinesInserted(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 12 /* viewEvents.ViewEventType.ViewRevealRangeRequest */:\n                    if (this.onRevealRangeRequest(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 13 /* viewEvents.ViewEventType.ViewScrollChanged */:\n                    if (this.onScrollChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 15 /* viewEvents.ViewEventType.ViewTokensChanged */:\n                    if (this.onTokensChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 14 /* viewEvents.ViewEventType.ViewThemeChanged */:\n                    if (this.onThemeChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 16 /* viewEvents.ViewEventType.ViewTokensColorsChanged */:\n                    if (this.onTokensColorsChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                case 17 /* viewEvents.ViewEventType.ViewZonesChanged */:\n                    if (this.onZonesChanged(e)) {\n                        shouldRender = true;\n                    }\n                    break;\n                default:\n                    console.info('View received unknown event: ');\n                    console.info(e);\n            }\n        }\n        if (shouldRender) {\n            this._shouldRender = 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 *--------------------------------------------------------------------------------------------*/\nexport class ViewCompositionStartEvent {\n    constructor() {\n        this.type = 0 /* ViewEventType.ViewCompositionStart */;\n    }\n}\nexport class ViewCompositionEndEvent {\n    constructor() {\n        this.type = 1 /* ViewEventType.ViewCompositionEnd */;\n    }\n}\nexport class ViewConfigurationChangedEvent {\n    constructor(source) {\n        this.type = 2 /* ViewEventType.ViewConfigurationChanged */;\n        this._source = source;\n    }\n    hasChanged(id) {\n        return this._source.hasChanged(id);\n    }\n}\nexport class ViewCursorStateChangedEvent {\n    constructor(selections, modelSelections, reason) {\n        this.selections = selections;\n        this.modelSelections = modelSelections;\n        this.reason = reason;\n        this.type = 3 /* ViewEventType.ViewCursorStateChanged */;\n    }\n}\nexport class ViewDecorationsChangedEvent {\n    constructor(source) {\n        this.type = 4 /* ViewEventType.ViewDecorationsChanged */;\n        if (source) {\n            this.affectsMinimap = source.affectsMinimap;\n            this.affectsOverviewRuler = source.affectsOverviewRuler;\n            this.affectsGlyphMargin = source.affectsGlyphMargin;\n            this.affectsLineNumber = source.affectsLineNumber;\n        }\n        else {\n            this.affectsMinimap = true;\n            this.affectsOverviewRuler = true;\n            this.affectsGlyphMargin = true;\n            this.affectsLineNumber = true;\n        }\n    }\n}\nexport class ViewFlushedEvent {\n    constructor() {\n        this.type = 5 /* ViewEventType.ViewFlushed */;\n        // Nothing to do\n    }\n}\nexport class ViewFocusChangedEvent {\n    constructor(isFocused) {\n        this.type = 6 /* ViewEventType.ViewFocusChanged */;\n        this.isFocused = isFocused;\n    }\n}\nexport class ViewLanguageConfigurationEvent {\n    constructor() {\n        this.type = 7 /* ViewEventType.ViewLanguageConfigurationChanged */;\n    }\n}\nexport class ViewLineMappingChangedEvent {\n    constructor() {\n        this.type = 8 /* ViewEventType.ViewLineMappingChanged */;\n        // Nothing to do\n    }\n}\nexport class ViewLinesChangedEvent {\n    constructor(\n    /**\n     * The first line that has changed.\n     */\n    fromLineNumber, \n    /**\n     * The number of lines that have changed.\n     */\n    count) {\n        this.fromLineNumber = fromLineNumber;\n        this.count = count;\n        this.type = 9 /* ViewEventType.ViewLinesChanged */;\n    }\n}\nexport class ViewLinesDeletedEvent {\n    constructor(fromLineNumber, toLineNumber) {\n        this.type = 10 /* ViewEventType.ViewLinesDeleted */;\n        this.fromLineNumber = fromLineNumber;\n        this.toLineNumber = toLineNumber;\n    }\n}\nexport class ViewLinesInsertedEvent {\n    constructor(fromLineNumber, toLineNumber) {\n        this.type = 11 /* ViewEventType.ViewLinesInserted */;\n        this.fromLineNumber = fromLineNumber;\n        this.toLineNumber = toLineNumber;\n    }\n}\nexport class ViewRevealRangeRequestEvent {\n    constructor(\n    /**\n     * Source of the call that caused the event.\n     */\n    source, \n    /**\n     * Reduce the revealing to a minimum (e.g. avoid scrolling if the bounding box is visible and near the viewport edge).\n     */\n    minimalReveal, \n    /**\n     * Range to be reavealed.\n     */\n    range, \n    /**\n     * Selections to be revealed.\n     */\n    selections, \n    /**\n     * The vertical reveal strategy.\n     */\n    verticalType, \n    /**\n     * If true: there should be a horizontal & vertical revealing.\n     * If false: there should be just a vertical revealing.\n     */\n    revealHorizontal, \n    /**\n     * The scroll type.\n     */\n    scrollType) {\n        this.source = source;\n        this.minimalReveal = minimalReveal;\n        this.range = range;\n        this.selections = selections;\n        this.verticalType = verticalType;\n        this.revealHorizontal = revealHorizontal;\n        this.scrollType = scrollType;\n        this.type = 12 /* ViewEventType.ViewRevealRangeRequest */;\n    }\n}\nexport class ViewScrollChangedEvent {\n    constructor(source) {\n        this.type = 13 /* ViewEventType.ViewScrollChanged */;\n        this.scrollWidth = source.scrollWidth;\n        this.scrollLeft = source.scrollLeft;\n        this.scrollHeight = source.scrollHeight;\n        this.scrollTop = source.scrollTop;\n        this.scrollWidthChanged = source.scrollWidthChanged;\n        this.scrollLeftChanged = source.scrollLeftChanged;\n        this.scrollHeightChanged = source.scrollHeightChanged;\n        this.scrollTopChanged = source.scrollTopChanged;\n    }\n}\nexport class ViewThemeChangedEvent {\n    constructor(theme) {\n        this.theme = theme;\n        this.type = 14 /* ViewEventType.ViewThemeChanged */;\n    }\n}\nexport class ViewTokensChangedEvent {\n    constructor(ranges) {\n        this.type = 15 /* ViewEventType.ViewTokensChanged */;\n        this.ranges = ranges;\n    }\n}\nexport class ViewTokensColorsChangedEvent {\n    constructor() {\n        this.type = 16 /* ViewEventType.ViewTokensColorsChanged */;\n        // Nothing to do\n    }\n}\nexport class ViewZonesChangedEvent {\n    constructor() {\n        this.type = 17 /* ViewEventType.ViewZonesChanged */;\n        // Nothing to do\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';\nexport class LineDecoration {\n    constructor(startColumn, endColumn, className, type) {\n        this.startColumn = startColumn;\n        this.endColumn = endColumn;\n        this.className = className;\n        this.type = type;\n        this._lineDecorationBrand = undefined;\n    }\n    static _equals(a, b) {\n        return (a.startColumn === b.startColumn\n            && a.endColumn === b.endColumn\n            && a.className === b.className\n            && a.type === b.type);\n    }\n    static equalsArr(a, b) {\n        const aLen = a.length;\n        const bLen = b.length;\n        if (aLen !== bLen) {\n            return false;\n        }\n        for (let i = 0; i < aLen; i++) {\n            if (!LineDecoration._equals(a[i], b[i])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    static extractWrapped(arr, startOffset, endOffset) {\n        if (arr.length === 0) {\n            return arr;\n        }\n        const startColumn = startOffset + 1;\n        const endColumn = endOffset + 1;\n        const lineLength = endOffset - startOffset;\n        const r = [];\n        let rLength = 0;\n        for (const dec of arr) {\n            if (dec.endColumn <= startColumn || dec.startColumn >= endColumn) {\n                continue;\n            }\n            r[rLength++] = new LineDecoration(Math.max(1, dec.startColumn - startColumn + 1), Math.min(lineLength + 1, dec.endColumn - startColumn + 1), dec.className, dec.type);\n        }\n        return r;\n    }\n    static filter(lineDecorations, lineNumber, minLineColumn, maxLineColumn) {\n        if (lineDecorations.length === 0) {\n            return [];\n        }\n        const result = [];\n        let resultLen = 0;\n        for (let i = 0, len = lineDecorations.length; i < len; i++) {\n            const d = lineDecorations[i];\n            const range = d.range;\n            if (range.endLineNumber < lineNumber || range.startLineNumber > lineNumber) {\n                // Ignore decorations that sit outside this line\n                continue;\n            }\n            if (range.isEmpty() && (d.type === 0 /* InlineDecorationType.Regular */ || d.type === 3 /* InlineDecorationType.RegularAffectingLetterSpacing */)) {\n                // Ignore empty range decorations\n                continue;\n            }\n            const startColumn = (range.startLineNumber === lineNumber ? range.startColumn : minLineColumn);\n            const endColumn = (range.endLineNumber === lineNumber ? range.endColumn : maxLineColumn);\n            result[resultLen++] = new LineDecoration(startColumn, endColumn, d.inlineClassName, d.type);\n        }\n        return result;\n    }\n    static _typeCompare(a, b) {\n        const ORDER = [2, 0, 1, 3];\n        return ORDER[a] - ORDER[b];\n    }\n    static compare(a, b) {\n        if (a.startColumn !== b.startColumn) {\n            return a.startColumn - b.startColumn;\n        }\n        if (a.endColumn !== b.endColumn) {\n            return a.endColumn - b.endColumn;\n        }\n        const typeCmp = LineDecoration._typeCompare(a.type, b.type);\n        if (typeCmp !== 0) {\n            return typeCmp;\n        }\n        if (a.className !== b.className) {\n            return a.className < b.className ? -1 : 1;\n        }\n        return 0;\n    }\n}\nexport class DecorationSegment {\n    constructor(startOffset, endOffset, className, metadata) {\n        this.startOffset = startOffset;\n        this.endOffset = endOffset;\n        this.className = className;\n        this.metadata = metadata;\n    }\n}\nclass Stack {\n    constructor() {\n        this.stopOffsets = [];\n        this.classNames = [];\n        this.metadata = [];\n        this.count = 0;\n    }\n    static _metadata(metadata) {\n        let result = 0;\n        for (let i = 0, len = metadata.length; i < len; i++) {\n            result |= metadata[i];\n        }\n        return result;\n    }\n    consumeLowerThan(maxStopOffset, nextStartOffset, result) {\n        while (this.count > 0 && this.stopOffsets[0] < maxStopOffset) {\n            let i = 0;\n            // Take all equal stopping offsets\n            while (i + 1 < this.count && this.stopOffsets[i] === this.stopOffsets[i + 1]) {\n                i++;\n            }\n            // Basically we are consuming the first i + 1 elements of the stack\n            result.push(new DecorationSegment(nextStartOffset, this.stopOffsets[i], this.classNames.join(' '), Stack._metadata(this.metadata)));\n            nextStartOffset = this.stopOffsets[i] + 1;\n            // Consume them\n            this.stopOffsets.splice(0, i + 1);\n            this.classNames.splice(0, i + 1);\n            this.metadata.splice(0, i + 1);\n            this.count -= (i + 1);\n        }\n        if (this.count > 0 && nextStartOffset < maxStopOffset) {\n            result.push(new DecorationSegment(nextStartOffset, maxStopOffset - 1, this.classNames.join(' '), Stack._metadata(this.metadata)));\n            nextStartOffset = maxStopOffset;\n        }\n        return nextStartOffset;\n    }\n    insert(stopOffset, className, metadata) {\n        if (this.count === 0 || this.stopOffsets[this.count - 1] <= stopOffset) {\n            // Insert at the end\n            this.stopOffsets.push(stopOffset);\n            this.classNames.push(className);\n            this.metadata.push(metadata);\n        }\n        else {\n            // Find the insertion position for `stopOffset`\n            for (let i = 0; i < this.count; i++) {\n                if (this.stopOffsets[i] >= stopOffset) {\n                    this.stopOffsets.splice(i, 0, stopOffset);\n                    this.classNames.splice(i, 0, className);\n                    this.metadata.splice(i, 0, metadata);\n                    break;\n                }\n            }\n        }\n        this.count++;\n        return;\n    }\n}\nexport class LineDecorationsNormalizer {\n    /**\n     * Normalize line decorations. Overlapping decorations will generate multiple segments\n     */\n    static normalize(lineContent, lineDecorations) {\n        if (lineDecorations.length === 0) {\n            return [];\n        }\n        const result = [];\n        const stack = new Stack();\n        let nextStartOffset = 0;\n        for (let i = 0, len = lineDecorations.length; i < len; i++) {\n            const d = lineDecorations[i];\n            let startColumn = d.startColumn;\n            let endColumn = d.endColumn;\n            const className = d.className;\n            const metadata = (d.type === 1 /* InlineDecorationType.Before */\n                ? 2 /* LinePartMetadata.PSEUDO_BEFORE */\n                : d.type === 2 /* InlineDecorationType.After */\n                    ? 4 /* LinePartMetadata.PSEUDO_AFTER */\n                    : 0);\n            // If the position would end up in the middle of a high-low surrogate pair, we move it to before the pair\n            if (startColumn > 1) {\n                const charCodeBefore = lineContent.charCodeAt(startColumn - 2);\n                if (strings.isHighSurrogate(charCodeBefore)) {\n                    startColumn--;\n                }\n            }\n            if (endColumn > 1) {\n                const charCodeBefore = lineContent.charCodeAt(endColumn - 2);\n                if (strings.isHighSurrogate(charCodeBefore)) {\n                    endColumn--;\n                }\n            }\n            const currentStartOffset = startColumn - 1;\n            const currentEndOffset = endColumn - 2;\n            nextStartOffset = stack.consumeLowerThan(currentStartOffset, nextStartOffset, result);\n            if (stack.count === 0) {\n                nextStartOffset = currentStartOffset;\n            }\n            stack.insert(currentEndOffset, className, metadata);\n        }\n        stack.consumeLowerThan(1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */, nextStartOffset, result);\n        return result;\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';\nclass PendingChanges {\n    constructor() {\n        this._hasPending = false;\n        this._inserts = [];\n        this._changes = [];\n        this._removes = [];\n    }\n    insert(x) {\n        this._hasPending = true;\n        this._inserts.push(x);\n    }\n    change(x) {\n        this._hasPending = true;\n        this._changes.push(x);\n    }\n    remove(x) {\n        this._hasPending = true;\n        this._removes.push(x);\n    }\n    mustCommit() {\n        return this._hasPending;\n    }\n    commit(linesLayout) {\n        if (!this._hasPending) {\n            return;\n        }\n        const inserts = this._inserts;\n        const changes = this._changes;\n        const removes = this._removes;\n        this._hasPending = false;\n        this._inserts = [];\n        this._changes = [];\n        this._removes = [];\n        linesLayout._commitPendingChanges(inserts, changes, removes);\n    }\n}\nexport class EditorWhitespace {\n    constructor(id, afterLineNumber, ordinal, height, minWidth) {\n        this.id = id;\n        this.afterLineNumber = afterLineNumber;\n        this.ordinal = ordinal;\n        this.height = height;\n        this.minWidth = minWidth;\n        this.prefixSum = 0;\n    }\n}\n/**\n * Layouting of objects that take vertical space (by having a height) and push down other objects.\n *\n * These objects are basically either text (lines) or spaces between those lines (whitespaces).\n * This provides commodity operations for working with lines that contain whitespace that pushes lines lower (vertically).\n */\nexport class LinesLayout {\n    constructor(lineCount, lineHeight, paddingTop, paddingBottom) {\n        this._instanceId = strings.singleLetterHash(++LinesLayout.INSTANCE_COUNT);\n        this._pendingChanges = new PendingChanges();\n        this._lastWhitespaceId = 0;\n        this._arr = [];\n        this._prefixSumValidIndex = -1;\n        this._minWidth = -1; /* marker for not being computed */\n        this._lineCount = lineCount;\n        this._lineHeight = lineHeight;\n        this._paddingTop = paddingTop;\n        this._paddingBottom = paddingBottom;\n    }\n    /**\n     * Find the insertion index for a new value inside a sorted array of values.\n     * If the value is already present in the sorted array, the insertion index will be after the already existing value.\n     */\n    static findInsertionIndex(arr, afterLineNumber, ordinal) {\n        let low = 0;\n        let high = arr.length;\n        while (low < high) {\n            const mid = ((low + high) >>> 1);\n            if (afterLineNumber === arr[mid].afterLineNumber) {\n                if (ordinal < arr[mid].ordinal) {\n                    high = mid;\n                }\n                else {\n                    low = mid + 1;\n                }\n            }\n            else if (afterLineNumber < arr[mid].afterLineNumber) {\n                high = mid;\n            }\n            else {\n                low = mid + 1;\n            }\n        }\n        return low;\n    }\n    /**\n     * Change the height of a line in pixels.\n     */\n    setLineHeight(lineHeight) {\n        this._checkPendingChanges();\n        this._lineHeight = lineHeight;\n    }\n    /**\n     * Changes the padding used to calculate vertical offsets.\n     */\n    setPadding(paddingTop, paddingBottom) {\n        this._paddingTop = paddingTop;\n        this._paddingBottom = paddingBottom;\n    }\n    /**\n     * Set the number of lines.\n     *\n     * @param lineCount New number of lines.\n     */\n    onFlushed(lineCount) {\n        this._checkPendingChanges();\n        this._lineCount = lineCount;\n    }\n    changeWhitespace(callback) {\n        let hadAChange = false;\n        try {\n            const accessor = {\n                insertWhitespace: (afterLineNumber, ordinal, heightInPx, minWidth) => {\n                    hadAChange = true;\n                    afterLineNumber = afterLineNumber | 0;\n                    ordinal = ordinal | 0;\n                    heightInPx = heightInPx | 0;\n                    minWidth = minWidth | 0;\n                    const id = this._instanceId + (++this._lastWhitespaceId);\n                    this._pendingChanges.insert(new EditorWhitespace(id, afterLineNumber, ordinal, heightInPx, minWidth));\n                    return id;\n                },\n                changeOneWhitespace: (id, newAfterLineNumber, newHeight) => {\n                    hadAChange = true;\n                    newAfterLineNumber = newAfterLineNumber | 0;\n                    newHeight = newHeight | 0;\n                    this._pendingChanges.change({ id, newAfterLineNumber, newHeight });\n                },\n                removeWhitespace: (id) => {\n                    hadAChange = true;\n                    this._pendingChanges.remove({ id });\n                }\n            };\n            callback(accessor);\n        }\n        finally {\n            this._pendingChanges.commit(this);\n        }\n        return hadAChange;\n    }\n    _commitPendingChanges(inserts, changes, removes) {\n        if (inserts.length > 0 || removes.length > 0) {\n            this._minWidth = -1; /* marker for not being computed */\n        }\n        if (inserts.length + changes.length + removes.length <= 1) {\n            // when only one thing happened, handle it \"delicately\"\n            for (const insert of inserts) {\n                this._insertWhitespace(insert);\n            }\n            for (const change of changes) {\n                this._changeOneWhitespace(change.id, change.newAfterLineNumber, change.newHeight);\n            }\n            for (const remove of removes) {\n                const index = this._findWhitespaceIndex(remove.id);\n                if (index === -1) {\n                    continue;\n                }\n                this._removeWhitespace(index);\n            }\n            return;\n        }\n        // simply rebuild the entire datastructure\n        const toRemove = new Set();\n        for (const remove of removes) {\n            toRemove.add(remove.id);\n        }\n        const toChange = new Map();\n        for (const change of changes) {\n            toChange.set(change.id, change);\n        }\n        const applyRemoveAndChange = (whitespaces) => {\n            const result = [];\n            for (const whitespace of whitespaces) {\n                if (toRemove.has(whitespace.id)) {\n                    continue;\n                }\n                if (toChange.has(whitespace.id)) {\n                    const change = toChange.get(whitespace.id);\n                    whitespace.afterLineNumber = change.newAfterLineNumber;\n                    whitespace.height = change.newHeight;\n                }\n                result.push(whitespace);\n            }\n            return result;\n        };\n        const result = applyRemoveAndChange(this._arr).concat(applyRemoveAndChange(inserts));\n        result.sort((a, b) => {\n            if (a.afterLineNumber === b.afterLineNumber) {\n                return a.ordinal - b.ordinal;\n            }\n            return a.afterLineNumber - b.afterLineNumber;\n        });\n        this._arr = result;\n        this._prefixSumValidIndex = -1;\n    }\n    _checkPendingChanges() {\n        if (this._pendingChanges.mustCommit()) {\n            this._pendingChanges.commit(this);\n        }\n    }\n    _insertWhitespace(whitespace) {\n        const insertIndex = LinesLayout.findInsertionIndex(this._arr, whitespace.afterLineNumber, whitespace.ordinal);\n        this._arr.splice(insertIndex, 0, whitespace);\n        this._prefixSumValidIndex = Math.min(this._prefixSumValidIndex, insertIndex - 1);\n    }\n    _findWhitespaceIndex(id) {\n        const arr = this._arr;\n        for (let i = 0, len = arr.length; i < len; i++) {\n            if (arr[i].id === id) {\n                return i;\n            }\n        }\n        return -1;\n    }\n    _changeOneWhitespace(id, newAfterLineNumber, newHeight) {\n        const index = this._findWhitespaceIndex(id);\n        if (index === -1) {\n            return;\n        }\n        if (this._arr[index].height !== newHeight) {\n            this._arr[index].height = newHeight;\n            this._prefixSumValidIndex = Math.min(this._prefixSumValidIndex, index - 1);\n        }\n        if (this._arr[index].afterLineNumber !== newAfterLineNumber) {\n            // `afterLineNumber` changed for this whitespace\n            // Record old whitespace\n            const whitespace = this._arr[index];\n            // Since changing `afterLineNumber` can trigger a reordering, we're gonna remove this whitespace\n            this._removeWhitespace(index);\n            whitespace.afterLineNumber = newAfterLineNumber;\n            // And add it again\n            this._insertWhitespace(whitespace);\n        }\n    }\n    _removeWhitespace(removeIndex) {\n        this._arr.splice(removeIndex, 1);\n        this._prefixSumValidIndex = Math.min(this._prefixSumValidIndex, removeIndex - 1);\n    }\n    /**\n     * Notify the layouter that lines have been deleted (a continuous zone of lines).\n     *\n     * @param fromLineNumber The line number at which the deletion started, inclusive\n     * @param toLineNumber The line number at which the deletion ended, inclusive\n     */\n    onLinesDeleted(fromLineNumber, toLineNumber) {\n        this._checkPendingChanges();\n        fromLineNumber = fromLineNumber | 0;\n        toLineNumber = toLineNumber | 0;\n        this._lineCount -= (toLineNumber - fromLineNumber + 1);\n        for (let i = 0, len = this._arr.length; i < len; i++) {\n            const afterLineNumber = this._arr[i].afterLineNumber;\n            if (fromLineNumber <= afterLineNumber && afterLineNumber <= toLineNumber) {\n                // The line this whitespace was after has been deleted\n                //  => move whitespace to before first deleted line\n                this._arr[i].afterLineNumber = fromLineNumber - 1;\n            }\n            else if (afterLineNumber > toLineNumber) {\n                // The line this whitespace was after has been moved up\n                //  => move whitespace up\n                this._arr[i].afterLineNumber -= (toLineNumber - fromLineNumber + 1);\n            }\n        }\n    }\n    /**\n     * Notify the layouter that lines have been inserted (a continuous zone of lines).\n     *\n     * @param fromLineNumber The line number at which the insertion started, inclusive\n     * @param toLineNumber The line number at which the insertion ended, inclusive.\n     */\n    onLinesInserted(fromLineNumber, toLineNumber) {\n        this._checkPendingChanges();\n        fromLineNumber = fromLineNumber | 0;\n        toLineNumber = toLineNumber | 0;\n        this._lineCount += (toLineNumber - fromLineNumber + 1);\n        for (let i = 0, len = this._arr.length; i < len; i++) {\n            const afterLineNumber = this._arr[i].afterLineNumber;\n            if (fromLineNumber <= afterLineNumber) {\n                this._arr[i].afterLineNumber += (toLineNumber - fromLineNumber + 1);\n            }\n        }\n    }\n    /**\n     * Get the sum of all the whitespaces.\n     */\n    getWhitespacesTotalHeight() {\n        this._checkPendingChanges();\n        if (this._arr.length === 0) {\n            return 0;\n        }\n        return this.getWhitespacesAccumulatedHeight(this._arr.length - 1);\n    }\n    /**\n     * Return the sum of the heights of the whitespaces at [0..index].\n     * This includes the whitespace at `index`.\n     *\n     * @param index The index of the whitespace.\n     * @return The sum of the heights of all whitespaces before the one at `index`, including the one at `index`.\n     */\n    getWhitespacesAccumulatedHeight(index) {\n        this._checkPendingChanges();\n        index = index | 0;\n        let startIndex = Math.max(0, this._prefixSumValidIndex + 1);\n        if (startIndex === 0) {\n            this._arr[0].prefixSum = this._arr[0].height;\n            startIndex++;\n        }\n        for (let i = startIndex; i <= index; i++) {\n            this._arr[i].prefixSum = this._arr[i - 1].prefixSum + this._arr[i].height;\n        }\n        this._prefixSumValidIndex = Math.max(this._prefixSumValidIndex, index);\n        return this._arr[index].prefixSum;\n    }\n    /**\n     * Get the sum of heights for all objects.\n     *\n     * @return The sum of heights for all objects.\n     */\n    getLinesTotalHeight() {\n        this._checkPendingChanges();\n        const linesHeight = this._lineHeight * this._lineCount;\n        const whitespacesHeight = this.getWhitespacesTotalHeight();\n        return linesHeight + whitespacesHeight + this._paddingTop + this._paddingBottom;\n    }\n    /**\n     * Returns the accumulated height of whitespaces before the given line number.\n     *\n     * @param lineNumber The line number\n     */\n    getWhitespaceAccumulatedHeightBeforeLineNumber(lineNumber) {\n        this._checkPendingChanges();\n        lineNumber = lineNumber | 0;\n        const lastWhitespaceBeforeLineNumber = this._findLastWhitespaceBeforeLineNumber(lineNumber);\n        if (lastWhitespaceBeforeLineNumber === -1) {\n            return 0;\n        }\n        return this.getWhitespacesAccumulatedHeight(lastWhitespaceBeforeLineNumber);\n    }\n    _findLastWhitespaceBeforeLineNumber(lineNumber) {\n        lineNumber = lineNumber | 0;\n        // Find the whitespace before line number\n        const arr = this._arr;\n        let low = 0;\n        let high = arr.length - 1;\n        while (low <= high) {\n            const delta = (high - low) | 0;\n            const halfDelta = (delta / 2) | 0;\n            const mid = (low + halfDelta) | 0;\n            if (arr[mid].afterLineNumber < lineNumber) {\n                if (mid + 1 >= arr.length || arr[mid + 1].afterLineNumber >= lineNumber) {\n                    return mid;\n                }\n                else {\n                    low = (mid + 1) | 0;\n                }\n            }\n            else {\n                high = (mid - 1) | 0;\n            }\n        }\n        return -1;\n    }\n    _findFirstWhitespaceAfterLineNumber(lineNumber) {\n        lineNumber = lineNumber | 0;\n        const lastWhitespaceBeforeLineNumber = this._findLastWhitespaceBeforeLineNumber(lineNumber);\n        const firstWhitespaceAfterLineNumber = lastWhitespaceBeforeLineNumber + 1;\n        if (firstWhitespaceAfterLineNumber < this._arr.length) {\n            return firstWhitespaceAfterLineNumber;\n        }\n        return -1;\n    }\n    /**\n     * Find the index of the first whitespace which has `afterLineNumber` >= `lineNumber`.\n     * @return The index of the first whitespace with `afterLineNumber` >= `lineNumber` or -1 if no whitespace is found.\n     */\n    getFirstWhitespaceIndexAfterLineNumber(lineNumber) {\n        this._checkPendingChanges();\n        lineNumber = lineNumber | 0;\n        return this._findFirstWhitespaceAfterLineNumber(lineNumber);\n    }\n    /**\n     * Get the vertical offset (the sum of heights for all objects above) a certain line number.\n     *\n     * @param lineNumber The line number\n     * @return The sum of heights for all objects above `lineNumber`.\n     */\n    getVerticalOffsetForLineNumber(lineNumber, includeViewZones = false) {\n        this._checkPendingChanges();\n        lineNumber = lineNumber | 0;\n        let previousLinesHeight;\n        if (lineNumber > 1) {\n            previousLinesHeight = this._lineHeight * (lineNumber - 1);\n        }\n        else {\n            previousLinesHeight = 0;\n        }\n        const previousWhitespacesHeight = this.getWhitespaceAccumulatedHeightBeforeLineNumber(lineNumber - (includeViewZones ? 1 : 0));\n        return previousLinesHeight + previousWhitespacesHeight + this._paddingTop;\n    }\n    /**\n     * Get the vertical offset (the sum of heights for all objects above) a certain line number.\n     *\n     * @param lineNumber The line number\n     * @return The sum of heights for all objects above `lineNumber`.\n     */\n    getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones = false) {\n        this._checkPendingChanges();\n        lineNumber = lineNumber | 0;\n        const previousLinesHeight = this._lineHeight * lineNumber;\n        const previousWhitespacesHeight = this.getWhitespaceAccumulatedHeightBeforeLineNumber(lineNumber + (includeViewZones ? 1 : 0));\n        return previousLinesHeight + previousWhitespacesHeight + this._paddingTop;\n    }\n    /**\n     * The maximum min width for all whitespaces.\n     */\n    getWhitespaceMinWidth() {\n        this._checkPendingChanges();\n        if (this._minWidth === -1) {\n            let minWidth = 0;\n            for (let i = 0, len = this._arr.length; i < len; i++) {\n                minWidth = Math.max(minWidth, this._arr[i].minWidth);\n            }\n            this._minWidth = minWidth;\n        }\n        return this._minWidth;\n    }\n    /**\n     * Check if `verticalOffset` is below all lines.\n     */\n    isAfterLines(verticalOffset) {\n        this._checkPendingChanges();\n        const totalHeight = this.getLinesTotalHeight();\n        return verticalOffset > totalHeight;\n    }\n    isInTopPadding(verticalOffset) {\n        if (this._paddingTop === 0) {\n            return false;\n        }\n        this._checkPendingChanges();\n        return (verticalOffset < this._paddingTop);\n    }\n    isInBottomPadding(verticalOffset) {\n        if (this._paddingBottom === 0) {\n            return false;\n        }\n        this._checkPendingChanges();\n        const totalHeight = this.getLinesTotalHeight();\n        return (verticalOffset >= totalHeight - this._paddingBottom);\n    }\n    /**\n     * Find the first line number that is at or after vertical offset `verticalOffset`.\n     * i.e. if getVerticalOffsetForLine(line) is x and getVerticalOffsetForLine(line + 1) is y, then\n     * getLineNumberAtOrAfterVerticalOffset(i) = line, x <= i < y.\n     *\n     * @param verticalOffset The vertical offset to search at.\n     * @return The line number at or after vertical offset `verticalOffset`.\n     */\n    getLineNumberAtOrAfterVerticalOffset(verticalOffset) {\n        this._checkPendingChanges();\n        verticalOffset = verticalOffset | 0;\n        if (verticalOffset < 0) {\n            return 1;\n        }\n        const linesCount = this._lineCount | 0;\n        const lineHeight = this._lineHeight;\n        let minLineNumber = 1;\n        let maxLineNumber = linesCount;\n        while (minLineNumber < maxLineNumber) {\n            const midLineNumber = ((minLineNumber + maxLineNumber) / 2) | 0;\n            const midLineNumberVerticalOffset = this.getVerticalOffsetForLineNumber(midLineNumber) | 0;\n            if (verticalOffset >= midLineNumberVerticalOffset + lineHeight) {\n                // vertical offset is after mid line number\n                minLineNumber = midLineNumber + 1;\n            }\n            else if (verticalOffset >= midLineNumberVerticalOffset) {\n                // Hit\n                return midLineNumber;\n            }\n            else {\n                // vertical offset is before mid line number, but mid line number could still be what we're searching for\n                maxLineNumber = midLineNumber;\n            }\n        }\n        if (minLineNumber > linesCount) {\n            return linesCount;\n        }\n        return minLineNumber;\n    }\n    /**\n     * Get all the lines and their relative vertical offsets that are positioned between `verticalOffset1` and `verticalOffset2`.\n     *\n     * @param verticalOffset1 The beginning of the viewport.\n     * @param verticalOffset2 The end of the viewport.\n     * @return A structure describing the lines positioned between `verticalOffset1` and `verticalOffset2`.\n     */\n    getLinesViewportData(verticalOffset1, verticalOffset2) {\n        this._checkPendingChanges();\n        verticalOffset1 = verticalOffset1 | 0;\n        verticalOffset2 = verticalOffset2 | 0;\n        const lineHeight = this._lineHeight;\n        // Find first line number\n        // We don't live in a perfect world, so the line number might start before or after verticalOffset1\n        const startLineNumber = this.getLineNumberAtOrAfterVerticalOffset(verticalOffset1) | 0;\n        const startLineNumberVerticalOffset = this.getVerticalOffsetForLineNumber(startLineNumber) | 0;\n        let endLineNumber = this._lineCount | 0;\n        // Also keep track of what whitespace we've got\n        let whitespaceIndex = this.getFirstWhitespaceIndexAfterLineNumber(startLineNumber) | 0;\n        const whitespaceCount = this.getWhitespacesCount() | 0;\n        let currentWhitespaceHeight;\n        let currentWhitespaceAfterLineNumber;\n        if (whitespaceIndex === -1) {\n            whitespaceIndex = whitespaceCount;\n            currentWhitespaceAfterLineNumber = endLineNumber + 1;\n            currentWhitespaceHeight = 0;\n        }\n        else {\n            currentWhitespaceAfterLineNumber = this.getAfterLineNumberForWhitespaceIndex(whitespaceIndex) | 0;\n            currentWhitespaceHeight = this.getHeightForWhitespaceIndex(whitespaceIndex) | 0;\n        }\n        let currentVerticalOffset = startLineNumberVerticalOffset;\n        let currentLineRelativeOffset = currentVerticalOffset;\n        // IE (all versions) cannot handle units above about 1,533,908 px, so every 500k pixels bring numbers down\n        const STEP_SIZE = 500000;\n        let bigNumbersDelta = 0;\n        if (startLineNumberVerticalOffset >= STEP_SIZE) {\n            // Compute a delta that guarantees that lines are positioned at `lineHeight` increments\n            bigNumbersDelta = Math.floor(startLineNumberVerticalOffset / STEP_SIZE) * STEP_SIZE;\n            bigNumbersDelta = Math.floor(bigNumbersDelta / lineHeight) * lineHeight;\n            currentLineRelativeOffset -= bigNumbersDelta;\n        }\n        const linesOffsets = [];\n        const verticalCenter = verticalOffset1 + (verticalOffset2 - verticalOffset1) / 2;\n        let centeredLineNumber = -1;\n        // Figure out how far the lines go\n        for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {\n            if (centeredLineNumber === -1) {\n                const currentLineTop = currentVerticalOffset;\n                const currentLineBottom = currentVerticalOffset + lineHeight;\n                if ((currentLineTop <= verticalCenter && verticalCenter < currentLineBottom) || currentLineTop > verticalCenter) {\n                    centeredLineNumber = lineNumber;\n                }\n            }\n            // Count current line height in the vertical offsets\n            currentVerticalOffset += lineHeight;\n            linesOffsets[lineNumber - startLineNumber] = currentLineRelativeOffset;\n            // Next line starts immediately after this one\n            currentLineRelativeOffset += lineHeight;\n            while (currentWhitespaceAfterLineNumber === lineNumber) {\n                // Push down next line with the height of the current whitespace\n                currentLineRelativeOffset += currentWhitespaceHeight;\n                // Count current whitespace in the vertical offsets\n                currentVerticalOffset += currentWhitespaceHeight;\n                whitespaceIndex++;\n                if (whitespaceIndex >= whitespaceCount) {\n                    currentWhitespaceAfterLineNumber = endLineNumber + 1;\n                }\n                else {\n                    currentWhitespaceAfterLineNumber = this.getAfterLineNumberForWhitespaceIndex(whitespaceIndex) | 0;\n                    currentWhitespaceHeight = this.getHeightForWhitespaceIndex(whitespaceIndex) | 0;\n                }\n            }\n            if (currentVerticalOffset >= verticalOffset2) {\n                // We have covered the entire viewport area, time to stop\n                endLineNumber = lineNumber;\n                break;\n            }\n        }\n        if (centeredLineNumber === -1) {\n            centeredLineNumber = endLineNumber;\n        }\n        const endLineNumberVerticalOffset = this.getVerticalOffsetForLineNumber(endLineNumber) | 0;\n        let completelyVisibleStartLineNumber = startLineNumber;\n        let completelyVisibleEndLineNumber = endLineNumber;\n        if (completelyVisibleStartLineNumber < completelyVisibleEndLineNumber) {\n            if (startLineNumberVerticalOffset < verticalOffset1) {\n                completelyVisibleStartLineNumber++;\n            }\n        }\n        if (completelyVisibleStartLineNumber < completelyVisibleEndLineNumber) {\n            if (endLineNumberVerticalOffset + lineHeight > verticalOffset2) {\n                completelyVisibleEndLineNumber--;\n            }\n        }\n        return {\n            bigNumbersDelta: bigNumbersDelta,\n            startLineNumber: startLineNumber,\n            endLineNumber: endLineNumber,\n            relativeVerticalOffset: linesOffsets,\n            centeredLineNumber: centeredLineNumber,\n            completelyVisibleStartLineNumber: completelyVisibleStartLineNumber,\n            completelyVisibleEndLineNumber: completelyVisibleEndLineNumber,\n            lineHeight: this._lineHeight,\n        };\n    }\n    getVerticalOffsetForWhitespaceIndex(whitespaceIndex) {\n        this._checkPendingChanges();\n        whitespaceIndex = whitespaceIndex | 0;\n        const afterLineNumber = this.getAfterLineNumberForWhitespaceIndex(whitespaceIndex);\n        let previousLinesHeight;\n        if (afterLineNumber >= 1) {\n            previousLinesHeight = this._lineHeight * afterLineNumber;\n        }\n        else {\n            previousLinesHeight = 0;\n        }\n        let previousWhitespacesHeight;\n        if (whitespaceIndex > 0) {\n            previousWhitespacesHeight = this.getWhitespacesAccumulatedHeight(whitespaceIndex - 1);\n        }\n        else {\n            previousWhitespacesHeight = 0;\n        }\n        return previousLinesHeight + previousWhitespacesHeight + this._paddingTop;\n    }\n    getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset) {\n        this._checkPendingChanges();\n        verticalOffset = verticalOffset | 0;\n        let minWhitespaceIndex = 0;\n        let maxWhitespaceIndex = this.getWhitespacesCount() - 1;\n        if (maxWhitespaceIndex < 0) {\n            return -1;\n        }\n        // Special case: nothing to be found\n        const maxWhitespaceVerticalOffset = this.getVerticalOffsetForWhitespaceIndex(maxWhitespaceIndex);\n        const maxWhitespaceHeight = this.getHeightForWhitespaceIndex(maxWhitespaceIndex);\n        if (verticalOffset >= maxWhitespaceVerticalOffset + maxWhitespaceHeight) {\n            return -1;\n        }\n        while (minWhitespaceIndex < maxWhitespaceIndex) {\n            const midWhitespaceIndex = Math.floor((minWhitespaceIndex + maxWhitespaceIndex) / 2);\n            const midWhitespaceVerticalOffset = this.getVerticalOffsetForWhitespaceIndex(midWhitespaceIndex);\n            const midWhitespaceHeight = this.getHeightForWhitespaceIndex(midWhitespaceIndex);\n            if (verticalOffset >= midWhitespaceVerticalOffset + midWhitespaceHeight) {\n                // vertical offset is after whitespace\n                minWhitespaceIndex = midWhitespaceIndex + 1;\n            }\n            else if (verticalOffset >= midWhitespaceVerticalOffset) {\n                // Hit\n                return midWhitespaceIndex;\n            }\n            else {\n                // vertical offset is before whitespace, but midWhitespaceIndex might still be what we're searching for\n                maxWhitespaceIndex = midWhitespaceIndex;\n            }\n        }\n        return minWhitespaceIndex;\n    }\n    /**\n     * Get exactly the whitespace that is layouted at `verticalOffset`.\n     *\n     * @param verticalOffset The vertical offset.\n     * @return Precisely the whitespace that is layouted at `verticaloffset` or null.\n     */\n    getWhitespaceAtVerticalOffset(verticalOffset) {\n        this._checkPendingChanges();\n        verticalOffset = verticalOffset | 0;\n        const candidateIndex = this.getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset);\n        if (candidateIndex < 0) {\n            return null;\n        }\n        if (candidateIndex >= this.getWhitespacesCount()) {\n            return null;\n        }\n        const candidateTop = this.getVerticalOffsetForWhitespaceIndex(candidateIndex);\n        if (candidateTop > verticalOffset) {\n            return null;\n        }\n        const candidateHeight = this.getHeightForWhitespaceIndex(candidateIndex);\n        const candidateId = this.getIdForWhitespaceIndex(candidateIndex);\n        const candidateAfterLineNumber = this.getAfterLineNumberForWhitespaceIndex(candidateIndex);\n        return {\n            id: candidateId,\n            afterLineNumber: candidateAfterLineNumber,\n            verticalOffset: candidateTop,\n            height: candidateHeight\n        };\n    }\n    /**\n     * Get a list of whitespaces that are positioned between `verticalOffset1` and `verticalOffset2`.\n     *\n     * @param verticalOffset1 The beginning of the viewport.\n     * @param verticalOffset2 The end of the viewport.\n     * @return An array with all the whitespaces in the viewport. If no whitespace is in viewport, the array is empty.\n     */\n    getWhitespaceViewportData(verticalOffset1, verticalOffset2) {\n        this._checkPendingChanges();\n        verticalOffset1 = verticalOffset1 | 0;\n        verticalOffset2 = verticalOffset2 | 0;\n        const startIndex = this.getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset1);\n        const endIndex = this.getWhitespacesCount() - 1;\n        if (startIndex < 0) {\n            return [];\n        }\n        const result = [];\n        for (let i = startIndex; i <= endIndex; i++) {\n            const top = this.getVerticalOffsetForWhitespaceIndex(i);\n            const height = this.getHeightForWhitespaceIndex(i);\n            if (top >= verticalOffset2) {\n                break;\n            }\n            result.push({\n                id: this.getIdForWhitespaceIndex(i),\n                afterLineNumber: this.getAfterLineNumberForWhitespaceIndex(i),\n                verticalOffset: top,\n                height: height\n            });\n        }\n        return result;\n    }\n    /**\n     * Get all whitespaces.\n     */\n    getWhitespaces() {\n        this._checkPendingChanges();\n        return this._arr.slice(0);\n    }\n    /**\n     * The number of whitespaces.\n     */\n    getWhitespacesCount() {\n        this._checkPendingChanges();\n        return this._arr.length;\n    }\n    /**\n     * Get the `id` for whitespace at index `index`.\n     *\n     * @param index The index of the whitespace.\n     * @return `id` of whitespace at `index`.\n     */\n    getIdForWhitespaceIndex(index) {\n        this._checkPendingChanges();\n        index = index | 0;\n        return this._arr[index].id;\n    }\n    /**\n     * Get the `afterLineNumber` for whitespace at index `index`.\n     *\n     * @param index The index of the whitespace.\n     * @return `afterLineNumber` of whitespace at `index`.\n     */\n    getAfterLineNumberForWhitespaceIndex(index) {\n        this._checkPendingChanges();\n        index = index | 0;\n        return this._arr[index].afterLineNumber;\n    }\n    /**\n     * Get the `height` for whitespace at index `index`.\n     *\n     * @param index The index of the whitespace.\n     * @return `height` of whitespace at `index`.\n     */\n    getHeightForWhitespaceIndex(index) {\n        this._checkPendingChanges();\n        index = index | 0;\n        return this._arr[index].height;\n    }\n}\nLinesLayout.INSTANCE_COUNT = 0;\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 { Emitter } from '../../../base/common/event.js';\nimport { Disposable } from '../../../base/common/lifecycle.js';\nimport { Scrollable } from '../../../base/common/scrollable.js';\nimport { LinesLayout } from './linesLayout.js';\nimport { Viewport } from '../viewModel.js';\nimport { ContentSizeChangedEvent } from '../viewModelEventDispatcher.js';\nconst SMOOTH_SCROLLING_TIME = 125;\nclass EditorScrollDimensions {\n    constructor(width, contentWidth, height, contentHeight) {\n        width = width | 0;\n        contentWidth = contentWidth | 0;\n        height = height | 0;\n        contentHeight = contentHeight | 0;\n        if (width < 0) {\n            width = 0;\n        }\n        if (contentWidth < 0) {\n            contentWidth = 0;\n        }\n        if (height < 0) {\n            height = 0;\n        }\n        if (contentHeight < 0) {\n            contentHeight = 0;\n        }\n        this.width = width;\n        this.contentWidth = contentWidth;\n        this.scrollWidth = Math.max(width, contentWidth);\n        this.height = height;\n        this.contentHeight = contentHeight;\n        this.scrollHeight = Math.max(height, contentHeight);\n    }\n    equals(other) {\n        return (this.width === other.width\n            && this.contentWidth === other.contentWidth\n            && this.height === other.height\n            && this.contentHeight === other.contentHeight);\n    }\n}\nclass EditorScrollable extends Disposable {\n    constructor(smoothScrollDuration, scheduleAtNextAnimationFrame) {\n        super();\n        this._onDidContentSizeChange = this._register(new Emitter());\n        this.onDidContentSizeChange = this._onDidContentSizeChange.event;\n        this._dimensions = new EditorScrollDimensions(0, 0, 0, 0);\n        this._scrollable = this._register(new Scrollable({\n            forceIntegerValues: true,\n            smoothScrollDuration,\n            scheduleAtNextAnimationFrame\n        }));\n        this.onDidScroll = this._scrollable.onScroll;\n    }\n    getScrollable() {\n        return this._scrollable;\n    }\n    setSmoothScrollDuration(smoothScrollDuration) {\n        this._scrollable.setSmoothScrollDuration(smoothScrollDuration);\n    }\n    validateScrollPosition(scrollPosition) {\n        return this._scrollable.validateScrollPosition(scrollPosition);\n    }\n    getScrollDimensions() {\n        return this._dimensions;\n    }\n    setScrollDimensions(dimensions) {\n        if (this._dimensions.equals(dimensions)) {\n            return;\n        }\n        const oldDimensions = this._dimensions;\n        this._dimensions = dimensions;\n        this._scrollable.setScrollDimensions({\n            width: dimensions.width,\n            scrollWidth: dimensions.scrollWidth,\n            height: dimensions.height,\n            scrollHeight: dimensions.scrollHeight\n        }, true);\n        const contentWidthChanged = (oldDimensions.contentWidth !== dimensions.contentWidth);\n        const contentHeightChanged = (oldDimensions.contentHeight !== dimensions.contentHeight);\n        if (contentWidthChanged || contentHeightChanged) {\n            this._onDidContentSizeChange.fire(new ContentSizeChangedEvent(oldDimensions.contentWidth, oldDimensions.contentHeight, dimensions.contentWidth, dimensions.contentHeight));\n        }\n    }\n    getFutureScrollPosition() {\n        return this._scrollable.getFutureScrollPosition();\n    }\n    getCurrentScrollPosition() {\n        return this._scrollable.getCurrentScrollPosition();\n    }\n    setScrollPositionNow(update) {\n        this._scrollable.setScrollPositionNow(update);\n    }\n    setScrollPositionSmooth(update) {\n        this._scrollable.setScrollPositionSmooth(update);\n    }\n    hasPendingScrollAnimation() {\n        return this._scrollable.hasPendingScrollAnimation();\n    }\n}\nexport class ViewLayout extends Disposable {\n    constructor(configuration, lineCount, scheduleAtNextAnimationFrame) {\n        super();\n        this._configuration = configuration;\n        const options = this._configuration.options;\n        const layoutInfo = options.get(145 /* EditorOption.layoutInfo */);\n        const padding = options.get(84 /* EditorOption.padding */);\n        this._linesLayout = new LinesLayout(lineCount, options.get(67 /* EditorOption.lineHeight */), padding.top, padding.bottom);\n        this._maxLineWidth = 0;\n        this._overlayWidgetsMinWidth = 0;\n        this._scrollable = this._register(new EditorScrollable(0, scheduleAtNextAnimationFrame));\n        this._configureSmoothScrollDuration();\n        this._scrollable.setScrollDimensions(new EditorScrollDimensions(layoutInfo.contentWidth, 0, layoutInfo.height, 0));\n        this.onDidScroll = this._scrollable.onDidScroll;\n        this.onDidContentSizeChange = this._scrollable.onDidContentSizeChange;\n        this._updateHeight();\n    }\n    dispose() {\n        super.dispose();\n    }\n    getScrollable() {\n        return this._scrollable.getScrollable();\n    }\n    onHeightMaybeChanged() {\n        this._updateHeight();\n    }\n    _configureSmoothScrollDuration() {\n        this._scrollable.setSmoothScrollDuration(this._configuration.options.get(114 /* EditorOption.smoothScrolling */) ? SMOOTH_SCROLLING_TIME : 0);\n    }\n    // ---- begin view event handlers\n    onConfigurationChanged(e) {\n        const options = this._configuration.options;\n        if (e.hasChanged(67 /* EditorOption.lineHeight */)) {\n            this._linesLayout.setLineHeight(options.get(67 /* EditorOption.lineHeight */));\n        }\n        if (e.hasChanged(84 /* EditorOption.padding */)) {\n            const padding = options.get(84 /* EditorOption.padding */);\n            this._linesLayout.setPadding(padding.top, padding.bottom);\n        }\n        if (e.hasChanged(145 /* EditorOption.layoutInfo */)) {\n            const layoutInfo = options.get(145 /* EditorOption.layoutInfo */);\n            const width = layoutInfo.contentWidth;\n            const height = layoutInfo.height;\n            const scrollDimensions = this._scrollable.getScrollDimensions();\n            const contentWidth = scrollDimensions.contentWidth;\n            this._scrollable.setScrollDimensions(new EditorScrollDimensions(width, scrollDimensions.contentWidth, height, this._getContentHeight(width, height, contentWidth)));\n        }\n        else {\n            this._updateHeight();\n        }\n        if (e.hasChanged(114 /* EditorOption.smoothScrolling */)) {\n            this._configureSmoothScrollDuration();\n        }\n    }\n    onFlushed(lineCount) {\n        this._linesLayout.onFlushed(lineCount);\n    }\n    onLinesDeleted(fromLineNumber, toLineNumber) {\n        this._linesLayout.onLinesDeleted(fromLineNumber, toLineNumber);\n    }\n    onLinesInserted(fromLineNumber, toLineNumber) {\n        this._linesLayout.onLinesInserted(fromLineNumber, toLineNumber);\n    }\n    // ---- end view event handlers\n    _getHorizontalScrollbarHeight(width, scrollWidth) {\n        const options = this._configuration.options;\n        const scrollbar = options.get(103 /* EditorOption.scrollbar */);\n        if (scrollbar.horizontal === 2 /* ScrollbarVisibility.Hidden */) {\n            // horizontal scrollbar not visible\n            return 0;\n        }\n        if (width >= scrollWidth) {\n            // horizontal scrollbar not visible\n            return 0;\n        }\n        return scrollbar.horizontalScrollbarSize;\n    }\n    _getContentHeight(width, height, contentWidth) {\n        const options = this._configuration.options;\n        let result = this._linesLayout.getLinesTotalHeight();\n        if (options.get(105 /* EditorOption.scrollBeyondLastLine */)) {\n            result += Math.max(0, height - options.get(67 /* EditorOption.lineHeight */) - options.get(84 /* EditorOption.padding */).bottom);\n        }\n        else if (!options.get(103 /* EditorOption.scrollbar */).ignoreHorizontalScrollbarInContentHeight) {\n            result += this._getHorizontalScrollbarHeight(width, contentWidth);\n        }\n        return result;\n    }\n    _updateHeight() {\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        const width = scrollDimensions.width;\n        const height = scrollDimensions.height;\n        const contentWidth = scrollDimensions.contentWidth;\n        this._scrollable.setScrollDimensions(new EditorScrollDimensions(width, scrollDimensions.contentWidth, height, this._getContentHeight(width, height, contentWidth)));\n    }\n    // ---- Layouting logic\n    getCurrentViewport() {\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        const currentScrollPosition = this._scrollable.getCurrentScrollPosition();\n        return new Viewport(currentScrollPosition.scrollTop, currentScrollPosition.scrollLeft, scrollDimensions.width, scrollDimensions.height);\n    }\n    getFutureViewport() {\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        const currentScrollPosition = this._scrollable.getFutureScrollPosition();\n        return new Viewport(currentScrollPosition.scrollTop, currentScrollPosition.scrollLeft, scrollDimensions.width, scrollDimensions.height);\n    }\n    _computeContentWidth() {\n        const options = this._configuration.options;\n        const maxLineWidth = this._maxLineWidth;\n        const wrappingInfo = options.get(146 /* EditorOption.wrappingInfo */);\n        const fontInfo = options.get(50 /* EditorOption.fontInfo */);\n        const layoutInfo = options.get(145 /* EditorOption.layoutInfo */);\n        if (wrappingInfo.isViewportWrapping) {\n            const minimap = options.get(73 /* EditorOption.minimap */);\n            if (maxLineWidth > layoutInfo.contentWidth + fontInfo.typicalHalfwidthCharacterWidth) {\n                // This is a case where viewport wrapping is on, but the line extends above the viewport\n                if (minimap.enabled && minimap.side === 'right') {\n                    // We need to accomodate the scrollbar width\n                    return maxLineWidth + layoutInfo.verticalScrollbarWidth;\n                }\n            }\n            return maxLineWidth;\n        }\n        else {\n            const extraHorizontalSpace = options.get(104 /* EditorOption.scrollBeyondLastColumn */) * fontInfo.typicalHalfwidthCharacterWidth;\n            const whitespaceMinWidth = this._linesLayout.getWhitespaceMinWidth();\n            return Math.max(maxLineWidth + extraHorizontalSpace + layoutInfo.verticalScrollbarWidth, whitespaceMinWidth, this._overlayWidgetsMinWidth);\n        }\n    }\n    setMaxLineWidth(maxLineWidth) {\n        this._maxLineWidth = maxLineWidth;\n        this._updateContentWidth();\n    }\n    setOverlayWidgetsMinWidth(maxMinWidth) {\n        this._overlayWidgetsMinWidth = maxMinWidth;\n        this._updateContentWidth();\n    }\n    _updateContentWidth() {\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        this._scrollable.setScrollDimensions(new EditorScrollDimensions(scrollDimensions.width, this._computeContentWidth(), scrollDimensions.height, scrollDimensions.contentHeight));\n        // The height might depend on the fact that there is a horizontal scrollbar or not\n        this._updateHeight();\n    }\n    // ---- view state\n    saveState() {\n        const currentScrollPosition = this._scrollable.getFutureScrollPosition();\n        const scrollTop = currentScrollPosition.scrollTop;\n        const firstLineNumberInViewport = this._linesLayout.getLineNumberAtOrAfterVerticalOffset(scrollTop);\n        const whitespaceAboveFirstLine = this._linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(firstLineNumberInViewport);\n        return {\n            scrollTop: scrollTop,\n            scrollTopWithoutViewZones: scrollTop - whitespaceAboveFirstLine,\n            scrollLeft: currentScrollPosition.scrollLeft\n        };\n    }\n    // ----\n    changeWhitespace(callback) {\n        const hadAChange = this._linesLayout.changeWhitespace(callback);\n        if (hadAChange) {\n            this.onHeightMaybeChanged();\n        }\n        return hadAChange;\n    }\n    getVerticalOffsetForLineNumber(lineNumber, includeViewZones = false) {\n        return this._linesLayout.getVerticalOffsetForLineNumber(lineNumber, includeViewZones);\n    }\n    getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones = false) {\n        return this._linesLayout.getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones);\n    }\n    isAfterLines(verticalOffset) {\n        return this._linesLayout.isAfterLines(verticalOffset);\n    }\n    isInTopPadding(verticalOffset) {\n        return this._linesLayout.isInTopPadding(verticalOffset);\n    }\n    isInBottomPadding(verticalOffset) {\n        return this._linesLayout.isInBottomPadding(verticalOffset);\n    }\n    getLineNumberAtVerticalOffset(verticalOffset) {\n        return this._linesLayout.getLineNumberAtOrAfterVerticalOffset(verticalOffset);\n    }\n    getWhitespaceAtVerticalOffset(verticalOffset) {\n        return this._linesLayout.getWhitespaceAtVerticalOffset(verticalOffset);\n    }\n    getLinesViewportData() {\n        const visibleBox = this.getCurrentViewport();\n        return this._linesLayout.getLinesViewportData(visibleBox.top, visibleBox.top + visibleBox.height);\n    }\n    getLinesViewportDataAtScrollTop(scrollTop) {\n        // do some minimal validations on scrollTop\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        if (scrollTop + scrollDimensions.height > scrollDimensions.scrollHeight) {\n            scrollTop = scrollDimensions.scrollHeight - scrollDimensions.height;\n        }\n        if (scrollTop < 0) {\n            scrollTop = 0;\n        }\n        return this._linesLayout.getLinesViewportData(scrollTop, scrollTop + scrollDimensions.height);\n    }\n    getWhitespaceViewportData() {\n        const visibleBox = this.getCurrentViewport();\n        return this._linesLayout.getWhitespaceViewportData(visibleBox.top, visibleBox.top + visibleBox.height);\n    }\n    getWhitespaces() {\n        return this._linesLayout.getWhitespaces();\n    }\n    // ----\n    getContentWidth() {\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        return scrollDimensions.contentWidth;\n    }\n    getScrollWidth() {\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        return scrollDimensions.scrollWidth;\n    }\n    getContentHeight() {\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        return scrollDimensions.contentHeight;\n    }\n    getScrollHeight() {\n        const scrollDimensions = this._scrollable.getScrollDimensions();\n        return scrollDimensions.scrollHeight;\n    }\n    getCurrentScrollLeft() {\n        const currentScrollPosition = this._scrollable.getCurrentScrollPosition();\n        return currentScrollPosition.scrollLeft;\n    }\n    getCurrentScrollTop() {\n        const currentScrollPosition = this._scrollable.getCurrentScrollPosition();\n        return currentScrollPosition.scrollTop;\n    }\n    validateScrollPosition(scrollPosition) {\n        return this._scrollable.validateScrollPosition(scrollPosition);\n    }\n    setScrollPosition(position, type) {\n        if (type === 1 /* ScrollType.Immediate */) {\n            this._scrollable.setScrollPositionNow(position);\n        }\n        else {\n            this._scrollable.setScrollPositionSmooth(position);\n        }\n    }\n    hasPendingScrollAnimation() {\n        return this._scrollable.hasPendingScrollAnimation();\n    }\n    deltaScrollNow(deltaScrollLeft, deltaScrollTop) {\n        const currentScrollPosition = this._scrollable.getCurrentScrollPosition();\n        this._scrollable.setScrollPositionNow({\n            scrollLeft: currentScrollPosition.scrollLeft + deltaScrollLeft,\n            scrollTop: currentScrollPosition.scrollTop + deltaScrollTop\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 *--------------------------------------------------------------------------------------------*/\nexport class LinePart {\n    constructor(\n    /**\n     * last char index of this token (not inclusive).\n     */\n    endIndex, type, metadata, containsRTL) {\n        this.endIndex = endIndex;\n        this.type = type;\n        this.metadata = metadata;\n        this.containsRTL = containsRTL;\n        this._linePartBrand = undefined;\n    }\n    isWhitespace() {\n        return (this.metadata & 1 /* LinePartMetadata.IS_WHITESPACE_MASK */ ? true : false);\n    }\n    isPseudoAfter() {\n        return (this.metadata & 4 /* LinePartMetadata.PSEUDO_AFTER_MASK */ ? true : false);\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 * as strings from '../../../base/common/strings.js';\nimport { StringBuilder } from '../core/stringBuilder.js';\nimport { LineDecoration, LineDecorationsNormalizer } from './lineDecorations.js';\nimport { LinePart } from './linePart.js';\nexport class LineRange {\n    constructor(startIndex, endIndex) {\n        this.startOffset = startIndex;\n        this.endOffset = endIndex;\n    }\n    equals(otherLineRange) {\n        return this.startOffset === otherLineRange.startOffset\n            && this.endOffset === otherLineRange.endOffset;\n    }\n}\nexport class RenderLineInput {\n    constructor(useMonospaceOptimizations, canUseHalfwidthRightwardsArrow, lineContent, continuesWithWrappedLine, isBasicASCII, containsRTL, fauxIndentLength, lineTokens, lineDecorations, tabSize, startVisibleColumn, spaceWidth, middotWidth, wsmiddotWidth, stopRenderingLineAfter, renderWhitespace, renderControlCharacters, fontLigatures, selectionsOnLine) {\n        this.useMonospaceOptimizations = useMonospaceOptimizations;\n        this.canUseHalfwidthRightwardsArrow = canUseHalfwidthRightwardsArrow;\n        this.lineContent = lineContent;\n        this.continuesWithWrappedLine = continuesWithWrappedLine;\n        this.isBasicASCII = isBasicASCII;\n        this.containsRTL = containsRTL;\n        this.fauxIndentLength = fauxIndentLength;\n        this.lineTokens = lineTokens;\n        this.lineDecorations = lineDecorations.sort(LineDecoration.compare);\n        this.tabSize = tabSize;\n        this.startVisibleColumn = startVisibleColumn;\n        this.spaceWidth = spaceWidth;\n        this.stopRenderingLineAfter = stopRenderingLineAfter;\n        this.renderWhitespace = (renderWhitespace === 'all'\n            ? 4 /* RenderWhitespace.All */\n            : renderWhitespace === 'boundary'\n                ? 1 /* RenderWhitespace.Boundary */\n                : renderWhitespace === 'selection'\n                    ? 2 /* RenderWhitespace.Selection */\n                    : renderWhitespace === 'trailing'\n                        ? 3 /* RenderWhitespace.Trailing */\n                        : 0 /* RenderWhitespace.None */);\n        this.renderControlCharacters = renderControlCharacters;\n        this.fontLigatures = fontLigatures;\n        this.selectionsOnLine = selectionsOnLine && selectionsOnLine.sort((a, b) => a.startOffset < b.startOffset ? -1 : 1);\n        const wsmiddotDiff = Math.abs(wsmiddotWidth - spaceWidth);\n        const middotDiff = Math.abs(middotWidth - spaceWidth);\n        if (wsmiddotDiff < middotDiff) {\n            this.renderSpaceWidth = wsmiddotWidth;\n            this.renderSpaceCharCode = 0x2E31; // U+2E31 - WORD SEPARATOR MIDDLE DOT\n        }\n        else {\n            this.renderSpaceWidth = middotWidth;\n            this.renderSpaceCharCode = 0xB7; // U+00B7 - MIDDLE DOT\n        }\n    }\n    sameSelection(otherSelections) {\n        if (this.selectionsOnLine === null) {\n            return otherSelections === null;\n        }\n        if (otherSelections === null) {\n            return false;\n        }\n        if (otherSelections.length !== this.selectionsOnLine.length) {\n            return false;\n        }\n        for (let i = 0; i < this.selectionsOnLine.length; i++) {\n            if (!this.selectionsOnLine[i].equals(otherSelections[i])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    equals(other) {\n        return (this.useMonospaceOptimizations === other.useMonospaceOptimizations\n            && this.canUseHalfwidthRightwardsArrow === other.canUseHalfwidthRightwardsArrow\n            && this.lineContent === other.lineContent\n            && this.continuesWithWrappedLine === other.continuesWithWrappedLine\n            && this.isBasicASCII === other.isBasicASCII\n            && this.containsRTL === other.containsRTL\n            && this.fauxIndentLength === other.fauxIndentLength\n            && this.tabSize === other.tabSize\n            && this.startVisibleColumn === other.startVisibleColumn\n            && this.spaceWidth === other.spaceWidth\n            && this.renderSpaceWidth === other.renderSpaceWidth\n            && this.renderSpaceCharCode === other.renderSpaceCharCode\n            && this.stopRenderingLineAfter === other.stopRenderingLineAfter\n            && this.renderWhitespace === other.renderWhitespace\n            && this.renderControlCharacters === other.renderControlCharacters\n            && this.fontLigatures === other.fontLigatures\n            && LineDecoration.equalsArr(this.lineDecorations, other.lineDecorations)\n            && this.lineTokens.equals(other.lineTokens)\n            && this.sameSelection(other.selectionsOnLine));\n    }\n}\nexport class DomPosition {\n    constructor(partIndex, charIndex) {\n        this.partIndex = partIndex;\n        this.charIndex = charIndex;\n    }\n}\n/**\n * Provides a both direction mapping between a line's character and its rendered position.\n */\nexport class CharacterMapping {\n    static getPartIndex(partData) {\n        return (partData & 4294901760 /* CharacterMappingConstants.PART_INDEX_MASK */) >>> 16 /* CharacterMappingConstants.PART_INDEX_OFFSET */;\n    }\n    static getCharIndex(partData) {\n        return (partData & 65535 /* CharacterMappingConstants.CHAR_INDEX_MASK */) >>> 0 /* CharacterMappingConstants.CHAR_INDEX_OFFSET */;\n    }\n    constructor(length, partCount) {\n        this.length = length;\n        this._data = new Uint32Array(this.length);\n        this._horizontalOffset = new Uint32Array(this.length);\n    }\n    setColumnInfo(column, partIndex, charIndex, horizontalOffset) {\n        const partData = ((partIndex << 16 /* CharacterMappingConstants.PART_INDEX_OFFSET */)\n            | (charIndex << 0 /* CharacterMappingConstants.CHAR_INDEX_OFFSET */)) >>> 0;\n        this._data[column - 1] = partData;\n        this._horizontalOffset[column - 1] = horizontalOffset;\n    }\n    getHorizontalOffset(column) {\n        if (this._horizontalOffset.length === 0) {\n            // No characters on this line\n            return 0;\n        }\n        return this._horizontalOffset[column - 1];\n    }\n    charOffsetToPartData(charOffset) {\n        if (this.length === 0) {\n            return 0;\n        }\n        if (charOffset < 0) {\n            return this._data[0];\n        }\n        if (charOffset >= this.length) {\n            return this._data[this.length - 1];\n        }\n        return this._data[charOffset];\n    }\n    getDomPosition(column) {\n        const partData = this.charOffsetToPartData(column - 1);\n        const partIndex = CharacterMapping.getPartIndex(partData);\n        const charIndex = CharacterMapping.getCharIndex(partData);\n        return new DomPosition(partIndex, charIndex);\n    }\n    getColumn(domPosition, partLength) {\n        const charOffset = this.partDataToCharOffset(domPosition.partIndex, partLength, domPosition.charIndex);\n        return charOffset + 1;\n    }\n    partDataToCharOffset(partIndex, partLength, charIndex) {\n        if (this.length === 0) {\n            return 0;\n        }\n        const searchEntry = ((partIndex << 16 /* CharacterMappingConstants.PART_INDEX_OFFSET */)\n            | (charIndex << 0 /* CharacterMappingConstants.CHAR_INDEX_OFFSET */)) >>> 0;\n        let min = 0;\n        let max = this.length - 1;\n        while (min + 1 < max) {\n            const mid = ((min + max) >>> 1);\n            const midEntry = this._data[mid];\n            if (midEntry === searchEntry) {\n                return mid;\n            }\n            else if (midEntry > searchEntry) {\n                max = mid;\n            }\n            else {\n                min = mid;\n            }\n        }\n        if (min === max) {\n            return min;\n        }\n        const minEntry = this._data[min];\n        const maxEntry = this._data[max];\n        if (minEntry === searchEntry) {\n            return min;\n        }\n        if (maxEntry === searchEntry) {\n            return max;\n        }\n        const minPartIndex = CharacterMapping.getPartIndex(minEntry);\n        const minCharIndex = CharacterMapping.getCharIndex(minEntry);\n        const maxPartIndex = CharacterMapping.getPartIndex(maxEntry);\n        let maxCharIndex;\n        if (minPartIndex !== maxPartIndex) {\n            // sitting between parts\n            maxCharIndex = partLength;\n        }\n        else {\n            maxCharIndex = CharacterMapping.getCharIndex(maxEntry);\n        }\n        const minEntryDistance = charIndex - minCharIndex;\n        const maxEntryDistance = maxCharIndex - charIndex;\n        if (minEntryDistance <= maxEntryDistance) {\n            return min;\n        }\n        return max;\n    }\n}\nexport class RenderLineOutput {\n    constructor(characterMapping, containsRTL, containsForeignElements) {\n        this._renderLineOutputBrand = undefined;\n        this.characterMapping = characterMapping;\n        this.containsRTL = containsRTL;\n        this.containsForeignElements = containsForeignElements;\n    }\n}\nexport function renderViewLine(input, sb) {\n    if (input.lineContent.length === 0) {\n        if (input.lineDecorations.length > 0) {\n            // This line is empty, but it contains inline decorations\n            sb.appendString(`<span>`);\n            let beforeCount = 0;\n            let afterCount = 0;\n            let containsForeignElements = 0 /* ForeignElementType.None */;\n            for (const lineDecoration of input.lineDecorations) {\n                if (lineDecoration.type === 1 /* InlineDecorationType.Before */ || lineDecoration.type === 2 /* InlineDecorationType.After */) {\n                    sb.appendString(`<span class=\"`);\n                    sb.appendString(lineDecoration.className);\n                    sb.appendString(`\"></span>`);\n                    if (lineDecoration.type === 1 /* InlineDecorationType.Before */) {\n                        containsForeignElements |= 1 /* ForeignElementType.Before */;\n                        beforeCount++;\n                    }\n                    if (lineDecoration.type === 2 /* InlineDecorationType.After */) {\n                        containsForeignElements |= 2 /* ForeignElementType.After */;\n                        afterCount++;\n                    }\n                }\n            }\n            sb.appendString(`</span>`);\n            const characterMapping = new CharacterMapping(1, beforeCount + afterCount);\n            characterMapping.setColumnInfo(1, beforeCount, 0, 0);\n            return new RenderLineOutput(characterMapping, false, containsForeignElements);\n        }\n        // completely empty line\n        sb.appendString('<span><span></span></span>');\n        return new RenderLineOutput(new CharacterMapping(0, 0), false, 0 /* ForeignElementType.None */);\n    }\n    return _renderLine(resolveRenderLineInput(input), sb);\n}\nexport class RenderLineOutput2 {\n    constructor(characterMapping, html, containsRTL, containsForeignElements) {\n        this.characterMapping = characterMapping;\n        this.html = html;\n        this.containsRTL = containsRTL;\n        this.containsForeignElements = containsForeignElements;\n    }\n}\nexport function renderViewLine2(input) {\n    const sb = new StringBuilder(10000);\n    const out = renderViewLine(input, sb);\n    return new RenderLineOutput2(out.characterMapping, sb.build(), out.containsRTL, out.containsForeignElements);\n}\nclass ResolvedRenderLineInput {\n    constructor(fontIsMonospace, canUseHalfwidthRightwardsArrow, lineContent, len, isOverflowing, overflowingCharCount, parts, containsForeignElements, fauxIndentLength, tabSize, startVisibleColumn, containsRTL, spaceWidth, renderSpaceCharCode, renderWhitespace, renderControlCharacters) {\n        this.fontIsMonospace = fontIsMonospace;\n        this.canUseHalfwidthRightwardsArrow = canUseHalfwidthRightwardsArrow;\n        this.lineContent = lineContent;\n        this.len = len;\n        this.isOverflowing = isOverflowing;\n        this.overflowingCharCount = overflowingCharCount;\n        this.parts = parts;\n        this.containsForeignElements = containsForeignElements;\n        this.fauxIndentLength = fauxIndentLength;\n        this.tabSize = tabSize;\n        this.startVisibleColumn = startVisibleColumn;\n        this.containsRTL = containsRTL;\n        this.spaceWidth = spaceWidth;\n        this.renderSpaceCharCode = renderSpaceCharCode;\n        this.renderWhitespace = renderWhitespace;\n        this.renderControlCharacters = renderControlCharacters;\n        //\n    }\n}\nfunction resolveRenderLineInput(input) {\n    const lineContent = input.lineContent;\n    let isOverflowing;\n    let overflowingCharCount;\n    let len;\n    if (input.stopRenderingLineAfter !== -1 && input.stopRenderingLineAfter < lineContent.length) {\n        isOverflowing = true;\n        overflowingCharCount = lineContent.length - input.stopRenderingLineAfter;\n        len = input.stopRenderingLineAfter;\n    }\n    else {\n        isOverflowing = false;\n        overflowingCharCount = 0;\n        len = lineContent.length;\n    }\n    let tokens = transformAndRemoveOverflowing(lineContent, input.containsRTL, input.lineTokens, input.fauxIndentLength, len);\n    if (input.renderControlCharacters && !input.isBasicASCII) {\n        // Calling `extractControlCharacters` before adding (possibly empty) line parts\n        // for inline decorations. `extractControlCharacters` removes empty line parts.\n        tokens = extractControlCharacters(lineContent, tokens);\n    }\n    if (input.renderWhitespace === 4 /* RenderWhitespace.All */ ||\n        input.renderWhitespace === 1 /* RenderWhitespace.Boundary */ ||\n        (input.renderWhitespace === 2 /* RenderWhitespace.Selection */ && !!input.selectionsOnLine) ||\n        (input.renderWhitespace === 3 /* RenderWhitespace.Trailing */ && !input.continuesWithWrappedLine)) {\n        tokens = _applyRenderWhitespace(input, lineContent, len, tokens);\n    }\n    let containsForeignElements = 0 /* ForeignElementType.None */;\n    if (input.lineDecorations.length > 0) {\n        for (let i = 0, len = input.lineDecorations.length; i < len; i++) {\n            const lineDecoration = input.lineDecorations[i];\n            if (lineDecoration.type === 3 /* InlineDecorationType.RegularAffectingLetterSpacing */) {\n                // Pretend there are foreign elements... although not 100% accurate.\n                containsForeignElements |= 1 /* ForeignElementType.Before */;\n            }\n            else if (lineDecoration.type === 1 /* InlineDecorationType.Before */) {\n                containsForeignElements |= 1 /* ForeignElementType.Before */;\n            }\n            else if (lineDecoration.type === 2 /* InlineDecorationType.After */) {\n                containsForeignElements |= 2 /* ForeignElementType.After */;\n            }\n        }\n        tokens = _applyInlineDecorations(lineContent, len, tokens, input.lineDecorations);\n    }\n    if (!input.containsRTL) {\n        // We can never split RTL text, as it ruins the rendering\n        tokens = splitLargeTokens(lineContent, tokens, !input.isBasicASCII || input.fontLigatures);\n    }\n    return new ResolvedRenderLineInput(input.useMonospaceOptimizations, input.canUseHalfwidthRightwardsArrow, lineContent, len, isOverflowing, overflowingCharCount, tokens, containsForeignElements, input.fauxIndentLength, input.tabSize, input.startVisibleColumn, input.containsRTL, input.spaceWidth, input.renderSpaceCharCode, input.renderWhitespace, input.renderControlCharacters);\n}\n/**\n * In the rendering phase, characters are always looped until token.endIndex.\n * Ensure that all tokens end before `len` and the last one ends precisely at `len`.\n */\nfunction transformAndRemoveOverflowing(lineContent, lineContainsRTL, tokens, fauxIndentLength, len) {\n    const result = [];\n    let resultLen = 0;\n    // The faux indent part of the line should have no token type\n    if (fauxIndentLength > 0) {\n        result[resultLen++] = new LinePart(fauxIndentLength, '', 0, false);\n    }\n    let startOffset = fauxIndentLength;\n    for (let tokenIndex = 0, tokensLen = tokens.getCount(); tokenIndex < tokensLen; tokenIndex++) {\n        const endIndex = tokens.getEndOffset(tokenIndex);\n        if (endIndex <= fauxIndentLength) {\n            // The faux indent part of the line should have no token type\n            continue;\n        }\n        const type = tokens.getClassName(tokenIndex);\n        if (endIndex >= len) {\n            const tokenContainsRTL = (lineContainsRTL ? strings.containsRTL(lineContent.substring(startOffset, len)) : false);\n            result[resultLen++] = new LinePart(len, type, 0, tokenContainsRTL);\n            break;\n        }\n        const tokenContainsRTL = (lineContainsRTL ? strings.containsRTL(lineContent.substring(startOffset, endIndex)) : false);\n        result[resultLen++] = new LinePart(endIndex, type, 0, tokenContainsRTL);\n        startOffset = endIndex;\n    }\n    return result;\n}\n/**\n * See https://github.com/microsoft/vscode/issues/6885.\n * It appears that having very large spans causes very slow reading of character positions.\n * So here we try to avoid that.\n */\nfunction splitLargeTokens(lineContent, tokens, onlyAtSpaces) {\n    let lastTokenEndIndex = 0;\n    const result = [];\n    let resultLen = 0;\n    if (onlyAtSpaces) {\n        // Split only at spaces => we need to walk each character\n        for (let i = 0, len = tokens.length; i < len; i++) {\n            const token = tokens[i];\n            const tokenEndIndex = token.endIndex;\n            if (lastTokenEndIndex + 50 /* Constants.LongToken */ < tokenEndIndex) {\n                const tokenType = token.type;\n                const tokenMetadata = token.metadata;\n                const tokenContainsRTL = token.containsRTL;\n                let lastSpaceOffset = -1;\n                let currTokenStart = lastTokenEndIndex;\n                for (let j = lastTokenEndIndex; j < tokenEndIndex; j++) {\n                    if (lineContent.charCodeAt(j) === 32 /* CharCode.Space */) {\n                        lastSpaceOffset = j;\n                    }\n                    if (lastSpaceOffset !== -1 && j - currTokenStart >= 50 /* Constants.LongToken */) {\n                        // Split at `lastSpaceOffset` + 1\n                        result[resultLen++] = new LinePart(lastSpaceOffset + 1, tokenType, tokenMetadata, tokenContainsRTL);\n                        currTokenStart = lastSpaceOffset + 1;\n                        lastSpaceOffset = -1;\n                    }\n                }\n                if (currTokenStart !== tokenEndIndex) {\n                    result[resultLen++] = new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL);\n                }\n            }\n            else {\n                result[resultLen++] = token;\n            }\n            lastTokenEndIndex = tokenEndIndex;\n        }\n    }\n    else {\n        // Split anywhere => we don't need to walk each character\n        for (let i = 0, len = tokens.length; i < len; i++) {\n            const token = tokens[i];\n            const tokenEndIndex = token.endIndex;\n            const diff = (tokenEndIndex - lastTokenEndIndex);\n            if (diff > 50 /* Constants.LongToken */) {\n                const tokenType = token.type;\n                const tokenMetadata = token.metadata;\n                const tokenContainsRTL = token.containsRTL;\n                const piecesCount = Math.ceil(diff / 50 /* Constants.LongToken */);\n                for (let j = 1; j < piecesCount; j++) {\n                    const pieceEndIndex = lastTokenEndIndex + (j * 50 /* Constants.LongToken */);\n                    result[resultLen++] = new LinePart(pieceEndIndex, tokenType, tokenMetadata, tokenContainsRTL);\n                }\n                result[resultLen++] = new LinePart(tokenEndIndex, tokenType, tokenMetadata, tokenContainsRTL);\n            }\n            else {\n                result[resultLen++] = token;\n            }\n            lastTokenEndIndex = tokenEndIndex;\n        }\n    }\n    return result;\n}\nfunction isControlCharacter(charCode) {\n    if (charCode < 32) {\n        return (charCode !== 9 /* CharCode.Tab */);\n    }\n    if (charCode === 127) {\n        // DEL\n        return true;\n    }\n    if ((charCode >= 0x202A && charCode <= 0x202E)\n        || (charCode >= 0x2066 && charCode <= 0x2069)\n        || (charCode >= 0x200E && charCode <= 0x200F)\n        || charCode === 0x061C) {\n        // Unicode Directional Formatting Characters\n        // LRE\tU+202A\tLEFT-TO-RIGHT EMBEDDING\n        // RLE\tU+202B\tRIGHT-TO-LEFT EMBEDDING\n        // PDF\tU+202C\tPOP DIRECTIONAL FORMATTING\n        // LRO\tU+202D\tLEFT-TO-RIGHT OVERRIDE\n        // RLO\tU+202E\tRIGHT-TO-LEFT OVERRIDE\n        // LRI\tU+2066\tLEFT-TO-RIGHT ISOLATE\n        // RLI\tU+2067\tRIGHT-TO-LEFT ISOLATE\n        // FSI\tU+2068\tFIRST STRONG ISOLATE\n        // PDI\tU+2069\tPOP DIRECTIONAL ISOLATE\n        // LRM\tU+200E\tLEFT-TO-RIGHT MARK\n        // RLM\tU+200F\tRIGHT-TO-LEFT MARK\n        // ALM\tU+061C\tARABIC LETTER MARK\n        return true;\n    }\n    return false;\n}\nfunction extractControlCharacters(lineContent, tokens) {\n    const result = [];\n    let lastLinePart = new LinePart(0, '', 0, false);\n    let charOffset = 0;\n    for (const token of tokens) {\n        const tokenEndIndex = token.endIndex;\n        for (; charOffset < tokenEndIndex; charOffset++) {\n            const charCode = lineContent.charCodeAt(charOffset);\n            if (isControlCharacter(charCode)) {\n                if (charOffset > lastLinePart.endIndex) {\n                    // emit previous part if it has text\n                    lastLinePart = new LinePart(charOffset, token.type, token.metadata, token.containsRTL);\n                    result.push(lastLinePart);\n                }\n                lastLinePart = new LinePart(charOffset + 1, 'mtkcontrol', token.metadata, false);\n                result.push(lastLinePart);\n            }\n        }\n        if (charOffset > lastLinePart.endIndex) {\n            // emit previous part if it has text\n            lastLinePart = new LinePart(tokenEndIndex, token.type, token.metadata, token.containsRTL);\n            result.push(lastLinePart);\n        }\n    }\n    return result;\n}\n/**\n * Whitespace is rendered by \"replacing\" tokens with a special-purpose `mtkw` type that is later recognized in the rendering phase.\n * Moreover, a token is created for every visual indent because on some fonts the glyphs used for rendering whitespace (&rarr; or &middot;) do not have the same width as &nbsp;.\n * The rendering phase will generate `style=\"width:...\"` for these tokens.\n */\nfunction _applyRenderWhitespace(input, lineContent, len, tokens) {\n    const continuesWithWrappedLine = input.continuesWithWrappedLine;\n    const fauxIndentLength = input.fauxIndentLength;\n    const tabSize = input.tabSize;\n    const startVisibleColumn = input.startVisibleColumn;\n    const useMonospaceOptimizations = input.useMonospaceOptimizations;\n    const selections = input.selectionsOnLine;\n    const onlyBoundary = (input.renderWhitespace === 1 /* RenderWhitespace.Boundary */);\n    const onlyTrailing = (input.renderWhitespace === 3 /* RenderWhitespace.Trailing */);\n    const generateLinePartForEachWhitespace = (input.renderSpaceWidth !== input.spaceWidth);\n    const result = [];\n    let resultLen = 0;\n    let tokenIndex = 0;\n    let tokenType = tokens[tokenIndex].type;\n    let tokenContainsRTL = tokens[tokenIndex].containsRTL;\n    let tokenEndIndex = tokens[tokenIndex].endIndex;\n    const tokensLength = tokens.length;\n    let lineIsEmptyOrWhitespace = false;\n    let firstNonWhitespaceIndex = strings.firstNonWhitespaceIndex(lineContent);\n    let lastNonWhitespaceIndex;\n    if (firstNonWhitespaceIndex === -1) {\n        lineIsEmptyOrWhitespace = true;\n        firstNonWhitespaceIndex = len;\n        lastNonWhitespaceIndex = len;\n    }\n    else {\n        lastNonWhitespaceIndex = strings.lastNonWhitespaceIndex(lineContent);\n    }\n    let wasInWhitespace = false;\n    let currentSelectionIndex = 0;\n    let currentSelection = selections && selections[currentSelectionIndex];\n    let tmpIndent = startVisibleColumn % tabSize;\n    for (let charIndex = fauxIndentLength; charIndex < len; charIndex++) {\n        const chCode = lineContent.charCodeAt(charIndex);\n        if (currentSelection && charIndex >= currentSelection.endOffset) {\n            currentSelectionIndex++;\n            currentSelection = selections && selections[currentSelectionIndex];\n        }\n        let isInWhitespace;\n        if (charIndex < firstNonWhitespaceIndex || charIndex > lastNonWhitespaceIndex) {\n            // in leading or trailing whitespace\n            isInWhitespace = true;\n        }\n        else if (chCode === 9 /* CharCode.Tab */) {\n            // a tab character is rendered both in all and boundary cases\n            isInWhitespace = true;\n        }\n        else if (chCode === 32 /* CharCode.Space */) {\n            // hit a space character\n            if (onlyBoundary) {\n                // rendering only boundary whitespace\n                if (wasInWhitespace) {\n                    isInWhitespace = true;\n                }\n                else {\n                    const nextChCode = (charIndex + 1 < len ? lineContent.charCodeAt(charIndex + 1) : 0 /* CharCode.Null */);\n                    isInWhitespace = (nextChCode === 32 /* CharCode.Space */ || nextChCode === 9 /* CharCode.Tab */);\n                }\n            }\n            else {\n                isInWhitespace = true;\n            }\n        }\n        else {\n            isInWhitespace = false;\n        }\n        // If rendering whitespace on selection, check that the charIndex falls within a selection\n        if (isInWhitespace && selections) {\n            isInWhitespace = !!currentSelection && currentSelection.startOffset <= charIndex && currentSelection.endOffset > charIndex;\n        }\n        // If rendering only trailing whitespace, check that the charIndex points to trailing whitespace.\n        if (isInWhitespace && onlyTrailing) {\n            isInWhitespace = lineIsEmptyOrWhitespace || charIndex > lastNonWhitespaceIndex;\n        }\n        if (isInWhitespace && tokenContainsRTL) {\n            // If the token contains RTL text, breaking it up into multiple line parts\n            // to render whitespace might affect the browser's bidi layout.\n            //\n            // We render whitespace in such tokens only if the whitespace\n            // is the leading or the trailing whitespace of the line,\n            // which doesn't affect the browser's bidi layout.\n            if (charIndex >= firstNonWhitespaceIndex && charIndex <= lastNonWhitespaceIndex) {\n                isInWhitespace = false;\n            }\n        }\n        if (wasInWhitespace) {\n            // was in whitespace token\n            if (!isInWhitespace || (!useMonospaceOptimizations && tmpIndent >= tabSize)) {\n                // leaving whitespace token or entering a new indent\n                if (generateLinePartForEachWhitespace) {\n                    const lastEndIndex = (resultLen > 0 ? result[resultLen - 1].endIndex : fauxIndentLength);\n                    for (let i = lastEndIndex + 1; i <= charIndex; i++) {\n                        result[resultLen++] = new LinePart(i, 'mtkw', 1 /* LinePartMetadata.IS_WHITESPACE */, false);\n                    }\n                }\n                else {\n                    result[resultLen++] = new LinePart(charIndex, 'mtkw', 1 /* LinePartMetadata.IS_WHITESPACE */, false);\n                }\n                tmpIndent = tmpIndent % tabSize;\n            }\n        }\n        else {\n            // was in regular token\n            if (charIndex === tokenEndIndex || (isInWhitespace && charIndex > fauxIndentLength)) {\n                result[resultLen++] = new LinePart(charIndex, tokenType, 0, tokenContainsRTL);\n                tmpIndent = tmpIndent % tabSize;\n            }\n        }\n        if (chCode === 9 /* CharCode.Tab */) {\n            tmpIndent = tabSize;\n        }\n        else if (strings.isFullWidthCharacter(chCode)) {\n            tmpIndent += 2;\n        }\n        else {\n            tmpIndent++;\n        }\n        wasInWhitespace = isInWhitespace;\n        while (charIndex === tokenEndIndex) {\n            tokenIndex++;\n            if (tokenIndex < tokensLength) {\n                tokenType = tokens[tokenIndex].type;\n                tokenContainsRTL = tokens[tokenIndex].containsRTL;\n                tokenEndIndex = tokens[tokenIndex].endIndex;\n            }\n            else {\n                break;\n            }\n        }\n    }\n    let generateWhitespace = false;\n    if (wasInWhitespace) {\n        // was in whitespace token\n        if (continuesWithWrappedLine && onlyBoundary) {\n            const lastCharCode = (len > 0 ? lineContent.charCodeAt(len - 1) : 0 /* CharCode.Null */);\n            const prevCharCode = (len > 1 ? lineContent.charCodeAt(len - 2) : 0 /* CharCode.Null */);\n            const isSingleTrailingSpace = (lastCharCode === 32 /* CharCode.Space */ && (prevCharCode !== 32 /* CharCode.Space */ && prevCharCode !== 9 /* CharCode.Tab */));\n            if (!isSingleTrailingSpace) {\n                generateWhitespace = true;\n            }\n        }\n        else {\n            generateWhitespace = true;\n        }\n    }\n    if (generateWhitespace) {\n        if (generateLinePartForEachWhitespace) {\n            const lastEndIndex = (resultLen > 0 ? result[resultLen - 1].endIndex : fauxIndentLength);\n            for (let i = lastEndIndex + 1; i <= len; i++) {\n                result[resultLen++] = new LinePart(i, 'mtkw', 1 /* LinePartMetadata.IS_WHITESPACE */, false);\n            }\n        }\n        else {\n            result[resultLen++] = new LinePart(len, 'mtkw', 1 /* LinePartMetadata.IS_WHITESPACE */, false);\n        }\n    }\n    else {\n        result[resultLen++] = new LinePart(len, tokenType, 0, tokenContainsRTL);\n    }\n    return result;\n}\n/**\n * Inline decorations are \"merged\" on top of tokens.\n * Special care must be taken when multiple inline decorations are at play and they overlap.\n */\nfunction _applyInlineDecorations(lineContent, len, tokens, _lineDecorations) {\n    _lineDecorations.sort(LineDecoration.compare);\n    const lineDecorations = LineDecorationsNormalizer.normalize(lineContent, _lineDecorations);\n    const lineDecorationsLen = lineDecorations.length;\n    let lineDecorationIndex = 0;\n    const result = [];\n    let resultLen = 0;\n    let lastResultEndIndex = 0;\n    for (let tokenIndex = 0, len = tokens.length; tokenIndex < len; tokenIndex++) {\n        const token = tokens[tokenIndex];\n        const tokenEndIndex = token.endIndex;\n        const tokenType = token.type;\n        const tokenMetadata = token.metadata;\n        const tokenContainsRTL = token.containsRTL;\n        while (lineDecorationIndex < lineDecorationsLen && lineDecorations[lineDecorationIndex].startOffset < tokenEndIndex) {\n            const lineDecoration = lineDecorations[lineDecorationIndex];\n            if (lineDecoration.startOffset > lastResultEndIndex) {\n                lastResultEndIndex = lineDecoration.startOffset;\n                result[resultLen++] = new LinePart(lastResultEndIndex, tokenType, tokenMetadata, tokenContainsRTL);\n            }\n            if (lineDecoration.endOffset + 1 <= tokenEndIndex) {\n                // This line decoration ends before this token ends\n                lastResultEndIndex = lineDecoration.endOffset + 1;\n                result[resultLen++] = new LinePart(lastResultEndIndex, tokenType + ' ' + lineDecoration.className, tokenMetadata | lineDecoration.metadata, tokenContainsRTL);\n                lineDecorationIndex++;\n            }\n            else {\n                // This line decoration continues on to the next token\n                lastResultEndIndex = tokenEndIndex;\n                result[resultLen++] = new LinePart(lastResultEndIndex, tokenType + ' ' + lineDecoration.className, tokenMetadata | lineDecoration.metadata, tokenContainsRTL);\n                break;\n            }\n        }\n        if (tokenEndIndex > lastResultEndIndex) {\n            lastResultEndIndex = tokenEndIndex;\n            result[resultLen++] = new LinePart(lastResultEndIndex, tokenType, tokenMetadata, tokenContainsRTL);\n        }\n    }\n    const lastTokenEndIndex = tokens[tokens.length - 1].endIndex;\n    if (lineDecorationIndex < lineDecorationsLen && lineDecorations[lineDecorationIndex].startOffset === lastTokenEndIndex) {\n        while (lineDecorationIndex < lineDecorationsLen && lineDecorations[lineDecorationIndex].startOffset === lastTokenEndIndex) {\n            const lineDecoration = lineDecorations[lineDecorationIndex];\n            result[resultLen++] = new LinePart(lastResultEndIndex, lineDecoration.className, lineDecoration.metadata, false);\n            lineDecorationIndex++;\n        }\n    }\n    return result;\n}\n/**\n * This function is on purpose not split up into multiple functions to allow runtime type inference (i.e. performance reasons).\n * Notice how all the needed data is fully resolved and passed in (i.e. no other calls).\n */\nfunction _renderLine(input, sb) {\n    const fontIsMonospace = input.fontIsMonospace;\n    const canUseHalfwidthRightwardsArrow = input.canUseHalfwidthRightwardsArrow;\n    const containsForeignElements = input.containsForeignElements;\n    const lineContent = input.lineContent;\n    const len = input.len;\n    const isOverflowing = input.isOverflowing;\n    const overflowingCharCount = input.overflowingCharCount;\n    const parts = input.parts;\n    const fauxIndentLength = input.fauxIndentLength;\n    const tabSize = input.tabSize;\n    const startVisibleColumn = input.startVisibleColumn;\n    const containsRTL = input.containsRTL;\n    const spaceWidth = input.spaceWidth;\n    const renderSpaceCharCode = input.renderSpaceCharCode;\n    const renderWhitespace = input.renderWhitespace;\n    const renderControlCharacters = input.renderControlCharacters;\n    const characterMapping = new CharacterMapping(len + 1, parts.length);\n    let lastCharacterMappingDefined = false;\n    let charIndex = 0;\n    let visibleColumn = startVisibleColumn;\n    let charOffsetInPart = 0; // the character offset in the current part\n    let charHorizontalOffset = 0; // the character horizontal position in terms of chars relative to line start\n    let partDisplacement = 0;\n    if (containsRTL) {\n        sb.appendString('<span dir=\"ltr\">');\n    }\n    else {\n        sb.appendString('<span>');\n    }\n    for (let partIndex = 0, tokensLen = parts.length; partIndex < tokensLen; partIndex++) {\n        const part = parts[partIndex];\n        const partEndIndex = part.endIndex;\n        const partType = part.type;\n        const partContainsRTL = part.containsRTL;\n        const partRendersWhitespace = (renderWhitespace !== 0 /* RenderWhitespace.None */ && part.isWhitespace());\n        const partRendersWhitespaceWithWidth = partRendersWhitespace && !fontIsMonospace && (partType === 'mtkw' /*only whitespace*/ || !containsForeignElements);\n        const partIsEmptyAndHasPseudoAfter = (charIndex === partEndIndex && part.isPseudoAfter());\n        charOffsetInPart = 0;\n        sb.appendString('<span ');\n        if (partContainsRTL) {\n            sb.appendString('style=\"unicode-bidi:isolate\" ');\n        }\n        sb.appendString('class=\"');\n        sb.appendString(partRendersWhitespaceWithWidth ? 'mtkz' : partType);\n        sb.appendASCIICharCode(34 /* CharCode.DoubleQuote */);\n        if (partRendersWhitespace) {\n            let partWidth = 0;\n            {\n                let _charIndex = charIndex;\n                let _visibleColumn = visibleColumn;\n                for (; _charIndex < partEndIndex; _charIndex++) {\n                    const charCode = lineContent.charCodeAt(_charIndex);\n                    const charWidth = (charCode === 9 /* CharCode.Tab */ ? (tabSize - (_visibleColumn % tabSize)) : 1) | 0;\n                    partWidth += charWidth;\n                    if (_charIndex >= fauxIndentLength) {\n                        _visibleColumn += charWidth;\n                    }\n                }\n            }\n            if (partRendersWhitespaceWithWidth) {\n                sb.appendString(' style=\"width:');\n                sb.appendString(String(spaceWidth * partWidth));\n                sb.appendString('px\"');\n            }\n            sb.appendASCIICharCode(62 /* CharCode.GreaterThan */);\n            for (; charIndex < partEndIndex; charIndex++) {\n                characterMapping.setColumnInfo(charIndex + 1, partIndex - partDisplacement, charOffsetInPart, charHorizontalOffset);\n                partDisplacement = 0;\n                const charCode = lineContent.charCodeAt(charIndex);\n                let producedCharacters;\n                let charWidth;\n                if (charCode === 9 /* CharCode.Tab */) {\n                    producedCharacters = (tabSize - (visibleColumn % tabSize)) | 0;\n                    charWidth = producedCharacters;\n                    if (!canUseHalfwidthRightwardsArrow || charWidth > 1) {\n                        sb.appendCharCode(0x2192); // RIGHTWARDS ARROW\n                    }\n                    else {\n                        sb.appendCharCode(0xFFEB); // HALFWIDTH RIGHTWARDS ARROW\n                    }\n                    for (let space = 2; space <= charWidth; space++) {\n                        sb.appendCharCode(0xA0); // &nbsp;\n                    }\n                }\n                else { // must be CharCode.Space\n                    producedCharacters = 2;\n                    charWidth = 1;\n                    sb.appendCharCode(renderSpaceCharCode); // &middot; or word separator middle dot\n                    sb.appendCharCode(0x200C); // ZERO WIDTH NON-JOINER\n                }\n                charOffsetInPart += producedCharacters;\n                charHorizontalOffset += charWidth;\n                if (charIndex >= fauxIndentLength) {\n                    visibleColumn += charWidth;\n                }\n            }\n        }\n        else {\n            sb.appendASCIICharCode(62 /* CharCode.GreaterThan */);\n            for (; charIndex < partEndIndex; charIndex++) {\n                characterMapping.setColumnInfo(charIndex + 1, partIndex - partDisplacement, charOffsetInPart, charHorizontalOffset);\n                partDisplacement = 0;\n                const charCode = lineContent.charCodeAt(charIndex);\n                let producedCharacters = 1;\n                let charWidth = 1;\n                switch (charCode) {\n                    case 9 /* CharCode.Tab */:\n                        producedCharacters = (tabSize - (visibleColumn % tabSize));\n                        charWidth = producedCharacters;\n                        for (let space = 1; space <= producedCharacters; space++) {\n                            sb.appendCharCode(0xA0); // &nbsp;\n                        }\n                        break;\n                    case 32 /* CharCode.Space */:\n                        sb.appendCharCode(0xA0); // &nbsp;\n                        break;\n                    case 60 /* CharCode.LessThan */:\n                        sb.appendString('&lt;');\n                        break;\n                    case 62 /* CharCode.GreaterThan */:\n                        sb.appendString('&gt;');\n                        break;\n                    case 38 /* CharCode.Ampersand */:\n                        sb.appendString('&amp;');\n                        break;\n                    case 0 /* CharCode.Null */:\n                        if (renderControlCharacters) {\n                            // See https://unicode-table.com/en/blocks/control-pictures/\n                            sb.appendCharCode(9216);\n                        }\n                        else {\n                            sb.appendString('&#00;');\n                        }\n                        break;\n                    case 65279 /* CharCode.UTF8_BOM */:\n                    case 8232 /* CharCode.LINE_SEPARATOR */:\n                    case 8233 /* CharCode.PARAGRAPH_SEPARATOR */:\n                    case 133 /* CharCode.NEXT_LINE */:\n                        sb.appendCharCode(0xFFFD);\n                        break;\n                    default:\n                        if (strings.isFullWidthCharacter(charCode)) {\n                            charWidth++;\n                        }\n                        // See https://unicode-table.com/en/blocks/control-pictures/\n                        if (renderControlCharacters && charCode < 32) {\n                            sb.appendCharCode(9216 + charCode);\n                        }\n                        else if (renderControlCharacters && charCode === 127) {\n                            // DEL\n                            sb.appendCharCode(9249);\n                        }\n                        else if (renderControlCharacters && isControlCharacter(charCode)) {\n                            sb.appendString('[U+');\n                            sb.appendString(to4CharHex(charCode));\n                            sb.appendString(']');\n                            producedCharacters = 8;\n                            charWidth = producedCharacters;\n                        }\n                        else {\n                            sb.appendCharCode(charCode);\n                        }\n                }\n                charOffsetInPart += producedCharacters;\n                charHorizontalOffset += charWidth;\n                if (charIndex >= fauxIndentLength) {\n                    visibleColumn += charWidth;\n                }\n            }\n        }\n        if (partIsEmptyAndHasPseudoAfter) {\n            partDisplacement++;\n        }\n        else {\n            partDisplacement = 0;\n        }\n        if (charIndex >= len && !lastCharacterMappingDefined && part.isPseudoAfter()) {\n            lastCharacterMappingDefined = true;\n            characterMapping.setColumnInfo(charIndex + 1, partIndex, charOffsetInPart, charHorizontalOffset);\n        }\n        sb.appendString('</span>');\n    }\n    if (!lastCharacterMappingDefined) {\n        // When getting client rects for the last character, we will position the\n        // text range at the end of the span, insteaf of at the beginning of next span\n        characterMapping.setColumnInfo(len + 1, parts.length - 1, charOffsetInPart, charHorizontalOffset);\n    }\n    if (isOverflowing) {\n        sb.appendString('<span class=\"mtkoverflow\">');\n        sb.appendString(nls.localize('showMore', \"Show more ({0})\", renderOverflowingCharCount(overflowingCharCount)));\n        sb.appendString('</span>');\n    }\n    sb.appendString('</span>');\n    return new RenderLineOutput(characterMapping, containsRTL, containsForeignElements);\n}\nfunction to4CharHex(n) {\n    return n.toString(16).toUpperCase().padStart(4, '0');\n}\nfunction renderOverflowingCharCount(n) {\n    if (n < 1024) {\n        return nls.localize('overflow.chars', \"{0} chars\", n);\n    }\n    if (n < 1024 * 1024) {\n        return `${(n / 1024).toFixed(1)} KB`;\n    }\n    return `${(n / 1024 / 1024).toFixed(1)} MB`;\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 '../core/range.js';\n/**\n * Contains all data needed to render at a specific viewport.\n */\nexport class ViewportData {\n    constructor(selections, partialData, whitespaceViewportData, model) {\n        this.selections = selections;\n        this.startLineNumber = partialData.startLineNumber | 0;\n        this.endLineNumber = partialData.endLineNumber | 0;\n        this.relativeVerticalOffset = partialData.relativeVerticalOffset;\n        this.bigNumbersDelta = partialData.bigNumbersDelta | 0;\n        this.lineHeight = partialData.lineHeight | 0;\n        this.whitespaceViewportData = whitespaceViewportData;\n        this._model = model;\n        this.visibleRange = new Range(partialData.startLineNumber, this._model.getLineMinColumn(partialData.startLineNumber), partialData.endLineNumber, this._model.getLineMaxColumn(partialData.endLineNumber));\n    }\n    getViewLineRenderingData(lineNumber) {\n        return this._model.getViewportViewLineRenderingData(this.visibleRange, lineNumber);\n    }\n    getDecorationsInViewport() {\n        return this._model.getDecorationsInViewport(this.visibleRange);\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 { GlyphMarginLane } from '../model.js';\nconst MAX_LANE = GlyphMarginLane.Right;\nexport class GlyphMarginLanesModel {\n    constructor(maxLine) {\n        this.persist = 0;\n        this._requiredLanes = 1; // always render at least one lane\n        this.lanes = new Uint8Array(Math.ceil(((maxLine + 1) * MAX_LANE) / 8));\n    }\n    reset(maxLine) {\n        const bytes = Math.ceil(((maxLine + 1) * MAX_LANE) / 8);\n        if (this.lanes.length < bytes) {\n            this.lanes = new Uint8Array(bytes);\n        }\n        else {\n            this.lanes.fill(0);\n        }\n        this._requiredLanes = 1;\n    }\n    get requiredLanes() {\n        return this._requiredLanes;\n    }\n    push(lane, range, persist) {\n        if (persist) {\n            this.persist |= (1 << (lane - 1));\n        }\n        for (let i = range.startLineNumber; i <= range.endLineNumber; i++) {\n            const bit = (MAX_LANE * i) + (lane - 1);\n            this.lanes[bit >>> 3] |= (1 << (bit % 8));\n            this._requiredLanes = Math.max(this._requiredLanes, this.countAtLine(i));\n        }\n    }\n    getLanesAtLine(lineNumber) {\n        const lanes = [];\n        let bit = MAX_LANE * lineNumber;\n        for (let i = 0; i < MAX_LANE; i++) {\n            if (this.persist & (1 << i) || this.lanes[bit >>> 3] & (1 << (bit % 8))) {\n                lanes.push(i + 1);\n            }\n            bit++;\n        }\n        return lanes.length ? lanes : [GlyphMarginLane.Center];\n    }\n    countAtLine(lineNumber) {\n        let bit = MAX_LANE * lineNumber;\n        let count = 0;\n        for (let i = 0; i < MAX_LANE; i++) {\n            if (this.persist & (1 << i) || this.lanes[bit >>> 3] & (1 << (bit % 8))) {\n                count++;\n            }\n            bit++;\n        }\n        return count;\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 { Emitter } from '../../base/common/event.js';\nimport { Disposable } from '../../base/common/lifecycle.js';\nexport class ViewModelEventDispatcher extends Disposable {\n    constructor() {\n        super();\n        this._onEvent = this._register(new Emitter());\n        this.onEvent = this._onEvent.event;\n        this._eventHandlers = [];\n        this._viewEventQueue = null;\n        this._isConsumingViewEventQueue = false;\n        this._collector = null;\n        this._collectorCnt = 0;\n        this._outgoingEvents = [];\n    }\n    emitOutgoingEvent(e) {\n        this._addOutgoingEvent(e);\n        this._emitOutgoingEvents();\n    }\n    _addOutgoingEvent(e) {\n        for (let i = 0, len = this._outgoingEvents.length; i < len; i++) {\n            const mergeResult = (this._outgoingEvents[i].kind === e.kind ? this._outgoingEvents[i].attemptToMerge(e) : null);\n            if (mergeResult) {\n                this._outgoingEvents[i] = mergeResult;\n                return;\n            }\n        }\n        // not merged\n        this._outgoingEvents.push(e);\n    }\n    _emitOutgoingEvents() {\n        while (this._outgoingEvents.length > 0) {\n            if (this._collector || this._isConsumingViewEventQueue) {\n                // right now collecting or emitting view events, so let's postpone emitting\n                return;\n            }\n            const event = this._outgoingEvents.shift();\n            if (event.isNoOp()) {\n                continue;\n            }\n            this._onEvent.fire(event);\n        }\n    }\n    addViewEventHandler(eventHandler) {\n        for (let i = 0, len = this._eventHandlers.length; i < len; i++) {\n            if (this._eventHandlers[i] === eventHandler) {\n                console.warn('Detected duplicate listener in ViewEventDispatcher', eventHandler);\n            }\n        }\n        this._eventHandlers.push(eventHandler);\n    }\n    removeViewEventHandler(eventHandler) {\n        for (let i = 0; i < this._eventHandlers.length; i++) {\n            if (this._eventHandlers[i] === eventHandler) {\n                this._eventHandlers.splice(i, 1);\n                break;\n            }\n        }\n    }\n    beginEmitViewEvents() {\n        this._collectorCnt++;\n        if (this._collectorCnt === 1) {\n            this._collector = new ViewModelEventsCollector();\n        }\n        return this._collector;\n    }\n    endEmitViewEvents() {\n        this._collectorCnt--;\n        if (this._collectorCnt === 0) {\n            const outgoingEvents = this._collector.outgoingEvents;\n            const viewEvents = this._collector.viewEvents;\n            this._collector = null;\n            for (const outgoingEvent of outgoingEvents) {\n                this._addOutgoingEvent(outgoingEvent);\n            }\n            if (viewEvents.length > 0) {\n                this._emitMany(viewEvents);\n            }\n        }\n        this._emitOutgoingEvents();\n    }\n    emitSingleViewEvent(event) {\n        try {\n            const eventsCollector = this.beginEmitViewEvents();\n            eventsCollector.emitViewEvent(event);\n        }\n        finally {\n            this.endEmitViewEvents();\n        }\n    }\n    _emitMany(events) {\n        if (this._viewEventQueue) {\n            this._viewEventQueue = this._viewEventQueue.concat(events);\n        }\n        else {\n            this._viewEventQueue = events;\n        }\n        if (!this._isConsumingViewEventQueue) {\n            this._consumeViewEventQueue();\n        }\n    }\n    _consumeViewEventQueue() {\n        try {\n            this._isConsumingViewEventQueue = true;\n            this._doConsumeQueue();\n        }\n        finally {\n            this._isConsumingViewEventQueue = false;\n        }\n    }\n    _doConsumeQueue() {\n        while (this._viewEventQueue) {\n            // Empty event queue, as events might come in while sending these off\n            const events = this._viewEventQueue;\n            this._viewEventQueue = null;\n            // Use a clone of the event handlers list, as they might remove themselves\n            const eventHandlers = this._eventHandlers.slice(0);\n            for (const eventHandler of eventHandlers) {\n                eventHandler.handleEvents(events);\n            }\n        }\n    }\n}\nexport class ViewModelEventsCollector {\n    constructor() {\n        this.viewEvents = [];\n        this.outgoingEvents = [];\n    }\n    emitViewEvent(event) {\n        this.viewEvents.push(event);\n    }\n    emitOutgoingEvent(e) {\n        this.outgoingEvents.push(e);\n    }\n}\nexport class ContentSizeChangedEvent {\n    constructor(oldContentWidth, oldContentHeight, contentWidth, contentHeight) {\n        this.kind = 0 /* OutgoingViewModelEventKind.ContentSizeChanged */;\n        this._oldContentWidth = oldContentWidth;\n        this._oldContentHeight = oldContentHeight;\n        this.contentWidth = contentWidth;\n        this.contentHeight = contentHeight;\n        this.contentWidthChanged = (this._oldContentWidth !== this.contentWidth);\n        this.contentHeightChanged = (this._oldContentHeight !== this.contentHeight);\n    }\n    isNoOp() {\n        return (!this.contentWidthChanged && !this.contentHeightChanged);\n    }\n    attemptToMerge(other) {\n        if (other.kind !== this.kind) {\n            return null;\n        }\n        return new ContentSizeChangedEvent(this._oldContentWidth, this._oldContentHeight, other.contentWidth, other.contentHeight);\n    }\n}\nexport class FocusChangedEvent {\n    constructor(oldHasFocus, hasFocus) {\n        this.kind = 1 /* OutgoingViewModelEventKind.FocusChanged */;\n        this.oldHasFocus = oldHasFocus;\n        this.hasFocus = hasFocus;\n    }\n    isNoOp() {\n        return (this.oldHasFocus === this.hasFocus);\n    }\n    attemptToMerge(other) {\n        if (other.kind !== this.kind) {\n            return null;\n        }\n        return new FocusChangedEvent(this.oldHasFocus, other.hasFocus);\n    }\n}\nexport class ScrollChangedEvent {\n    constructor(oldScrollWidth, oldScrollLeft, oldScrollHeight, oldScrollTop, scrollWidth, scrollLeft, scrollHeight, scrollTop) {\n        this.kind = 2 /* OutgoingViewModelEventKind.ScrollChanged */;\n        this._oldScrollWidth = oldScrollWidth;\n        this._oldScrollLeft = oldScrollLeft;\n        this._oldScrollHeight = oldScrollHeight;\n        this._oldScrollTop = oldScrollTop;\n        this.scrollWidth = scrollWidth;\n        this.scrollLeft = scrollLeft;\n        this.scrollHeight = scrollHeight;\n        this.scrollTop = scrollTop;\n        this.scrollWidthChanged = (this._oldScrollWidth !== this.scrollWidth);\n        this.scrollLeftChanged = (this._oldScrollLeft !== this.scrollLeft);\n        this.scrollHeightChanged = (this._oldScrollHeight !== this.scrollHeight);\n        this.scrollTopChanged = (this._oldScrollTop !== this.scrollTop);\n    }\n    isNoOp() {\n        return (!this.scrollWidthChanged && !this.scrollLeftChanged && !this.scrollHeightChanged && !this.scrollTopChanged);\n    }\n    attemptToMerge(other) {\n        if (other.kind !== this.kind) {\n            return null;\n        }\n        return new ScrollChangedEvent(this._oldScrollWidth, this._oldScrollLeft, this._oldScrollHeight, this._oldScrollTop, other.scrollWidth, other.scrollLeft, other.scrollHeight, other.scrollTop);\n    }\n}\nexport class ViewZonesChangedEvent {\n    constructor() {\n        this.kind = 3 /* OutgoingViewModelEventKind.ViewZonesChanged */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        if (other.kind !== this.kind) {\n            return null;\n        }\n        return this;\n    }\n}\nexport class HiddenAreasChangedEvent {\n    constructor() {\n        this.kind = 4 /* OutgoingViewModelEventKind.HiddenAreasChanged */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        if (other.kind !== this.kind) {\n            return null;\n        }\n        return this;\n    }\n}\nexport class CursorStateChangedEvent {\n    constructor(oldSelections, selections, oldModelVersionId, modelVersionId, source, reason, reachedMaxCursorCount) {\n        this.kind = 6 /* OutgoingViewModelEventKind.CursorStateChanged */;\n        this.oldSelections = oldSelections;\n        this.selections = selections;\n        this.oldModelVersionId = oldModelVersionId;\n        this.modelVersionId = modelVersionId;\n        this.source = source;\n        this.reason = reason;\n        this.reachedMaxCursorCount = reachedMaxCursorCount;\n    }\n    static _selectionsAreEqual(a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        if (!a || !b) {\n            return false;\n        }\n        const aLen = a.length;\n        const bLen = b.length;\n        if (aLen !== bLen) {\n            return false;\n        }\n        for (let i = 0; i < aLen; i++) {\n            if (!a[i].equalsSelection(b[i])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    isNoOp() {\n        return (CursorStateChangedEvent._selectionsAreEqual(this.oldSelections, this.selections)\n            && this.oldModelVersionId === this.modelVersionId);\n    }\n    attemptToMerge(other) {\n        if (other.kind !== this.kind) {\n            return null;\n        }\n        return new CursorStateChangedEvent(this.oldSelections, other.selections, this.oldModelVersionId, other.modelVersionId, other.source, other.reason, this.reachedMaxCursorCount || other.reachedMaxCursorCount);\n    }\n}\nexport class ReadOnlyEditAttemptEvent {\n    constructor() {\n        this.kind = 5 /* OutgoingViewModelEventKind.ReadOnlyEditAttempt */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        if (other.kind !== this.kind) {\n            return null;\n        }\n        return this;\n    }\n}\nexport class ModelDecorationsChangedEvent {\n    constructor(event) {\n        this.event = event;\n        this.kind = 7 /* OutgoingViewModelEventKind.ModelDecorationsChanged */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        return null;\n    }\n}\nexport class ModelLanguageChangedEvent {\n    constructor(event) {\n        this.event = event;\n        this.kind = 8 /* OutgoingViewModelEventKind.ModelLanguageChanged */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        return null;\n    }\n}\nexport class ModelLanguageConfigurationChangedEvent {\n    constructor(event) {\n        this.event = event;\n        this.kind = 9 /* OutgoingViewModelEventKind.ModelLanguageConfigurationChanged */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        return null;\n    }\n}\nexport class ModelContentChangedEvent {\n    constructor(event) {\n        this.event = event;\n        this.kind = 10 /* OutgoingViewModelEventKind.ModelContentChanged */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        return null;\n    }\n}\nexport class ModelOptionsChangedEvent {\n    constructor(event) {\n        this.event = event;\n        this.kind = 11 /* OutgoingViewModelEventKind.ModelOptionsChanged */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        return null;\n    }\n}\nexport class ModelTokensChangedEvent {\n    constructor(event) {\n        this.event = event;\n        this.kind = 12 /* OutgoingViewModelEventKind.ModelTokensChanged */;\n    }\n    isNoOp() {\n        return false;\n    }\n    attemptToMerge(other) {\n        return null;\n    }\n}\n"],"names":["ViewEventHandler","constructor","super","this","_shouldRender","shouldRender","forceShouldRender","setShouldRender","onDidRender","onCompositionStart","e","onCompositionEnd","onConfigurationChanged","onCursorStateChanged","onDecorationsChanged","onFlushed","onFocusChanged","onLanguageConfigurationChanged","onLineMappingChanged","onLinesChanged","onLinesDeleted","onLinesInserted","onRevealRangeRequest","onScrollChanged","onThemeChanged","onTokensChanged","onTokensColorsChanged","onZonesChanged","handleEvents","events","i","len","length","type","console","info","ViewCompositionStartEvent","ViewCompositionEndEvent","ViewConfigurationChangedEvent","source","_source","hasChanged","id","ViewCursorStateChangedEvent","selections","modelSelections","reason","ViewDecorationsChangedEvent","affectsMinimap","affectsOverviewRuler","affectsGlyphMargin","affectsLineNumber","ViewFlushedEvent","ViewFocusChangedEvent","isFocused","ViewLanguageConfigurationEvent","ViewLineMappingChangedEvent","ViewLinesChangedEvent","fromLineNumber","count","ViewLinesDeletedEvent","toLineNumber","ViewLinesInsertedEvent","ViewRevealRangeRequestEvent","minimalReveal","range","verticalType","revealHorizontal","scrollType","ViewScrollChangedEvent","scrollWidth","scrollLeft","scrollHeight","scrollTop","scrollWidthChanged","scrollLeftChanged","scrollHeightChanged","scrollTopChanged","ViewThemeChangedEvent","theme","ViewTokensChangedEvent","ranges","ViewTokensColorsChangedEvent","ViewZonesChangedEvent","LineDecoration","startColumn","endColumn","className","_lineDecorationBrand","undefined","_equals","a","b","equalsArr","aLen","extractWrapped","arr","startOffset","endOffset","lineLength","r","rLength","dec","Math","max","min","filter","lineDecorations","lineNumber","minLineColumn","maxLineColumn","result","resultLen","d","endLineNumber","startLineNumber","isEmpty","inlineClassName","_typeCompare","ORDER","compare","typeCmp","DecorationSegment","metadata","Stack","stopOffsets","classNames","_metadata","consumeLowerThan","maxStopOffset","nextStartOffset","push","join","splice","insert","stopOffset","LineDecorationsNormalizer","normalize","lineContent","stack","charCodeBefore","charCodeAt","currentStartOffset","currentEndOffset","PendingChanges","_hasPending","_inserts","_changes","_removes","x","change","remove","mustCommit","commit","linesLayout","inserts","changes","removes","_commitPendingChanges","EditorWhitespace","afterLineNumber","ordinal","height","minWidth","prefixSum","LinesLayout","lineCount","lineHeight","paddingTop","paddingBottom","_instanceId","strings","INSTANCE_COUNT","_pendingChanges","_lastWhitespaceId","_arr","_prefixSumValidIndex","_minWidth","_lineCount","_lineHeight","_paddingTop","_paddingBottom","findInsertionIndex","low","high","mid","setLineHeight","_checkPendingChanges","setPadding","changeWhitespace","callback","hadAChange","insertWhitespace","heightInPx","changeOneWhitespace","newAfterLineNumber","newHeight","removeWhitespace","_insertWhitespace","_changeOneWhitespace","index","_findWhitespaceIndex","_removeWhitespace","toRemove","Set","add","toChange","Map","set","applyRemoveAndChange","whitespaces","whitespace","has","get","concat","sort","insertIndex","removeIndex","getWhitespacesTotalHeight","getWhitespacesAccumulatedHeight","startIndex","getLinesTotalHeight","getWhitespaceAccumulatedHeightBeforeLineNumber","lastWhitespaceBeforeLineNumber","_findLastWhitespaceBeforeLineNumber","_findFirstWhitespaceAfterLineNumber","firstWhitespaceAfterLineNumber","getFirstWhitespaceIndexAfterLineNumber","getVerticalOffsetForLineNumber","includeViewZones","previousLinesHeight","getVerticalOffsetAfterLineNumber","getWhitespaceMinWidth","isAfterLines","verticalOffset","isInTopPadding","isInBottomPadding","getLineNumberAtOrAfterVerticalOffset","linesCount","minLineNumber","maxLineNumber","midLineNumber","midLineNumberVerticalOffset","getLinesViewportData","verticalOffset1","verticalOffset2","startLineNumberVerticalOffset","whitespaceIndex","whitespaceCount","getWhitespacesCount","currentWhitespaceHeight","currentWhitespaceAfterLineNumber","getAfterLineNumberForWhitespaceIndex","getHeightForWhitespaceIndex","currentVerticalOffset","currentLineRelativeOffset","STEP_SIZE","bigNumbersDelta","floor","linesOffsets","verticalCenter","centeredLineNumber","endLineNumberVerticalOffset","completelyVisibleStartLineNumber","completelyVisibleEndLineNumber","relativeVerticalOffset","getVerticalOffsetForWhitespaceIndex","previousWhitespacesHeight","getWhitespaceIndexAtOrAfterVerticallOffset","minWhitespaceIndex","maxWhitespaceIndex","midWhitespaceIndex","midWhitespaceVerticalOffset","getWhitespaceAtVerticalOffset","candidateIndex","candidateTop","candidateHeight","getIdForWhitespaceIndex","getWhitespaceViewportData","endIndex","top","getWhitespaces","slice","EditorScrollDimensions","width","contentWidth","contentHeight","equals","other","EditorScrollable","smoothScrollDuration","scheduleAtNextAnimationFrame","_onDidContentSizeChange","_register","onDidContentSizeChange","event","_dimensions","_scrollable","forceIntegerValues","onDidScroll","onScroll","getScrollable","setSmoothScrollDuration","validateScrollPosition","scrollPosition","getScrollDimensions","setScrollDimensions","dimensions","oldDimensions","contentWidthChanged","contentHeightChanged","fire","getFutureScrollPosition","getCurrentScrollPosition","setScrollPositionNow","update","setScrollPositionSmooth","hasPendingScrollAnimation","ViewLayout","configuration","_configuration","options","layoutInfo","padding","_linesLayout","bottom","_maxLineWidth","_overlayWidgetsMinWidth","_configureSmoothScrollDuration","_updateHeight","dispose","onHeightMaybeChanged","scrollDimensions","_getContentHeight","_getHorizontalScrollbarHeight","scrollbar","horizontal","horizontalScrollbarSize","ignoreHorizontalScrollbarInContentHeight","getCurrentViewport","currentScrollPosition","getFutureViewport","_computeContentWidth","maxLineWidth","wrappingInfo","fontInfo","isViewportWrapping","minimap","typicalHalfwidthCharacterWidth","enabled","side","verticalScrollbarWidth","extraHorizontalSpace","whitespaceMinWidth","setMaxLineWidth","_updateContentWidth","setOverlayWidgetsMinWidth","maxMinWidth","saveState","firstLineNumberInViewport","scrollTopWithoutViewZones","getLineNumberAtVerticalOffset","visibleBox","getLinesViewportDataAtScrollTop","getContentWidth","getScrollWidth","getContentHeight","getScrollHeight","getCurrentScrollLeft","getCurrentScrollTop","setScrollPosition","position","deltaScrollNow","deltaScrollLeft","deltaScrollTop","LinePart","containsRTL","_linePartBrand","isWhitespace","isPseudoAfter","LineRange","otherLineRange","RenderLineInput","useMonospaceOptimizations","canUseHalfwidthRightwardsArrow","continuesWithWrappedLine","isBasicASCII","fauxIndentLength","lineTokens","tabSize","startVisibleColumn","spaceWidth","middotWidth","wsmiddotWidth","stopRenderingLineAfter","renderWhitespace","renderControlCharacters","fontLigatures","selectionsOnLine","abs","renderSpaceWidth","renderSpaceCharCode","sameSelection","otherSelections","DomPosition","partIndex","charIndex","CharacterMapping","getPartIndex","partData","getCharIndex","partCount","_data","Uint32Array","_horizontalOffset","setColumnInfo","column","horizontalOffset","getHorizontalOffset","charOffsetToPartData","charOffset","getDomPosition","getColumn","domPosition","partLength","partDataToCharOffset","searchEntry","midEntry","minEntry","maxEntry","minPartIndex","minCharIndex","maxCharIndex","RenderLineOutput","characterMapping","containsForeignElements","_renderLineOutputBrand","renderViewLine","input","sb","appendString","beforeCount","afterCount","lineDecoration","fontIsMonospace","isOverflowing","overflowingCharCount","parts","lastCharacterMappingDefined","visibleColumn","charOffsetInPart","charHorizontalOffset","partDisplacement","tokensLen","part","partEndIndex","partType","partContainsRTL","partRendersWhitespace","partRendersWhitespaceWithWidth","partIsEmptyAndHasPseudoAfter","appendASCIICharCode","partWidth","_charIndex","_visibleColumn","charWidth","String","producedCharacters","appendCharCode","space","charCode","isControlCharacter","to4CharHex","nls","n","toFixed","renderOverflowingCharCount","_renderLine","tokens","lineContainsRTL","tokenIndex","getCount","getEndOffset","getClassName","tokenContainsRTL","substring","transformAndRemoveOverflowing","lastLinePart","token","tokenEndIndex","extractControlCharacters","onlyBoundary","onlyTrailing","generateLinePartForEachWhitespace","tokenType","tokensLength","lastNonWhitespaceIndex","lineIsEmptyOrWhitespace","firstNonWhitespaceIndex","wasInWhitespace","currentSelectionIndex","currentSelection","tmpIndent","chCode","isInWhitespace","nextChCode","generateWhitespace","lastCharCode","prevCharCode","_applyRenderWhitespace","_lineDecorations","lineDecorationsLen","lineDecorationIndex","lastResultEndIndex","tokenMetadata","lastTokenEndIndex","_applyInlineDecorations","onlyAtSpaces","lastSpaceOffset","currTokenStart","j","diff","piecesCount","ceil","pieceEndIndex","splitLargeTokens","ResolvedRenderLineInput","resolveRenderLineInput","RenderLineOutput2","html","renderViewLine2","out","build","toString","toUpperCase","padStart","ViewportData","partialData","whitespaceViewportData","model","_model","visibleRange","getLineMinColumn","getLineMaxColumn","getViewLineRenderingData","getViewportViewLineRenderingData","getDecorationsInViewport","MAX_LANE","GlyphMarginLanesModel","maxLine","persist","_requiredLanes","lanes","Uint8Array","reset","bytes","fill","requiredLanes","lane","bit","countAtLine","getLanesAtLine","ViewModelEventDispatcher","_onEvent","onEvent","_eventHandlers","_viewEventQueue","_isConsumingViewEventQueue","_collector","_collectorCnt","_outgoingEvents","emitOutgoingEvent","_addOutgoingEvent","_emitOutgoingEvents","mergeResult","kind","attemptToMerge","shift","isNoOp","addViewEventHandler","eventHandler","warn","removeViewEventHandler","beginEmitViewEvents","ViewModelEventsCollector","endEmitViewEvents","outgoingEvents","viewEvents","outgoingEvent","_emitMany","emitSingleViewEvent","emitViewEvent","_consumeViewEventQueue","_doConsumeQueue","eventHandlers","ContentSizeChangedEvent","oldContentWidth","oldContentHeight","_oldContentWidth","_oldContentHeight","FocusChangedEvent","oldHasFocus","hasFocus","ScrollChangedEvent","oldScrollWidth","oldScrollLeft","oldScrollHeight","oldScrollTop","_oldScrollWidth","_oldScrollLeft","_oldScrollHeight","_oldScrollTop","HiddenAreasChangedEvent","CursorStateChangedEvent","oldSelections","oldModelVersionId","modelVersionId","reachedMaxCursorCount","_selectionsAreEqual","equalsSelection","ReadOnlyEditAttemptEvent","ModelDecorationsChangedEvent","ModelLanguageChangedEvent","ModelLanguageConfigurationChangedEvent","ModelContentChangedEvent","ModelOptionsChangedEvent","ModelTokensChangedEvent"],"sourceRoot":""}