monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,205 +0,0 @@
-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

@@ -1,269 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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 };