@codingame/monaco-vscode-api 16.1.1 → 17.1.0

package/vscode/src/vs/base/common/observableInternal/logging/logging.d.ts

@@ -21,8 +21,8 @@ export interface IObservableLogger {
     handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
     handleAutorunStarted(autorun: AutorunObserver): void;
     handleAutorunFinished(autorun: AutorunObserver): void;
-    handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void;
-    handleDerivedCleared(observable: Derived<any>): void;
+    handleDerivedDependencyChanged(derived: Derived<any, any, any>, observable: IObservable<any>, change: unknown): void;
+    handleDerivedCleared(observable: Derived<any, any, any>): void;
     handleBeginTransaction(transaction: TransactionImpl): void;
     handleEndTransaction(transaction: TransactionImpl): void;
 }

package/vscode/src/vs/base/common/observableInternal/promise.d.ts

@@ -0,0 +1,28 @@
+import { IObservable } from "./base.js";
+export declare class ObservableLazy<T> {
+    private readonly _computeValue;
+    private readonly _value;
+    get cachedValue(): IObservable<T | undefined>;
+    constructor(_computeValue: () => T);
+    getValue(): T;
+}
+export declare class ObservablePromise<T> {
+    static fromFn<T>(fn: () => Promise<T>): ObservablePromise<T>;
+    private readonly _value;
+    readonly promise: Promise<T>;
+    readonly promiseResult: IObservable<PromiseResult<T> | undefined>;
+    constructor(promise: Promise<T>);
+}
+export declare class PromiseResult<T> {
+    readonly data: T | undefined;
+    readonly error: unknown | undefined;
+    constructor(data: T | undefined, error: unknown | undefined);
+    getDataOrThrow(): T;
+}
+export declare class ObservableLazyPromise<T> {
+    private readonly _computePromise;
+    private readonly _lazyValue;
+    readonly cachedPromiseResult: IObservable<PromiseResult<T> | undefined>;
+    constructor(_computePromise: () => Promise<T>);
+    getPromise(): Promise<T>;
+}

package/vscode/src/vs/base/common/observableInternal/promise.js

@@ -0,0 +1,65 @@
+
+import { observableValue, transaction } from './base.js';
+import { derived } from './derived.js';
+
+class ObservableLazy {
+    get cachedValue() { return this._value; }
+    constructor(_computeValue) {
+        this._computeValue = _computeValue;
+        this._value = observableValue(this, undefined);
+    }
+    getValue() {
+        let v = this._value.get();
+        if (!v) {
+            v = this._computeValue();
+            this._value.set(v, undefined);
+        }
+        return v;
+    }
+}
+class ObservablePromise {
+    static fromFn(fn) {
+        return ( new ObservablePromise(fn()));
+    }
+    constructor(promise) {
+        this._value = observableValue(this, undefined);
+        this.promiseResult = this._value;
+        this.promise = promise.then(value => {
+            transaction(tx => {
+                this._value.set(( new PromiseResult(value, undefined)), tx);
+            });
+            return value;
+        }, error => {
+            transaction(tx => {
+                this._value.set(( new PromiseResult(undefined, error)), tx);
+            });
+            throw error;
+        });
+    }
+}
+class PromiseResult {
+    constructor(
+    data,
+    error) {
+        this.data = data;
+        this.error = error;
+    }
+    getDataOrThrow() {
+        if (this.error) {
+            throw this.error;
+        }
+        return this.data;
+    }
+}
+class ObservableLazyPromise {
+    constructor(_computePromise) {
+        this._computePromise = _computePromise;
+        this._lazyValue = ( new ObservableLazy(() => ( new ObservablePromise(this._computePromise()))));
+        this.cachedPromiseResult = derived(this, reader => this._lazyValue.cachedValue.read(reader)?.promiseResult.read(reader));
+    }
+    getPromise() {
+        return this._lazyValue.getValue().promise;
+    }
+}
+
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult };

package/vscode/src/vs/base/common/observableInternal/reducer.d.ts

