{"version":3,"file":"static/js/1606_64474d8a1c1db40f093b.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/position.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/range.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/rgba.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/selection.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/stringBuilder.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/textChange.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/positionToOffset.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/textEdit.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/textLength.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/textModelDefaults.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/wordCharacterClassifier.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/monaco-editor@0.50.0/node_modules/monaco-editor/esm/vs/editor/common/core/wordHelper.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/cursorCommon.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 *--------------------------------------------------------------------------------------------*/\n/**\n * A position in the editor.\n */\nexport class Position {\n    constructor(lineNumber, column) {\n        this.lineNumber = lineNumber;\n        this.column = column;\n    }\n    /**\n     * Create a new position from this position.\n     *\n     * @param newLineNumber new line number\n     * @param newColumn new column\n     */\n    with(newLineNumber = this.lineNumber, newColumn = this.column) {\n        if (newLineNumber === this.lineNumber && newColumn === this.column) {\n            return this;\n        }\n        else {\n            return new Position(newLineNumber, newColumn);\n        }\n    }\n    /**\n     * Derive a new position from this position.\n     *\n     * @param deltaLineNumber line number delta\n     * @param deltaColumn column delta\n     */\n    delta(deltaLineNumber = 0, deltaColumn = 0) {\n        return this.with(this.lineNumber + deltaLineNumber, this.column + deltaColumn);\n    }\n    /**\n     * Test if this position equals other position\n     */\n    equals(other) {\n        return Position.equals(this, other);\n    }\n    /**\n     * Test if position `a` equals position `b`\n     */\n    static equals(a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        return (!!a &&\n            !!b &&\n            a.lineNumber === b.lineNumber &&\n            a.column === b.column);\n    }\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be false.\n     */\n    isBefore(other) {\n        return Position.isBefore(this, other);\n    }\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be false.\n     */\n    static isBefore(a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column < b.column;\n    }\n    /**\n     * Test if this position is before other position.\n     * If the two positions are equal, the result will be true.\n     */\n    isBeforeOrEqual(other) {\n        return Position.isBeforeOrEqual(this, other);\n    }\n    /**\n     * Test if position `a` is before position `b`.\n     * If the two positions are equal, the result will be true.\n     */\n    static isBeforeOrEqual(a, b) {\n        if (a.lineNumber < b.lineNumber) {\n            return true;\n        }\n        if (b.lineNumber < a.lineNumber) {\n            return false;\n        }\n        return a.column <= b.column;\n    }\n    /**\n     * A function that compares positions, useful for sorting\n     */\n    static compare(a, b) {\n        const aLineNumber = a.lineNumber | 0;\n        const bLineNumber = b.lineNumber | 0;\n        if (aLineNumber === bLineNumber) {\n            const aColumn = a.column | 0;\n            const bColumn = b.column | 0;\n            return aColumn - bColumn;\n        }\n        return aLineNumber - bLineNumber;\n    }\n    /**\n     * Clone this position.\n     */\n    clone() {\n        return new Position(this.lineNumber, this.column);\n    }\n    /**\n     * Convert to a human-readable representation.\n     */\n    toString() {\n        return '(' + this.lineNumber + ',' + this.column + ')';\n    }\n    // ---\n    /**\n     * Create a `Position` from an `IPosition`.\n     */\n    static lift(pos) {\n        return new Position(pos.lineNumber, pos.column);\n    }\n    /**\n     * Test if `obj` is an `IPosition`.\n     */\n    static isIPosition(obj) {\n        return (obj\n            && (typeof obj.lineNumber === 'number')\n            && (typeof obj.column === 'number'));\n    }\n    toJSON() {\n        return {\n            lineNumber: this.lineNumber,\n            column: this.column\n        };\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Position } from './position.js';\n/**\n * A range in the editor. (startLineNumber,startColumn) is <= (endLineNumber,endColumn)\n */\nexport class Range {\n    constructor(startLineNumber, startColumn, endLineNumber, endColumn) {\n        if ((startLineNumber > endLineNumber) || (startLineNumber === endLineNumber && startColumn > endColumn)) {\n            this.startLineNumber = endLineNumber;\n            this.startColumn = endColumn;\n            this.endLineNumber = startLineNumber;\n            this.endColumn = startColumn;\n        }\n        else {\n            this.startLineNumber = startLineNumber;\n            this.startColumn = startColumn;\n            this.endLineNumber = endLineNumber;\n            this.endColumn = endColumn;\n        }\n    }\n    /**\n     * Test if this range is empty.\n     */\n    isEmpty() {\n        return Range.isEmpty(this);\n    }\n    /**\n     * Test if `range` is empty.\n     */\n    static isEmpty(range) {\n        return (range.startLineNumber === range.endLineNumber && range.startColumn === range.endColumn);\n    }\n    /**\n     * Test if position is in this range. If the position is at the edges, will return true.\n     */\n    containsPosition(position) {\n        return Range.containsPosition(this, position);\n    }\n    /**\n     * Test if `position` is in `range`. If the position is at the edges, will return true.\n     */\n    static containsPosition(range, position) {\n        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (position.lineNumber === range.startLineNumber && position.column < range.startColumn) {\n            return false;\n        }\n        if (position.lineNumber === range.endLineNumber && position.column > range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * Test if `position` is in `range`. If the position is at the edges, will return false.\n     * @internal\n     */\n    static strictContainsPosition(range, position) {\n        if (position.lineNumber < range.startLineNumber || position.lineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (position.lineNumber === range.startLineNumber && position.column <= range.startColumn) {\n            return false;\n        }\n        if (position.lineNumber === range.endLineNumber && position.column >= range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * Test if range is in this range. If the range is equal to this range, will return true.\n     */\n    containsRange(range) {\n        return Range.containsRange(this, range);\n    }\n    /**\n     * Test if `otherRange` is in `range`. If the ranges are equal, will return true.\n     */\n    static containsRange(range, otherRange) {\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn < range.startColumn) {\n            return false;\n        }\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn > range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * Test if `range` is strictly in this range. `range` must start after and end before this range for the result to be true.\n     */\n    strictContainsRange(range) {\n        return Range.strictContainsRange(this, range);\n    }\n    /**\n     * Test if `otherRange` is strictly in `range` (must start after, and end before). If the ranges are equal, will return false.\n     */\n    static strictContainsRange(range, otherRange) {\n        if (otherRange.startLineNumber < range.startLineNumber || otherRange.endLineNumber < range.startLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber > range.endLineNumber || otherRange.endLineNumber > range.endLineNumber) {\n            return false;\n        }\n        if (otherRange.startLineNumber === range.startLineNumber && otherRange.startColumn <= range.startColumn) {\n            return false;\n        }\n        if (otherRange.endLineNumber === range.endLineNumber && otherRange.endColumn >= range.endColumn) {\n            return false;\n        }\n        return true;\n    }\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    plusRange(range) {\n        return Range.plusRange(this, range);\n    }\n    /**\n     * A reunion of the two ranges.\n     * The smallest position will be used as the start point, and the largest one as the end point.\n     */\n    static plusRange(a, b) {\n        let startLineNumber;\n        let startColumn;\n        let endLineNumber;\n        let endColumn;\n        if (b.startLineNumber < a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = b.startColumn;\n        }\n        else if (b.startLineNumber === a.startLineNumber) {\n            startLineNumber = b.startLineNumber;\n            startColumn = Math.min(b.startColumn, a.startColumn);\n        }\n        else {\n            startLineNumber = a.startLineNumber;\n            startColumn = a.startColumn;\n        }\n        if (b.endLineNumber > a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = b.endColumn;\n        }\n        else if (b.endLineNumber === a.endLineNumber) {\n            endLineNumber = b.endLineNumber;\n            endColumn = Math.max(b.endColumn, a.endColumn);\n        }\n        else {\n            endLineNumber = a.endLineNumber;\n            endColumn = a.endColumn;\n        }\n        return new Range(startLineNumber, startColumn, endLineNumber, endColumn);\n    }\n    /**\n     * A intersection of the two ranges.\n     */\n    intersectRanges(range) {\n        return Range.intersectRanges(this, range);\n    }\n    /**\n     * A intersection of the two ranges.\n     */\n    static intersectRanges(a, b) {\n        let resultStartLineNumber = a.startLineNumber;\n        let resultStartColumn = a.startColumn;\n        let resultEndLineNumber = a.endLineNumber;\n        let resultEndColumn = a.endColumn;\n        const otherStartLineNumber = b.startLineNumber;\n        const otherStartColumn = b.startColumn;\n        const otherEndLineNumber = b.endLineNumber;\n        const otherEndColumn = b.endColumn;\n        if (resultStartLineNumber < otherStartLineNumber) {\n            resultStartLineNumber = otherStartLineNumber;\n            resultStartColumn = otherStartColumn;\n        }\n        else if (resultStartLineNumber === otherStartLineNumber) {\n            resultStartColumn = Math.max(resultStartColumn, otherStartColumn);\n        }\n        if (resultEndLineNumber > otherEndLineNumber) {\n            resultEndLineNumber = otherEndLineNumber;\n            resultEndColumn = otherEndColumn;\n        }\n        else if (resultEndLineNumber === otherEndLineNumber) {\n            resultEndColumn = Math.min(resultEndColumn, otherEndColumn);\n        }\n        // Check if selection is now empty\n        if (resultStartLineNumber > resultEndLineNumber) {\n            return null;\n        }\n        if (resultStartLineNumber === resultEndLineNumber && resultStartColumn > resultEndColumn) {\n            return null;\n        }\n        return new Range(resultStartLineNumber, resultStartColumn, resultEndLineNumber, resultEndColumn);\n    }\n    /**\n     * Test if this range equals other.\n     */\n    equalsRange(other) {\n        return Range.equalsRange(this, other);\n    }\n    /**\n     * Test if range `a` equals `b`.\n     */\n    static equalsRange(a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        return (!!a &&\n            !!b &&\n            a.startLineNumber === b.startLineNumber &&\n            a.startColumn === b.startColumn &&\n            a.endLineNumber === b.endLineNumber &&\n            a.endColumn === b.endColumn);\n    }\n    /**\n     * Return the end position (which will be after or equal to the start position)\n     */\n    getEndPosition() {\n        return Range.getEndPosition(this);\n    }\n    /**\n     * Return the end position (which will be after or equal to the start position)\n     */\n    static getEndPosition(range) {\n        return new Position(range.endLineNumber, range.endColumn);\n    }\n    /**\n     * Return the start position (which will be before or equal to the end position)\n     */\n    getStartPosition() {\n        return Range.getStartPosition(this);\n    }\n    /**\n     * Return the start position (which will be before or equal to the end position)\n     */\n    static getStartPosition(range) {\n        return new Position(range.startLineNumber, range.startColumn);\n    }\n    /**\n     * Transform to a user presentable string representation.\n     */\n    toString() {\n        return '[' + this.startLineNumber + ',' + this.startColumn + ' -> ' + this.endLineNumber + ',' + this.endColumn + ']';\n    }\n    /**\n     * Create a new range using this range's start position, and using endLineNumber and endColumn as the end position.\n     */\n    setEndPosition(endLineNumber, endColumn) {\n        return new Range(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n    }\n    /**\n     * Create a new range using this range's end position, and using startLineNumber and startColumn as the start position.\n     */\n    setStartPosition(startLineNumber, startColumn) {\n        return new Range(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n    }\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    collapseToStart() {\n        return Range.collapseToStart(this);\n    }\n    /**\n     * Create a new empty range using this range's start position.\n     */\n    static collapseToStart(range) {\n        return new Range(range.startLineNumber, range.startColumn, range.startLineNumber, range.startColumn);\n    }\n    /**\n     * Create a new empty range using this range's end position.\n     */\n    collapseToEnd() {\n        return Range.collapseToEnd(this);\n    }\n    /**\n     * Create a new empty range using this range's end position.\n     */\n    static collapseToEnd(range) {\n        return new Range(range.endLineNumber, range.endColumn, range.endLineNumber, range.endColumn);\n    }\n    /**\n     * Moves the range by the given amount of lines.\n     */\n    delta(lineCount) {\n        return new Range(this.startLineNumber + lineCount, this.startColumn, this.endLineNumber + lineCount, this.endColumn);\n    }\n    // ---\n    static fromPositions(start, end = start) {\n        return new Range(start.lineNumber, start.column, end.lineNumber, end.column);\n    }\n    static lift(range) {\n        if (!range) {\n            return null;\n        }\n        return new Range(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n    }\n    /**\n     * Test if `obj` is an `IRange`.\n     */\n    static isIRange(obj) {\n        return (obj\n            && (typeof obj.startLineNumber === 'number')\n            && (typeof obj.startColumn === 'number')\n            && (typeof obj.endLineNumber === 'number')\n            && (typeof obj.endColumn === 'number'));\n    }\n    /**\n     * Test if the two ranges are touching in any way.\n     */\n    static areIntersectingOrTouching(a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn < b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn < a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    }\n    /**\n     * Test if the two ranges are intersecting. If the ranges are touching it returns true.\n     */\n    static areIntersecting(a, b) {\n        // Check if `a` is before `b`\n        if (a.endLineNumber < b.startLineNumber || (a.endLineNumber === b.startLineNumber && a.endColumn <= b.startColumn)) {\n            return false;\n        }\n        // Check if `b` is before `a`\n        if (b.endLineNumber < a.startLineNumber || (b.endLineNumber === a.startLineNumber && b.endColumn <= a.startColumn)) {\n            return false;\n        }\n        // These ranges must intersect\n        return true;\n    }\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the startPosition and then on the endPosition\n     */\n    static compareRangesUsingStarts(a, b) {\n        if (a && b) {\n            const aStartLineNumber = a.startLineNumber | 0;\n            const bStartLineNumber = b.startLineNumber | 0;\n            if (aStartLineNumber === bStartLineNumber) {\n                const aStartColumn = a.startColumn | 0;\n                const bStartColumn = b.startColumn | 0;\n                if (aStartColumn === bStartColumn) {\n                    const aEndLineNumber = a.endLineNumber | 0;\n                    const bEndLineNumber = b.endLineNumber | 0;\n                    if (aEndLineNumber === bEndLineNumber) {\n                        const aEndColumn = a.endColumn | 0;\n                        const bEndColumn = b.endColumn | 0;\n                        return aEndColumn - bEndColumn;\n                    }\n                    return aEndLineNumber - bEndLineNumber;\n                }\n                return aStartColumn - bStartColumn;\n            }\n            return aStartLineNumber - bStartLineNumber;\n        }\n        const aExists = (a ? 1 : 0);\n        const bExists = (b ? 1 : 0);\n        return aExists - bExists;\n    }\n    /**\n     * A function that compares ranges, useful for sorting ranges\n     * It will first compare ranges on the endPosition and then on the startPosition\n     */\n    static compareRangesUsingEnds(a, b) {\n        if (a.endLineNumber === b.endLineNumber) {\n            if (a.endColumn === b.endColumn) {\n                if (a.startLineNumber === b.startLineNumber) {\n                    return a.startColumn - b.startColumn;\n                }\n                return a.startLineNumber - b.startLineNumber;\n            }\n            return a.endColumn - b.endColumn;\n        }\n        return a.endLineNumber - b.endLineNumber;\n    }\n    /**\n     * Test if the range spans multiple lines.\n     */\n    static spansMultipleLines(range) {\n        return range.endLineNumber > range.startLineNumber;\n    }\n    toJSON() {\n        return this;\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 *--------------------------------------------------------------------------------------------*/\n/**\n * A very VM friendly rgba datastructure.\n * Please don't touch unless you take a look at the IR.\n */\nexport class RGBA8 {\n    constructor(r, g, b, a) {\n        this._rgba8Brand = undefined;\n        this.r = RGBA8._clamp(r);\n        this.g = RGBA8._clamp(g);\n        this.b = RGBA8._clamp(b);\n        this.a = RGBA8._clamp(a);\n    }\n    equals(other) {\n        return (this.r === other.r\n            && this.g === other.g\n            && this.b === other.b\n            && this.a === other.a);\n    }\n    static _clamp(c) {\n        if (c < 0) {\n            return 0;\n        }\n        if (c > 255) {\n            return 255;\n        }\n        return c | 0;\n    }\n}\nRGBA8.Empty = new RGBA8(0, 0, 0, 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 { Position } from './position.js';\nimport { Range } from './range.js';\n/**\n * A selection in the editor.\n * The selection is a range that has an orientation.\n */\nexport class Selection extends Range {\n    constructor(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn) {\n        super(selectionStartLineNumber, selectionStartColumn, positionLineNumber, positionColumn);\n        this.selectionStartLineNumber = selectionStartLineNumber;\n        this.selectionStartColumn = selectionStartColumn;\n        this.positionLineNumber = positionLineNumber;\n        this.positionColumn = positionColumn;\n    }\n    /**\n     * Transform to a human-readable representation.\n     */\n    toString() {\n        return '[' + this.selectionStartLineNumber + ',' + this.selectionStartColumn + ' -> ' + this.positionLineNumber + ',' + this.positionColumn + ']';\n    }\n    /**\n     * Test if equals other selection.\n     */\n    equalsSelection(other) {\n        return (Selection.selectionsEqual(this, other));\n    }\n    /**\n     * Test if the two selections are equal.\n     */\n    static selectionsEqual(a, b) {\n        return (a.selectionStartLineNumber === b.selectionStartLineNumber &&\n            a.selectionStartColumn === b.selectionStartColumn &&\n            a.positionLineNumber === b.positionLineNumber &&\n            a.positionColumn === b.positionColumn);\n    }\n    /**\n     * Get directions (LTR or RTL).\n     */\n    getDirection() {\n        if (this.selectionStartLineNumber === this.startLineNumber && this.selectionStartColumn === this.startColumn) {\n            return 0 /* SelectionDirection.LTR */;\n        }\n        return 1 /* SelectionDirection.RTL */;\n    }\n    /**\n     * Create a new selection with a different `positionLineNumber` and `positionColumn`.\n     */\n    setEndPosition(endLineNumber, endColumn) {\n        if (this.getDirection() === 0 /* SelectionDirection.LTR */) {\n            return new Selection(this.startLineNumber, this.startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, this.startLineNumber, this.startColumn);\n    }\n    /**\n     * Get the position at `positionLineNumber` and `positionColumn`.\n     */\n    getPosition() {\n        return new Position(this.positionLineNumber, this.positionColumn);\n    }\n    /**\n     * Get the position at the start of the selection.\n    */\n    getSelectionStart() {\n        return new Position(this.selectionStartLineNumber, this.selectionStartColumn);\n    }\n    /**\n     * Create a new selection with a different `selectionStartLineNumber` and `selectionStartColumn`.\n     */\n    setStartPosition(startLineNumber, startColumn) {\n        if (this.getDirection() === 0 /* SelectionDirection.LTR */) {\n            return new Selection(startLineNumber, startColumn, this.endLineNumber, this.endColumn);\n        }\n        return new Selection(this.endLineNumber, this.endColumn, startLineNumber, startColumn);\n    }\n    // ----\n    /**\n     * Create a `Selection` from one or two positions\n     */\n    static fromPositions(start, end = start) {\n        return new Selection(start.lineNumber, start.column, end.lineNumber, end.column);\n    }\n    /**\n     * Creates a `Selection` from a range, given a direction.\n     */\n    static fromRange(range, direction) {\n        if (direction === 0 /* SelectionDirection.LTR */) {\n            return new Selection(range.startLineNumber, range.startColumn, range.endLineNumber, range.endColumn);\n        }\n        else {\n            return new Selection(range.endLineNumber, range.endColumn, range.startLineNumber, range.startColumn);\n        }\n    }\n    /**\n     * Create a `Selection` from an `ISelection`.\n     */\n    static liftSelection(sel) {\n        return new Selection(sel.selectionStartLineNumber, sel.selectionStartColumn, sel.positionLineNumber, sel.positionColumn);\n    }\n    /**\n     * `a` equals `b`.\n     */\n    static selectionsArrEqual(a, b) {\n        if (a && !b || !a && b) {\n            return false;\n        }\n        if (!a && !b) {\n            return true;\n        }\n        if (a.length !== b.length) {\n            return false;\n        }\n        for (let i = 0, len = a.length; i < len; i++) {\n            if (!this.selectionsEqual(a[i], b[i])) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * Test if `obj` is an `ISelection`.\n     */\n    static isISelection(obj) {\n        return (obj\n            && (typeof obj.selectionStartLineNumber === 'number')\n            && (typeof obj.selectionStartColumn === 'number')\n            && (typeof obj.positionLineNumber === 'number')\n            && (typeof obj.positionColumn === 'number'));\n    }\n    /**\n     * Create with a direction.\n     */\n    static createWithDirection(startLineNumber, startColumn, endLineNumber, endColumn, direction) {\n        if (direction === 0 /* SelectionDirection.LTR */) {\n            return new Selection(startLineNumber, startColumn, endLineNumber, endColumn);\n        }\n        return new Selection(endLineNumber, endColumn, startLineNumber, startColumn);\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';\nimport * as platform from '../../../base/common/platform.js';\nimport * as buffer from '../../../base/common/buffer.js';\nlet _utf16LE_TextDecoder;\nfunction getUTF16LE_TextDecoder() {\n    if (!_utf16LE_TextDecoder) {\n        _utf16LE_TextDecoder = new TextDecoder('UTF-16LE');\n    }\n    return _utf16LE_TextDecoder;\n}\nlet _utf16BE_TextDecoder;\nfunction getUTF16BE_TextDecoder() {\n    if (!_utf16BE_TextDecoder) {\n        _utf16BE_TextDecoder = new TextDecoder('UTF-16BE');\n    }\n    return _utf16BE_TextDecoder;\n}\nlet _platformTextDecoder;\nexport function getPlatformTextDecoder() {\n    if (!_platformTextDecoder) {\n        _platformTextDecoder = platform.isLittleEndian() ? getUTF16LE_TextDecoder() : getUTF16BE_TextDecoder();\n    }\n    return _platformTextDecoder;\n}\nexport function decodeUTF16LE(source, offset, len) {\n    const view = new Uint16Array(source.buffer, offset, len);\n    if (len > 0 && (view[0] === 0xFEFF || view[0] === 0xFFFE)) {\n        // UTF16 sometimes starts with a BOM https://de.wikipedia.org/wiki/Byte_Order_Mark\n        // It looks like TextDecoder.decode will eat up a leading BOM (0xFEFF or 0xFFFE)\n        // We don't want that behavior because we know the string is UTF16LE and the BOM should be maintained\n        // So we use the manual decoder\n        return compatDecodeUTF16LE(source, offset, len);\n    }\n    return getUTF16LE_TextDecoder().decode(view);\n}\nfunction compatDecodeUTF16LE(source, offset, len) {\n    const result = [];\n    let resultLen = 0;\n    for (let i = 0; i < len; i++) {\n        const charCode = buffer.readUInt16LE(source, offset);\n        offset += 2;\n        result[resultLen++] = String.fromCharCode(charCode);\n    }\n    return result.join('');\n}\nexport class StringBuilder {\n    constructor(capacity) {\n        this._capacity = capacity | 0;\n        this._buffer = new Uint16Array(this._capacity);\n        this._completedStrings = null;\n        this._bufferLength = 0;\n    }\n    reset() {\n        this._completedStrings = null;\n        this._bufferLength = 0;\n    }\n    build() {\n        if (this._completedStrings !== null) {\n            this._flushBuffer();\n            return this._completedStrings.join('');\n        }\n        return this._buildBuffer();\n    }\n    _buildBuffer() {\n        if (this._bufferLength === 0) {\n            return '';\n        }\n        const view = new Uint16Array(this._buffer.buffer, 0, this._bufferLength);\n        return getPlatformTextDecoder().decode(view);\n    }\n    _flushBuffer() {\n        const bufferString = this._buildBuffer();\n        this._bufferLength = 0;\n        if (this._completedStrings === null) {\n            this._completedStrings = [bufferString];\n        }\n        else {\n            this._completedStrings[this._completedStrings.length] = bufferString;\n        }\n    }\n    /**\n     * Append a char code (<2^16)\n     */\n    appendCharCode(charCode) {\n        const remainingSpace = this._capacity - this._bufferLength;\n        if (remainingSpace <= 1) {\n            if (remainingSpace === 0 || strings.isHighSurrogate(charCode)) {\n                this._flushBuffer();\n            }\n        }\n        this._buffer[this._bufferLength++] = charCode;\n    }\n    /**\n     * Append an ASCII char code (<2^8)\n     */\n    appendASCIICharCode(charCode) {\n        if (this._bufferLength === this._capacity) {\n            // buffer is full\n            this._flushBuffer();\n        }\n        this._buffer[this._bufferLength++] = charCode;\n    }\n    appendString(str) {\n        const strLen = str.length;\n        if (this._bufferLength + strLen >= this._capacity) {\n            // This string does not fit in the remaining buffer space\n            this._flushBuffer();\n            this._completedStrings[this._completedStrings.length] = str;\n            return;\n        }\n        for (let i = 0; i < strLen; i++) {\n            this._buffer[this._bufferLength++] = str.charCodeAt(i);\n        }\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as buffer from '../../../base/common/buffer.js';\nimport { decodeUTF16LE } from './stringBuilder.js';\nfunction escapeNewLine(str) {\n    return (str\n        .replace(/\\n/g, '\\\\n')\n        .replace(/\\r/g, '\\\\r'));\n}\nexport class TextChange {\n    get oldLength() {\n        return this.oldText.length;\n    }\n    get oldEnd() {\n        return this.oldPosition + this.oldText.length;\n    }\n    get newLength() {\n        return this.newText.length;\n    }\n    get newEnd() {\n        return this.newPosition + this.newText.length;\n    }\n    constructor(oldPosition, oldText, newPosition, newText) {\n        this.oldPosition = oldPosition;\n        this.oldText = oldText;\n        this.newPosition = newPosition;\n        this.newText = newText;\n    }\n    toString() {\n        if (this.oldText.length === 0) {\n            return `(insert@${this.oldPosition} \"${escapeNewLine(this.newText)}\")`;\n        }\n        if (this.newText.length === 0) {\n            return `(delete@${this.oldPosition} \"${escapeNewLine(this.oldText)}\")`;\n        }\n        return `(replace@${this.oldPosition} \"${escapeNewLine(this.oldText)}\" with \"${escapeNewLine(this.newText)}\")`;\n    }\n    static _writeStringSize(str) {\n        return (4 + 2 * str.length);\n    }\n    static _writeString(b, str, offset) {\n        const len = str.length;\n        buffer.writeUInt32BE(b, len, offset);\n        offset += 4;\n        for (let i = 0; i < len; i++) {\n            buffer.writeUInt16LE(b, str.charCodeAt(i), offset);\n            offset += 2;\n        }\n        return offset;\n    }\n    static _readString(b, offset) {\n        const len = buffer.readUInt32BE(b, offset);\n        offset += 4;\n        return decodeUTF16LE(b, offset, len);\n    }\n    writeSize() {\n        return (+4 // oldPosition\n            + 4 // newPosition\n            + TextChange._writeStringSize(this.oldText)\n            + TextChange._writeStringSize(this.newText));\n    }\n    write(b, offset) {\n        buffer.writeUInt32BE(b, this.oldPosition, offset);\n        offset += 4;\n        buffer.writeUInt32BE(b, this.newPosition, offset);\n        offset += 4;\n        offset = TextChange._writeString(b, this.oldText, offset);\n        offset = TextChange._writeString(b, this.newText, offset);\n        return offset;\n    }\n    static read(b, offset, dest) {\n        const oldPosition = buffer.readUInt32BE(b, offset);\n        offset += 4;\n        const newPosition = buffer.readUInt32BE(b, offset);\n        offset += 4;\n        const oldText = TextChange._readString(b, offset);\n        offset += TextChange._writeStringSize(oldText);\n        const newText = TextChange._readString(b, offset);\n        offset += TextChange._writeStringSize(newText);\n        dest.push(new TextChange(oldPosition, oldText, newPosition, newText));\n        return offset;\n    }\n}\nexport function compressConsecutiveTextChanges(prevEdits, currEdits) {\n    if (prevEdits === null || prevEdits.length === 0) {\n        return currEdits;\n    }\n    const compressor = new TextChangeCompressor(prevEdits, currEdits);\n    return compressor.compress();\n}\nclass TextChangeCompressor {\n    constructor(prevEdits, currEdits) {\n        this._prevEdits = prevEdits;\n        this._currEdits = currEdits;\n        this._result = [];\n        this._resultLen = 0;\n        this._prevLen = this._prevEdits.length;\n        this._prevDeltaOffset = 0;\n        this._currLen = this._currEdits.length;\n        this._currDeltaOffset = 0;\n    }\n    compress() {\n        let prevIndex = 0;\n        let currIndex = 0;\n        let prevEdit = this._getPrev(prevIndex);\n        let currEdit = this._getCurr(currIndex);\n        while (prevIndex < this._prevLen || currIndex < this._currLen) {\n            if (prevEdit === null) {\n                this._acceptCurr(currEdit);\n                currEdit = this._getCurr(++currIndex);\n                continue;\n            }\n            if (currEdit === null) {\n                this._acceptPrev(prevEdit);\n                prevEdit = this._getPrev(++prevIndex);\n                continue;\n            }\n            if (currEdit.oldEnd <= prevEdit.newPosition) {\n                this._acceptCurr(currEdit);\n                currEdit = this._getCurr(++currIndex);\n                continue;\n            }\n            if (prevEdit.newEnd <= currEdit.oldPosition) {\n                this._acceptPrev(prevEdit);\n                prevEdit = this._getPrev(++prevIndex);\n                continue;\n            }\n            if (currEdit.oldPosition < prevEdit.newPosition) {\n                const [e1, e2] = TextChangeCompressor._splitCurr(currEdit, prevEdit.newPosition - currEdit.oldPosition);\n                this._acceptCurr(e1);\n                currEdit = e2;\n                continue;\n            }\n            if (prevEdit.newPosition < currEdit.oldPosition) {\n                const [e1, e2] = TextChangeCompressor._splitPrev(prevEdit, currEdit.oldPosition - prevEdit.newPosition);\n                this._acceptPrev(e1);\n                prevEdit = e2;\n                continue;\n            }\n            // At this point, currEdit.oldPosition === prevEdit.newPosition\n            let mergePrev;\n            let mergeCurr;\n            if (currEdit.oldEnd === prevEdit.newEnd) {\n                mergePrev = prevEdit;\n                mergeCurr = currEdit;\n                prevEdit = this._getPrev(++prevIndex);\n                currEdit = this._getCurr(++currIndex);\n            }\n            else if (currEdit.oldEnd < prevEdit.newEnd) {\n                const [e1, e2] = TextChangeCompressor._splitPrev(prevEdit, currEdit.oldLength);\n                mergePrev = e1;\n                mergeCurr = currEdit;\n                prevEdit = e2;\n                currEdit = this._getCurr(++currIndex);\n            }\n            else {\n                const [e1, e2] = TextChangeCompressor._splitCurr(currEdit, prevEdit.newLength);\n                mergePrev = prevEdit;\n                mergeCurr = e1;\n                prevEdit = this._getPrev(++prevIndex);\n                currEdit = e2;\n            }\n            this._result[this._resultLen++] = new TextChange(mergePrev.oldPosition, mergePrev.oldText, mergeCurr.newPosition, mergeCurr.newText);\n            this._prevDeltaOffset += mergePrev.newLength - mergePrev.oldLength;\n            this._currDeltaOffset += mergeCurr.newLength - mergeCurr.oldLength;\n        }\n        const merged = TextChangeCompressor._merge(this._result);\n        const cleaned = TextChangeCompressor._removeNoOps(merged);\n        return cleaned;\n    }\n    _acceptCurr(currEdit) {\n        this._result[this._resultLen++] = TextChangeCompressor._rebaseCurr(this._prevDeltaOffset, currEdit);\n        this._currDeltaOffset += currEdit.newLength - currEdit.oldLength;\n    }\n    _getCurr(currIndex) {\n        return (currIndex < this._currLen ? this._currEdits[currIndex] : null);\n    }\n    _acceptPrev(prevEdit) {\n        this._result[this._resultLen++] = TextChangeCompressor._rebasePrev(this._currDeltaOffset, prevEdit);\n        this._prevDeltaOffset += prevEdit.newLength - prevEdit.oldLength;\n    }\n    _getPrev(prevIndex) {\n        return (prevIndex < this._prevLen ? this._prevEdits[prevIndex] : null);\n    }\n    static _rebaseCurr(prevDeltaOffset, currEdit) {\n        return new TextChange(currEdit.oldPosition - prevDeltaOffset, currEdit.oldText, currEdit.newPosition, currEdit.newText);\n    }\n    static _rebasePrev(currDeltaOffset, prevEdit) {\n        return new TextChange(prevEdit.oldPosition, prevEdit.oldText, prevEdit.newPosition + currDeltaOffset, prevEdit.newText);\n    }\n    static _splitPrev(edit, offset) {\n        const preText = edit.newText.substr(0, offset);\n        const postText = edit.newText.substr(offset);\n        return [\n            new TextChange(edit.oldPosition, edit.oldText, edit.newPosition, preText),\n            new TextChange(edit.oldEnd, '', edit.newPosition + offset, postText)\n        ];\n    }\n    static _splitCurr(edit, offset) {\n        const preText = edit.oldText.substr(0, offset);\n        const postText = edit.oldText.substr(offset);\n        return [\n            new TextChange(edit.oldPosition, preText, edit.newPosition, edit.newText),\n            new TextChange(edit.oldPosition + offset, postText, edit.newEnd, '')\n        ];\n    }\n    static _merge(edits) {\n        if (edits.length === 0) {\n            return edits;\n        }\n        const result = [];\n        let resultLen = 0;\n        let prev = edits[0];\n        for (let i = 1; i < edits.length; i++) {\n            const curr = edits[i];\n            if (prev.oldEnd === curr.oldPosition) {\n                // Merge into `prev`\n                prev = new TextChange(prev.oldPosition, prev.oldText + curr.oldText, prev.newPosition, prev.newText + curr.newText);\n            }\n            else {\n                result[resultLen++] = prev;\n                prev = curr;\n            }\n        }\n        result[resultLen++] = prev;\n        return result;\n    }\n    static _removeNoOps(edits) {\n        if (edits.length === 0) {\n            return edits;\n        }\n        const result = [];\n        let resultLen = 0;\n        for (let i = 0; i < edits.length; i++) {\n            const edit = edits[i];\n            if (edit.oldText === edit.newText) {\n                continue;\n            }\n            result[resultLen++] = edit;\n        }\n        return result;\n    }\n}\n","import { OffsetRange } from './offsetRange.js';\nimport { TextLength } from './textLength.js';\nexport class PositionOffsetTransformer {\n    constructor(text) {\n        this.text = text;\n        this.lineStartOffsetByLineIdx = [];\n        this.lineStartOffsetByLineIdx.push(0);\n        for (let i = 0; i < text.length; i++) {\n            if (text.charAt(i) === '\\n') {\n                this.lineStartOffsetByLineIdx.push(i + 1);\n            }\n        }\n    }\n    getOffset(position) {\n        return this.lineStartOffsetByLineIdx[position.lineNumber - 1] + position.column - 1;\n    }\n    getOffsetRange(range) {\n        return new OffsetRange(this.getOffset(range.getStartPosition()), this.getOffset(range.getEndPosition()));\n    }\n    get textLength() {\n        const lineIdx = this.lineStartOffsetByLineIdx.length - 1;\n        return new TextLength(lineIdx, this.text.length - this.lineStartOffsetByLineIdx[lineIdx]);\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 { assertFn, checkAdjacentItems } from '../../../base/common/assert.js';\nimport { BugIndicatingError } from '../../../base/common/errors.js';\nimport { Position } from './position.js';\nimport { PositionOffsetTransformer } from './positionToOffset.js';\nimport { Range } from './range.js';\nimport { TextLength } from './textLength.js';\nexport class TextEdit {\n    constructor(edits) {\n        this.edits = edits;\n        assertFn(() => checkAdjacentItems(edits, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));\n    }\n    apply(text) {\n        let result = '';\n        let lastEditEnd = new Position(1, 1);\n        for (const edit of this.edits) {\n            const editRange = edit.range;\n            const editStart = editRange.getStartPosition();\n            const editEnd = editRange.getEndPosition();\n            const r = rangeFromPositions(lastEditEnd, editStart);\n            if (!r.isEmpty()) {\n                result += text.getValueOfRange(r);\n            }\n            result += edit.text;\n            lastEditEnd = editEnd;\n        }\n        const r = rangeFromPositions(lastEditEnd, text.endPositionExclusive);\n        if (!r.isEmpty()) {\n            result += text.getValueOfRange(r);\n        }\n        return result;\n    }\n    applyToString(str) {\n        const strText = new StringText(str);\n        return this.apply(strText);\n    }\n    getNewRanges() {\n        const newRanges = [];\n        let previousEditEndLineNumber = 0;\n        let lineOffset = 0;\n        let columnOffset = 0;\n        for (const edit of this.edits) {\n            const textLength = TextLength.ofText(edit.text);\n            const newRangeStart = Position.lift({\n                lineNumber: edit.range.startLineNumber + lineOffset,\n                column: edit.range.startColumn + (edit.range.startLineNumber === previousEditEndLineNumber ? columnOffset : 0)\n            });\n            const newRange = textLength.createRange(newRangeStart);\n            newRanges.push(newRange);\n            lineOffset = newRange.endLineNumber - edit.range.endLineNumber;\n            columnOffset = newRange.endColumn - edit.range.endColumn;\n            previousEditEndLineNumber = edit.range.endLineNumber;\n        }\n        return newRanges;\n    }\n}\nexport class SingleTextEdit {\n    constructor(range, text) {\n        this.range = range;\n        this.text = text;\n    }\n}\nfunction rangeFromPositions(start, end) {\n    if (start.lineNumber === end.lineNumber && start.column === Number.MAX_SAFE_INTEGER) {\n        return Range.fromPositions(end, end);\n    }\n    else if (!start.isBeforeOrEqual(end)) {\n        throw new BugIndicatingError('start must be before end');\n    }\n    return new Range(start.lineNumber, start.column, end.lineNumber, end.column);\n}\nexport class AbstractText {\n    get endPositionExclusive() {\n        return this.length.addToPosition(new Position(1, 1));\n    }\n}\nexport class StringText extends AbstractText {\n    constructor(value) {\n        super();\n        this.value = value;\n        this._t = new PositionOffsetTransformer(this.value);\n    }\n    getValueOfRange(range) {\n        return this._t.getOffsetRange(range).substring(this.value);\n    }\n    get length() {\n        return this._t.textLength;\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 { Position } from './position.js';\nimport { Range } from './range.js';\n/**\n * Represents a non-negative length of text in terms of line and column count.\n*/\nexport class TextLength {\n    static betweenPositions(position1, position2) {\n        if (position1.lineNumber === position2.lineNumber) {\n            return new TextLength(0, position2.column - position1.column);\n        }\n        else {\n            return new TextLength(position2.lineNumber - position1.lineNumber, position2.column - 1);\n        }\n    }\n    static ofRange(range) {\n        return TextLength.betweenPositions(range.getStartPosition(), range.getEndPosition());\n    }\n    static ofText(text) {\n        let line = 0;\n        let column = 0;\n        for (const c of text) {\n            if (c === '\\n') {\n                line++;\n                column = 0;\n            }\n            else {\n                column++;\n            }\n        }\n        return new TextLength(line, column);\n    }\n    constructor(lineCount, columnCount) {\n        this.lineCount = lineCount;\n        this.columnCount = columnCount;\n    }\n    isGreaterThanOrEqualTo(other) {\n        if (this.lineCount !== other.lineCount) {\n            return this.lineCount > other.lineCount;\n        }\n        return this.columnCount >= other.columnCount;\n    }\n    createRange(startPosition) {\n        if (this.lineCount === 0) {\n            return new Range(startPosition.lineNumber, startPosition.column, startPosition.lineNumber, startPosition.column + this.columnCount);\n        }\n        else {\n            return new Range(startPosition.lineNumber, startPosition.column, startPosition.lineNumber + this.lineCount, this.columnCount + 1);\n        }\n    }\n    addToPosition(position) {\n        if (this.lineCount === 0) {\n            return new Position(position.lineNumber, position.column + this.columnCount);\n        }\n        else {\n            return new Position(position.lineNumber + this.lineCount, this.columnCount + 1);\n        }\n    }\n    toString() {\n        return `${this.lineCount},${this.columnCount}`;\n    }\n}\nTextLength.zero = new TextLength(0, 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 *--------------------------------------------------------------------------------------------*/\nexport const EDITOR_MODEL_DEFAULTS = {\n    tabSize: 4,\n    indentSize: 4,\n    insertSpaces: true,\n    detectIndentation: true,\n    trimAutoWhitespace: true,\n    largeFileOptimizations: true,\n    bracketPairColorizationOptions: {\n        enabled: true,\n        independentColorPoolPerBracketType: 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 { LRUCache } from '../../../base/common/map.js';\nimport { CharacterClassifier } from './characterClassifier.js';\nexport class WordCharacterClassifier extends CharacterClassifier {\n    constructor(wordSeparators, intlSegmenterLocales) {\n        super(0 /* WordCharacterClass.Regular */);\n        this._segmenter = null;\n        this._cachedLine = null;\n        this._cachedSegments = [];\n        this.intlSegmenterLocales = intlSegmenterLocales;\n        if (this.intlSegmenterLocales.length > 0) {\n            this._segmenter = new Intl.Segmenter(this.intlSegmenterLocales, { granularity: 'word' });\n        }\n        else {\n            this._segmenter = null;\n        }\n        for (let i = 0, len = wordSeparators.length; i < len; i++) {\n            this.set(wordSeparators.charCodeAt(i), 2 /* WordCharacterClass.WordSeparator */);\n        }\n        this.set(32 /* CharCode.Space */, 1 /* WordCharacterClass.Whitespace */);\n        this.set(9 /* CharCode.Tab */, 1 /* WordCharacterClass.Whitespace */);\n    }\n    findPrevIntlWordBeforeOrAtOffset(line, offset) {\n        let candidate = null;\n        for (const segment of this._getIntlSegmenterWordsOnLine(line)) {\n            if (segment.index > offset) {\n                break;\n            }\n            candidate = segment;\n        }\n        return candidate;\n    }\n    findNextIntlWordAtOrAfterOffset(lineContent, offset) {\n        for (const segment of this._getIntlSegmenterWordsOnLine(lineContent)) {\n            if (segment.index < offset) {\n                continue;\n            }\n            return segment;\n        }\n        return null;\n    }\n    _getIntlSegmenterWordsOnLine(line) {\n        if (!this._segmenter) {\n            return [];\n        }\n        // Check if the line has changed from the previous call\n        if (this._cachedLine === line) {\n            return this._cachedSegments;\n        }\n        // Update the cache with the new line\n        this._cachedLine = line;\n        this._cachedSegments = this._filterWordSegments(this._segmenter.segment(line));\n        return this._cachedSegments;\n    }\n    _filterWordSegments(segments) {\n        const result = [];\n        for (const segment of segments) {\n            if (this._isWordLike(segment)) {\n                result.push(segment);\n            }\n        }\n        return result;\n    }\n    _isWordLike(segment) {\n        if (segment.isWordLike) {\n            return true;\n        }\n        return false;\n    }\n}\nconst wordClassifierCache = new LRUCache(10);\nexport function getMapForWordSeparators(wordSeparators, intlSegmenterLocales) {\n    const key = `${wordSeparators}/${intlSegmenterLocales.join(',')}`;\n    let result = wordClassifierCache.get(key);\n    if (!result) {\n        result = new WordCharacterClassifier(wordSeparators, intlSegmenterLocales);\n        wordClassifierCache.set(key, result);\n    }\n    return result;\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 { Iterable } from '../../../base/common/iterator.js';\nimport { LinkedList } from '../../../base/common/linkedList.js';\nexport const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\\\|;:\\'\",.<>/?';\n/**\n * Create a word definition regular expression based on default word separators.\n * Optionally provide allowed separators that should be included in words.\n *\n * The default would look like this:\n * /(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\$\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)/g\n */\nfunction createWordRegExp(allowInWords = '') {\n    let source = '(-?\\\\d*\\\\.\\\\d\\\\w*)|([^';\n    for (const sep of USUAL_WORD_SEPARATORS) {\n        if (allowInWords.indexOf(sep) >= 0) {\n            continue;\n        }\n        source += '\\\\' + sep;\n    }\n    source += '\\\\s]+)';\n    return new RegExp(source, 'g');\n}\n// catches numbers (including floating numbers) in the first group, and alphanum in the second\nexport const DEFAULT_WORD_REGEXP = createWordRegExp();\nexport function ensureValidWordDefinition(wordDefinition) {\n    let result = DEFAULT_WORD_REGEXP;\n    if (wordDefinition && (wordDefinition instanceof RegExp)) {\n        if (!wordDefinition.global) {\n            let flags = 'g';\n            if (wordDefinition.ignoreCase) {\n                flags += 'i';\n            }\n            if (wordDefinition.multiline) {\n                flags += 'm';\n            }\n            if (wordDefinition.unicode) {\n                flags += 'u';\n            }\n            result = new RegExp(wordDefinition.source, flags);\n        }\n        else {\n            result = wordDefinition;\n        }\n    }\n    result.lastIndex = 0;\n    return result;\n}\nconst _defaultConfig = new LinkedList();\n_defaultConfig.unshift({\n    maxLen: 1000,\n    windowSize: 15,\n    timeBudget: 150\n});\nexport function getWordAtText(column, wordDefinition, text, textOffset, config) {\n    // Ensure the regex has the 'g' flag, otherwise this will loop forever\n    wordDefinition = ensureValidWordDefinition(wordDefinition);\n    if (!config) {\n        config = Iterable.first(_defaultConfig);\n    }\n    if (text.length > config.maxLen) {\n        // don't throw strings that long at the regexp\n        // but use a sub-string in which a word must occur\n        let start = column - config.maxLen / 2;\n        if (start < 0) {\n            start = 0;\n        }\n        else {\n            textOffset += start;\n        }\n        text = text.substring(start, column + config.maxLen / 2);\n        return getWordAtText(column, wordDefinition, text, textOffset, config);\n    }\n    const t1 = Date.now();\n    const pos = column - 1 - textOffset;\n    let prevRegexIndex = -1;\n    let match = null;\n    for (let i = 1;; i++) {\n        // check time budget\n        if (Date.now() - t1 >= config.timeBudget) {\n            break;\n        }\n        // reset the index at which the regexp should start matching, also know where it\n        // should stop so that subsequent search don't repeat previous searches\n        const regexIndex = pos - config.windowSize * i;\n        wordDefinition.lastIndex = Math.max(0, regexIndex);\n        const thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex);\n        if (!thisMatch && match) {\n            // stop: we have something\n            break;\n        }\n        match = thisMatch;\n        // stop: searched at start\n        if (regexIndex <= 0) {\n            break;\n        }\n        prevRegexIndex = regexIndex;\n    }\n    if (match) {\n        const result = {\n            word: match[0],\n            startColumn: textOffset + 1 + match.index,\n            endColumn: textOffset + 1 + match.index + match[0].length\n        };\n        wordDefinition.lastIndex = 0;\n        return result;\n    }\n    return null;\n}\nfunction _findRegexMatchEnclosingPosition(wordDefinition, text, pos, stopPos) {\n    let match;\n    while (match = wordDefinition.exec(text)) {\n        const matchIndex = match.index || 0;\n        if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {\n            return match;\n        }\n        else if (stopPos > 0 && matchIndex > stopPos) {\n            return null;\n        }\n    }\n    return null;\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 { Position } from './core/position.js';\nimport { Range } from './core/range.js';\nimport { Selection } from './core/selection.js';\nimport { createScopedLineTokens } from './languages/supports.js';\nimport { CursorColumns } from './core/cursorColumns.js';\nimport { normalizeIndentation } from './core/indentation.js';\nconst autoCloseAlways = () => true;\nconst autoCloseNever = () => false;\nconst autoCloseBeforeWhitespace = (chr) => (chr === ' ' || chr === '\\t');\nexport class CursorConfiguration {\n    static shouldRecreate(e) {\n        return (e.hasChanged(145 /* EditorOption.layoutInfo */)\n            || e.hasChanged(131 /* EditorOption.wordSeparators */)\n            || e.hasChanged(37 /* EditorOption.emptySelectionClipboard */)\n            || e.hasChanged(77 /* EditorOption.multiCursorMergeOverlapping */)\n            || e.hasChanged(79 /* EditorOption.multiCursorPaste */)\n            || e.hasChanged(80 /* EditorOption.multiCursorLimit */)\n            || e.hasChanged(6 /* EditorOption.autoClosingBrackets */)\n            || e.hasChanged(7 /* EditorOption.autoClosingComments */)\n            || e.hasChanged(11 /* EditorOption.autoClosingQuotes */)\n            || e.hasChanged(9 /* EditorOption.autoClosingDelete */)\n            || e.hasChanged(10 /* EditorOption.autoClosingOvertype */)\n            || e.hasChanged(14 /* EditorOption.autoSurround */)\n            || e.hasChanged(128 /* EditorOption.useTabStops */)\n            || e.hasChanged(50 /* EditorOption.fontInfo */)\n            || e.hasChanged(91 /* EditorOption.readOnly */)\n            || e.hasChanged(130 /* EditorOption.wordSegmenterLocales */));\n    }\n    constructor(languageId, modelOptions, configuration, languageConfigurationService) {\n        var _a;\n        this.languageConfigurationService = languageConfigurationService;\n        this._cursorMoveConfigurationBrand = undefined;\n        this._languageId = languageId;\n        const options = configuration.options;\n        const layoutInfo = options.get(145 /* EditorOption.layoutInfo */);\n        const fontInfo = options.get(50 /* EditorOption.fontInfo */);\n        this.readOnly = options.get(91 /* EditorOption.readOnly */);\n        this.tabSize = modelOptions.tabSize;\n        this.indentSize = modelOptions.indentSize;\n        this.insertSpaces = modelOptions.insertSpaces;\n        this.stickyTabStops = options.get(116 /* EditorOption.stickyTabStops */);\n        this.lineHeight = fontInfo.lineHeight;\n        this.typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;\n        this.pageSize = Math.max(1, Math.floor(layoutInfo.height / this.lineHeight) - 2);\n        this.useTabStops = options.get(128 /* EditorOption.useTabStops */);\n        this.wordSeparators = options.get(131 /* EditorOption.wordSeparators */);\n        this.emptySelectionClipboard = options.get(37 /* EditorOption.emptySelectionClipboard */);\n        this.copyWithSyntaxHighlighting = options.get(25 /* EditorOption.copyWithSyntaxHighlighting */);\n        this.multiCursorMergeOverlapping = options.get(77 /* EditorOption.multiCursorMergeOverlapping */);\n        this.multiCursorPaste = options.get(79 /* EditorOption.multiCursorPaste */);\n        this.multiCursorLimit = options.get(80 /* EditorOption.multiCursorLimit */);\n        this.autoClosingBrackets = options.get(6 /* EditorOption.autoClosingBrackets */);\n        this.autoClosingComments = options.get(7 /* EditorOption.autoClosingComments */);\n        this.autoClosingQuotes = options.get(11 /* EditorOption.autoClosingQuotes */);\n        this.autoClosingDelete = options.get(9 /* EditorOption.autoClosingDelete */);\n        this.autoClosingOvertype = options.get(10 /* EditorOption.autoClosingOvertype */);\n        this.autoSurround = options.get(14 /* EditorOption.autoSurround */);\n        this.autoIndent = options.get(12 /* EditorOption.autoIndent */);\n        this.wordSegmenterLocales = options.get(130 /* EditorOption.wordSegmenterLocales */);\n        this.surroundingPairs = {};\n        this._electricChars = null;\n        this.shouldAutoCloseBefore = {\n            quote: this._getShouldAutoClose(languageId, this.autoClosingQuotes, true),\n            comment: this._getShouldAutoClose(languageId, this.autoClosingComments, false),\n            bracket: this._getShouldAutoClose(languageId, this.autoClosingBrackets, false),\n        };\n        this.autoClosingPairs = this.languageConfigurationService.getLanguageConfiguration(languageId).getAutoClosingPairs();\n        const surroundingPairs = this.languageConfigurationService.getLanguageConfiguration(languageId).getSurroundingPairs();\n        if (surroundingPairs) {\n            for (const pair of surroundingPairs) {\n                this.surroundingPairs[pair.open] = pair.close;\n            }\n        }\n        const commentsConfiguration = this.languageConfigurationService.getLanguageConfiguration(languageId).comments;\n        this.blockCommentStartToken = (_a = commentsConfiguration === null || commentsConfiguration === void 0 ? void 0 : commentsConfiguration.blockCommentStartToken) !== null && _a !== void 0 ? _a : null;\n    }\n    get electricChars() {\n        var _a;\n        if (!this._electricChars) {\n            this._electricChars = {};\n            const electricChars = (_a = this.languageConfigurationService.getLanguageConfiguration(this._languageId).electricCharacter) === null || _a === void 0 ? void 0 : _a.getElectricCharacters();\n            if (electricChars) {\n                for (const char of electricChars) {\n                    this._electricChars[char] = true;\n                }\n            }\n        }\n        return this._electricChars;\n    }\n    /**\n     * Should return opening bracket type to match indentation with\n     */\n    onElectricCharacter(character, context, column) {\n        const scopedLineTokens = createScopedLineTokens(context, column - 1);\n        const electricCharacterSupport = this.languageConfigurationService.getLanguageConfiguration(scopedLineTokens.languageId).electricCharacter;\n        if (!electricCharacterSupport) {\n            return null;\n        }\n        return electricCharacterSupport.onElectricCharacter(character, scopedLineTokens, column - scopedLineTokens.firstCharOffset);\n    }\n    normalizeIndentation(str) {\n        return normalizeIndentation(str, this.indentSize, this.insertSpaces);\n    }\n    _getShouldAutoClose(languageId, autoCloseConfig, forQuotes) {\n        switch (autoCloseConfig) {\n            case 'beforeWhitespace':\n                return autoCloseBeforeWhitespace;\n            case 'languageDefined':\n                return this._getLanguageDefinedShouldAutoClose(languageId, forQuotes);\n            case 'always':\n                return autoCloseAlways;\n            case 'never':\n                return autoCloseNever;\n        }\n    }\n    _getLanguageDefinedShouldAutoClose(languageId, forQuotes) {\n        const autoCloseBeforeSet = this.languageConfigurationService.getLanguageConfiguration(languageId).getAutoCloseBeforeSet(forQuotes);\n        return c => autoCloseBeforeSet.indexOf(c) !== -1;\n    }\n    /**\n     * Returns a visible column from a column.\n     * @see {@link CursorColumns}\n     */\n    visibleColumnFromColumn(model, position) {\n        return CursorColumns.visibleColumnFromColumn(model.getLineContent(position.lineNumber), position.column, this.tabSize);\n    }\n    /**\n     * Returns a visible column from a column.\n     * @see {@link CursorColumns}\n     */\n    columnFromVisibleColumn(model, lineNumber, visibleColumn) {\n        const result = CursorColumns.columnFromVisibleColumn(model.getLineContent(lineNumber), visibleColumn, this.tabSize);\n        const minColumn = model.getLineMinColumn(lineNumber);\n        if (result < minColumn) {\n            return minColumn;\n        }\n        const maxColumn = model.getLineMaxColumn(lineNumber);\n        if (result > maxColumn) {\n            return maxColumn;\n        }\n        return result;\n    }\n}\nexport class CursorState {\n    static fromModelState(modelState) {\n        return new PartialModelCursorState(modelState);\n    }\n    static fromViewState(viewState) {\n        return new PartialViewCursorState(viewState);\n    }\n    static fromModelSelection(modelSelection) {\n        const selection = Selection.liftSelection(modelSelection);\n        const modelState = new SingleCursorState(Range.fromPositions(selection.getSelectionStart()), 0 /* SelectionStartKind.Simple */, 0, selection.getPosition(), 0);\n        return CursorState.fromModelState(modelState);\n    }\n    static fromModelSelections(modelSelections) {\n        const states = [];\n        for (let i = 0, len = modelSelections.length; i < len; i++) {\n            states[i] = this.fromModelSelection(modelSelections[i]);\n        }\n        return states;\n    }\n    constructor(modelState, viewState) {\n        this._cursorStateBrand = undefined;\n        this.modelState = modelState;\n        this.viewState = viewState;\n    }\n    equals(other) {\n        return (this.viewState.equals(other.viewState) && this.modelState.equals(other.modelState));\n    }\n}\nexport class PartialModelCursorState {\n    constructor(modelState) {\n        this.modelState = modelState;\n        this.viewState = null;\n    }\n}\nexport class PartialViewCursorState {\n    constructor(viewState) {\n        this.modelState = null;\n        this.viewState = viewState;\n    }\n}\n/**\n * Represents the cursor state on either the model or on the view model.\n */\nexport class SingleCursorState {\n    constructor(selectionStart, selectionStartKind, selectionStartLeftoverVisibleColumns, position, leftoverVisibleColumns) {\n        this.selectionStart = selectionStart;\n        this.selectionStartKind = selectionStartKind;\n        this.selectionStartLeftoverVisibleColumns = selectionStartLeftoverVisibleColumns;\n        this.position = position;\n        this.leftoverVisibleColumns = leftoverVisibleColumns;\n        this._singleCursorStateBrand = undefined;\n        this.selection = SingleCursorState._computeSelection(this.selectionStart, this.position);\n    }\n    equals(other) {\n        return (this.selectionStartLeftoverVisibleColumns === other.selectionStartLeftoverVisibleColumns\n            && this.leftoverVisibleColumns === other.leftoverVisibleColumns\n            && this.selectionStartKind === other.selectionStartKind\n            && this.position.equals(other.position)\n            && this.selectionStart.equalsRange(other.selectionStart));\n    }\n    hasSelection() {\n        return (!this.selection.isEmpty() || !this.selectionStart.isEmpty());\n    }\n    move(inSelectionMode, lineNumber, column, leftoverVisibleColumns) {\n        if (inSelectionMode) {\n            // move just position\n            return new SingleCursorState(this.selectionStart, this.selectionStartKind, this.selectionStartLeftoverVisibleColumns, new Position(lineNumber, column), leftoverVisibleColumns);\n        }\n        else {\n            // move everything\n            return new SingleCursorState(new Range(lineNumber, column, lineNumber, column), 0 /* SelectionStartKind.Simple */, leftoverVisibleColumns, new Position(lineNumber, column), leftoverVisibleColumns);\n        }\n    }\n    static _computeSelection(selectionStart, position) {\n        if (selectionStart.isEmpty() || !position.isBeforeOrEqual(selectionStart.getStartPosition())) {\n            return Selection.fromPositions(selectionStart.getStartPosition(), position);\n        }\n        else {\n            return Selection.fromPositions(selectionStart.getEndPosition(), position);\n        }\n    }\n}\nexport class EditOperationResult {\n    constructor(type, commands, opts) {\n        this._editOperationResultBrand = undefined;\n        this.type = type;\n        this.commands = commands;\n        this.shouldPushStackElementBefore = opts.shouldPushStackElementBefore;\n        this.shouldPushStackElementAfter = opts.shouldPushStackElementAfter;\n    }\n}\nexport function isQuote(ch) {\n    return (ch === '\\'' || ch === '\"' || ch === '`');\n}\n"],"names":["Position","constructor","lineNumber","column","this","newLineNumber","newColumn","delta","deltaLineNumber","deltaColumn","with","equals","other","a","b","isBefore","isBeforeOrEqual","compare","aLineNumber","bLineNumber","clone","toString","lift","pos","isIPosition","obj","toJSON","Range","startLineNumber","startColumn","endLineNumber","endColumn","isEmpty","range","containsPosition","position","strictContainsPosition","containsRange","otherRange","strictContainsRange","plusRange","Math","min","max","intersectRanges","resultStartLineNumber","resultStartColumn","resultEndLineNumber","resultEndColumn","otherStartLineNumber","otherStartColumn","otherEndLineNumber","otherEndColumn","equalsRange","getEndPosition","getStartPosition","setEndPosition","setStartPosition","collapseToStart","collapseToEnd","lineCount","fromPositions","start","end","isIRange","areIntersectingOrTouching","areIntersecting","compareRangesUsingStarts","aStartLineNumber","bStartLineNumber","aStartColumn","bStartColumn","aEndLineNumber","bEndLineNumber","compareRangesUsingEnds","spansMultipleLines","RGBA8","r","g","_rgba8Brand","undefined","_clamp","c","Empty","Selection","selectionStartLineNumber","selectionStartColumn","positionLineNumber","positionColumn","super","equalsSelection","selectionsEqual","getDirection","getPosition","getSelectionStart","fromRange","direction","liftSelection","sel","selectionsArrEqual","length","i","len","isISelection","createWithDirection","_utf16LE_TextDecoder","_utf16BE_TextDecoder","_platformTextDecoder","getUTF16LE_TextDecoder","TextDecoder","getPlatformTextDecoder","decodeUTF16LE","source","offset","view","Uint16Array","buffer","result","resultLen","charCode","String","fromCharCode","join","compatDecodeUTF16LE","decode","StringBuilder","capacity","_capacity","_buffer","_completedStrings","_bufferLength","reset","build","_flushBuffer","_buildBuffer","bufferString","appendCharCode","remainingSpace","appendASCIICharCode","appendString","str","strLen","charCodeAt","escapeNewLine","replace","TextChange","oldLength","oldText","oldEnd","oldPosition","newLength","newText","newEnd","newPosition","_writeStringSize","_writeString","_readString","writeSize","write","read","dest","push","compressConsecutiveTextChanges","prevEdits","currEdits","TextChangeCompressor","compress","_prevEdits","_currEdits","_result","_resultLen","_prevLen","_prevDeltaOffset","_currLen","_currDeltaOffset","prevIndex","currIndex","prevEdit","_getPrev","currEdit","_getCurr","_acceptCurr","_acceptPrev","e1","e2","_splitCurr","_splitPrev","mergePrev","mergeCurr","merged","_merge","_removeNoOps","_rebaseCurr","_rebasePrev","prevDeltaOffset","currDeltaOffset","edit","preText","substr","postText","edits","prev","curr","PositionOffsetTransformer","text","lineStartOffsetByLineIdx","charAt","getOffset","getOffsetRange","textLength","lineIdx","TextEdit","assert","apply","lastEditEnd","editRange","editStart","editEnd","rangeFromPositions","getValueOfRange","endPositionExclusive","applyToString","strText","StringText","getNewRanges","newRanges","previousEditEndLineNumber","lineOffset","columnOffset","newRangeStart","newRange","createRange","SingleTextEdit","Number","MAX_SAFE_INTEGER","AbstractText","addToPosition","value","_t","substring","TextLength","betweenPositions","position1","position2","ofRange","ofText","line","columnCount","isGreaterThanOrEqualTo","startPosition","zero","EDITOR_MODEL_DEFAULTS","tabSize","indentSize","insertSpaces","detectIndentation","trimAutoWhitespace","largeFileOptimizations","bracketPairColorizationOptions","enabled","independentColorPoolPerBracketType","WordCharacterClassifier","wordSeparators","intlSegmenterLocales","_segmenter","_cachedLine","_cachedSegments","Intl","Segmenter","granularity","set","findPrevIntlWordBeforeOrAtOffset","candidate","segment","_getIntlSegmenterWordsOnLine","index","findNextIntlWordAtOrAfterOffset","lineContent","_filterWordSegments","segments","_isWordLike","isWordLike","wordClassifierCache","getMapForWordSeparators","key","get","USUAL_WORD_SEPARATORS","DEFAULT_WORD_REGEXP","allowInWords","sep","indexOf","RegExp","createWordRegExp","ensureValidWordDefinition","wordDefinition","global","flags","ignoreCase","multiline","unicode","lastIndex","_defaultConfig","getWordAtText","textOffset","config","maxLen","t1","Date","now","prevRegexIndex","match","timeBudget","regexIndex","windowSize","thisMatch","_findRegexMatchEnclosingPosition","word","stopPos","exec","matchIndex","unshift","autoCloseAlways","autoCloseNever","autoCloseBeforeWhitespace","chr","CursorConfiguration","shouldRecreate","e","hasChanged","languageId","modelOptions","configuration","languageConfigurationService","_a","_cursorMoveConfigurationBrand","_languageId","options","layoutInfo","fontInfo","readOnly","stickyTabStops","lineHeight","typicalHalfwidthCharacterWidth","pageSize","floor","height","useTabStops","emptySelectionClipboard","copyWithSyntaxHighlighting","multiCursorMergeOverlapping","multiCursorPaste","multiCursorLimit","autoClosingBrackets","autoClosingComments","autoClosingQuotes","autoClosingDelete","autoClosingOvertype","autoSurround","autoIndent","wordSegmenterLocales","surroundingPairs","_electricChars","shouldAutoCloseBefore","quote","_getShouldAutoClose","comment","bracket","autoClosingPairs","getLanguageConfiguration","getAutoClosingPairs","getSurroundingPairs","pair","open","close","commentsConfiguration","comments","blockCommentStartToken","electricChars","electricCharacter","getElectricCharacters","char","onElectricCharacter","character","context","scopedLineTokens","electricCharacterSupport","firstCharOffset","normalizeIndentation","autoCloseConfig","forQuotes","_getLanguageDefinedShouldAutoClose","autoCloseBeforeSet","getAutoCloseBeforeSet","visibleColumnFromColumn","model","getLineContent","columnFromVisibleColumn","visibleColumn","minColumn","getLineMinColumn","maxColumn","getLineMaxColumn","CursorState","fromModelState","modelState","PartialModelCursorState","fromViewState","viewState","PartialViewCursorState","fromModelSelection","modelSelection","selection","SingleCursorState","fromModelSelections","modelSelections","states","_cursorStateBrand","selectionStart","selectionStartKind","selectionStartLeftoverVisibleColumns","leftoverVisibleColumns","_singleCursorStateBrand","_computeSelection","hasSelection","move","inSelectionMode","EditOperationResult","type","commands","opts","_editOperationResultBrand","shouldPushStackElementBefore","shouldPushStackElementAfter","isQuote","ch"],"sourceRoot":""}