monaco-editor11 1.0.9 → 1.1.0

package/dist/workers/editor/common/monospaceLineBreaksComputer.js

@@ -1,473 +0,0 @@
-import { isHighSurrogate, isLowSurrogate, firstNonWhitespaceIndex, isFullWidthCharacter } from '../../../base/common/strings.js';
-import { CharacterClassifier } from '../core/characterClassifier.js';
-import { LineInjectedText } from '../textModelEvents.js';
-import { ModelLineProjectionData } from '../modelLineProjectionData.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class MonospaceLineBreaksComputerFactory {
-    static create(options) {
-        return new MonospaceLineBreaksComputerFactory(options.get(151 /* EditorOption.wordWrapBreakBeforeCharacters */), options.get(150 /* EditorOption.wordWrapBreakAfterCharacters */));
-    }
-    constructor(breakBeforeChars, breakAfterChars) {
-        this.classifier = new WrappingCharacterClassifier(breakBeforeChars, breakAfterChars);
-    }
-    createLineBreaksComputer(fontInfo, tabSize, wrappingColumn, wrappingIndent, wordBreak, wrapOnEscapedLineFeeds) {
-        const requests = [];
-        const injectedTexts = [];
-        const previousBreakingData = [];
-        return {
-            addRequest: (lineText, injectedText, previousLineBreakData) => {
-                requests.push(lineText);
-                injectedTexts.push(injectedText);
-                previousBreakingData.push(previousLineBreakData);
-            },
-            finalize: () => {
-                const columnsForFullWidthChar = fontInfo.typicalFullwidthCharacterWidth / fontInfo.typicalHalfwidthCharacterWidth;
-                const result = [];
-                for (let i = 0, len = requests.length; i < len; i++) {
-                    const injectedText = injectedTexts[i];
-                    const previousLineBreakData = previousBreakingData[i];
-                    const lineText = requests[i];
-                    const isLineFeedWrappingEnabled = wrapOnEscapedLineFeeds && lineText.includes('"') && lineText.includes('\\n');
-                    if (previousLineBreakData && !previousLineBreakData.injectionOptions && !injectedText && !isLineFeedWrappingEnabled) {
-                        result[i] = createLineBreaksFromPreviousLineBreaks(this.classifier, previousLineBreakData, lineText, tabSize, wrappingColumn, columnsForFullWidthChar, wrappingIndent, wordBreak);
-                    }
-                    else {
-                        result[i] = createLineBreaks(this.classifier, lineText, injectedText, tabSize, wrappingColumn, columnsForFullWidthChar, wrappingIndent, wordBreak, isLineFeedWrappingEnabled);
-                    }
-                }
-                arrPool1.length = 0;
-                arrPool2.length = 0;
-                return result;
-            }
-        };
-    }
-}
-class WrappingCharacterClassifier extends CharacterClassifier {
-    constructor(BREAK_BEFORE, BREAK_AFTER) {
-        super(0 /* CharacterClass.NONE */);
-        for (let i = 0; i < BREAK_BEFORE.length; i++) {
-            this.set(BREAK_BEFORE.charCodeAt(i), 1 /* CharacterClass.BREAK_BEFORE */);
-        }
-        for (let i = 0; i < BREAK_AFTER.length; i++) {
-            this.set(BREAK_AFTER.charCodeAt(i), 2 /* CharacterClass.BREAK_AFTER */);
-        }
-    }
-    get(charCode) {
-        if (charCode >= 0 && charCode < 256) {
-            return this._asciiMap[charCode];
-        }
-        else {
-            // Initialize CharacterClass.BREAK_IDEOGRAPHIC for these Unicode ranges:
-            // 1. CJK Unified Ideographs (0x4E00 -- 0x9FFF)
-            // 2. CJK Unified Ideographs Extension A (0x3400 -- 0x4DBF)
-            // 3. Hiragana and Katakana (0x3040 -- 0x30FF)
-            if ((charCode >= 0x3040 && charCode <= 0x30FF)
-                || (charCode >= 0x3400 && charCode <= 0x4DBF)
-                || (charCode >= 0x4E00 && charCode <= 0x9FFF)) {
-                return 3 /* CharacterClass.BREAK_IDEOGRAPHIC */;
-            }
-            return (this._map.get(charCode) || this._defaultValue);
-        }
-    }
-}
-let arrPool1 = [];
-let arrPool2 = [];
-function createLineBreaksFromPreviousLineBreaks(classifier, previousBreakingData, lineText, tabSize, firstLineBreakColumn, columnsForFullWidthChar, wrappingIndent, wordBreak) {
-    if (firstLineBreakColumn === -1) {
-        return null;
-    }
-    const len = lineText.length;
-    if (len <= 1) {
-        return null;
-    }
-    const isKeepAll = (wordBreak === 'keepAll');
-    const prevBreakingOffsets = previousBreakingData.breakOffsets;
-    const prevBreakingOffsetsVisibleColumn = previousBreakingData.breakOffsetsVisibleColumn;
-    const wrappedTextIndentLength = computeWrappedTextIndentLength(lineText, tabSize, firstLineBreakColumn, columnsForFullWidthChar, wrappingIndent);
-    const wrappedLineBreakColumn = firstLineBreakColumn - wrappedTextIndentLength;
-    const breakingOffsets = arrPool1;
-    const breakingOffsetsVisibleColumn = arrPool2;
-    let breakingOffsetsCount = 0;
-    let lastBreakingOffset = 0;
-    let lastBreakingOffsetVisibleColumn = 0;
-    let breakingColumn = firstLineBreakColumn;
-    const prevLen = prevBreakingOffsets.length;
-    let prevIndex = 0;
-    if (prevIndex >= 0) {
-        let bestDistance = Math.abs(prevBreakingOffsetsVisibleColumn[prevIndex] - breakingColumn);
-        while (prevIndex + 1 < prevLen) {
-            const distance = Math.abs(prevBreakingOffsetsVisibleColumn[prevIndex + 1] - breakingColumn);
-            if (distance >= bestDistance) {
-                break;
-            }
-            bestDistance = distance;
-            prevIndex++;
-        }
-    }
-    while (prevIndex < prevLen) {
-        // Allow for prevIndex to be -1 (for the case where we hit a tab when walking backwards from the first break)
-        let prevBreakOffset = prevIndex < 0 ? 0 : prevBreakingOffsets[prevIndex];
-        let prevBreakOffsetVisibleColumn = prevIndex < 0 ? 0 : prevBreakingOffsetsVisibleColumn[prevIndex];
-        if (lastBreakingOffset > prevBreakOffset) {
-            prevBreakOffset = lastBreakingOffset;
-            prevBreakOffsetVisibleColumn = lastBreakingOffsetVisibleColumn;
-        }
-        let breakOffset = 0;
-        let breakOffsetVisibleColumn = 0;
-        let forcedBreakOffset = 0;
-        let forcedBreakOffsetVisibleColumn = 0;
-        // initially, we search as much as possible to the right (if it fits)
-        if (prevBreakOffsetVisibleColumn <= breakingColumn) {
-            let visibleColumn = prevBreakOffsetVisibleColumn;
-            let prevCharCode = prevBreakOffset === 0 ? 0 /* CharCode.Null */ : lineText.charCodeAt(prevBreakOffset - 1);
-            let prevCharCodeClass = prevBreakOffset === 0 ? 0 /* CharacterClass.NONE */ : classifier.get(prevCharCode);
-            let entireLineFits = true;
-            for (let i = prevBreakOffset; i < len; i++) {
-                const charStartOffset = i;
-                const charCode = lineText.charCodeAt(i);
-                let charCodeClass;
-                let charWidth;
-                if (isHighSurrogate(charCode)) {
-                    // A surrogate pair must always be considered as a single unit, so it is never to be broken
-                    i++;
-                    charCodeClass = 0 /* CharacterClass.NONE */;
-                    charWidth = 2;
-                }
-                else {
-                    charCodeClass = classifier.get(charCode);
-                    charWidth = computeCharWidth(charCode, visibleColumn, tabSize, columnsForFullWidthChar);
-                }
-                if (charStartOffset > lastBreakingOffset && canBreak(prevCharCode, prevCharCodeClass, charCode, charCodeClass, isKeepAll)) {
-                    breakOffset = charStartOffset;
-                    breakOffsetVisibleColumn = visibleColumn;
-                }
-                visibleColumn += charWidth;
-                // check if adding character at `i` will go over the breaking column
-                if (visibleColumn > breakingColumn) {
-                    // We need to break at least before character at `i`:
-                    if (charStartOffset > lastBreakingOffset) {
-                        forcedBreakOffset = charStartOffset;
-                        forcedBreakOffsetVisibleColumn = visibleColumn - charWidth;
-                    }
-                    else {
-                        // we need to advance at least by one character
-                        forcedBreakOffset = i + 1;
-                        forcedBreakOffsetVisibleColumn = visibleColumn;
-                    }
-                    if (visibleColumn - breakOffsetVisibleColumn > wrappedLineBreakColumn) {
-                        // Cannot break at `breakOffset` => reset it if it was set
-                        breakOffset = 0;
-                    }
-                    entireLineFits = false;
-                    break;
-                }
-                prevCharCode = charCode;
-                prevCharCodeClass = charCodeClass;
-            }
-            if (entireLineFits) {
-                // there is no more need to break => stop the outer loop!
-                if (breakingOffsetsCount > 0) {
-                    // Add last segment, no need to assign to `lastBreakingOffset` and `lastBreakingOffsetVisibleColumn`
-                    breakingOffsets[breakingOffsetsCount] = prevBreakingOffsets[prevBreakingOffsets.length - 1];
-                    breakingOffsetsVisibleColumn[breakingOffsetsCount] = prevBreakingOffsetsVisibleColumn[prevBreakingOffsets.length - 1];
-                    breakingOffsetsCount++;
-                }
-                break;
-            }
-        }
-        if (breakOffset === 0) {
-            // must search left
-            let visibleColumn = prevBreakOffsetVisibleColumn;
-            let charCode = lineText.charCodeAt(prevBreakOffset);
-            let charCodeClass = classifier.get(charCode);
-            let hitATabCharacter = false;
-            for (let i = prevBreakOffset - 1; i >= lastBreakingOffset; i--) {
-                const charStartOffset = i + 1;
-                const prevCharCode = lineText.charCodeAt(i);
-                if (prevCharCode === 9 /* CharCode.Tab */) {
-                    // cannot determine the width of a tab when going backwards, so we must go forwards
-                    hitATabCharacter = true;
-                    break;
-                }
-                let prevCharCodeClass;
-                let prevCharWidth;
-                if (isLowSurrogate(prevCharCode)) {
-                    // A surrogate pair must always be considered as a single unit, so it is never to be broken
-                    i--;
-                    prevCharCodeClass = 0 /* CharacterClass.NONE */;
-                    prevCharWidth = 2;
-                }
-                else {
-                    prevCharCodeClass = classifier.get(prevCharCode);
-                    prevCharWidth = (isFullWidthCharacter(prevCharCode) ? columnsForFullWidthChar : 1);
-                }
-                if (visibleColumn <= breakingColumn) {
-                    if (forcedBreakOffset === 0) {
-                        forcedBreakOffset = charStartOffset;
-                        forcedBreakOffsetVisibleColumn = visibleColumn;
-                    }
-                    if (visibleColumn <= breakingColumn - wrappedLineBreakColumn) {
-                        // went too far!
-                        break;
-                    }
-                    if (canBreak(prevCharCode, prevCharCodeClass, charCode, charCodeClass, isKeepAll)) {
-                        breakOffset = charStartOffset;
-                        breakOffsetVisibleColumn = visibleColumn;
-                        break;
-                    }
-                }
-                visibleColumn -= prevCharWidth;
-                charCode = prevCharCode;
-                charCodeClass = prevCharCodeClass;
-            }
-            if (breakOffset !== 0) {
-                const remainingWidthOfNextLine = wrappedLineBreakColumn - (forcedBreakOffsetVisibleColumn - breakOffsetVisibleColumn);
-                if (remainingWidthOfNextLine <= tabSize) {
-                    const charCodeAtForcedBreakOffset = lineText.charCodeAt(forcedBreakOffset);
-                    let charWidth;
-                    if (isHighSurrogate(charCodeAtForcedBreakOffset)) {
-                        // A surrogate pair must always be considered as a single unit, so it is never to be broken
-                        charWidth = 2;
-                    }
-                    else {
-                        charWidth = computeCharWidth(charCodeAtForcedBreakOffset, forcedBreakOffsetVisibleColumn, tabSize, columnsForFullWidthChar);
-                    }
-                    if (remainingWidthOfNextLine - charWidth < 0) {
-                        // it is not worth it to break at breakOffset, it just introduces an extra needless line!
-                        breakOffset = 0;
-                    }
-                }
-            }
-            if (hitATabCharacter) {
-                // cannot determine the width of a tab when going backwards, so we must go forwards from the previous break
-                prevIndex--;
-                continue;
-            }
-        }
-        if (breakOffset === 0) {
-            // Could not find a good breaking point
-            breakOffset = forcedBreakOffset;
-            breakOffsetVisibleColumn = forcedBreakOffsetVisibleColumn;
-        }
-        if (breakOffset <= lastBreakingOffset) {
-            // Make sure that we are advancing (at least one character)
-            const charCode = lineText.charCodeAt(lastBreakingOffset);
-            if (isHighSurrogate(charCode)) {
-                // A surrogate pair must always be considered as a single unit, so it is never to be broken
-                breakOffset = lastBreakingOffset + 2;
-                breakOffsetVisibleColumn = lastBreakingOffsetVisibleColumn + 2;
-            }
-            else {
-                breakOffset = lastBreakingOffset + 1;
-                breakOffsetVisibleColumn = lastBreakingOffsetVisibleColumn + computeCharWidth(charCode, lastBreakingOffsetVisibleColumn, tabSize, columnsForFullWidthChar);
-            }
-        }
-        lastBreakingOffset = breakOffset;
-        breakingOffsets[breakingOffsetsCount] = breakOffset;
-        lastBreakingOffsetVisibleColumn = breakOffsetVisibleColumn;
-        breakingOffsetsVisibleColumn[breakingOffsetsCount] = breakOffsetVisibleColumn;
-        breakingOffsetsCount++;
-        breakingColumn = breakOffsetVisibleColumn + wrappedLineBreakColumn;
-        while (prevIndex < 0 || (prevIndex < prevLen && prevBreakingOffsetsVisibleColumn[prevIndex] < breakOffsetVisibleColumn)) {
-            prevIndex++;
-        }
-        let bestDistance = Math.abs(prevBreakingOffsetsVisibleColumn[prevIndex] - breakingColumn);
-        while (prevIndex + 1 < prevLen) {
-            const distance = Math.abs(prevBreakingOffsetsVisibleColumn[prevIndex + 1] - breakingColumn);
-            if (distance >= bestDistance) {
-                break;
-            }
-            bestDistance = distance;
-            prevIndex++;
-        }
-    }
-    if (breakingOffsetsCount === 0) {
-        return null;
-    }
-    // Doing here some object reuse which ends up helping a huge deal with GC pauses!
-    breakingOffsets.length = breakingOffsetsCount;
-    breakingOffsetsVisibleColumn.length = breakingOffsetsCount;
-    arrPool1 = previousBreakingData.breakOffsets;
-    arrPool2 = previousBreakingData.breakOffsetsVisibleColumn;
-    previousBreakingData.breakOffsets = breakingOffsets;
-    previousBreakingData.breakOffsetsVisibleColumn = breakingOffsetsVisibleColumn;
-    previousBreakingData.wrappedTextIndentLength = wrappedTextIndentLength;
-    return previousBreakingData;
-}
-function createLineBreaks(classifier, _lineText, injectedTexts, tabSize, firstLineBreakColumn, columnsForFullWidthChar, wrappingIndent, wordBreak, wrapOnEscapedLineFeeds) {
-    const lineText = LineInjectedText.applyInjectedText(_lineText, injectedTexts);
-    let injectionOptions;
-    let injectionOffsets;
-    if (injectedTexts && injectedTexts.length > 0) {
-        injectionOptions = injectedTexts.map(t => t.options);
-        injectionOffsets = injectedTexts.map(text => text.column - 1);
-    }
-    else {
-        injectionOptions = null;
-        injectionOffsets = null;
-    }
-    if (firstLineBreakColumn === -1) {
-        if (!injectionOptions) {
-            return null;
-        }
-        // creating a `LineBreakData` with an invalid `breakOffsetsVisibleColumn` is OK
-        // because `breakOffsetsVisibleColumn` will never be used because it contains injected text
-        return new ModelLineProjectionData(injectionOffsets, injectionOptions, [lineText.length], [], 0);
-    }
-    const len = lineText.length;
-    if (len <= 1) {
-        if (!injectionOptions) {
-            return null;
-        }
-        // creating a `LineBreakData` with an invalid `breakOffsetsVisibleColumn` is OK
-        // because `breakOffsetsVisibleColumn` will never be used because it contains injected text
-        return new ModelLineProjectionData(injectionOffsets, injectionOptions, [lineText.length], [], 0);
-    }
-    const isKeepAll = (wordBreak === 'keepAll');
-    const wrappedTextIndentLength = computeWrappedTextIndentLength(lineText, tabSize, firstLineBreakColumn, columnsForFullWidthChar, wrappingIndent);
-    const wrappedLineBreakColumn = firstLineBreakColumn - wrappedTextIndentLength;
-    const breakingOffsets = [];
-    const breakingOffsetsVisibleColumn = [];
-    let breakingOffsetsCount = 0;
-    let breakOffset = 0;
-    let breakOffsetVisibleColumn = 0;
-    let breakingColumn = firstLineBreakColumn;
-    let prevCharCode = lineText.charCodeAt(0);
-    let prevCharCodeClass = classifier.get(prevCharCode);
-    let visibleColumn = computeCharWidth(prevCharCode, 0, tabSize, columnsForFullWidthChar);
-    let startOffset = 1;
-    if (isHighSurrogate(prevCharCode)) {
-        // A surrogate pair must always be considered as a single unit, so it is never to be broken
-        visibleColumn += 1;
-        prevCharCode = lineText.charCodeAt(1);
-        prevCharCodeClass = classifier.get(prevCharCode);
-        startOffset++;
-    }
-    for (let i = startOffset; i < len; i++) {
-        const charStartOffset = i;
-        const charCode = lineText.charCodeAt(i);
-        let charCodeClass;
-        let charWidth;
-        let wrapEscapedLineFeed = false;
-        if (isHighSurrogate(charCode)) {
-            // A surrogate pair must always be considered as a single unit, so it is never to be broken
-            i++;
-            charCodeClass = 0 /* CharacterClass.NONE */;
-            charWidth = 2;
-        }
-        else {
-            charCodeClass = classifier.get(charCode);
-            charWidth = computeCharWidth(charCode, visibleColumn, tabSize, columnsForFullWidthChar);
-        }
-        // literal \n shall trigger a softwrap
-        if (wrapOnEscapedLineFeeds && isEscapedLineBreakAtPosition(lineText, i)) {
-            breakOffset = charStartOffset;
-            breakOffsetVisibleColumn = visibleColumn;
-            wrapEscapedLineFeed = true;
-        }
-        else if (canBreak(prevCharCode, prevCharCodeClass, charCode, charCodeClass, isKeepAll)) {
-            breakOffset = charStartOffset;
-            breakOffsetVisibleColumn = visibleColumn;
-        }
-        visibleColumn += charWidth;
-        // check if adding character at `i` will go over the breaking column
-        if (visibleColumn > breakingColumn || wrapEscapedLineFeed) {
-            // We need to break at least before character at `i`:
-            if (breakOffset === 0 || visibleColumn - breakOffsetVisibleColumn > wrappedLineBreakColumn) {
-                // Cannot break at `breakOffset`, must break at `i`
-                breakOffset = charStartOffset;
-                breakOffsetVisibleColumn = visibleColumn - charWidth;
-            }
-            breakingOffsets[breakingOffsetsCount] = breakOffset;
-            breakingOffsetsVisibleColumn[breakingOffsetsCount] = breakOffsetVisibleColumn;
-            breakingOffsetsCount++;
-            breakingColumn = breakOffsetVisibleColumn + wrappedLineBreakColumn;
-            breakOffset = 0;
-        }
-        prevCharCode = charCode;
-        prevCharCodeClass = charCodeClass;
-    }
-    if (breakingOffsetsCount === 0 && (!injectedTexts || injectedTexts.length === 0)) {
-        return null;
-    }
-    // Add last segment
-    breakingOffsets[breakingOffsetsCount] = len;
-    breakingOffsetsVisibleColumn[breakingOffsetsCount] = visibleColumn;
-    return new ModelLineProjectionData(injectionOffsets, injectionOptions, breakingOffsets, breakingOffsetsVisibleColumn, wrappedTextIndentLength);
-}
-function computeCharWidth(charCode, visibleColumn, tabSize, columnsForFullWidthChar) {
-    if (charCode === 9 /* CharCode.Tab */) {
-        return (tabSize - (visibleColumn % tabSize));
-    }
-    if (isFullWidthCharacter(charCode)) {
-        return columnsForFullWidthChar;
-    }
-    if (charCode < 32) {
-        // when using `editor.renderControlCharacters`, the substitutions are often wide
-        return columnsForFullWidthChar;
-    }
-    return 1;
-}
-function tabCharacterWidth(visibleColumn, tabSize) {
-    return (tabSize - (visibleColumn % tabSize));
-}
-/**
- * Checks if the current position in the text should trigger a soft wrap due to escaped line feeds.
- * This handles the wrapOnEscapedLineFeeds feature which allows \n sequences in strings to trigger wrapping.
- */
-function isEscapedLineBreakAtPosition(lineText, i) {
-    if (i >= 2 && lineText.charAt(i - 1) === 'n') {
-        // Check if there's an odd number of backslashes
-        let escapeCount = 0;
-        for (let j = i - 2; j >= 0; j--) {
-            if (lineText.charAt(j) === '\\') {
-                escapeCount++;
-            }
-            else {
-                return escapeCount % 2 === 1;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Kinsoku Shori : Don't break after a leading character, like an open bracket
- * Kinsoku Shori : Don't break before a trailing character, like a period
- */
-function canBreak(prevCharCode, prevCharCodeClass, charCode, charCodeClass, isKeepAll) {
-    return (charCode !== 32 /* CharCode.Space */
-        && ((prevCharCodeClass === 2 /* CharacterClass.BREAK_AFTER */ && charCodeClass !== 2 /* CharacterClass.BREAK_AFTER */) // break at the end of multiple BREAK_AFTER
-            || (prevCharCodeClass !== 1 /* CharacterClass.BREAK_BEFORE */ && charCodeClass === 1 /* CharacterClass.BREAK_BEFORE */) // break at the start of multiple BREAK_BEFORE
-            || (!isKeepAll && prevCharCodeClass === 3 /* CharacterClass.BREAK_IDEOGRAPHIC */ && charCodeClass !== 2 /* CharacterClass.BREAK_AFTER */)
-            || (!isKeepAll && charCodeClass === 3 /* CharacterClass.BREAK_IDEOGRAPHIC */ && prevCharCodeClass !== 1 /* CharacterClass.BREAK_BEFORE */)));
-}
-function computeWrappedTextIndentLength(lineText, tabSize, firstLineBreakColumn, columnsForFullWidthChar, wrappingIndent) {
-    let wrappedTextIndentLength = 0;
-    if (wrappingIndent !== 0 /* WrappingIndent.None */) {
-        const firstNonWhitespaceIndex$1 = firstNonWhitespaceIndex(lineText);
-        if (firstNonWhitespaceIndex$1 !== -1) {
-            // Track existing indent
-            for (let i = 0; i < firstNonWhitespaceIndex$1; i++) {
-                const charWidth = (lineText.charCodeAt(i) === 9 /* CharCode.Tab */ ? tabCharacterWidth(wrappedTextIndentLength, tabSize) : 1);
-                wrappedTextIndentLength += charWidth;
-            }
-            // Increase indent of continuation lines, if desired
-            const numberOfAdditionalTabs = (wrappingIndent === 3 /* WrappingIndent.DeepIndent */ ? 2 : wrappingIndent === 2 /* WrappingIndent.Indent */ ? 1 : 0);
-            for (let i = 0; i < numberOfAdditionalTabs; i++) {
-                const charWidth = tabCharacterWidth(wrappedTextIndentLength, tabSize);
-                wrappedTextIndentLength += charWidth;
-            }
-            // Force sticking to beginning of line if no character would fit except for the indentation
-            if (wrappedTextIndentLength + columnsForFullWidthChar > firstLineBreakColumn) {
-                wrappedTextIndentLength = 0;
-            }
-        }
-    }
-    return wrappedTextIndentLength;
-}
-
-export { MonospaceLineBreaksComputerFactory };

package/dist/workers/editor/common/myersDiffAlgorithm.js

@@ -1,159 +0,0 @@
-import { OffsetRange } from '../../../core/ranges/offsetRange.js';
-import { InfiniteTimeout, DiffAlgorithmResult, SequenceDiff } from './diffAlgorithm.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * An O(ND) diff algorithm that has a quadratic space worst-case complexity.
-*/
-class MyersDiffAlgorithm {
-    compute(seq1, seq2, timeout = InfiniteTimeout.instance) {
-        // These are common special cases.
-        // The early return improves performance dramatically.
-        if (seq1.length === 0 || seq2.length === 0) {
-            return DiffAlgorithmResult.trivial(seq1, seq2);
-        }
-        const seqX = seq1; // Text on the x axis
-        const seqY = seq2; // Text on the y axis
-        function getXAfterSnake(x, y) {
-            while (x < seqX.length && y < seqY.length && seqX.getElement(x) === seqY.getElement(y)) {
-                x++;
-                y++;
-            }
-            return x;
-        }
-        let d = 0;
-        // V[k]: X value of longest d-line that ends in diagonal k.
-        // d-line: path from (0,0) to (x,y) that uses exactly d non-diagonals.
-        // diagonal k: Set of points (x,y) with x-y = k.
-        // k=1 -> (1,0),(2,1)
-        const V = new FastInt32Array();
-        V.set(0, getXAfterSnake(0, 0));
-        const paths = new FastArrayNegativeIndices();
-        paths.set(0, V.get(0) === 0 ? null : new SnakePath(null, 0, 0, V.get(0)));
-        let k = 0;
-        loop: while (true) {
-            d++;
-            if (!timeout.isValid()) {
-                return DiffAlgorithmResult.trivialTimedOut(seqX, seqY);
-            }
-            // The paper has `for (k = -d; k <= d; k += 2)`, but we can ignore diagonals that cannot influence the result.
-            const lowerBound = -Math.min(d, seqY.length + (d % 2));
-            const upperBound = Math.min(d, seqX.length + (d % 2));
-            for (k = lowerBound; k <= upperBound; k += 2) {
-                // We can use the X values of (d-1)-lines to compute X value of the longest d-lines.
-                const maxXofDLineTop = k === upperBound ? -1 : V.get(k + 1); // We take a vertical non-diagonal (add a symbol in seqX)
-                const maxXofDLineLeft = k === lowerBound ? -1 : V.get(k - 1) + 1; // We take a horizontal non-diagonal (+1 x) (delete a symbol in seqX)
-                const x = Math.min(Math.max(maxXofDLineTop, maxXofDLineLeft), seqX.length);
-                const y = x - k;
-                if (x > seqX.length || y > seqY.length) {
-                    // This diagonal is irrelevant for the result.
-                    // TODO: Don't pay the cost for this in the next iteration.
-                    continue;
-                }
-                const newMaxX = getXAfterSnake(x, y);
-                V.set(k, newMaxX);
-                const lastPath = x === maxXofDLineTop ? paths.get(k + 1) : paths.get(k - 1);
-                paths.set(k, newMaxX !== x ? new SnakePath(lastPath, x, y, newMaxX - x) : lastPath);
-                if (V.get(k) === seqX.length && V.get(k) - k === seqY.length) {
-                    break loop;
-                }
-            }
-        }
-        let path = paths.get(k);
-        const result = [];
-        let lastAligningPosS1 = seqX.length;
-        let lastAligningPosS2 = seqY.length;
-        while (true) {
-            const endX = path ? path.x + path.length : 0;
-            const endY = path ? path.y + path.length : 0;
-            if (endX !== lastAligningPosS1 || endY !== lastAligningPosS2) {
-                result.push(new SequenceDiff(new OffsetRange(endX, lastAligningPosS1), new OffsetRange(endY, lastAligningPosS2)));
-            }
-            if (!path) {
-                break;
-            }
-            lastAligningPosS1 = path.x;
-            lastAligningPosS2 = path.y;
-            path = path.prev;
-        }
-        result.reverse();
-        return new DiffAlgorithmResult(result, false);
-    }
-}
-class SnakePath {
-    constructor(prev, x, y, length) {
-        this.prev = prev;
-        this.x = x;
-        this.y = y;
-        this.length = length;
-    }
-}
-/**
- * An array that supports fast negative indices.
-*/
-class FastInt32Array {
-    constructor() {
-        this.positiveArr = new Int32Array(10);
-        this.negativeArr = new Int32Array(10);
-    }
-    get(idx) {
-        if (idx < 0) {
-            idx = -idx - 1;
-            return this.negativeArr[idx];
-        }
-        else {
-            return this.positiveArr[idx];
-        }
-    }
-    set(idx, value) {
-        if (idx < 0) {
-            idx = -idx - 1;
-            if (idx >= this.negativeArr.length) {
-                const arr = this.negativeArr;
-                this.negativeArr = new Int32Array(arr.length * 2);
-                this.negativeArr.set(arr);
-            }
-            this.negativeArr[idx] = value;
-        }
-        else {
-            if (idx >= this.positiveArr.length) {
-                const arr = this.positiveArr;
-                this.positiveArr = new Int32Array(arr.length * 2);
-                this.positiveArr.set(arr);
-            }
-            this.positiveArr[idx] = value;
-        }
-    }
-}
-/**
- * An array that supports fast negative indices.
-*/
-class FastArrayNegativeIndices {
-    constructor() {
-        this.positiveArr = [];
-        this.negativeArr = [];
-    }
-    get(idx) {
-        if (idx < 0) {
-            idx = -idx - 1;
-            return this.negativeArr[idx];
-        }
-        else {
-            return this.positiveArr[idx];
-        }
-    }
-    set(idx, value) {
-        if (idx < 0) {
-            idx = -idx - 1;
-            this.negativeArr[idx] = value;
-        }
-        else {
-            this.positiveArr[idx] = value;
-        }
-    }
-}
-
-export { MyersDiffAlgorithm };