@umbraco-cms/backoffice 16.1.1 → 16.2.0-rc2

package/dist-cms/monaco-editor/vs/editor/common/cursor/oneCursor.js

@@ -1,114 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { CursorState, SingleCursorState } from '../cursorCommon.js';
-import { Position } from '../core/position.js';
-import { Range } from '../core/range.js';
-import { Selection } from '../core/selection.js';
-/**
- * Represents a single cursor.
-*/
-export class Cursor {
-    constructor(context) {
-        this._selTrackedRange = null;
-        this._trackSelection = true;
-        this._setState(context, new SingleCursorState(new Range(1, 1, 1, 1), 0 /* SelectionStartKind.Simple */, 0, new Position(1, 1), 0), new SingleCursorState(new Range(1, 1, 1, 1), 0 /* SelectionStartKind.Simple */, 0, new Position(1, 1), 0));
-    }
-    dispose(context) {
-        this._removeTrackedRange(context);
-    }
-    startTrackingSelection(context) {
-        this._trackSelection = true;
-        this._updateTrackedRange(context);
-    }
-    stopTrackingSelection(context) {
-        this._trackSelection = false;
-        this._removeTrackedRange(context);
-    }
-    _updateTrackedRange(context) {
-        if (!this._trackSelection) {
-            // don't track the selection
-            return;
-        }
-        this._selTrackedRange = context.model._setTrackedRange(this._selTrackedRange, this.modelState.selection, 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */);
-    }
-    _removeTrackedRange(context) {
-        this._selTrackedRange = context.model._setTrackedRange(this._selTrackedRange, null, 0 /* TrackedRangeStickiness.AlwaysGrowsWhenTypingAtEdges */);
-    }
-    asCursorState() {
-        return new CursorState(this.modelState, this.viewState);
-    }
-    readSelectionFromMarkers(context) {
-        const range = context.model._getTrackedRange(this._selTrackedRange);
-        if (this.modelState.selection.isEmpty() && !range.isEmpty()) {
-            // Avoid selecting text when recovering from markers
-            return Selection.fromRange(range.collapseToEnd(), this.modelState.selection.getDirection());
-        }
-        return Selection.fromRange(range, this.modelState.selection.getDirection());
-    }
-    ensureValidState(context) {
-        this._setState(context, this.modelState, this.viewState);
-    }
-    setState(context, modelState, viewState) {
-        this._setState(context, modelState, viewState);
-    }
-    static _validatePositionWithCache(viewModel, position, cacheInput, cacheOutput) {
-        if (position.equals(cacheInput)) {
-            return cacheOutput;
-        }
-        return viewModel.normalizePosition(position, 2 /* PositionAffinity.None */);
-    }
-    static _validateViewState(viewModel, viewState) {
-        const position = viewState.position;
-        const sStartPosition = viewState.selectionStart.getStartPosition();
-        const sEndPosition = viewState.selectionStart.getEndPosition();
-        const validPosition = viewModel.normalizePosition(position, 2 /* PositionAffinity.None */);
-        const validSStartPosition = this._validatePositionWithCache(viewModel, sStartPosition, position, validPosition);
-        const validSEndPosition = this._validatePositionWithCache(viewModel, sEndPosition, sStartPosition, validSStartPosition);
-        if (position.equals(validPosition) && sStartPosition.equals(validSStartPosition) && sEndPosition.equals(validSEndPosition)) {
-            // fast path: the state is valid
-            return viewState;
-        }
-        return new SingleCursorState(Range.fromPositions(validSStartPosition, validSEndPosition), viewState.selectionStartKind, viewState.selectionStartLeftoverVisibleColumns + sStartPosition.column - validSStartPosition.column, validPosition, viewState.leftoverVisibleColumns + position.column - validPosition.column);
-    }
-    _setState(context, modelState, viewState) {
-        if (viewState) {
-            viewState = Cursor._validateViewState(context.viewModel, viewState);
-        }
-        if (!modelState) {
-            if (!viewState) {
-                return;
-            }
-            // We only have the view state => compute the model state
-            const selectionStart = context.model.validateRange(context.coordinatesConverter.convertViewRangeToModelRange(viewState.selectionStart));
-            const position = context.model.validatePosition(context.coordinatesConverter.convertViewPositionToModelPosition(viewState.position));
-            modelState = new SingleCursorState(selectionStart, viewState.selectionStartKind, viewState.selectionStartLeftoverVisibleColumns, position, viewState.leftoverVisibleColumns);
-        }
-        else {
-            // Validate new model state
-            const selectionStart = context.model.validateRange(modelState.selectionStart);
-            const selectionStartLeftoverVisibleColumns = modelState.selectionStart.equalsRange(selectionStart) ? modelState.selectionStartLeftoverVisibleColumns : 0;
-            const position = context.model.validatePosition(modelState.position);
-            const leftoverVisibleColumns = modelState.position.equals(position) ? modelState.leftoverVisibleColumns : 0;
-            modelState = new SingleCursorState(selectionStart, modelState.selectionStartKind, selectionStartLeftoverVisibleColumns, position, leftoverVisibleColumns);
-        }
-        if (!viewState) {
-            // We only have the model state => compute the view state
-            const viewSelectionStart1 = context.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelState.selectionStart.startLineNumber, modelState.selectionStart.startColumn));
-            const viewSelectionStart2 = context.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelState.selectionStart.endLineNumber, modelState.selectionStart.endColumn));
-            const viewSelectionStart = new Range(viewSelectionStart1.lineNumber, viewSelectionStart1.column, viewSelectionStart2.lineNumber, viewSelectionStart2.column);
-            const viewPosition = context.coordinatesConverter.convertModelPositionToViewPosition(modelState.position);
-            viewState = new SingleCursorState(viewSelectionStart, modelState.selectionStartKind, modelState.selectionStartLeftoverVisibleColumns, viewPosition, modelState.leftoverVisibleColumns);
-        }
-        else {
-            // Validate new view state
-            const viewSelectionStart = context.coordinatesConverter.validateViewRange(viewState.selectionStart, modelState.selectionStart);
-            const viewPosition = context.coordinatesConverter.validateViewPosition(viewState.position, modelState.position);
-            viewState = new SingleCursorState(viewSelectionStart, modelState.selectionStartKind, modelState.selectionStartLeftoverVisibleColumns, viewPosition, modelState.leftoverVisibleColumns);
-        }
-        this.modelState = modelState;
-        this.viewState = viewState;
-        this._updateTrackedRange(context);
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/cursorCommon.js

