monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,138 @@
+import { Color, HSLA } from '../../../base/common/color.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function _parseCaptureGroups(captureGroups) {
+    const values = [];
+    for (const captureGroup of captureGroups) {
+        const parsedNumber = Number(captureGroup);
+        if (parsedNumber || parsedNumber === 0 && captureGroup.replace(/\s/g, '') !== '') {
+            values.push(parsedNumber);
+        }
+    }
+    return values;
+}
+function _toIColor(r, g, b, a) {
+    return {
+        red: r / 255,
+        blue: b / 255,
+        green: g / 255,
+        alpha: a
+    };
+}
+function _findRange(model, match) {
+    const index = match.index;
+    const length = match[0].length;
+    if (index === undefined) {
+        return;
+    }
+    const startPosition = model.positionAt(index);
+    const range = {
+        startLineNumber: startPosition.lineNumber,
+        startColumn: startPosition.column,
+        endLineNumber: startPosition.lineNumber,
+        endColumn: startPosition.column + length
+    };
+    return range;
+}
+function _findHexColorInformation(range, hexValue) {
+    if (!range) {
+        return;
+    }
+    const parsedHexColor = Color.Format.CSS.parseHex(hexValue);
+    if (!parsedHexColor) {
+        return;
+    }
+    return {
+        range: range,
+        color: _toIColor(parsedHexColor.rgba.r, parsedHexColor.rgba.g, parsedHexColor.rgba.b, parsedHexColor.rgba.a)
+    };
+}
+function _findRGBColorInformation(range, matches, isAlpha) {
+    if (!range || matches.length !== 1) {
+        return;
+    }
+    const match = matches[0];
+    const captureGroups = match.values();
+    const parsedRegex = _parseCaptureGroups(captureGroups);
+    return {
+        range: range,
+        color: _toIColor(parsedRegex[0], parsedRegex[1], parsedRegex[2], isAlpha ? parsedRegex[3] : 1)
+    };
+}
+function _findHSLColorInformation(range, matches, isAlpha) {
+    if (!range || matches.length !== 1) {
+        return;
+    }
+    const match = matches[0];
+    const captureGroups = match.values();
+    const parsedRegex = _parseCaptureGroups(captureGroups);
+    const colorEquivalent = new Color(new HSLA(parsedRegex[0], parsedRegex[1] / 100, parsedRegex[2] / 100, isAlpha ? parsedRegex[3] : 1));
+    return {
+        range: range,
+        color: _toIColor(colorEquivalent.rgba.r, colorEquivalent.rgba.g, colorEquivalent.rgba.b, colorEquivalent.rgba.a)
+    };
+}
+function _findMatches(model, regex) {
+    if (typeof model === 'string') {
+        return [...model.matchAll(regex)];
+    }
+    else {
+        return model.findMatches(regex);
+    }
+}
+function computeColors(model) {
+    const result = [];
+    // Early validation for RGB and HSL
+    const initialValidationRegex = /\b(rgb|rgba|hsl|hsla)(\([0-9\s,.\%]*\))|^(#)([A-Fa-f0-9]{3})\b|^(#)([A-Fa-f0-9]{4})\b|^(#)([A-Fa-f0-9]{6})\b|^(#)([A-Fa-f0-9]{8})\b|(?<=['"\s])(#)([A-Fa-f0-9]{3})\b|(?<=['"\s])(#)([A-Fa-f0-9]{4})\b|(?<=['"\s])(#)([A-Fa-f0-9]{6})\b|(?<=['"\s])(#)([A-Fa-f0-9]{8})\b/gm;
+    const initialValidationMatches = _findMatches(model, initialValidationRegex);
+    // Potential colors have been found, validate the parameters
+    if (initialValidationMatches.length > 0) {
+        for (const initialMatch of initialValidationMatches) {
+            const initialCaptureGroups = initialMatch.filter(captureGroup => captureGroup !== undefined);
+            const colorScheme = initialCaptureGroups[1];
+            const colorParameters = initialCaptureGroups[2];
+            if (!colorParameters) {
+                continue;
+            }
+            let colorInformation;
+            if (colorScheme === 'rgb') {
+                const regexParameters = /^\(\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*\)$/gm;
+                colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false);
+            }
+            else if (colorScheme === 'rgba') {
+                const regexParameters = /^\(\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])\s*,\s*(0[.][0-9]+|[.][0-9]+|[01][.]|[01])\s*\)$/gm;
+                colorInformation = _findRGBColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true);
+            }
+            else if (colorScheme === 'hsl') {
+                const regexParameters = /^\(\s*((?:360(?:\.0+)?|(?:36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])(?:\.\d+)?))\s*[\s,]\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*[\s,]\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*\)$/gm;
+                colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), false);
+            }
+            else if (colorScheme === 'hsla') {
+                const regexParameters = /^\(\s*((?:360(?:\.0+)?|(?:36[0]|3[0-5][0-9]|[12][0-9][0-9]|[1-9]?[0-9])(?:\.\d+)?))\s*[\s,]\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*[\s,]\s*(100|\d{1,2}[.]\d*|\d{1,2})%\s*[\s,]\s*(0[.][0-9]+|[.][0-9]+|[01][.]0*|[01])\s*\)$/gm;
+                colorInformation = _findHSLColorInformation(_findRange(model, initialMatch), _findMatches(colorParameters, regexParameters), true);
+            }
+            else if (colorScheme === '#') {
+                colorInformation = _findHexColorInformation(_findRange(model, initialMatch), colorScheme + colorParameters);
+            }
+            if (colorInformation) {
+                result.push(colorInformation);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Returns an array of all default document colors in the provided document
+ */
+function computeDefaultDocumentColors(model) {
+    if (!model || typeof model.getValue !== 'function' || typeof model.positionAt !== 'function') {
+        // Unknown caller!
+        return [];
+    }
+    return computeColors(model);
+}
+
+export { computeDefaultDocumentColors };

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

@@ -0,0 +1,188 @@
+import { equals } from '../../../../base/common/arrays.js';
+import { assertFn } from '../../../../base/common/assert.js';
+import { LineRange } from '../../core/ranges/lineRange.js';
+import { OffsetRange } from '../../core/ranges/offsetRange.js';
+import { Range } from '../../core/range.js';
+import { ArrayText } from '../../core/text/abstractText.js';
+import { LinesDiff, MovedText } from '../linesDiffComputer.js';
+import { DetailedLineRangeMapping, RangeMapping, lineRangeMappingFromRangeMappings, LineRangeMapping } from '../rangeMapping.js';
+import { InfiniteTimeout, DateTimeout, SequenceDiff } from './algorithms/diffAlgorithm.js';
+import { DynamicProgrammingDiffing } from './algorithms/dynamicProgrammingDiffing.js';
+import { MyersDiffAlgorithm } from './algorithms/myersDiffAlgorithm.js';
+import { computeMovedLines } from './computeMovedLines.js';
+import { optimizeSequenceDiffs, removeVeryShortMatchingLinesBetweenDiffs, extendDiffsToEntireWordIfAppropriate, removeShortMatches, removeVeryShortMatchingTextBetweenLongDiffs } from './heuristicSequenceOptimizations.js';
+import { LineSequence } from './lineSequence.js';
+import { LinesSliceCharSequence } from './linesSliceCharSequence.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class DefaultLinesDiffComputer {
+    constructor() {
+        this.dynamicProgrammingDiffing = new DynamicProgrammingDiffing();
+        this.myersDiffingAlgorithm = new MyersDiffAlgorithm();
+    }
+    computeDiff(originalLines, modifiedLines, options) {
+        if (originalLines.length <= 1 && equals(originalLines, modifiedLines, (a, b) => a === b)) {
+            return new LinesDiff([], [], false);
+        }
+        if (originalLines.length === 1 && originalLines[0].length === 0 || modifiedLines.length === 1 && modifiedLines[0].length === 0) {
+            return new LinesDiff([
+                new DetailedLineRangeMapping(new LineRange(1, originalLines.length + 1), new LineRange(1, modifiedLines.length + 1), [
+                    new RangeMapping(new Range(1, 1, originalLines.length, originalLines[originalLines.length - 1].length + 1), new Range(1, 1, modifiedLines.length, modifiedLines[modifiedLines.length - 1].length + 1))
+                ])
+            ], [], false);
+        }
+        const timeout = options.maxComputationTimeMs === 0 ? InfiniteTimeout.instance : new DateTimeout(options.maxComputationTimeMs);
+        const considerWhitespaceChanges = !options.ignoreTrimWhitespace;
+        const perfectHashes = new Map();
+        function getOrCreateHash(text) {
+            let hash = perfectHashes.get(text);
+            if (hash === undefined) {
+                hash = perfectHashes.size;
+                perfectHashes.set(text, hash);
+            }
+            return hash;
+        }
+        const originalLinesHashes = originalLines.map((l) => getOrCreateHash(l.trim()));
+        const modifiedLinesHashes = modifiedLines.map((l) => getOrCreateHash(l.trim()));
+        const sequence1 = new LineSequence(originalLinesHashes, originalLines);
+        const sequence2 = new LineSequence(modifiedLinesHashes, modifiedLines);
+        const lineAlignmentResult = (() => {
+            if (sequence1.length + sequence2.length < 1700) {
+                // Use the improved algorithm for small files
+                return this.dynamicProgrammingDiffing.compute(sequence1, sequence2, timeout, (offset1, offset2) => originalLines[offset1] === modifiedLines[offset2]
+                    ? modifiedLines[offset2].length === 0
+                        ? 0.1
+                        : 1 + Math.log(1 + modifiedLines[offset2].length)
+                    : 0.99);
+            }
+            return this.myersDiffingAlgorithm.compute(sequence1, sequence2, timeout);
+        })();
+        let lineAlignments = lineAlignmentResult.diffs;
+        let hitTimeout = lineAlignmentResult.hitTimeout;
+        lineAlignments = optimizeSequenceDiffs(sequence1, sequence2, lineAlignments);
+        lineAlignments = removeVeryShortMatchingLinesBetweenDiffs(sequence1, sequence2, lineAlignments);
+        const alignments = [];
+        const scanForWhitespaceChanges = (equalLinesCount) => {
+            if (!considerWhitespaceChanges) {
+                return;
+            }
+            for (let i = 0; i < equalLinesCount; i++) {
+                const seq1Offset = seq1LastStart + i;
+                const seq2Offset = seq2LastStart + i;
+                if (originalLines[seq1Offset] !== modifiedLines[seq2Offset]) {
+                    // This is because of whitespace changes, diff these lines
+                    const characterDiffs = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(new OffsetRange(seq1Offset, seq1Offset + 1), new OffsetRange(seq2Offset, seq2Offset + 1)), timeout, considerWhitespaceChanges, options);
+                    for (const a of characterDiffs.mappings) {
+                        alignments.push(a);
+                    }
+                    if (characterDiffs.hitTimeout) {
+                        hitTimeout = true;
+                    }
+                }
+            }
+        };
+        let seq1LastStart = 0;
+        let seq2LastStart = 0;
+        for (const diff of lineAlignments) {
+            assertFn(() => diff.seq1Range.start - seq1LastStart === diff.seq2Range.start - seq2LastStart);
+            const equalLinesCount = diff.seq1Range.start - seq1LastStart;
+            scanForWhitespaceChanges(equalLinesCount);
+            seq1LastStart = diff.seq1Range.endExclusive;
+            seq2LastStart = diff.seq2Range.endExclusive;
+            const characterDiffs = this.refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options);
+            if (characterDiffs.hitTimeout) {
+                hitTimeout = true;
+            }
+            for (const a of characterDiffs.mappings) {
+                alignments.push(a);
+            }
+        }
+        scanForWhitespaceChanges(originalLines.length - seq1LastStart);
+        const original = new ArrayText(originalLines);
+        const modified = new ArrayText(modifiedLines);
+        const changes = lineRangeMappingFromRangeMappings(alignments, original, modified);
+        let moves = [];
+        if (options.computeMoves) {
+            moves = this.computeMoves(changes, originalLines, modifiedLines, originalLinesHashes, modifiedLinesHashes, timeout, considerWhitespaceChanges, options);
+        }
+        // Make sure all ranges are valid
+        assertFn(() => {
+            function validatePosition(pos, lines) {
+                if (pos.lineNumber < 1 || pos.lineNumber > lines.length) {
+                    return false;
+                }
+                const line = lines[pos.lineNumber - 1];
+                if (pos.column < 1 || pos.column > line.length + 1) {
+                    return false;
+                }
+                return true;
+            }
+            function validateRange(range, lines) {
+                if (range.startLineNumber < 1 || range.startLineNumber > lines.length + 1) {
+                    return false;
+                }
+                if (range.endLineNumberExclusive < 1 || range.endLineNumberExclusive > lines.length + 1) {
+                    return false;
+                }
+                return true;
+            }
+            for (const c of changes) {
+                if (!c.innerChanges) {
+                    return false;
+                }
+                for (const ic of c.innerChanges) {
+                    const valid = validatePosition(ic.modifiedRange.getStartPosition(), modifiedLines) && validatePosition(ic.modifiedRange.getEndPosition(), modifiedLines) &&
+                        validatePosition(ic.originalRange.getStartPosition(), originalLines) && validatePosition(ic.originalRange.getEndPosition(), originalLines);
+                    if (!valid) {
+                        return false;
+                    }
+                }
+                if (!validateRange(c.modified, modifiedLines) || !validateRange(c.original, originalLines)) {
+                    return false;
+                }
+            }
+            return true;
+        });
+        return new LinesDiff(changes, moves, hitTimeout);
+    }
+    computeMoves(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout, considerWhitespaceChanges, options) {
+        const moves = computeMovedLines(changes, originalLines, modifiedLines, hashedOriginalLines, hashedModifiedLines, timeout);
+        const movesWithDiffs = moves.map(m => {
+            const moveChanges = this.refineDiff(originalLines, modifiedLines, new SequenceDiff(m.original.toOffsetRange(), m.modified.toOffsetRange()), timeout, considerWhitespaceChanges, options);
+            const mappings = lineRangeMappingFromRangeMappings(moveChanges.mappings, new ArrayText(originalLines), new ArrayText(modifiedLines), true);
+            return new MovedText(m, mappings);
+        });
+        return movesWithDiffs;
+    }
+    refineDiff(originalLines, modifiedLines, diff, timeout, considerWhitespaceChanges, options) {
+        const lineRangeMapping = toLineRangeMapping(diff);
+        const rangeMapping = lineRangeMapping.toRangeMapping2(originalLines, modifiedLines);
+        const slice1 = new LinesSliceCharSequence(originalLines, rangeMapping.originalRange, considerWhitespaceChanges);
+        const slice2 = new LinesSliceCharSequence(modifiedLines, rangeMapping.modifiedRange, considerWhitespaceChanges);
+        const diffResult = slice1.length + slice2.length < 500
+            ? this.dynamicProgrammingDiffing.compute(slice1, slice2, timeout)
+            : this.myersDiffingAlgorithm.compute(slice1, slice2, timeout);
+        let diffs = diffResult.diffs;
+        diffs = optimizeSequenceDiffs(slice1, slice2, diffs);
+        diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findWordContaining(idx));
+        if (options.extendToSubwords) {
+            diffs = extendDiffsToEntireWordIfAppropriate(slice1, slice2, diffs, (seq, idx) => seq.findSubWordContaining(idx), true);
+        }
+        diffs = removeShortMatches(slice1, slice2, diffs);
+        diffs = removeVeryShortMatchingTextBetweenLongDiffs(slice1, slice2, diffs);
+        const result = diffs.map((d) => new RangeMapping(slice1.translateRange(d.seq1Range), slice2.translateRange(d.seq2Range)));
+        // Assert: result applied on original should be the same as diff applied to original
+        return {
+            mappings: result,
+            hitTimeout: diffResult.hitTimeout,
+        };
+    }
+}
+function toLineRangeMapping(sequenceDiff) {
+    return new LineRangeMapping(new LineRange(sequenceDiff.seq1Range.start + 1, sequenceDiff.seq1Range.endExclusive + 1), new LineRange(sequenceDiff.seq2Range.start + 1, sequenceDiff.seq2Range.endExclusive + 1));
+}
+
+export { DefaultLinesDiffComputer };

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

