monaco-editor11 1.0.9 → 1.1.0

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

@@ -1,188 +0,0 @@
-import { Range } from '../core/range.js';
-import { Searcher } from '../model/textModelSearch.js';
-import { isHighSurrogate, AmbiguousCharacters, InvisibleCharacters, escapeRegExpCharacters, isBasicASCII } from '../../../base/common/strings.js';
-import { assertNever } from '../../../base/common/assert.js';
-import { getWordAtText, DEFAULT_WORD_REGEXP } from '../core/wordHelper.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class UnicodeTextModelHighlighter {
-    static computeUnicodeHighlights(model, options, range) {
-        const startLine = range ? range.startLineNumber : 1;
-        const endLine = range ? range.endLineNumber : model.getLineCount();
-        const codePointHighlighter = new CodePointHighlighter(options);
-        const candidates = codePointHighlighter.getCandidateCodePoints();
-        let regex;
-        if (candidates === 'allNonBasicAscii') {
-            regex = new RegExp('[^\\t\\n\\r\\x20-\\x7E]', 'g');
-        }
-        else {
-            regex = new RegExp(`${buildRegExpCharClassExpr(Array.from(candidates))}`, 'g');
-        }
-        const searcher = new Searcher(null, regex);
-        const ranges = [];
-        let hasMore = false;
-        let m;
-        let ambiguousCharacterCount = 0;
-        let invisibleCharacterCount = 0;
-        let nonBasicAsciiCharacterCount = 0;
-        forLoop: for (let lineNumber = startLine, lineCount = endLine; lineNumber <= lineCount; lineNumber++) {
-            const lineContent = model.getLineContent(lineNumber);
-            const lineLength = lineContent.length;
-            // Reset regex to search from the beginning
-            searcher.reset(0);
-            do {
-                m = searcher.next(lineContent);
-                if (m) {
-                    let startIndex = m.index;
-                    let endIndex = m.index + m[0].length;
-                    // Extend range to entire code point
-                    if (startIndex > 0) {
-                        const charCodeBefore = lineContent.charCodeAt(startIndex - 1);
-                        if (isHighSurrogate(charCodeBefore)) {
-                            startIndex--;
-                        }
-                    }
-                    if (endIndex + 1 < lineLength) {
-                        const charCodeBefore = lineContent.charCodeAt(endIndex - 1);
-                        if (isHighSurrogate(charCodeBefore)) {
-                            endIndex++;
-                        }
-                    }
-                    const str = lineContent.substring(startIndex, endIndex);
-                    let word = getWordAtText(startIndex + 1, DEFAULT_WORD_REGEXP, lineContent, 0);
-                    if (word && word.endColumn <= startIndex + 1) {
-                        // The word does not include the problematic character, ignore the word
-                        word = null;
-                    }
-                    const highlightReason = codePointHighlighter.shouldHighlightNonBasicASCII(str, word ? word.word : null);
-                    if (highlightReason !== 0 /* SimpleHighlightReason.None */) {
-                        if (highlightReason === 3 /* SimpleHighlightReason.Ambiguous */) {
-                            ambiguousCharacterCount++;
-                        }
-                        else if (highlightReason === 2 /* SimpleHighlightReason.Invisible */) {
-                            invisibleCharacterCount++;
-                        }
-                        else if (highlightReason === 1 /* SimpleHighlightReason.NonBasicASCII */) {
-                            nonBasicAsciiCharacterCount++;
-                        }
-                        else {
-                            assertNever();
-                        }
-                        const MAX_RESULT_LENGTH = 1000;
-                        if (ranges.length >= MAX_RESULT_LENGTH) {
-                            hasMore = true;
-                            break forLoop;
-                        }
-                        ranges.push(new Range(lineNumber, startIndex + 1, lineNumber, endIndex + 1));
-                    }
-                }
-            } while (m);
-        }
-        return {
-            ranges,
-            hasMore,
-            ambiguousCharacterCount,
-            invisibleCharacterCount,
-            nonBasicAsciiCharacterCount
-        };
-    }
-    static computeUnicodeHighlightReason(char, options) {
-        const codePointHighlighter = new CodePointHighlighter(options);
-        const reason = codePointHighlighter.shouldHighlightNonBasicASCII(char, null);
-        switch (reason) {
-            case 0 /* SimpleHighlightReason.None */:
-                return null;
-            case 2 /* SimpleHighlightReason.Invisible */:
-                return { kind: 1 /* UnicodeHighlighterReasonKind.Invisible */ };
-            case 3 /* SimpleHighlightReason.Ambiguous */: {
-                const codePoint = char.codePointAt(0);
-                const primaryConfusable = codePointHighlighter.ambiguousCharacters.getPrimaryConfusable(codePoint);
-                const notAmbiguousInLocales = AmbiguousCharacters.getLocales().filter((l) => !AmbiguousCharacters.getInstance(new Set([...options.allowedLocales, l])).isAmbiguous(codePoint));
-                return { kind: 0 /* UnicodeHighlighterReasonKind.Ambiguous */, confusableWith: String.fromCodePoint(primaryConfusable), notAmbiguousInLocales };
-            }
-            case 1 /* SimpleHighlightReason.NonBasicASCII */:
-                return { kind: 2 /* UnicodeHighlighterReasonKind.NonBasicAscii */ };
-        }
-    }
-}
-function buildRegExpCharClassExpr(codePoints, flags) {
-    const src = `[${escapeRegExpCharacters(codePoints.map((i) => String.fromCodePoint(i)).join(''))}]`;
-    return src;
-}
-class CodePointHighlighter {
-    constructor(options) {
-        this.options = options;
-        this.allowedCodePoints = new Set(options.allowedCodePoints);
-        this.ambiguousCharacters = AmbiguousCharacters.getInstance(new Set(options.allowedLocales));
-    }
-    getCandidateCodePoints() {
-        if (this.options.nonBasicASCII) {
-            return 'allNonBasicAscii';
-        }
-        const set = new Set();
-        if (this.options.invisibleCharacters) {
-            for (const cp of InvisibleCharacters.codePoints) {
-                if (!isAllowedInvisibleCharacter(String.fromCodePoint(cp))) {
-                    set.add(cp);
-                }
-            }
-        }
-        if (this.options.ambiguousCharacters) {
-            for (const cp of this.ambiguousCharacters.getConfusableCodePoints()) {
-                set.add(cp);
-            }
-        }
-        for (const cp of this.allowedCodePoints) {
-            set.delete(cp);
-        }
-        return set;
-    }
-    shouldHighlightNonBasicASCII(character, wordContext) {
-        const codePoint = character.codePointAt(0);
-        if (this.allowedCodePoints.has(codePoint)) {
-            return 0 /* SimpleHighlightReason.None */;
-        }
-        if (this.options.nonBasicASCII) {
-            return 1 /* SimpleHighlightReason.NonBasicASCII */;
-        }
-        let hasBasicASCIICharacters = false;
-        let hasNonConfusableNonBasicAsciiCharacter = false;
-        if (wordContext) {
-            for (const char of wordContext) {
-                const codePoint = char.codePointAt(0);
-                const isBasicASCII$1 = isBasicASCII(char);
-                hasBasicASCIICharacters = hasBasicASCIICharacters || isBasicASCII$1;
-                if (!isBasicASCII$1 &&
-                    !this.ambiguousCharacters.isAmbiguous(codePoint) &&
-                    !InvisibleCharacters.isInvisibleCharacter(codePoint)) {
-                    hasNonConfusableNonBasicAsciiCharacter = true;
-                }
-            }
-        }
-        if (
-        /* Don't allow mixing weird looking characters with ASCII */ !hasBasicASCIICharacters &&
-            /* Is there an obviously weird looking character? */ hasNonConfusableNonBasicAsciiCharacter) {
-            return 0 /* SimpleHighlightReason.None */;
-        }
-        if (this.options.invisibleCharacters) {
-            // TODO check for emojis
-            if (!isAllowedInvisibleCharacter(character) && InvisibleCharacters.isInvisibleCharacter(codePoint)) {
-                return 2 /* SimpleHighlightReason.Invisible */;
-            }
-        }
-        if (this.options.ambiguousCharacters) {
-            if (this.ambiguousCharacters.isAmbiguous(codePoint)) {
-                return 3 /* SimpleHighlightReason.Ambiguous */;
-            }
-        }
-        return 0 /* SimpleHighlightReason.None */;
-    }
-}
-function isAllowedInvisibleCharacter(character) {
-    return character === ' ' || character === '\n' || character === '\t';
-}
-
-export { UnicodeTextModelHighlighter };

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