@@ -1,239 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { Position } from './core/position.js';
-import { Range } from './core/range.js';
-import { Selection } from './core/selection.js';
-import { createScopedLineTokens } from './languages/supports.js';
-import { CursorColumns } from './core/cursorColumns.js';
-import { normalizeIndentation } from './core/indentation.js';
-const autoCloseAlways = () => true;
-const autoCloseNever = () => false;
-const autoCloseBeforeWhitespace = (chr) => (chr === ' ' || chr === '\t');
-export class CursorConfiguration {
-    static shouldRecreate(e) {
-        return (e.hasChanged(146 /* EditorOption.layoutInfo */)
-            || e.hasChanged(132 /* EditorOption.wordSeparators */)
-            || e.hasChanged(37 /* EditorOption.emptySelectionClipboard */)
-            || e.hasChanged(77 /* EditorOption.multiCursorMergeOverlapping */)
-            || e.hasChanged(79 /* EditorOption.multiCursorPaste */)
-            || e.hasChanged(80 /* EditorOption.multiCursorLimit */)
-            || e.hasChanged(6 /* EditorOption.autoClosingBrackets */)
-            || e.hasChanged(7 /* EditorOption.autoClosingComments */)
-            || e.hasChanged(11 /* EditorOption.autoClosingQuotes */)
-            || e.hasChanged(9 /* EditorOption.autoClosingDelete */)
-            || e.hasChanged(10 /* EditorOption.autoClosingOvertype */)
-            || e.hasChanged(14 /* EditorOption.autoSurround */)
-            || e.hasChanged(129 /* EditorOption.useTabStops */)
-            || e.hasChanged(50 /* EditorOption.fontInfo */)
-            || e.hasChanged(92 /* EditorOption.readOnly */)
-            || e.hasChanged(131 /* EditorOption.wordSegmenterLocales */));
-    }
-    constructor(languageId, modelOptions, configuration, languageConfigurationService) {
-        this.languageConfigurationService = languageConfigurationService;
-        this._cursorMoveConfigurationBrand = undefined;
-        this._languageId = languageId;
-        const options = configuration.options;
-        const layoutInfo = options.get(146 /* EditorOption.layoutInfo */);
-        const fontInfo = options.get(50 /* EditorOption.fontInfo */);
-        this.readOnly = options.get(92 /* EditorOption.readOnly */);
-        this.tabSize = modelOptions.tabSize;
-        this.indentSize = modelOptions.indentSize;
-        this.insertSpaces = modelOptions.insertSpaces;
-        this.stickyTabStops = options.get(117 /* EditorOption.stickyTabStops */);
-        this.lineHeight = fontInfo.lineHeight;
-        this.typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
-        this.pageSize = Math.max(1, Math.floor(layoutInfo.height / this.lineHeight) - 2);
-        this.useTabStops = options.get(129 /* EditorOption.useTabStops */);
-        this.wordSeparators = options.get(132 /* EditorOption.wordSeparators */);
-        this.emptySelectionClipboard = options.get(37 /* EditorOption.emptySelectionClipboard */);
-        this.copyWithSyntaxHighlighting = options.get(25 /* EditorOption.copyWithSyntaxHighlighting */);
-        this.multiCursorMergeOverlapping = options.get(77 /* EditorOption.multiCursorMergeOverlapping */);
-        this.multiCursorPaste = options.get(79 /* EditorOption.multiCursorPaste */);
-        this.multiCursorLimit = options.get(80 /* EditorOption.multiCursorLimit */);
-        this.autoClosingBrackets = options.get(6 /* EditorOption.autoClosingBrackets */);
-        this.autoClosingComments = options.get(7 /* EditorOption.autoClosingComments */);
-        this.autoClosingQuotes = options.get(11 /* EditorOption.autoClosingQuotes */);
-        this.autoClosingDelete = options.get(9 /* EditorOption.autoClosingDelete */);
-        this.autoClosingOvertype = options.get(10 /* EditorOption.autoClosingOvertype */);
-        this.autoSurround = options.get(14 /* EditorOption.autoSurround */);
-        this.autoIndent = options.get(12 /* EditorOption.autoIndent */);
-        this.wordSegmenterLocales = options.get(131 /* EditorOption.wordSegmenterLocales */);
-        this.surroundingPairs = {};
-        this._electricChars = null;
-        this.shouldAutoCloseBefore = {
-            quote: this._getShouldAutoClose(languageId, this.autoClosingQuotes, true),
-            comment: this._getShouldAutoClose(languageId, this.autoClosingComments, false),
-            bracket: this._getShouldAutoClose(languageId, this.autoClosingBrackets, false),
-        };
-        this.autoClosingPairs = this.languageConfigurationService.getLanguageConfiguration(languageId).getAutoClosingPairs();
-        const surroundingPairs = this.languageConfigurationService.getLanguageConfiguration(languageId).getSurroundingPairs();
-        if (surroundingPairs) {
-            for (const pair of surroundingPairs) {
-                this.surroundingPairs[pair.open] = pair.close;
-            }
-        }
-        const commentsConfiguration = this.languageConfigurationService.getLanguageConfiguration(languageId).comments;
-        this.blockCommentStartToken = commentsConfiguration?.blockCommentStartToken ?? null;
-    }
-    get electricChars() {
-        if (!this._electricChars) {
-            this._electricChars = {};
-            const electricChars = this.languageConfigurationService.getLanguageConfiguration(this._languageId).electricCharacter?.getElectricCharacters();
-            if (electricChars) {
-                for (const char of electricChars) {
-                    this._electricChars[char] = true;
-                }
-            }
-        }
-        return this._electricChars;
-    }
-    /**
-     * Should return opening bracket type to match indentation with
-     */
-    onElectricCharacter(character, context, column) {
-        const scopedLineTokens = createScopedLineTokens(context, column - 1);
-        const electricCharacterSupport = this.languageConfigurationService.getLanguageConfiguration(scopedLineTokens.languageId).electricCharacter;
-        if (!electricCharacterSupport) {
-            return null;
-        }
-        return electricCharacterSupport.onElectricCharacter(character, scopedLineTokens, column - scopedLineTokens.firstCharOffset);
-    }
-    normalizeIndentation(str) {
-        return normalizeIndentation(str, this.indentSize, this.insertSpaces);
-    }
-    _getShouldAutoClose(languageId, autoCloseConfig, forQuotes) {
-        switch (autoCloseConfig) {
-            case 'beforeWhitespace':
-                return autoCloseBeforeWhitespace;
-            case 'languageDefined':
-                return this._getLanguageDefinedShouldAutoClose(languageId, forQuotes);
-            case 'always':
-                return autoCloseAlways;
-            case 'never':
-                return autoCloseNever;
-        }
-    }
-    _getLanguageDefinedShouldAutoClose(languageId, forQuotes) {
-        const autoCloseBeforeSet = this.languageConfigurationService.getLanguageConfiguration(languageId).getAutoCloseBeforeSet(forQuotes);
-        return c => autoCloseBeforeSet.indexOf(c) !== -1;
-    }
-    /**
-     * Returns a visible column from a column.
-     * @see {@link CursorColumns}
-     */
-    visibleColumnFromColumn(model, position) {
-        return CursorColumns.visibleColumnFromColumn(model.getLineContent(position.lineNumber), position.column, this.tabSize);
-    }
-    /**
-     * Returns a visible column from a column.
-     * @see {@link CursorColumns}
-     */
-    columnFromVisibleColumn(model, lineNumber, visibleColumn) {
-        const result = CursorColumns.columnFromVisibleColumn(model.getLineContent(lineNumber), visibleColumn, this.tabSize);
-        const minColumn = model.getLineMinColumn(lineNumber);
-        if (result < minColumn) {
-            return minColumn;
-        }
-        const maxColumn = model.getLineMaxColumn(lineNumber);
-        if (result > maxColumn) {
-            return maxColumn;
-        }
-        return result;
-    }
-}
-export class CursorState {
-    static fromModelState(modelState) {
-        return new PartialModelCursorState(modelState);
-    }
-    static fromViewState(viewState) {
-        return new PartialViewCursorState(viewState);
-    }
-    static fromModelSelection(modelSelection) {
-        const selection = Selection.liftSelection(modelSelection);
-        const modelState = new SingleCursorState(Range.fromPositions(selection.getSelectionStart()), 0 /* SelectionStartKind.Simple */, 0, selection.getPosition(), 0);
-        return CursorState.fromModelState(modelState);
-    }
-    static fromModelSelections(modelSelections) {
-        const states = [];
-        for (let i = 0, len = modelSelections.length; i < len; i++) {
-            states[i] = this.fromModelSelection(modelSelections[i]);
-        }
-        return states;
-    }
-    constructor(modelState, viewState) {
-        this._cursorStateBrand = undefined;
-        this.modelState = modelState;
-        this.viewState = viewState;
-    }
-    equals(other) {
-        return (this.viewState.equals(other.viewState) && this.modelState.equals(other.modelState));
-    }
-}
-export class PartialModelCursorState {
-    constructor(modelState) {
-        this.modelState = modelState;
-        this.viewState = null;
-    }
-}
-export class PartialViewCursorState {
-    constructor(viewState) {
-        this.modelState = null;
-        this.viewState = viewState;
-    }
-}
-/**
- * Represents the cursor state on either the model or on the view model.
- */
-export class SingleCursorState {
-    constructor(selectionStart, selectionStartKind, selectionStartLeftoverVisibleColumns, position, leftoverVisibleColumns) {
-        this.selectionStart = selectionStart;
-        this.selectionStartKind = selectionStartKind;
-        this.selectionStartLeftoverVisibleColumns = selectionStartLeftoverVisibleColumns;
-        this.position = position;
-        this.leftoverVisibleColumns = leftoverVisibleColumns;
-        this._singleCursorStateBrand = undefined;
-        this.selection = SingleCursorState._computeSelection(this.selectionStart, this.position);
-    }
-    equals(other) {
-        return (this.selectionStartLeftoverVisibleColumns === other.selectionStartLeftoverVisibleColumns
-            && this.leftoverVisibleColumns === other.leftoverVisibleColumns
-            && this.selectionStartKind === other.selectionStartKind
-            && this.position.equals(other.position)
-            && this.selectionStart.equalsRange(other.selectionStart));
-    }
-    hasSelection() {
-        return (!this.selection.isEmpty() || !this.selectionStart.isEmpty());
-    }
-    move(inSelectionMode, lineNumber, column, leftoverVisibleColumns) {
-        if (inSelectionMode) {
-            // move just position
-            return new SingleCursorState(this.selectionStart, this.selectionStartKind, this.selectionStartLeftoverVisibleColumns, new Position(lineNumber, column), leftoverVisibleColumns);
-        }
-        else {
-            // move everything
-            return new SingleCursorState(new Range(lineNumber, column, lineNumber, column), 0 /* SelectionStartKind.Simple */, leftoverVisibleColumns, new Position(lineNumber, column), leftoverVisibleColumns);
-        }
-    }
-    static _computeSelection(selectionStart, position) {
-        if (selectionStart.isEmpty() || !position.isBeforeOrEqual(selectionStart.getStartPosition())) {
-            return Selection.fromPositions(selectionStart.getStartPosition(), position);
-        }
-        else {
-            return Selection.fromPositions(selectionStart.getEndPosition(), position);
-        }
-    }
-}
-export class EditOperationResult {
-    constructor(type, commands, opts) {
-        this._editOperationResultBrand = undefined;
-        this.type = type;
-        this.commands = commands;
-        this.shouldPushStackElementBefore = opts.shouldPushStackElementBefore;
-        this.shouldPushStackElementAfter = opts.shouldPushStackElementAfter;
-    }
-}
-export function isQuote(ch) {
-    return (ch === '\'' || ch === '"' || ch === '`');
-}