@@ -0,0 +1,16 @@
+import { EqualityComparer } from "../equals.js";
+import { IObservable, IObservableWithChange, ISettableObservable } from "./base.js";
+import { IChangeTracker } from "./changeTracker.js";
+import { DebugOwner } from "./debugName.js";
+import { IDerivedReader } from "./derived.js";
+export interface IReducerOptions<T, TChangeSummary = void, TOutChange = void> {
+    initial: T | (() => T);
+    disposeFinal?(value: T): void;
+    changeTracker?: IChangeTracker<TChangeSummary>;
+    equalityComparer?: EqualityComparer<T>;
+    update(reader: IDerivedReader<TOutChange>, previousValue: T, changes: TChangeSummary): T;
+}
+export declare function observableReducer<T, TInChanges, TOutChange = void>(owner: DebugOwner, options: IReducerOptions<T, TInChanges, TOutChange>): SimplifyObservableWithChange<T, TOutChange>;
+export declare function observableReducerSettable<T, TInChanges, TOutChange = void>(owner: DebugOwner, options: IReducerOptions<T, TInChanges, TOutChange>): ISettableObservable<T, TOutChange>;
+type SimplifyObservableWithChange<T, TChange> = TChange extends void ? IObservable<T> : IObservableWithChange<T, TChange>;
+export {};

package/vscode/src/vs/base/common/observableInternal/reducer.js

@@ -0,0 +1,36 @@
+
+import { strictEquals } from '../equals.js';
+import { BugIndicatingError } from '../errors.js';
+import { subtransaction } from './base.js';
+import { DebugNameData } from './debugName.js';
+import { DerivedWithSetter } from './derived.js';
+
+function observableReducerSettable(owner, options) {
+    let prevValue = undefined;
+    let hasValue = false;
+    const d = ( new DerivedWithSetter(( new DebugNameData(owner, undefined, options.update)), (reader, changeSummary) => {
+        if (!hasValue) {
+            prevValue = options.initial instanceof Function ? options.initial() : options.initial;
+            hasValue = true;
+        }
+        const newValue = options.update(reader, prevValue, changeSummary);
+        prevValue = newValue;
+        return newValue;
+    }, options.changeTracker, () => {
+        if (hasValue) {
+            options.disposeFinal?.(prevValue);
+            hasValue = false;
+        }
+    }, options.equalityComparer ?? strictEquals, (value, tx, change) => {
+        if (!hasValue) {
+            throw ( new BugIndicatingError('Can only set when there is a listener! This is to prevent leaks.'));
+        }
+        subtransaction(tx, tx => {
+            prevValue = value;
+            d.setValue(value, tx, change);
+        });
+    }));
+    return d;
+}
+
+export { observableReducerSettable };

package/vscode/src/vs/base/common/observableInternal/utils.d.ts

@@ -1,6 +1,7 @@
 import { BaseObservable, IObservable, IObservableWithChange, IObserver, IReader, ITransaction } from "./base.js";
 import { DebugNameData, DebugOwner, IDebugNameData } from "./debugName.js";
 import { DisposableStore, EqualityComparer, Event, IDisposable, IValueWithChangeEvent } from "./commonFacade/deps.js";
+import { CancellationToken } from "../cancellation.js";
 export declare function constObservable<T>(value: T): IObservable<T>;
 export declare function observableFromPromise<T>(promise: Promise<T>): IObservable<{
     value?: T;
@@ -73,4 +74,5 @@ export declare function derivedConstOnceDefined<T>(owner: DebugOwner, fn: (reade
 type RemoveUndefined<T> = T extends undefined ? never : T;
 export declare function runOnChange<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: undefined | T, deltas: RemoveUndefined<TChange>[]) => void): IDisposable;
 export declare function runOnChangeWithStore<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: undefined | T, deltas: RemoveUndefined<TChange>[], store: DisposableStore) => void): IDisposable;
+export declare function runOnChangeWithCancellationToken<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: undefined | T, deltas: RemoveUndefined<TChange>[], token: CancellationToken) => Promise<void>): IDisposable;
 export {};

package/vscode/src/vs/base/common/observableInternal/utils.js

@@ -8,6 +8,7 @@ import { Event } from '../event.js';
 import { toDisposable, DisposableStore } from '../lifecycle.js';
 import { derivedOpts, derived } from './derived.js';
 import { getLogger } from './logging/logging.js';