@@ -1,62 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class Array2D {
-    constructor(width, height) {
-        this.width = width;
-        this.height = height;
-        this.array = [];
-        this.array = new Array(width * height);
-    }
-    get(x, y) {
-        return this.array[x + y * this.width];
-    }
-    set(x, y, value) {
-        this.array[x + y * this.width] = value;
-    }
-}
-function isSpace(charCode) {
-    return charCode === 32 /* CharCode.Space */ || charCode === 9 /* CharCode.Tab */;
-}
-class LineRangeFragment {
-    static { this.chrKeys = new Map(); }
-    static getKey(chr) {
-        let key = this.chrKeys.get(chr);
-        if (key === undefined) {
-            key = this.chrKeys.size;
-            this.chrKeys.set(chr, key);
-        }
-        return key;
-    }
-    constructor(range, lines, source) {
-        this.range = range;
-        this.lines = lines;
-        this.source = source;
-        this.histogram = [];
-        let counter = 0;
-        for (let i = range.startLineNumber - 1; i < range.endLineNumberExclusive - 1; i++) {
-            const line = lines[i];
-            for (let j = 0; j < line.length; j++) {
-                counter++;
-                const chr = line[j];
-                const key = LineRangeFragment.getKey(chr);
-                this.histogram[key] = (this.histogram[key] || 0) + 1;
-            }
-            counter++;
-            const key = LineRangeFragment.getKey('\n');
-            this.histogram[key] = (this.histogram[key] || 0) + 1;
-        }
-        this.totalCount = counter;
-    }
-    computeSimilarity(other) {
-        let sumDifferences = 0;
-        const maxLength = Math.max(this.histogram.length, other.histogram.length);
-        for (let i = 0; i < maxLength; i++) {
-            sumDifferences += Math.abs((this.histogram[i] ?? 0) - (other.histogram[i] ?? 0));
-        }
-        return 1 - (sumDifferences / (this.totalCount + other.totalCount));
-    }
-}
-
-export { Array2D, LineRangeFragment, isSpace };

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

