monaco-editor11 1.0.7 → 1.0.9

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

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

@@ -0,0 +1,62 @@
+/*---------------------------------------------------------------------------------------------
+ *  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

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

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

@@ -0,0 +1,180 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 };