@codingame/monaco-vscode-api 1.85.4 → 2.0.0-rework-ci.1

package/vscode/src/vs/editor/common/config/editorZoom.js

@@ -0,0 +1,20 @@
+import { Emitter } from '../../../base/common/event.js';
+const EditorZoom = new (class {
+    constructor() {
+        this._zoomLevel = 0;
+        this._onDidChangeZoomLevel = ( new Emitter());
+        this.onDidChangeZoomLevel = this._onDidChangeZoomLevel.event;
+    }
+    getZoomLevel() {
+        return this._zoomLevel;
+    }
+    setZoomLevel(zoomLevel) {
+        zoomLevel = Math.min(Math.max(-5, zoomLevel), 20);
+        if (this._zoomLevel === zoomLevel) {
+            return;
+        }
+        this._zoomLevel = zoomLevel;
+        this._onDidChangeZoomLevel.fire(this._zoomLevel);
+    }
+});
+export { EditorZoom };

package/vscode/src/vs/editor/common/config/fontInfo.js

@@ -0,0 +1,127 @@
+import { isMacintosh } from '../../../base/common/platform.js';
+import { EditorOptions, EditorFontVariations, EDITOR_FONT_DEFAULTS } from './editorOptions.js';
+import { EditorZoom } from './editorZoom.js';
+const GOLDEN_LINE_HEIGHT_RATIO = isMacintosh ? 1.5 : 1.35;
+const MINIMUM_LINE_HEIGHT = 8;
+class BareFontInfo {
+    static createFromValidatedSettings(options, pixelRatio, ignoreEditorZoom) {
+        const fontFamily = options.get(49 );
+        const fontWeight = options.get(53 );
+        const fontSize = options.get(52 );
+        const fontFeatureSettings = options.get(51 );
+        const fontVariationSettings = options.get(54 );
+        const lineHeight = options.get(66 );
+        const letterSpacing = options.get(63 );
+        return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
+    }
+    static createFromRawSettings(opts, pixelRatio, ignoreEditorZoom = false) {
+        const fontFamily = EditorOptions.fontFamily.validate(opts.fontFamily);
+        const fontWeight = EditorOptions.fontWeight.validate(opts.fontWeight);
+        const fontSize = EditorOptions.fontSize.validate(opts.fontSize);
+        const fontFeatureSettings = EditorOptions.fontLigatures2.validate(opts.fontLigatures);
+        const fontVariationSettings = EditorOptions.fontVariations.validate(opts.fontVariations);
+        const lineHeight = EditorOptions.lineHeight.validate(opts.lineHeight);
+        const letterSpacing = EditorOptions.letterSpacing.validate(opts.letterSpacing);
+        return BareFontInfo._create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom);
+    }
+    static _create(fontFamily, fontWeight, fontSize, fontFeatureSettings, fontVariationSettings, lineHeight, letterSpacing, pixelRatio, ignoreEditorZoom) {
+        if (lineHeight === 0) {
+            lineHeight = GOLDEN_LINE_HEIGHT_RATIO * fontSize;
+        }
+        else if (lineHeight < MINIMUM_LINE_HEIGHT) {
+            lineHeight = lineHeight * fontSize;
+        }
+        lineHeight = Math.round(lineHeight);
+        if (lineHeight < MINIMUM_LINE_HEIGHT) {
+            lineHeight = MINIMUM_LINE_HEIGHT;
+        }
+        const editorZoomLevelMultiplier = 1 + (ignoreEditorZoom ? 0 : EditorZoom.getZoomLevel() * 0.1);
+        fontSize *= editorZoomLevelMultiplier;
+        lineHeight *= editorZoomLevelMultiplier;
+        if (fontVariationSettings === EditorFontVariations.TRANSLATE) {
+            if (fontWeight === 'normal' || fontWeight === 'bold') {
+                fontVariationSettings = EditorFontVariations.OFF;
+            }
+            else {
+                const fontWeightAsNumber = parseInt(fontWeight, 10);
+                fontVariationSettings = `'wght' ${fontWeightAsNumber}`;
+                fontWeight = 'normal';
+            }
+        }
+        return ( new BareFontInfo({
+            pixelRatio: pixelRatio,
+            fontFamily: fontFamily,
+            fontWeight: fontWeight,
+            fontSize: fontSize,
+            fontFeatureSettings: fontFeatureSettings,
+            fontVariationSettings,
+            lineHeight: lineHeight,
+            letterSpacing: letterSpacing
+        }));
+    }
+    constructor(opts) {
+        this._bareFontInfoBrand = undefined;
+        this.pixelRatio = opts.pixelRatio;
+        this.fontFamily = String(opts.fontFamily);
+        this.fontWeight = String(opts.fontWeight);
+        this.fontSize = opts.fontSize;
+        this.fontFeatureSettings = opts.fontFeatureSettings;
+        this.fontVariationSettings = opts.fontVariationSettings;
+        this.lineHeight = opts.lineHeight | 0;
+        this.letterSpacing = opts.letterSpacing;
+    }
+    getId() {
+        return `${this.pixelRatio}-${this.fontFamily}-${this.fontWeight}-${this.fontSize}-${this.fontFeatureSettings}-${this.fontVariationSettings}-${this.lineHeight}-${this.letterSpacing}`;
+    }
+    getMassagedFontFamily() {
+        const fallbackFontFamily = EDITOR_FONT_DEFAULTS.fontFamily;
+        const fontFamily = BareFontInfo._wrapInQuotes(this.fontFamily);
+        if (fallbackFontFamily && this.fontFamily !== fallbackFontFamily) {
+            return `${fontFamily}, ${fallbackFontFamily}`;
+        }
+        return fontFamily;
+    }
+    static _wrapInQuotes(fontFamily) {
+        if (/[,"']/.test(fontFamily)) {
+            return fontFamily;
+        }
+        if (/[+ ]/.test(fontFamily)) {
+            return `"${fontFamily}"`;
+        }
+        return fontFamily;
+    }
+}
+const SERIALIZED_FONT_INFO_VERSION = 2;
+class FontInfo extends BareFontInfo {
+    constructor(opts, isTrusted) {
+        super(opts);
+        this._editorStylingBrand = undefined;
+        this.version = SERIALIZED_FONT_INFO_VERSION;
+        this.isTrusted = isTrusted;
+        this.isMonospace = opts.isMonospace;
+        this.typicalHalfwidthCharacterWidth = opts.typicalHalfwidthCharacterWidth;
+        this.typicalFullwidthCharacterWidth = opts.typicalFullwidthCharacterWidth;
+        this.canUseHalfwidthRightwardsArrow = opts.canUseHalfwidthRightwardsArrow;
+        this.spaceWidth = opts.spaceWidth;
+        this.middotWidth = opts.middotWidth;
+        this.wsmiddotWidth = opts.wsmiddotWidth;
+        this.maxDigitWidth = opts.maxDigitWidth;
+    }
+    equals(other) {
+        return (this.fontFamily === other.fontFamily
+            && this.fontWeight === other.fontWeight
+            && this.fontSize === other.fontSize
+            && this.fontFeatureSettings === other.fontFeatureSettings
+            && this.fontVariationSettings === other.fontVariationSettings
+            && this.lineHeight === other.lineHeight
+            && this.letterSpacing === other.letterSpacing
+            && this.typicalHalfwidthCharacterWidth === other.typicalHalfwidthCharacterWidth
+            && this.typicalFullwidthCharacterWidth === other.typicalFullwidthCharacterWidth
+            && this.canUseHalfwidthRightwardsArrow === other.canUseHalfwidthRightwardsArrow
+            && this.spaceWidth === other.spaceWidth
+            && this.middotWidth === other.middotWidth
+            && this.wsmiddotWidth === other.wsmiddotWidth
+            && this.maxDigitWidth === other.maxDigitWidth);
+    }
+}
+export { BareFontInfo, FontInfo, SERIALIZED_FONT_INFO_VERSION };

