monaco-editor11 1.0.7 → 1.0.9

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

@@ -0,0 +1,205 @@
+import { findLastIdxMonotonous, findLastMonotonous, findFirstMonotonous } from '../../../../base/common/arraysFind.js';
+import { OffsetRange } from '../../core/ranges/offsetRange.js';
+import { Position } from '../../core/position.js';
+import { Range } from '../../core/range.js';
+import { isSpace } 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.
+ *--------------------------------------------------------------------------------------------*/
+class LinesSliceCharSequence {
+    constructor(lines, range, considerWhitespaceChanges) {
+        this.lines = lines;
+        this.range = range;
+        this.considerWhitespaceChanges = considerWhitespaceChanges;
+        this.elements = [];
+        this.firstElementOffsetByLineIdx = [];
+        this.lineStartOffsets = [];
+        this.trimmedWsLengthsByLineIdx = [];
+        this.firstElementOffsetByLineIdx.push(0);
+        for (let lineNumber = this.range.startLineNumber; lineNumber <= this.range.endLineNumber; lineNumber++) {
+            let line = lines[lineNumber - 1];
+            let lineStartOffset = 0;
+            if (lineNumber === this.range.startLineNumber && this.range.startColumn > 1) {
+                lineStartOffset = this.range.startColumn - 1;
+                line = line.substring(lineStartOffset);
+            }
+            this.lineStartOffsets.push(lineStartOffset);
+            let trimmedWsLength = 0;
+            if (!considerWhitespaceChanges) {
+                const trimmedStartLine = line.trimStart();
+                trimmedWsLength = line.length - trimmedStartLine.length;
+                line = trimmedStartLine.trimEnd();
+            }
+            this.trimmedWsLengthsByLineIdx.push(trimmedWsLength);
+            const lineLength = lineNumber === this.range.endLineNumber ? Math.min(this.range.endColumn - 1 - lineStartOffset - trimmedWsLength, line.length) : line.length;
+            for (let i = 0; i < lineLength; i++) {
+                this.elements.push(line.charCodeAt(i));
+            }
+            if (lineNumber < this.range.endLineNumber) {
+                this.elements.push('\n'.charCodeAt(0));
+                this.firstElementOffsetByLineIdx.push(this.elements.length);
+            }
+        }
+    }
+    toString() {
+        return `Slice: "${this.text}"`;
+    }
+    get text() {
+        return this.getText(new OffsetRange(0, this.length));
+    }
+    getText(range) {
+        return this.elements.slice(range.start, range.endExclusive).map(e => String.fromCharCode(e)).join('');
+    }
+    getElement(offset) {
+        return this.elements[offset];
+    }
+    get length() {
+        return this.elements.length;
+    }
+    getBoundaryScore(length) {
+        //   a   b   c   ,           d   e   f
+        // 11  0   0   12  15  6   13  0   0   11
+        const prevCategory = getCategory(length > 0 ? this.elements[length - 1] : -1);
+        const nextCategory = getCategory(length < this.elements.length ? this.elements[length] : -1);
+        if (prevCategory === 7 /* CharBoundaryCategory.LineBreakCR */ && nextCategory === 8 /* CharBoundaryCategory.LineBreakLF */) {
+            // don't break between \r and \n
+            return 0;
+        }
+        if (prevCategory === 8 /* CharBoundaryCategory.LineBreakLF */) {
+            // prefer the linebreak before the change
+            return 150;
+        }
+        let score = 0;
+        if (prevCategory !== nextCategory) {
+            score += 10;
+            if (prevCategory === 0 /* CharBoundaryCategory.WordLower */ && nextCategory === 1 /* CharBoundaryCategory.WordUpper */) {
+                score += 1;
+            }
+        }
+        score += getCategoryBoundaryScore(prevCategory);
+        score += getCategoryBoundaryScore(nextCategory);
+        return score;
+    }
+    translateOffset(offset, preference = 'right') {
+        // find smallest i, so that lineBreakOffsets[i] <= offset using binary search
+        const i = findLastIdxMonotonous(this.firstElementOffsetByLineIdx, (value) => value <= offset);
+        const lineOffset = offset - this.firstElementOffsetByLineIdx[i];
+        return new Position(this.range.startLineNumber + i, 1 + this.lineStartOffsets[i] + lineOffset + ((lineOffset === 0 && preference === 'left') ? 0 : this.trimmedWsLengthsByLineIdx[i]));
+    }
+    translateRange(range) {
+        const pos1 = this.translateOffset(range.start, 'right');
+        const pos2 = this.translateOffset(range.endExclusive, 'left');
+        if (pos2.isBefore(pos1)) {
+            return Range.fromPositions(pos2, pos2);
+        }
+        return Range.fromPositions(pos1, pos2);
+    }
+    /**
+     * Finds the word that contains the character at the given offset
+     */
+    findWordContaining(offset) {
+        if (offset < 0 || offset >= this.elements.length) {
+            return undefined;
+        }
+        if (!isWordChar(this.elements[offset])) {
+            return undefined;
+        }
+        // find start
+        let start = offset;
+        while (start > 0 && isWordChar(this.elements[start - 1])) {
+            start--;
+        }
+        // find end
+        let end = offset;
+        while (end < this.elements.length && isWordChar(this.elements[end])) {
+            end++;
+        }
+        return new OffsetRange(start, end);
+    }
+    /** fooBar has the two sub-words foo and bar */
+    findSubWordContaining(offset) {
+        if (offset < 0 || offset >= this.elements.length) {
+            return undefined;
+        }
+        if (!isWordChar(this.elements[offset])) {
+            return undefined;
+        }
+        // find start
+        let start = offset;
+        while (start > 0 && isWordChar(this.elements[start - 1]) && !isUpperCase(this.elements[start])) {
+            start--;
+        }
+        // find end
+        let end = offset;
+        while (end < this.elements.length && isWordChar(this.elements[end]) && !isUpperCase(this.elements[end])) {
+            end++;
+        }
+        return new OffsetRange(start, end);
+    }
+    countLinesIn(range) {
+        return this.translateOffset(range.endExclusive).lineNumber - this.translateOffset(range.start).lineNumber;
+    }
+    isStronglyEqual(offset1, offset2) {
+        return this.elements[offset1] === this.elements[offset2];
+    }
+    extendToFullLines(range) {
+        const start = findLastMonotonous(this.firstElementOffsetByLineIdx, x => x <= range.start) ?? 0;
+        const end = findFirstMonotonous(this.firstElementOffsetByLineIdx, x => range.endExclusive <= x) ?? this.elements.length;
+        return new OffsetRange(start, end);
+    }
+}
+function isWordChar(charCode) {
+    return charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */
+        || charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */
+        || charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */;
+}
+function isUpperCase(charCode) {
+    return charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */;
+}
+const score = {
+    [0 /* CharBoundaryCategory.WordLower */]: 0,
+    [1 /* CharBoundaryCategory.WordUpper */]: 0,
+    [2 /* CharBoundaryCategory.WordNumber */]: 0,
+    [3 /* CharBoundaryCategory.End */]: 10,
+    [4 /* CharBoundaryCategory.Other */]: 2,
+    [5 /* CharBoundaryCategory.Separator */]: 30,
+    [6 /* CharBoundaryCategory.Space */]: 3,
+    [7 /* CharBoundaryCategory.LineBreakCR */]: 10,
+    [8 /* CharBoundaryCategory.LineBreakLF */]: 10,
+};
+function getCategoryBoundaryScore(category) {
+    return score[category];
+}
+function getCategory(charCode) {
+    if (charCode === 10 /* CharCode.LineFeed */) {
+        return 8 /* CharBoundaryCategory.LineBreakLF */;
+    }
+    else if (charCode === 13 /* CharCode.CarriageReturn */) {
+        return 7 /* CharBoundaryCategory.LineBreakCR */;
+    }
+    else if (isSpace(charCode)) {
+        return 6 /* CharBoundaryCategory.Space */;
+    }
+    else if (charCode >= 97 /* CharCode.a */ && charCode <= 122 /* CharCode.z */) {
+        return 0 /* CharBoundaryCategory.WordLower */;
+    }
+    else if (charCode >= 65 /* CharCode.A */ && charCode <= 90 /* CharCode.Z */) {
+        return 1 /* CharBoundaryCategory.WordUpper */;
+    }
+    else if (charCode >= 48 /* CharCode.Digit0 */ && charCode <= 57 /* CharCode.Digit9 */) {
+        return 2 /* CharBoundaryCategory.WordNumber */;
+    }
+    else if (charCode === -1) {
+        return 3 /* CharBoundaryCategory.End */;
+    }
+    else if (charCode === 44 /* CharCode.Comma */ || charCode === 59 /* CharCode.Semicolon */) {
+        return 5 /* CharBoundaryCategory.Separator */;
+    }
+    else {
+        return 4 /* CharBoundaryCategory.Other */;
+    }
+}
+
+export { LinesSliceCharSequence };

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