package/dist-cms/monaco-editor/vs/editor/common/cursorEvents.js

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

package/dist-cms/monaco-editor/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/diffAlgorithm.js

@@ -1,138 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { forEachAdjacent } from '../../../../../base/common/arrays.js';
-import { BugIndicatingError } from '../../../../../base/common/errors.js';
-import { OffsetRange } from '../../../core/offsetRange.js';
-export class DiffAlgorithmResult {
-    static trivial(seq1, seq2) {
-        return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], false);
-    }
-    static trivialTimedOut(seq1, seq2) {
-        return new DiffAlgorithmResult([new SequenceDiff(OffsetRange.ofLength(seq1.length), OffsetRange.ofLength(seq2.length))], true);
-    }
-    constructor(diffs, 
-    /**
-     * Indicates if the time out was reached.
-     * In that case, the diffs might be an approximation and the user should be asked to rerun the diff with more time.
-     */
-    hitTimeout) {
-        this.diffs = diffs;
-        this.hitTimeout = hitTimeout;
-    }
-}
-export class SequenceDiff {
-    static invert(sequenceDiffs, doc1Length) {
-        const result = [];
-        forEachAdjacent(sequenceDiffs, (a, b) => {
-            result.push(SequenceDiff.fromOffsetPairs(a ? a.getEndExclusives() : OffsetPair.zero, b ? b.getStarts() : new OffsetPair(doc1Length, (a ? a.seq2Range.endExclusive - a.seq1Range.endExclusive : 0) + doc1Length)));
-        });
-        return result;
-    }
-    static fromOffsetPairs(start, endExclusive) {
-        return new SequenceDiff(new OffsetRange(start.offset1, endExclusive.offset1), new OffsetRange(start.offset2, endExclusive.offset2));
-    }
-    static assertSorted(sequenceDiffs) {
-        let last = undefined;
-        for (const cur of sequenceDiffs) {
-            if (last) {
-                if (!(last.seq1Range.endExclusive <= cur.seq1Range.start && last.seq2Range.endExclusive <= cur.seq2Range.start)) {
-                    throw new BugIndicatingError('Sequence diffs must be sorted');
-                }
-            }
-            last = cur;
-        }
-    }
-    constructor(seq1Range, seq2Range) {
-        this.seq1Range = seq1Range;
-        this.seq2Range = seq2Range;
-    }
-    swap() {
-        return new SequenceDiff(this.seq2Range, this.seq1Range);
-    }
-    toString() {
-        return `${this.seq1Range} <-> ${this.seq2Range}`;
-    }
-    join(other) {
-        return new SequenceDiff(this.seq1Range.join(other.seq1Range), this.seq2Range.join(other.seq2Range));
-    }
-    delta(offset) {
-        if (offset === 0) {
-            return this;
-        }
-        return new SequenceDiff(this.seq1Range.delta(offset), this.seq2Range.delta(offset));
-    }
-    deltaStart(offset) {
-        if (offset === 0) {
-            return this;
-        }
-        return new SequenceDiff(this.seq1Range.deltaStart(offset), this.seq2Range.deltaStart(offset));
-    }
-    deltaEnd(offset) {
-        if (offset === 0) {
-            return this;
-        }
-        return new SequenceDiff(this.seq1Range.deltaEnd(offset), this.seq2Range.deltaEnd(offset));
-    }
-    intersect(other) {
-        const i1 = this.seq1Range.intersect(other.seq1Range);
-        const i2 = this.seq2Range.intersect(other.seq2Range);
-        if (!i1 || !i2) {
-            return undefined;
-        }
-        return new SequenceDiff(i1, i2);
-    }
-    getStarts() {
-        return new OffsetPair(this.seq1Range.start, this.seq2Range.start);
-    }
-    getEndExclusives() {
-        return new OffsetPair(this.seq1Range.endExclusive, this.seq2Range.endExclusive);
-    }
-}
-export class OffsetPair {
-    static { this.zero = new OffsetPair(0, 0); }
-    static { this.max = new OffsetPair(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER); }
-    constructor(offset1, offset2) {
-        this.offset1 = offset1;
-        this.offset2 = offset2;
-    }
-    toString() {
-        return `${this.offset1} <-> ${this.offset2}`;
-    }
-    delta(offset) {
-        if (offset === 0) {
-            return this;
-        }
-        return new OffsetPair(this.offset1 + offset, this.offset2 + offset);
-    }
-    equals(other) {
-        return this.offset1 === other.offset1 && this.offset2 === other.offset2;
-    }
-}
-export class InfiniteTimeout {
-    static { this.instance = new InfiniteTimeout(); }
-    isValid() {
-        return true;
-    }
-}
-export class DateTimeout {
-    constructor(timeout) {
-        this.timeout = timeout;
-        this.startTime = Date.now();
-        this.valid = true;
-        if (timeout <= 0) {
-            throw new BugIndicatingError('timeout must be positive');
-        }
-    }
-    // Recommendation: Set a log-point `{this.disable()}` in the body
-    isValid() {
-        const valid = Date.now() - this.startTime < this.timeout;
-        if (!valid && this.valid) {
-            this.valid = false; // timeout reached
-            // eslint-disable-next-line no-debugger
-            debugger; // WARNING: Most likely debugging caused the timeout. Call `this.disable()` to continue without timing out.
-        }
-        return this.valid;
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/diff/defaultLinesDiffComputer/algorithms/dynamicProgrammingDiffing.js

@@ -1,98 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { OffsetRange } from '../../../core/offsetRange.js';
-import { SequenceDiff, InfiniteTimeout, DiffAlgorithmResult } from './diffAlgorithm.js';
-import { Array2D } from '../utils.js';
-/**
- * A O(MN) diffing algorithm that supports a score function.
- * The algorithm can be improved by processing the 2d array diagonally.
-*/
-export class DynamicProgrammingDiffing {
-    compute(sequence1, sequence2, timeout = InfiniteTimeout.instance, equalityScore) {
-        if (sequence1.length === 0 || sequence2.length === 0) {
-            return DiffAlgorithmResult.trivial(sequence1, sequence2);
-        }
-        /**
-         * lcsLengths.get(i, j): Length of the longest common subsequence of sequence1.substring(0, i + 1) and sequence2.substring(0, j + 1).
-         */
-        const lcsLengths = new Array2D(sequence1.length, sequence2.length);
-        const directions = new Array2D(sequence1.length, sequence2.length);
-        const lengths = new Array2D(sequence1.length, sequence2.length);
-        // ==== Initializing lcsLengths ====
-        for (let s1 = 0; s1 < sequence1.length; s1++) {
-            for (let s2 = 0; s2 < sequence2.length; s2++) {
-                if (!timeout.isValid()) {
-                    return DiffAlgorithmResult.trivialTimedOut(sequence1, sequence2);
-                }
-                const horizontalLen = s1 === 0 ? 0 : lcsLengths.get(s1 - 1, s2);
-                const verticalLen = s2 === 0 ? 0 : lcsLengths.get(s1, s2 - 1);
-                let extendedSeqScore;
-                if (sequence1.getElement(s1) === sequence2.getElement(s2)) {
-                    if (s1 === 0 || s2 === 0) {
-                        extendedSeqScore = 0;
-                    }
-                    else {
-                        extendedSeqScore = lcsLengths.get(s1 - 1, s2 - 1);
-                    }
-                    if (s1 > 0 && s2 > 0 && directions.get(s1 - 1, s2 - 1) === 3) {
-                        // Prefer consecutive diagonals
-                        extendedSeqScore += lengths.get(s1 - 1, s2 - 1);
-                    }
-                    extendedSeqScore += (equalityScore ? equalityScore(s1, s2) : 1);
-                }
-                else {
-                    extendedSeqScore = -1;
-                }
-                const newValue = Math.max(horizontalLen, verticalLen, extendedSeqScore);
-                if (newValue === extendedSeqScore) {
-                    // Prefer diagonals
-                    const prevLen = s1 > 0 && s2 > 0 ? lengths.get(s1 - 1, s2 - 1) : 0;
-                    lengths.set(s1, s2, prevLen + 1);
-                    directions.set(s1, s2, 3);
-                }
-                else if (newValue === horizontalLen) {
-                    lengths.set(s1, s2, 0);
-                    directions.set(s1, s2, 1);
-                }
-                else if (newValue === verticalLen) {
-                    lengths.set(s1, s2, 0);
-                    directions.set(s1, s2, 2);
-                }
-                lcsLengths.set(s1, s2, newValue);
-            }
-        }
-        // ==== Backtracking ====
-        const result = [];
-        let lastAligningPosS1 = sequence1.length;
-        let lastAligningPosS2 = sequence2.length;
-        function reportDecreasingAligningPositions(s1, s2) {
-            if (s1 + 1 !== lastAligningPosS1 || s2 + 1 !== lastAligningPosS2) {
-                result.push(new SequenceDiff(new OffsetRange(s1 + 1, lastAligningPosS1), new OffsetRange(s2 + 1, lastAligningPosS2)));
-            }
-            lastAligningPosS1 = s1;
-            lastAligningPosS2 = s2;
-        }
-        let s1 = sequence1.length - 1;
-        let s2 = sequence2.length - 1;
-        while (s1 >= 0 && s2 >= 0) {
-            if (directions.get(s1, s2) === 3) {
-                reportDecreasingAligningPositions(s1, s2);
-                s1--;
-                s2--;
-            }
-            else {
-                if (directions.get(s1, s2) === 1) {
-                    s1--;
-                }
-                else {
-                    s2--;
-                }
-            }
-        }
-        reportDecreasingAligningPositions(-1, -1);
-        result.reverse();
-        return new DiffAlgorithmResult(result, false);
-    }
-}