package/vscode/src/vs/editor/common/core/characterClassifier.js

@@ -0,0 +1,50 @@
+import { toUint8 } from '../../../base/common/uint.js';
+class CharacterClassifier {
+    constructor(_defaultValue) {
+        const defaultValue = toUint8(_defaultValue);
+        this._defaultValue = defaultValue;
+        this._asciiMap = CharacterClassifier._createAsciiMap(defaultValue);
+        this._map = ( new Map());
+    }
+    static _createAsciiMap(defaultValue) {
+        const asciiMap = ( new Uint8Array(256));
+        asciiMap.fill(defaultValue);
+        return asciiMap;
+    }
+    set(charCode, _value) {
+        const value = toUint8(_value);
+        if (charCode >= 0 && charCode < 256) {
+            this._asciiMap[charCode] = value;
+        }
+        else {
+            this._map.set(charCode, value);
+        }
+    }
+    get(charCode) {
+        if (charCode >= 0 && charCode < 256) {
+            return this._asciiMap[charCode];
+        }
+        else {
+            return (this._map.get(charCode) || this._defaultValue);
+        }
+    }
+    clear() {
+        this._asciiMap.fill(this._defaultValue);
+        this._map.clear();
+    }
+}
+class CharacterSet {
+    constructor() {
+        this._actual = ( new CharacterClassifier(0 ));
+    }
+    add(charCode) {
+        this._actual.set(charCode, 1 );
+    }
+    has(charCode) {
+        return (this._actual.get(charCode) === 1) ;
+    }
+    clear() {
+        return this._actual.clear();
+    }
+}
+export { CharacterClassifier, CharacterSet };