@@ -0,0 +1,139 @@
+import { forEachAdjacent } from '../../../../../base/common/arrays.js';
+import { BugIndicatingError } from '../../../../../base/common/errors.js';
+import { OffsetRange } from '../../../core/ranges/offsetRange.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+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;
+    }
+}
+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);
+    }
+}
+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;
+    }
+}
+class InfiniteTimeout {
+    static { this.instance = new InfiniteTimeout(); }
+    isValid() {
+        return true;
+    }
+}
+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
+        }
+        return this.valid;
+    }
+}
+
+export { DateTimeout, DiffAlgorithmResult, InfiniteTimeout, OffsetPair, SequenceDiff };

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

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const diffEditorDefaultOptions = {
+    enableSplitViewResizing: true,
+    renderSideBySide: true,
+    renderMarginRevertIcon: true,
+    renderGutterMenu: true,
+    maxComputationTime: 5000,
+    maxFileSize: 50,
+    ignoreTrimWhitespace: true,
+    renderIndicators: true,
+    originalEditable: false,
+    diffCodeLens: false,
+    renderOverviewRuler: true,
+    diffWordWrap: 'inherit',
+    diffAlgorithm: 'advanced',
+    accessibilityVerbose: false,
+    experimental: {
+        showMoves: false,
+        showEmptyDecorations: true,
+        useTrueInlineView: false,
+    },
+    hideUnchangedRegions: {
+        enabled: false,
+        contextLineCount: 3,
+        minimumLineCount: 3,
+        revealLineCount: 20,
+    },
+    isInEmbeddedEditor: false,
+    onlyShowAccessibleDiffViewer: false,
+    renderSideBySideInlineBreakpoint: 900,
+    useInlineViewWhenSpaceIsLimited: true,
+    compactMode: false,
+};
+
+export { diffEditorDefaultOptions };

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

@@ -0,0 +1,101 @@
+import { OffsetRange } from '../../../core/ranges/offsetRange.js';
+import { InfiniteTimeout, DiffAlgorithmResult, SequenceDiff } from './diffAlgorithm.js';
+import { Array2D } from '../utils.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * A O(MN) diffing algorithm that supports a score function.
+ * The algorithm can be improved by processing the 2d array diagonally.
+*/
+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);
+    }
+}
+
+export { DynamicProgrammingDiffing };