@@ -1,22 +0,0 @@
-import { EditorTheme } from '../editorTheme.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class ViewContext {
-    constructor(configuration, theme, model) {
-        this.configuration = configuration;
-        this.theme = new EditorTheme(theme);
-        this.viewModel = model;
-        this.viewLayout = model.viewLayout;
-    }
-    addEventHandler(eventHandler) {
-        this.viewModel.addViewEventHandler(eventHandler);
-    }
-    removeEventHandler(eventHandler) {
-        this.viewModel.removeViewEventHandler(eventHandler);
-    }
-}
-
-export { ViewContext };

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

@@ -1,186 +0,0 @@
-import { Disposable } from '../../base/common/lifecycle.js';
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class ViewEventHandler extends Disposable {
-    constructor() {
-        super();
-        this._shouldRender = true;
-    }
-    shouldRender() {
-        return this._shouldRender;
-    }
-    forceShouldRender() {
-        this._shouldRender = true;
-    }
-    setShouldRender() {
-        this._shouldRender = true;
-    }
-    onDidRender() {
-        this._shouldRender = false;
-    }
-    // --- begin event handlers
-    onCompositionStart(e) {
-        return false;
-    }
-    onCompositionEnd(e) {
-        return false;
-    }
-    onConfigurationChanged(e) {
-        return false;
-    }
-    onCursorStateChanged(e) {
-        return false;
-    }
-    onDecorationsChanged(e) {
-        return false;
-    }
-    onFlushed(e) {
-        return false;
-    }
-    onFocusChanged(e) {
-        return false;
-    }
-    onLanguageConfigurationChanged(e) {
-        return false;
-    }
-    onLineMappingChanged(e) {
-        return false;
-    }
-    onLinesChanged(e) {
-        return false;
-    }
-    onLinesDeleted(e) {
-        return false;
-    }
-    onLinesInserted(e) {
-        return false;
-    }
-    onRevealRangeRequest(e) {
-        return false;
-    }
-    onScrollChanged(e) {
-        return false;
-    }
-    onThemeChanged(e) {
-        return false;
-    }
-    onTokensChanged(e) {
-        return false;
-    }
-    onTokensColorsChanged(e) {
-        return false;
-    }
-    onZonesChanged(e) {
-        return false;
-    }
-    // --- end event handlers
-    handleEvents(events) {
-        let shouldRender = false;
-        for (let i = 0, len = events.length; i < len; i++) {
-            const e = events[i];
-            switch (e.type) {
-                case 0 /* viewEvents.ViewEventType.ViewCompositionStart */:
-                    if (this.onCompositionStart(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 1 /* viewEvents.ViewEventType.ViewCompositionEnd */:
-                    if (this.onCompositionEnd(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 2 /* viewEvents.ViewEventType.ViewConfigurationChanged */:
-                    if (this.onConfigurationChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 3 /* viewEvents.ViewEventType.ViewCursorStateChanged */:
-                    if (this.onCursorStateChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 4 /* viewEvents.ViewEventType.ViewDecorationsChanged */:
-                    if (this.onDecorationsChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 5 /* viewEvents.ViewEventType.ViewFlushed */:
-                    if (this.onFlushed(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 6 /* viewEvents.ViewEventType.ViewFocusChanged */:
-                    if (this.onFocusChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 7 /* viewEvents.ViewEventType.ViewLanguageConfigurationChanged */:
-                    if (this.onLanguageConfigurationChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 8 /* viewEvents.ViewEventType.ViewLineMappingChanged */:
-                    if (this.onLineMappingChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 9 /* viewEvents.ViewEventType.ViewLinesChanged */:
-                    if (this.onLinesChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 10 /* viewEvents.ViewEventType.ViewLinesDeleted */:
-                    if (this.onLinesDeleted(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 11 /* viewEvents.ViewEventType.ViewLinesInserted */:
-                    if (this.onLinesInserted(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 12 /* viewEvents.ViewEventType.ViewRevealRangeRequest */:
-                    if (this.onRevealRangeRequest(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 13 /* viewEvents.ViewEventType.ViewScrollChanged */:
-                    if (this.onScrollChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 15 /* viewEvents.ViewEventType.ViewTokensChanged */:
-                    if (this.onTokensChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 14 /* viewEvents.ViewEventType.ViewThemeChanged */:
-                    if (this.onThemeChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 16 /* viewEvents.ViewEventType.ViewTokensColorsChanged */:
-                    if (this.onTokensColorsChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                case 17 /* viewEvents.ViewEventType.ViewZonesChanged */:
-                    if (this.onZonesChanged(e)) {
-                        shouldRender = true;
-                    }
-                    break;
-                default:
-                    console.info('View received unknown event: ');
-                    console.info(e);
-            }
-        }
-        if (shouldRender) {
-            this._shouldRender = true;
-        }
-    }
-}
-
-export { ViewEventHandler };

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

@@ -1,180 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-class ViewCompositionStartEvent {
-    constructor() {
-        this.type = 0 /* ViewEventType.ViewCompositionStart */;
-    }
-}
-class ViewCompositionEndEvent {
-    constructor() {
-        this.type = 1 /* ViewEventType.ViewCompositionEnd */;
-    }
-}
-class ViewConfigurationChangedEvent {
-    constructor(source) {
-        this.type = 2 /* ViewEventType.ViewConfigurationChanged */;
-        this._source = source;
-    }
-    hasChanged(id) {
-        return this._source.hasChanged(id);
-    }
-}
-class ViewCursorStateChangedEvent {
-    constructor(selections, modelSelections, reason) {
-        this.selections = selections;
-        this.modelSelections = modelSelections;
-        this.reason = reason;
-        this.type = 3 /* ViewEventType.ViewCursorStateChanged */;
-    }
-}
-class ViewDecorationsChangedEvent {
-    constructor(source) {
-        this.type = 4 /* ViewEventType.ViewDecorationsChanged */;
-        if (source) {
-            this.affectsMinimap = source.affectsMinimap;
-            this.affectsOverviewRuler = source.affectsOverviewRuler;
-            this.affectsGlyphMargin = source.affectsGlyphMargin;
-            this.affectsLineNumber = source.affectsLineNumber;
-        }
-        else {
-            this.affectsMinimap = true;
-            this.affectsOverviewRuler = true;
-            this.affectsGlyphMargin = true;
-            this.affectsLineNumber = true;
-        }
-    }
-}
-class ViewFlushedEvent {
-    constructor() {
-        this.type = 5 /* ViewEventType.ViewFlushed */;
-        // Nothing to do
-    }
-}
-class ViewFocusChangedEvent {
-    constructor(isFocused) {
-        this.type = 6 /* ViewEventType.ViewFocusChanged */;
-        this.isFocused = isFocused;
-    }
-}
-class ViewLanguageConfigurationEvent {
-    constructor() {
-        this.type = 7 /* ViewEventType.ViewLanguageConfigurationChanged */;
-    }
-}
-class ViewLineMappingChangedEvent {
-    constructor() {
-        this.type = 8 /* ViewEventType.ViewLineMappingChanged */;
-        // Nothing to do
-    }
-}
-class ViewLinesChangedEvent {
-    constructor(
-    /**
-     * The first line that has changed.
-     */
-    fromLineNumber, 
-    /**
-     * The number of lines that have changed.
-     */
-    count) {
-        this.fromLineNumber = fromLineNumber;
-        this.count = count;
-        this.type = 9 /* ViewEventType.ViewLinesChanged */;
-    }
-}
-class ViewLinesDeletedEvent {
-    constructor(fromLineNumber, toLineNumber) {
-        this.type = 10 /* ViewEventType.ViewLinesDeleted */;
-        this.fromLineNumber = fromLineNumber;
-        this.toLineNumber = toLineNumber;
-    }
-}
-class ViewLinesInsertedEvent {
-    constructor(fromLineNumber, toLineNumber) {
-        this.type = 11 /* ViewEventType.ViewLinesInserted */;
-        this.fromLineNumber = fromLineNumber;
-        this.toLineNumber = toLineNumber;
-    }
-}
-class ViewRevealRangeRequestEvent {
-    constructor(
-    /**
-     * Source of the call that caused the event.
-     */
-    source, 
-    /**
-     * Reduce the revealing to a minimum (e.g. avoid scrolling if the bounding box is visible and near the viewport edge).
-     */
-    minimalReveal, 
-    /**
-     * Range to be reavealed.
-     */
-    range, 
-    /**
-     * Selections to be revealed.
-     */
-    selections, 
-    /**
-     * The vertical reveal strategy.
-     */
-    verticalType, 
-    /**
-     * If true: there should be a horizontal & vertical revealing.
-     * If false: there should be just a vertical revealing.
-     */
-    revealHorizontal, 
-    /**
-     * The scroll type.
-     */
-    scrollType) {
-        this.source = source;
-        this.minimalReveal = minimalReveal;
-        this.range = range;
-        this.selections = selections;
-        this.verticalType = verticalType;
-        this.revealHorizontal = revealHorizontal;
-        this.scrollType = scrollType;
-        this.type = 12 /* ViewEventType.ViewRevealRangeRequest */;
-    }
-}
-class ViewScrollChangedEvent {
-    constructor(source) {
-        this.type = 13 /* ViewEventType.ViewScrollChanged */;
-        this.scrollWidth = source.scrollWidth;
-        this.scrollLeft = source.scrollLeft;
-        this.scrollHeight = source.scrollHeight;
-        this.scrollTop = source.scrollTop;
-        this.scrollWidthChanged = source.scrollWidthChanged;
-        this.scrollLeftChanged = source.scrollLeftChanged;
-        this.scrollHeightChanged = source.scrollHeightChanged;
-        this.scrollTopChanged = source.scrollTopChanged;
-    }
-}
-class ViewThemeChangedEvent {
-    constructor(theme) {
-        this.theme = theme;
-        this.type = 14 /* ViewEventType.ViewThemeChanged */;
-    }
-}
-class ViewTokensChangedEvent {
-    constructor(ranges) {
-        this.type = 15 /* ViewEventType.ViewTokensChanged */;
-        this.ranges = ranges;
-    }
-}
-class ViewTokensColorsChangedEvent {
-    constructor() {
-        this.type = 16 /* ViewEventType.ViewTokensColorsChanged */;
-        // Nothing to do
-    }
-}
-class ViewZonesChangedEvent {
-    constructor() {
-        this.type = 17 /* ViewEventType.ViewZonesChanged */;
-        // Nothing to do
-    }
-}
-
-export { ViewCompositionEndEvent, ViewCompositionStartEvent, ViewConfigurationChangedEvent, ViewCursorStateChangedEvent, ViewDecorationsChangedEvent, ViewFlushedEvent, ViewFocusChangedEvent, ViewLanguageConfigurationEvent, ViewLineMappingChangedEvent, ViewLinesChangedEvent, ViewLinesDeletedEvent, ViewLinesInsertedEvent, ViewRevealRangeRequestEvent, ViewScrollChangedEvent, ViewThemeChangedEvent, ViewTokensChangedEvent, ViewTokensColorsChangedEvent, ViewZonesChangedEvent };