package/vscode/src/vs/editor/common/core/cursorColumns.js

@@ -0,0 +1,80 @@
+import { isFullWidthCharacter, isEmojiImprecise, getNextCodePoint, GraphemeIterator, CodePointIterator } from '../../../base/common/strings.js';
+class CursorColumns {
+    static _nextVisibleColumn(codePoint, visibleColumn, tabSize) {
+        if (codePoint === 9 ) {
+            return CursorColumns.nextRenderTabStop(visibleColumn, tabSize);
+        }
+        if (isFullWidthCharacter(codePoint) || isEmojiImprecise(codePoint)) {
+            return visibleColumn + 2;
+        }
+        return visibleColumn + 1;
+    }
+    static visibleColumnFromColumn(lineContent, column, tabSize) {
+        const textLen = Math.min(column - 1, lineContent.length);
+        const text = lineContent.substring(0, textLen);
+        const iterator = new GraphemeIterator(text);
+        let result = 0;
+        while (!iterator.eol()) {
+            const codePoint = getNextCodePoint(text, textLen, iterator.offset);
+            iterator.nextGraphemeLength();
+            result = this._nextVisibleColumn(codePoint, result, tabSize);
+        }
+        return result;
+    }
+    static toStatusbarColumn(lineContent, column, tabSize) {
+        const text = lineContent.substring(0, Math.min(column - 1, lineContent.length));
+        const iterator = new CodePointIterator(text);
+        let result = 0;
+        while (!iterator.eol()) {
+            const codePoint = iterator.nextCodePoint();
+            if (codePoint === 9 ) {
+                result = CursorColumns.nextRenderTabStop(result, tabSize);
+            }
+            else {
+                result = result + 1;
+            }
+        }
+        return result + 1;
+    }
+    static columnFromVisibleColumn(lineContent, visibleColumn, tabSize) {
+        if (visibleColumn <= 0) {
+            return 1;
+        }
+        const lineContentLength = lineContent.length;
+        const iterator = new GraphemeIterator(lineContent);
+        let beforeVisibleColumn = 0;
+        let beforeColumn = 1;
+        while (!iterator.eol()) {
+            const codePoint = getNextCodePoint(lineContent, lineContentLength, iterator.offset);
+            iterator.nextGraphemeLength();
+            const afterVisibleColumn = this._nextVisibleColumn(codePoint, beforeVisibleColumn, tabSize);
+            const afterColumn = iterator.offset + 1;
+            if (afterVisibleColumn >= visibleColumn) {
+                const beforeDelta = visibleColumn - beforeVisibleColumn;
+                const afterDelta = afterVisibleColumn - visibleColumn;
+                if (afterDelta < beforeDelta) {
+                    return afterColumn;
+                }
+                else {
+                    return beforeColumn;
+                }
+            }
+            beforeVisibleColumn = afterVisibleColumn;
+            beforeColumn = afterColumn;
+        }
+        return lineContentLength + 1;
+    }
+    static nextRenderTabStop(visibleColumn, tabSize) {
+        return visibleColumn + tabSize - visibleColumn % tabSize;
+    }
+    static nextIndentTabStop(visibleColumn, indentSize) {
+        return visibleColumn + indentSize - visibleColumn % indentSize;
+    }
+    static prevRenderTabStop(column, tabSize) {
+        return Math.max(0, column - 1 - (column - 1) % tabSize);
+    }
+    static prevIndentTabStop(column, indentSize) {
+        return Math.max(0, column - 1 - (column - 1) % indentSize);
+    }
+}
+export { CursorColumns };

package/vscode/src/vs/editor/common/core/editOperation.js

@@ -0,0 +1,30 @@
+import { Range } from './range.js';
+class EditOperation {
+    static insert(position, text) {
+        return {
+            range: ( new Range(position.lineNumber, position.column, position.lineNumber, position.column)),
+            text: text,
+            forceMoveMarkers: true
+        };
+    }
+    static delete(range) {
+        return {
+            range: range,
+            text: null
+        };
+    }
+    static replace(range, text) {
+        return {
+            range: range,
+            text: text
+        };
+    }
+    static replaceMove(range, text) {
+        return {
+            range: range,
+            text: text,
+            forceMoveMarkers: true
+        };
+    }
+}
+export { EditOperation };