@umbraco-cms/backoffice 16.1.0 → 16.2.0-rc

package/dist-cms/monaco-editor/vs/editor/common/core/textChange.js

@@ -1,245 +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 * as buffer from '../../../base/common/buffer.js';
-import { decodeUTF16LE } from './stringBuilder.js';
-function escapeNewLine(str) {
-    return (str
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r'));
-}
-export class TextChange {
-    get oldLength() {
-        return this.oldText.length;
-    }
-    get oldEnd() {
-        return this.oldPosition + this.oldText.length;
-    }
-    get newLength() {
-        return this.newText.length;
-    }
-    get newEnd() {
-        return this.newPosition + this.newText.length;
-    }
-    constructor(oldPosition, oldText, newPosition, newText) {
-        this.oldPosition = oldPosition;
-        this.oldText = oldText;
-        this.newPosition = newPosition;
-        this.newText = newText;
-    }
-    toString() {
-        if (this.oldText.length === 0) {
-            return `(insert@${this.oldPosition} "${escapeNewLine(this.newText)}")`;
-        }
-        if (this.newText.length === 0) {
-            return `(delete@${this.oldPosition} "${escapeNewLine(this.oldText)}")`;
-        }
-        return `(replace@${this.oldPosition} "${escapeNewLine(this.oldText)}" with "${escapeNewLine(this.newText)}")`;
-    }
-    static _writeStringSize(str) {
-        return (4 + 2 * str.length);
-    }
-    static _writeString(b, str, offset) {
-        const len = str.length;
-        buffer.writeUInt32BE(b, len, offset);
-        offset += 4;
-        for (let i = 0; i < len; i++) {
-            buffer.writeUInt16LE(b, str.charCodeAt(i), offset);
-            offset += 2;
-        }
-        return offset;
-    }
-    static _readString(b, offset) {
-        const len = buffer.readUInt32BE(b, offset);
-        offset += 4;
-        return decodeUTF16LE(b, offset, len);
-    }
-    writeSize() {
-        return (+4 // oldPosition
-            + 4 // newPosition
-            + TextChange._writeStringSize(this.oldText)
-            + TextChange._writeStringSize(this.newText));
-    }
-    write(b, offset) {
-        buffer.writeUInt32BE(b, this.oldPosition, offset);
-        offset += 4;
-        buffer.writeUInt32BE(b, this.newPosition, offset);
-        offset += 4;
-        offset = TextChange._writeString(b, this.oldText, offset);
-        offset = TextChange._writeString(b, this.newText, offset);
-        return offset;
-    }
-    static read(b, offset, dest) {
-        const oldPosition = buffer.readUInt32BE(b, offset);
-        offset += 4;
-        const newPosition = buffer.readUInt32BE(b, offset);
-        offset += 4;
-        const oldText = TextChange._readString(b, offset);
-        offset += TextChange._writeStringSize(oldText);
-        const newText = TextChange._readString(b, offset);
-        offset += TextChange._writeStringSize(newText);
-        dest.push(new TextChange(oldPosition, oldText, newPosition, newText));
-        return offset;
-    }
-}
-export function compressConsecutiveTextChanges(prevEdits, currEdits) {
-    if (prevEdits === null || prevEdits.length === 0) {
-        return currEdits;
-    }
-    const compressor = new TextChangeCompressor(prevEdits, currEdits);
-    return compressor.compress();
-}
-class TextChangeCompressor {
-    constructor(prevEdits, currEdits) {
-        this._prevEdits = prevEdits;
-        this._currEdits = currEdits;
-        this._result = [];
-        this._resultLen = 0;
-        this._prevLen = this._prevEdits.length;
-        this._prevDeltaOffset = 0;
-        this._currLen = this._currEdits.length;
-        this._currDeltaOffset = 0;
-    }
-    compress() {
-        let prevIndex = 0;
-        let currIndex = 0;
-        let prevEdit = this._getPrev(prevIndex);
-        let currEdit = this._getCurr(currIndex);
-        while (prevIndex < this._prevLen || currIndex < this._currLen) {
-            if (prevEdit === null) {
-                this._acceptCurr(currEdit);
-                currEdit = this._getCurr(++currIndex);
-                continue;
-            }
-            if (currEdit === null) {
-                this._acceptPrev(prevEdit);
-                prevEdit = this._getPrev(++prevIndex);
-                continue;
-            }
-            if (currEdit.oldEnd <= prevEdit.newPosition) {
-                this._acceptCurr(currEdit);
-                currEdit = this._getCurr(++currIndex);
-                continue;
-            }
-            if (prevEdit.newEnd <= currEdit.oldPosition) {
-                this._acceptPrev(prevEdit);
-                prevEdit = this._getPrev(++prevIndex);
-                continue;
-            }
-            if (currEdit.oldPosition < prevEdit.newPosition) {
-                const [e1, e2] = TextChangeCompressor._splitCurr(currEdit, prevEdit.newPosition - currEdit.oldPosition);
-                this._acceptCurr(e1);
-                currEdit = e2;
-                continue;
-            }
-            if (prevEdit.newPosition < currEdit.oldPosition) {
-                const [e1, e2] = TextChangeCompressor._splitPrev(prevEdit, currEdit.oldPosition - prevEdit.newPosition);
-                this._acceptPrev(e1);
-                prevEdit = e2;
-                continue;
-            }
-            // At this point, currEdit.oldPosition === prevEdit.newPosition
-            let mergePrev;
-            let mergeCurr;
-            if (currEdit.oldEnd === prevEdit.newEnd) {
-                mergePrev = prevEdit;
-                mergeCurr = currEdit;
-                prevEdit = this._getPrev(++prevIndex);
-                currEdit = this._getCurr(++currIndex);
-            }
-            else if (currEdit.oldEnd < prevEdit.newEnd) {
-                const [e1, e2] = TextChangeCompressor._splitPrev(prevEdit, currEdit.oldLength);
-                mergePrev = e1;
-                mergeCurr = currEdit;
-                prevEdit = e2;
-                currEdit = this._getCurr(++currIndex);
-            }
-            else {
-                const [e1, e2] = TextChangeCompressor._splitCurr(currEdit, prevEdit.newLength);
-                mergePrev = prevEdit;
-                mergeCurr = e1;
-                prevEdit = this._getPrev(++prevIndex);
-                currEdit = e2;
-            }
-            this._result[this._resultLen++] = new TextChange(mergePrev.oldPosition, mergePrev.oldText, mergeCurr.newPosition, mergeCurr.newText);
-            this._prevDeltaOffset += mergePrev.newLength - mergePrev.oldLength;
-            this._currDeltaOffset += mergeCurr.newLength - mergeCurr.oldLength;
-        }
-        const merged = TextChangeCompressor._merge(this._result);
-        const cleaned = TextChangeCompressor._removeNoOps(merged);
-        return cleaned;
-    }
-    _acceptCurr(currEdit) {
-        this._result[this._resultLen++] = TextChangeCompressor._rebaseCurr(this._prevDeltaOffset, currEdit);
-        this._currDeltaOffset += currEdit.newLength - currEdit.oldLength;
-    }
-    _getCurr(currIndex) {
-        return (currIndex < this._currLen ? this._currEdits[currIndex] : null);
-    }
-    _acceptPrev(prevEdit) {
-        this._result[this._resultLen++] = TextChangeCompressor._rebasePrev(this._currDeltaOffset, prevEdit);
-        this._prevDeltaOffset += prevEdit.newLength - prevEdit.oldLength;
-    }
-    _getPrev(prevIndex) {
-        return (prevIndex < this._prevLen ? this._prevEdits[prevIndex] : null);
-    }
-    static _rebaseCurr(prevDeltaOffset, currEdit) {
-        return new TextChange(currEdit.oldPosition - prevDeltaOffset, currEdit.oldText, currEdit.newPosition, currEdit.newText);
-    }
-    static _rebasePrev(currDeltaOffset, prevEdit) {
-        return new TextChange(prevEdit.oldPosition, prevEdit.oldText, prevEdit.newPosition + currDeltaOffset, prevEdit.newText);
-    }
-    static _splitPrev(edit, offset) {
-        const preText = edit.newText.substr(0, offset);
-        const postText = edit.newText.substr(offset);
-        return [
-            new TextChange(edit.oldPosition, edit.oldText, edit.newPosition, preText),
-            new TextChange(edit.oldEnd, '', edit.newPosition + offset, postText)
-        ];
-    }
-    static _splitCurr(edit, offset) {
-        const preText = edit.oldText.substr(0, offset);
-        const postText = edit.oldText.substr(offset);
-        return [
-            new TextChange(edit.oldPosition, preText, edit.newPosition, edit.newText),
-            new TextChange(edit.oldPosition + offset, postText, edit.newEnd, '')
-        ];
-    }
-    static _merge(edits) {
-        if (edits.length === 0) {
-            return edits;
-        }
-        const result = [];
-        let resultLen = 0;
-        let prev = edits[0];
-        for (let i = 1; i < edits.length; i++) {
-            const curr = edits[i];
-            if (prev.oldEnd === curr.oldPosition) {
-                // Merge into `prev`
-                prev = new TextChange(prev.oldPosition, prev.oldText + curr.oldText, prev.newPosition, prev.newText + curr.newText);
-            }
-            else {
-                result[resultLen++] = prev;
-                prev = curr;
-            }
-        }
-        result[resultLen++] = prev;
-        return result;
-    }
-    static _removeNoOps(edits) {
-        if (edits.length === 0) {
-            return edits;
-        }
-        const result = [];
-        let resultLen = 0;
-        for (let i = 0; i < edits.length; i++) {
-            const edit = edits[i];
-            if (edit.oldText === edit.newText) {
-                continue;
-            }
-            result[resultLen++] = edit;
-        }
-        return result;
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/core/textEdit.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 { assertFn, checkAdjacentItems } from '../../../base/common/assert.js';
-import { BugIndicatingError } from '../../../base/common/errors.js';
-import { Position } from './position.js';
-import { PositionOffsetTransformer } from './positionToOffset.js';
-import { Range } from './range.js';
-import { TextLength } from './textLength.js';
-export class TextEdit {
-    constructor(edits) {
-        this.edits = edits;
-        assertFn(() => checkAdjacentItems(edits, (a, b) => a.range.getEndPosition().isBeforeOrEqual(b.range.getStartPosition())));
-    }
-    apply(text) {
-        let result = '';
-        let lastEditEnd = new Position(1, 1);
-        for (const edit of this.edits) {
-            const editRange = edit.range;
-            const editStart = editRange.getStartPosition();
-            const editEnd = editRange.getEndPosition();
-            const r = rangeFromPositions(lastEditEnd, editStart);
-            if (!r.isEmpty()) {
-                result += text.getValueOfRange(r);
-            }
-            result += edit.text;
-            lastEditEnd = editEnd;
-        }
-        const r = rangeFromPositions(lastEditEnd, text.endPositionExclusive);
-        if (!r.isEmpty()) {
-            result += text.getValueOfRange(r);
-        }
-        return result;
-    }
-    applyToString(str) {
-        const strText = new StringText(str);
-        return this.apply(strText);
-    }
-    getNewRanges() {
-        const newRanges = [];
-        let previousEditEndLineNumber = 0;
-        let lineOffset = 0;
-        let columnOffset = 0;
-        for (const edit of this.edits) {
-            const textLength = TextLength.ofText(edit.text);
-            const newRangeStart = Position.lift({
-                lineNumber: edit.range.startLineNumber + lineOffset,
-                column: edit.range.startColumn + (edit.range.startLineNumber === previousEditEndLineNumber ? columnOffset : 0)
-            });
-            const newRange = textLength.createRange(newRangeStart);
-            newRanges.push(newRange);
-            lineOffset = newRange.endLineNumber - edit.range.endLineNumber;
-            columnOffset = newRange.endColumn - edit.range.endColumn;
-            previousEditEndLineNumber = edit.range.endLineNumber;
-        }
-        return newRanges;
-    }
-}
-export class SingleTextEdit {
-    constructor(range, text) {
-        this.range = range;
-        this.text = text;
-    }
-    toSingleEditOperation() {
-        return {
-            range: this.range,
-            text: this.text,
-        };
-    }
-}
-function rangeFromPositions(start, end) {
-    if (start.lineNumber === end.lineNumber && start.column === Number.MAX_SAFE_INTEGER) {
-        return Range.fromPositions(end, end);
-    }
-    else if (!start.isBeforeOrEqual(end)) {
-        throw new BugIndicatingError('start must be before end');
-    }
-    return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
-}
-export class AbstractText {
-    get endPositionExclusive() {
-        return this.length.addToPosition(new Position(1, 1));
-    }
-}
-export class StringText extends AbstractText {
-    constructor(value) {
-        super();
-        this.value = value;
-        this._t = new PositionOffsetTransformer(this.value);
-    }
-    getValueOfRange(range) {
-        return this._t.getOffsetRange(range).substring(this.value);
-    }
-    get length() {
-        return this._t.textLength;
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/core/textLength.js

@@ -1,66 +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 './position.js';
-import { Range } from './range.js';
-/**
- * Represents a non-negative length of text in terms of line and column count.
-*/
-export class TextLength {
-    static { this.zero = new TextLength(0, 0); }
-    static betweenPositions(position1, position2) {
-        if (position1.lineNumber === position2.lineNumber) {
-            return new TextLength(0, position2.column - position1.column);
-        }
-        else {
-            return new TextLength(position2.lineNumber - position1.lineNumber, position2.column - 1);
-        }
-    }
-    static ofRange(range) {
-        return TextLength.betweenPositions(range.getStartPosition(), range.getEndPosition());
-    }
-    static ofText(text) {
-        let line = 0;
-        let column = 0;
-        for (const c of text) {
-            if (c === '\n') {
-                line++;
-                column = 0;
-            }
-            else {
-                column++;
-            }
-        }
-        return new TextLength(line, column);
-    }
-    constructor(lineCount, columnCount) {
-        this.lineCount = lineCount;
-        this.columnCount = columnCount;
-    }
-    isGreaterThanOrEqualTo(other) {
-        if (this.lineCount !== other.lineCount) {
-            return this.lineCount > other.lineCount;
-        }
-        return this.columnCount >= other.columnCount;
-    }
-    createRange(startPosition) {
-        if (this.lineCount === 0) {
-            return new Range(startPosition.lineNumber, startPosition.column, startPosition.lineNumber, startPosition.column + this.columnCount);
-        }
-        else {
-            return new Range(startPosition.lineNumber, startPosition.column, startPosition.lineNumber + this.lineCount, this.columnCount + 1);
-        }
-    }
-    addToPosition(position) {
-        if (this.lineCount === 0) {
-            return new Position(position.lineNumber, position.column + this.columnCount);
-        }
-        else {
-            return new Position(position.lineNumber + this.lineCount, this.columnCount + 1);
-        }
-    }
-    toString() {
-        return `${this.lineCount},${this.columnCount}`;
-    }
-}

package/dist-cms/monaco-editor/vs/editor/common/core/textModelDefaults.js

@@ -1,16 +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 const EDITOR_MODEL_DEFAULTS = {
-    tabSize: 4,
-    indentSize: 4,
-    insertSpaces: true,
-    detectIndentation: true,
-    trimAutoWhitespace: true,
-    largeFileOptimizations: true,
-    bracketPairColorizationOptions: {
-        enabled: true,
-        independentColorPoolPerBracketType: false,
-    },
-};

package/dist-cms/monaco-editor/vs/editor/common/core/wordCharacterClassifier.js

@@ -1,83 +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 { LRUCache } from '../../../base/common/map.js';
-import { CharacterClassifier } from './characterClassifier.js';
-export class WordCharacterClassifier extends CharacterClassifier {
-    constructor(wordSeparators, intlSegmenterLocales) {
-        super(0 /* WordCharacterClass.Regular */);
-        this._segmenter = null;
-        this._cachedLine = null;
-        this._cachedSegments = [];
-        this.intlSegmenterLocales = intlSegmenterLocales;
-        if (this.intlSegmenterLocales.length > 0) {
-            this._segmenter = new Intl.Segmenter(this.intlSegmenterLocales, { granularity: 'word' });
-        }
-        else {
-            this._segmenter = null;
-        }
-        for (let i = 0, len = wordSeparators.length; i < len; i++) {
-            this.set(wordSeparators.charCodeAt(i), 2 /* WordCharacterClass.WordSeparator */);
-        }
-        this.set(32 /* CharCode.Space */, 1 /* WordCharacterClass.Whitespace */);
-        this.set(9 /* CharCode.Tab */, 1 /* WordCharacterClass.Whitespace */);
-    }
-    findPrevIntlWordBeforeOrAtOffset(line, offset) {
-        let candidate = null;
-        for (const segment of this._getIntlSegmenterWordsOnLine(line)) {
-            if (segment.index > offset) {
-                break;
-            }
-            candidate = segment;
-        }
-        return candidate;
-    }
-    findNextIntlWordAtOrAfterOffset(lineContent, offset) {
-        for (const segment of this._getIntlSegmenterWordsOnLine(lineContent)) {
-            if (segment.index < offset) {
-                continue;
-            }
-            return segment;
-        }
-        return null;
-    }
-    _getIntlSegmenterWordsOnLine(line) {
-        if (!this._segmenter) {
-            return [];
-        }
-        // Check if the line has changed from the previous call
-        if (this._cachedLine === line) {
-            return this._cachedSegments;
-        }
-        // Update the cache with the new line
-        this._cachedLine = line;
-        this._cachedSegments = this._filterWordSegments(this._segmenter.segment(line));
-        return this._cachedSegments;
-    }
-    _filterWordSegments(segments) {
-        const result = [];
-        for (const segment of segments) {
-            if (this._isWordLike(segment)) {
-                result.push(segment);
-            }
-        }
-        return result;
-    }
-    _isWordLike(segment) {
-        if (segment.isWordLike) {
-            return true;
-        }
-        return false;
-    }
-}
-const wordClassifierCache = new LRUCache(10);
-export function getMapForWordSeparators(wordSeparators, intlSegmenterLocales) {
-    const key = `${wordSeparators}/${intlSegmenterLocales.join(',')}`;
-    let result = wordClassifierCache.get(key);
-    if (!result) {
-        result = new WordCharacterClassifier(wordSeparators, intlSegmenterLocales);
-        wordClassifierCache.set(key, result);
-    }
-    return result;
-}

package/dist-cms/monaco-editor/vs/editor/common/core/wordHelper.js

@@ -1,124 +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 { Iterable } from '../../../base/common/iterator.js';
-import { LinkedList } from '../../../base/common/linkedList.js';
-export const USUAL_WORD_SEPARATORS = '`~!@#$%^&*()-=+[{]}\\|;:\'",.<>/?';
-/**
- * Create a word definition regular expression based on default word separators.
- * Optionally provide allowed separators that should be included in words.
- *
- * The default would look like this:
- * /(-?\d*\.\d\w*)|([^\`\~\!\@\#\$\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g
- */
-function createWordRegExp(allowInWords = '') {
-    let source = '(-?\\d*\\.\\d\\w*)|([^';
-    for (const sep of USUAL_WORD_SEPARATORS) {
-        if (allowInWords.indexOf(sep) >= 0) {
-            continue;
-        }
-        source += '\\' + sep;
-    }
-    source += '\\s]+)';
-    return new RegExp(source, 'g');
-}
-// catches numbers (including floating numbers) in the first group, and alphanum in the second
-export const DEFAULT_WORD_REGEXP = createWordRegExp();
-export function ensureValidWordDefinition(wordDefinition) {
-    let result = DEFAULT_WORD_REGEXP;
-    if (wordDefinition && (wordDefinition instanceof RegExp)) {
-        if (!wordDefinition.global) {
-            let flags = 'g';
-            if (wordDefinition.ignoreCase) {
-                flags += 'i';
-            }
-            if (wordDefinition.multiline) {
-                flags += 'm';
-            }
-            if (wordDefinition.unicode) {
-                flags += 'u';
-            }
-            result = new RegExp(wordDefinition.source, flags);
-        }
-        else {
-            result = wordDefinition;
-        }
-    }
-    result.lastIndex = 0;
-    return result;
-}
-const _defaultConfig = new LinkedList();
-_defaultConfig.unshift({
-    maxLen: 1000,
-    windowSize: 15,
-    timeBudget: 150
-});
-export function getWordAtText(column, wordDefinition, text, textOffset, config) {
-    // Ensure the regex has the 'g' flag, otherwise this will loop forever
-    wordDefinition = ensureValidWordDefinition(wordDefinition);
-    if (!config) {
-        config = Iterable.first(_defaultConfig);
-    }
-    if (text.length > config.maxLen) {
-        // don't throw strings that long at the regexp
-        // but use a sub-string in which a word must occur
-        let start = column - config.maxLen / 2;
-        if (start < 0) {
-            start = 0;
-        }
-        else {
-            textOffset += start;
-        }
-        text = text.substring(start, column + config.maxLen / 2);
-        return getWordAtText(column, wordDefinition, text, textOffset, config);
-    }
-    const t1 = Date.now();
-    const pos = column - 1 - textOffset;
-    let prevRegexIndex = -1;
-    let match = null;
-    for (let i = 1;; i++) {
-        // check time budget
-        if (Date.now() - t1 >= config.timeBudget) {
-            break;
-        }
-        // reset the index at which the regexp should start matching, also know where it
-        // should stop so that subsequent search don't repeat previous searches
-        const regexIndex = pos - config.windowSize * i;
-        wordDefinition.lastIndex = Math.max(0, regexIndex);
-        const thisMatch = _findRegexMatchEnclosingPosition(wordDefinition, text, pos, prevRegexIndex);
-        if (!thisMatch && match) {
-            // stop: we have something
-            break;
-        }
-        match = thisMatch;
-        // stop: searched at start
-        if (regexIndex <= 0) {
-            break;
-        }
-        prevRegexIndex = regexIndex;
-    }
-    if (match) {
-        const result = {
-            word: match[0],
-            startColumn: textOffset + 1 + match.index,
-            endColumn: textOffset + 1 + match.index + match[0].length
-        };
-        wordDefinition.lastIndex = 0;
-        return result;
-    }
-    return null;
-}
-function _findRegexMatchEnclosingPosition(wordDefinition, text, pos, stopPos) {
-    let match;
-    while (match = wordDefinition.exec(text)) {
-        const matchIndex = match.index || 0;
-        if (matchIndex <= pos && wordDefinition.lastIndex >= pos) {
-            return match;
-        }
-        else if (stopPos > 0 && matchIndex > stopPos) {
-            return null;
-        }
-    }
-    return null;
-}