+import { cancelOnDispose } from '../cancellation.js';
 
 function constObservable(value) {
     return ( new ConstObservable(value));
@@ -441,17 +442,19 @@ function derivedConstOnceDefined(owner, fn) {
 function runOnChange(observable, cb) {
     let _previousValue;
     return autorunWithStoreHandleChanges({
-        createEmptyChangeSummary: () => ({ deltas: [], didChange: false }),
-        handleChange: (context, changeSummary) => {
-            if (context.didChange(observable)) {
-                const e = context.change;
-                if (e !== undefined) {
-                    changeSummary.deltas.push(e);
+        changeTracker: {
+            createChangeSummary: () => ({ deltas: [], didChange: false }),
+            handleChange: (context, changeSummary) => {
+                if (context.didChange(observable)) {
+                    const e = context.change;
+                    if (e !== undefined) {
+                        changeSummary.deltas.push(e);
+                    }
+                    changeSummary.didChange = true;
                 }
-                changeSummary.didChange = true;
-            }
-            return true;
-        },
+                return true;
+            },
+        }
     }, (reader, changeSummary) => {
         const value = observable.read(reader);
         const previousValue = _previousValue;
@@ -474,5 +477,10 @@ function runOnChangeWithStore(observable, cb) {
         }
     };
 }
+function runOnChangeWithCancellationToken(observable, cb) {
+    return runOnChangeWithStore(observable, (value, previousValue, deltas, store) => {
+        cb(value, previousValue, deltas, cancelOnDispose(store));
+    });
+}
 
-export { FromEventObservable, KeepAliveObserver, ValueWithChangeEventFromObservable, constObservable, debouncedObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithStore, wasEventTriggeredRecently };
+export { FromEventObservable, KeepAliveObserver, ValueWithChangeEventFromObservable, constObservable, debouncedObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, wasEventTriggeredRecently };

package/vscode/src/vs/base/common/product.d.ts

@@ -177,6 +177,10 @@ export interface IProductConfiguration {
     readonly extensionVirtualWorkspacesSupport?: {
         readonly [extensionId: string]: ExtensionVirtualWorkspaceSupport;
     };
+    readonly extensionProperties: IStringDictionary<{
+        readonly hasPrereleaseVersion?: boolean;
+        readonly excludeVersionRange?: string;
+    }>;
     readonly msftInternalDomains?: string[];
     readonly linkProtectionTrustedDomains?: readonly string[];
     readonly defaultAccount?: {
@@ -309,6 +313,7 @@ export interface IDefaultChatAgent {
     readonly publicCodeMatchesUrl: string;
     readonly manageSettingsUrl: string;
     readonly managePlanUrl: string;
+    readonly manageOverageUrl: string;
     readonly upgradePlanUrl: string;
     readonly providerId: string;
     readonly providerName: string;

package/vscode/src/vs/base/common/sseParser.d.ts

@@ -0,0 +1,26 @@
+export interface ISSEEvent {
+    type: string;
+    data: string;
+    id?: string;
+    retry?: number;
+}
+export type SSEEventHandler = (event: ISSEEvent) => void;
+export declare class SSEParser {
+    private dataBuffer;
+    private eventTypeBuffer;
+    private currentEventId?;
+    private lastEventIdBuffer?;
+    private reconnectionTime?;
+    private buffer;
+    private endedOnCR;
+    private readonly onEventHandler;
+    private readonly decoder;
+    constructor(onEvent: SSEEventHandler);
+    getLastEventId(): string | undefined;
+    getReconnectionTime(): number | undefined;
+    feed(chunk: Uint8Array): void;
+    private processLine;
+    private processField;
+    private dispatchEvent;
+    reset(): void;
+}

package/vscode/src/vs/base/common/sseParser.js

@@ -0,0 +1,134 @@
+
+
+var Chr;
+(function (Chr) {
+    Chr[Chr["CR"] = 13] = "CR";
+    Chr[Chr["LF"] = 10] = "LF";
+    Chr[Chr["COLON"] = 58] = "COLON";
+    Chr[Chr["SPACE"] = 32] = "SPACE";
+})(Chr || (Chr = {}));
+class SSEParser {
+    constructor(onEvent) {
+        this.dataBuffer = '';
+        this.eventTypeBuffer = '';
+        this.buffer = [];
+        this.endedOnCR = false;
+        this.onEventHandler = onEvent;
+        this.decoder = ( new TextDecoder('utf-8'));
+    }
+    getLastEventId() {
+        return this.lastEventIdBuffer;
+    }
+    getReconnectionTime() {
+        return this.reconnectionTime;
+    }
+    feed(chunk) {
+        if (chunk.length === 0) {
+            return;
+        }
+        let offset = 0;
+        if (this.endedOnCR && chunk[0] === Chr.LF) {
+            offset++;
+        }
+        this.endedOnCR = false;
+        while (offset < chunk.length) {
+            const indexCR = chunk.indexOf(Chr.CR, offset);
+            const indexLF = chunk.indexOf(Chr.LF, offset);
+            const index = indexCR === -1 ? indexLF : (indexLF === -1 ? indexCR : Math.min(indexCR, indexLF));
+            if (index === -1) {
+                break;
+            }
+            let str = '';
+            for (const buf of this.buffer) {
+                str += this.decoder.decode(buf, { stream: true });
+            }
+            str += this.decoder.decode(chunk.subarray(offset, index));
+            this.processLine(str);
+            this.buffer.length = 0;
+            offset = index + (chunk[index] === Chr.CR && chunk[index + 1] === Chr.LF ? 2 : 1);
+        }
+        if (offset < chunk.length) {
+            this.buffer.push(chunk.subarray(offset));
+        }
+        else {
+            this.endedOnCR = chunk[chunk.length - 1] === Chr.CR;
+        }
+    }
+    processLine(line) {
+        if (!line.length) {
+            this.dispatchEvent();
+            return;
+        }
+        if (line.startsWith(':')) {
+            return;
+        }
+        let field;
+        let value;
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1) {
+            field = line;
+            value = '';
+        }
+        else {
+            field = line.substring(0, colonIndex);
+            value = line.substring(colonIndex + 1);
+            if (value.startsWith(' ')) {
+                value = value.substring(1);
+            }
+        }
+        this.processField(field, value);
+    }
+    processField(field, value) {
+        switch (field) {
+            case 'event':
+                this.eventTypeBuffer = value;
+                break;
+            case 'data':
+                this.dataBuffer += value;
+                this.dataBuffer += '\n';
+                break;
+            case 'id':
+                if (!value.includes('\0')) {
+                    this.currentEventId = this.lastEventIdBuffer = value;
+                }
+                else {
+                    this.currentEventId = undefined;
+                }
+                break;
+            case 'retry':
+                if (/^\d+$/.test(value)) {
+                    this.reconnectionTime = parseInt(value, 10);
+                }
+                break;
+        }
+    }
+    dispatchEvent() {
+        if (this.dataBuffer === '') {
+            this.dataBuffer = '';
+            this.eventTypeBuffer = '';
+            return;
+        }
+        if (this.dataBuffer.endsWith('\n')) {
+            this.dataBuffer = this.dataBuffer.substring(0, this.dataBuffer.length - 1);
+        }
+        const event = {
+            type: this.eventTypeBuffer || 'message',
+            data: this.dataBuffer,
+        };
+        if (this.currentEventId !== undefined) {
+            event.id = this.currentEventId;
+        }
+        if (this.reconnectionTime !== undefined) {
+            event.retry = this.reconnectionTime;
+        }
+        this.onEventHandler(event);
+        this.reset();
+    }
+    reset() {
+        this.dataBuffer = '';
+        this.eventTypeBuffer = '';
+        this.currentEventId = undefined;
+    }
+}
+
+export { SSEParser };

package/vscode/src/vs/base/common/stopwatch.js

@@ -1,12 +1,12 @@
 
 
-const hasPerformanceNow = (globalThis.performance && typeof globalThis.performance.now === 'function');
+const performanceNow = globalThis.performance.now.bind(globalThis.performance);
 class StopWatch {
     static create(highResolution) {
         return ( new StopWatch(highResolution));
     }
     constructor(highResolution) {
-        this._now = hasPerformanceNow && highResolution === false ? Date.now : globalThis.performance.now.bind(globalThis.performance);
+        this._now = highResolution === false ? Date.now : performanceNow;
         this._startTime = this._now();
         this._stopTime = -1;
     }

package/vscode/src/vs/base/common/strings.d.ts

@@ -24,6 +24,7 @@ export declare function regExpLeadsToEndlessLoop(regexp: RegExp): boolean;
 export declare function joinStrings(items: (string | undefined | null | false)[], separator: string): string;
 export declare function splitLines(str: string): string[];
 export declare function splitLinesIncludeSeparators(str: string): string[];
+export declare function indexOfPattern(str: string, re: RegExp): number;
 export declare function firstNonWhitespaceIndex(str: string): number;
 export declare function getLeadingWhitespace(str: string, start?: number, end?: number): string;
 export declare function lastNonWhitespaceIndex(str: string, startIndex?: number): number;

package/vscode/src/vs/base/common/strings.js

@@ -165,6 +165,13 @@ function joinStrings(items, separator) {
 function splitLines(str) {
     return str.split(/\r\n|\r|\n/);
 }
+function indexOfPattern(str, re) {
+    const match = re.exec(str);
+    if (match) {
+        return match.index;
+    }
+    return -1;
+}
 function firstNonWhitespaceIndex(str) {
     for (let i = 0, len = str.length; i < len; i++) {
         const chCode = str.charCodeAt(i);
@@ -470,24 +477,6 @@ function lcut(text, n, prefix = '') {
     }
     return prefix + trimmed.substring(i).trimStart();
 }
-function rcut(text, n, suffix = '') {
-    const trimmed = text.trimEnd();
-    if (trimmed.length < n) {
-        return trimmed;
-    }
-    const parts = text.split(/\b/);
-    let result = '';
-    for (const part of parts) {
-        if (result.length > 0 && result.length + part.length > n) {
-            break;
-        }
-        result += part;
-    }
-    if (result === trimmed) {
-        return result;
-    }
-    return result.trim().replace(/b$/, '') + suffix;
-}
 const CSI_SEQUENCE = /(?:\x1b\[|\x9b)[=?>!]?[\d;:]*["$#'* ]?[a-zA-Z@^`{}|~]/;
 const OSC_SEQUENCE = /(?:\x1b\]|\x9d).*?(?:\x1b\\|\x07|\x9c)/;
 const ESC_SEQUENCE = /\x1b(?:[ #%\(\)\*\+\-\.\/]?[a-zA-Z0-9\|}~@])/;
@@ -836,4 +825,4 @@ class InvisibleCharacters {
     }
 }
 
-export { AmbiguousCharacters, CodePointIterator, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getIndentationLength, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, nextCharLength, noBreakWhitespace, prevCharLength, rcut, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };
+export { AmbiguousCharacters, CodePointIterator, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getIndentationLength, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, indexOfPattern, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };

package/vscode/src/vs/base/common/ternarySearchTree.d.ts

@@ -77,6 +77,7 @@ export declare class TernarySearchTree<K, V> {
     deleteSuperstr(key: K): void;
     private _delete;
     private _min;
+    private _balanceByStack;
     findSubstr(key: K): V | undefined;
     findSuperstr(key: K): IterableIterator<[
         K,

package/vscode/src/vs/base/common/ternarySearchTree.js

@@ -1,5 +1,6 @@
 
 import { shuffle } from './arrays.js';
+import { assert } from './assert.js';
 import { CharCode } from './charCode.js';
 import { compareSubstring, compareSubstringIgnoreCase, compareIgnoreCase, compare } from './strings.js';
 
@@ -223,6 +224,11 @@ class Undef {
 class TernarySearchTreeNode {
     constructor() {
         this.height = 1;
+        this.value = undefined;
+        this.key = undefined;
+        this.left = undefined;
+        this.mid = undefined;
+        this.right = undefined;
     }
     isEmpty() {
         return !this.left && !this.mid && !this.right && this.value === undefined;
@@ -456,13 +462,44 @@ class TernarySearchTree {
         }
         if (!node.mid && !node.value) {
             if (node.left && node.right) {
-                const min = this._min(node.right);
+                const stack2 = [[Dir.Right, node]];
+                const min = this._min(node.right, stack2);
                 if (min.key) {
-                    const { key, value, segment } = min;
-                    this._delete(min.key, false);
-                    node.key = key;
-                    node.value = value;
-                    node.segment = segment;
+                    node.key = min.key;
+                    node.value = min.value;
+                    node.segment = min.segment;
+                    const newChild = min.right;
+                    if (stack2.length > 1) {
+                        const [dir, parent] = stack2[stack2.length - 1];
+                        switch (dir) {
+                            case Dir.Left:
+                                parent.left = newChild;
+                                break;
+                            case Dir.Mid: assert(false);
+                            case Dir.Right: assert(false);
+                        }
+                    }
+                    else {
+                        node.right = newChild;
+                    }
+                    const newChild2 = this._balanceByStack(stack2);
+                    if (stack.length > 0) {
+                        const [dir, parent] = stack[stack.length - 1];
+                        switch (dir) {
+                            case Dir.Left:
+                                parent.left = newChild2;
+                                break;
+                            case Dir.Mid:
+                                parent.mid = newChild2;
+                                break;
+                            case Dir.Right:
+                                parent.right = newChild2;
+                                break;
+                        }
+                    }
+                    else {
+                        this._root = newChild2;
+                    }
                 }
             }
             else {
@@ -486,6 +523,16 @@ class TernarySearchTree {
                 }
             }
         }
+        this._root = this._balanceByStack(stack) ?? this._root;
+    }
+    _min(node, stack) {
+        while (node.left) {
+            stack.push([Dir.Left, node]);
+            node = node.left;
+        }
+        return node;
+    }
+    _balanceByStack(stack) {
         for (let i = stack.length - 1; i >= 0; i--) {
             const node = stack[i][1];
             node.updateHeight();
@@ -522,15 +569,10 @@ class TernarySearchTree {
                 }
             }
             else {
-                this._root = stack[0][1];
+                return stack[0][1];
             }
         }
-    }
-    _min(node) {
-        while (node.left) {
-            node = node.left;
-        }
-        return node;
+        return undefined;
     }
     findSubstr(key) {
         const iter = this._iter.reset(key);

package/vscode/src/vs/editor/browser/config/editorConfiguration.d.ts

@@ -52,6 +52,7 @@ export interface IEnvConfiguration {
     emptySelectionClipboard: boolean;
     pixelRatio: number;
     accessibilitySupport: AccessibilitySupport;
+    editContextSupported: boolean;
 }
 declare class ValidatedEditorOptions implements IValidatedEditorOptions {
     private readonly _values;

package/vscode/src/vs/editor/browser/config/editorConfiguration.js

@@ -80,7 +80,8 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
             tabFocusMode: TabFocus.getTabFocusMode(),
             inputMode: InputMode.getInputMode(),
             accessibilitySupport: partialEnv.accessibilitySupport,
-            glyphMarginDecorationLaneCount: this._glyphMarginDecorationLaneCount
+            glyphMarginDecorationLaneCount: this._glyphMarginDecorationLaneCount,
+            editContextSupported: partialEnv.editContextSupported
         };
         return EditorOptionsUtil.computeOptions(this._validatedOptions, env);
     }
@@ -91,6 +92,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
             outerHeight: this._containerObserver.getHeight(),
             emptySelectionClipboard: isWebKit || isFirefox,
             pixelRatio: PixelRatio.getInstance(getWindowById(this._targetWindowId, true).window).value,
+            editContextSupported: typeof globalThis.EditContext === 'function',
             accessibilitySupport: (this._accessibilityService.isScreenReaderOptimized()
                 ? AccessibilitySupport.Enabled
                 : this._accessibilityService.getAccessibilitySupport())

package/vscode/src/vs/editor/browser/controller/editContext/native/nativeEditContext.css

@@ -7,7 +7,7 @@
 	z-index: -10;
 	white-space: pre-wrap;
 }
-.monaco-editor .native-edit-context-textarea {
+.monaco-editor .ime-text-area {
 	min-width: 0;
 	min-height: 0;
 	margin: 0;