@@ -0,0 +1,269 @@
+import { CharacterClassifier } from '../core/characterClassifier.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class Uint8Matrix {
+    constructor(rows, cols, defaultValue) {
+        const data = new Uint8Array(rows * cols);
+        for (let i = 0, len = rows * cols; i < len; i++) {
+            data[i] = defaultValue;
+        }
+        this._data = data;
+        this.rows = rows;
+        this.cols = cols;
+    }
+    get(row, col) {
+        return this._data[row * this.cols + col];
+    }
+    set(row, col, value) {
+        this._data[row * this.cols + col] = value;
+    }
+}
+class StateMachine {
+    constructor(edges) {
+        let maxCharCode = 0;
+        let maxState = 0 /* State.Invalid */;
+        for (let i = 0, len = edges.length; i < len; i++) {
+            const [from, chCode, to] = edges[i];
+            if (chCode > maxCharCode) {
+                maxCharCode = chCode;
+            }
+            if (from > maxState) {
+                maxState = from;
+            }
+            if (to > maxState) {
+                maxState = to;
+            }
+        }
+        maxCharCode++;
+        maxState++;
+        const states = new Uint8Matrix(maxState, maxCharCode, 0 /* State.Invalid */);
+        for (let i = 0, len = edges.length; i < len; i++) {
+            const [from, chCode, to] = edges[i];
+            states.set(from, chCode, to);
+        }
+        this._states = states;
+        this._maxCharCode = maxCharCode;
+    }
+    nextState(currentState, chCode) {
+        if (chCode < 0 || chCode >= this._maxCharCode) {
+            return 0 /* State.Invalid */;
+        }
+        return this._states.get(currentState, chCode);
+    }
+}
+// State machine for http:// or https:// or file://
+let _stateMachine = null;
+function getStateMachine() {
+    if (_stateMachine === null) {
+        _stateMachine = new StateMachine([
+            [1 /* State.Start */, 104 /* CharCode.h */, 2 /* State.H */],
+            [1 /* State.Start */, 72 /* CharCode.H */, 2 /* State.H */],
+            [1 /* State.Start */, 102 /* CharCode.f */, 6 /* State.F */],
+            [1 /* State.Start */, 70 /* CharCode.F */, 6 /* State.F */],
+            [2 /* State.H */, 116 /* CharCode.t */, 3 /* State.HT */],
+            [2 /* State.H */, 84 /* CharCode.T */, 3 /* State.HT */],
+            [3 /* State.HT */, 116 /* CharCode.t */, 4 /* State.HTT */],
+            [3 /* State.HT */, 84 /* CharCode.T */, 4 /* State.HTT */],
+            [4 /* State.HTT */, 112 /* CharCode.p */, 5 /* State.HTTP */],
+            [4 /* State.HTT */, 80 /* CharCode.P */, 5 /* State.HTTP */],
+            [5 /* State.HTTP */, 115 /* CharCode.s */, 9 /* State.BeforeColon */],
+            [5 /* State.HTTP */, 83 /* CharCode.S */, 9 /* State.BeforeColon */],
+            [5 /* State.HTTP */, 58 /* CharCode.Colon */, 10 /* State.AfterColon */],
+            [6 /* State.F */, 105 /* CharCode.i */, 7 /* State.FI */],
+            [6 /* State.F */, 73 /* CharCode.I */, 7 /* State.FI */],
+            [7 /* State.FI */, 108 /* CharCode.l */, 8 /* State.FIL */],
+            [7 /* State.FI */, 76 /* CharCode.L */, 8 /* State.FIL */],
+            [8 /* State.FIL */, 101 /* CharCode.e */, 9 /* State.BeforeColon */],
+            [8 /* State.FIL */, 69 /* CharCode.E */, 9 /* State.BeforeColon */],
+            [9 /* State.BeforeColon */, 58 /* CharCode.Colon */, 10 /* State.AfterColon */],
+            [10 /* State.AfterColon */, 47 /* CharCode.Slash */, 11 /* State.AlmostThere */],
+            [11 /* State.AlmostThere */, 47 /* CharCode.Slash */, 12 /* State.End */],
+        ]);
+    }
+    return _stateMachine;
+}
+let _classifier = null;
+function getClassifier() {
+    if (_classifier === null) {
+        _classifier = new CharacterClassifier(0 /* CharacterClass.None */);
+        // allow-any-unicode-next-line
+        const FORCE_TERMINATION_CHARACTERS = ' \t<>\'\"、。｡､，．：；‘〈「『〔（［｛｢｣｝］）〕』」〉’｀～…|';
+        for (let i = 0; i < FORCE_TERMINATION_CHARACTERS.length; i++) {
+            _classifier.set(FORCE_TERMINATION_CHARACTERS.charCodeAt(i), 1 /* CharacterClass.ForceTermination */);
+        }
+        const CANNOT_END_WITH_CHARACTERS = '.,;:';
+        for (let i = 0; i < CANNOT_END_WITH_CHARACTERS.length; i++) {
+            _classifier.set(CANNOT_END_WITH_CHARACTERS.charCodeAt(i), 2 /* CharacterClass.CannotEndIn */);
+        }
+    }
+    return _classifier;
+}
+class LinkComputer {
+    static _createLink(classifier, line, lineNumber, linkBeginIndex, linkEndIndex) {
+        // Do not allow to end link in certain characters...
+        let lastIncludedCharIndex = linkEndIndex - 1;
+        do {
+            const chCode = line.charCodeAt(lastIncludedCharIndex);
+            const chClass = classifier.get(chCode);
+            if (chClass !== 2 /* CharacterClass.CannotEndIn */) {
+                break;
+            }
+            lastIncludedCharIndex--;
+        } while (lastIncludedCharIndex > linkBeginIndex);
+        // Handle links enclosed in parens, square brackets and curlys.
+        if (linkBeginIndex > 0) {
+            const charCodeBeforeLink = line.charCodeAt(linkBeginIndex - 1);
+            const lastCharCodeInLink = line.charCodeAt(lastIncludedCharIndex);
+            if ((charCodeBeforeLink === 40 /* CharCode.OpenParen */ && lastCharCodeInLink === 41 /* CharCode.CloseParen */)
+                || (charCodeBeforeLink === 91 /* CharCode.OpenSquareBracket */ && lastCharCodeInLink === 93 /* CharCode.CloseSquareBracket */)
+                || (charCodeBeforeLink === 123 /* CharCode.OpenCurlyBrace */ && lastCharCodeInLink === 125 /* CharCode.CloseCurlyBrace */)) {
+                // Do not end in ) if ( is before the link start
+                // Do not end in ] if [ is before the link start
+                // Do not end in } if { is before the link start
+                lastIncludedCharIndex--;
+            }
+        }
+        return {
+            range: {
+                startLineNumber: lineNumber,
+                startColumn: linkBeginIndex + 1,
+                endLineNumber: lineNumber,
+                endColumn: lastIncludedCharIndex + 2
+            },
+            url: line.substring(linkBeginIndex, lastIncludedCharIndex + 1)
+        };
+    }
+    static computeLinks(model, stateMachine = getStateMachine()) {
+        const classifier = getClassifier();
+        const result = [];
+        for (let i = 1, lineCount = model.getLineCount(); i <= lineCount; i++) {
+            const line = model.getLineContent(i);
+            const len = line.length;
+            let j = 0;
+            let linkBeginIndex = 0;
+            let linkBeginChCode = 0;
+            let state = 1 /* State.Start */;
+            let hasOpenParens = false;
+            let hasOpenSquareBracket = false;
+            let inSquareBrackets = false;
+            let hasOpenCurlyBracket = false;
+            while (j < len) {
+                let resetStateMachine = false;
+                const chCode = line.charCodeAt(j);
+                if (state === 13 /* State.Accept */) {
+                    let chClass;
+                    switch (chCode) {
+                        case 40 /* CharCode.OpenParen */:
+                            hasOpenParens = true;
+                            chClass = 0 /* CharacterClass.None */;
+                            break;
+                        case 41 /* CharCode.CloseParen */:
+                            chClass = (hasOpenParens ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);
+                            break;
+                        case 91 /* CharCode.OpenSquareBracket */:
+                            inSquareBrackets = true;
+                            hasOpenSquareBracket = true;
+                            chClass = 0 /* CharacterClass.None */;
+                            break;
+                        case 93 /* CharCode.CloseSquareBracket */:
+                            inSquareBrackets = false;
+                            chClass = (hasOpenSquareBracket ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);
+                            break;
+                        case 123 /* CharCode.OpenCurlyBrace */:
+                            hasOpenCurlyBracket = true;
+                            chClass = 0 /* CharacterClass.None */;
+                            break;
+                        case 125 /* CharCode.CloseCurlyBrace */:
+                            chClass = (hasOpenCurlyBracket ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);
+                            break;
+                        // The following three rules make it that ' or " or ` are allowed inside links
+                        // only if the link is wrapped by some other quote character
+                        case 39 /* CharCode.SingleQuote */:
+                        case 34 /* CharCode.DoubleQuote */:
+                        case 96 /* CharCode.BackTick */:
+                            if (linkBeginChCode === chCode) {
+                                chClass = 1 /* CharacterClass.ForceTermination */;
+                            }
+                            else if (linkBeginChCode === 39 /* CharCode.SingleQuote */ || linkBeginChCode === 34 /* CharCode.DoubleQuote */ || linkBeginChCode === 96 /* CharCode.BackTick */) {
+                                chClass = 0 /* CharacterClass.None */;
+                            }
+                            else {
+                                chClass = 1 /* CharacterClass.ForceTermination */;
+                            }
+                            break;
+                        case 42 /* CharCode.Asterisk */:
+                            // `*` terminates a link if the link began with `*`
+                            chClass = (linkBeginChCode === 42 /* CharCode.Asterisk */) ? 1 /* CharacterClass.ForceTermination */ : 0 /* CharacterClass.None */;
+                            break;
+                        case 32 /* CharCode.Space */:
+                            // ` ` allow space in between [ and ]
+                            chClass = (inSquareBrackets ? 0 /* CharacterClass.None */ : 1 /* CharacterClass.ForceTermination */);
+                            break;
+                        default:
+                            chClass = classifier.get(chCode);
+                    }
+                    // Check if character terminates link
+                    if (chClass === 1 /* CharacterClass.ForceTermination */) {
+                        result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, j));
+                        resetStateMachine = true;
+                    }
+                }
+                else if (state === 12 /* State.End */) {
+                    let chClass;
+                    if (chCode === 91 /* CharCode.OpenSquareBracket */) {
+                        // Allow for the authority part to contain ipv6 addresses which contain [ and ]
+                        hasOpenSquareBracket = true;
+                        chClass = 0 /* CharacterClass.None */;
+                    }
+                    else {
+                        chClass = classifier.get(chCode);
+                    }
+                    // Check if character terminates link
+                    if (chClass === 1 /* CharacterClass.ForceTermination */) {
+                        resetStateMachine = true;
+                    }
+                    else {
+                        state = 13 /* State.Accept */;
+                    }
+                }
+                else {
+                    state = stateMachine.nextState(state, chCode);
+                    if (state === 0 /* State.Invalid */) {
+                        resetStateMachine = true;
+                    }
+                }
+                if (resetStateMachine) {
+                    state = 1 /* State.Start */;
+                    hasOpenParens = false;
+                    hasOpenSquareBracket = false;
+                    hasOpenCurlyBracket = false;
+                    // Record where the link started
+                    linkBeginIndex = j + 1;
+                    linkBeginChCode = chCode;
+                }
+                j++;
+            }
+            if (state === 13 /* State.Accept */) {
+                result.push(LinkComputer._createLink(classifier, line, i, linkBeginIndex, len));
+            }
+        }
+        return result;
+    }
+}
+/**
+ * Returns an array of all links contains in the provided
+ * document. *Note* that this operation is computational
+ * expensive and should not run in the UI thread.
+ */
+function computeLinks(model) {
+    if (!model || typeof model.getLineCount !== 'function' || typeof model.getLineContent !== 'function') {
+        // Unknown caller!
+        return [];
+    }
+    return LinkComputer.computeLinks(model);
+}
+
+export { LinkComputer, StateMachine, computeLinks };

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

@@ -0,0 +1,9 @@
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const IMarkerDecorationsService = createDecorator('markerDecorationsService');
+
+export { IMarkerDecorationsService };