@codingame/monaco-vscode-api 13.1.6 → 14.0.0

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

@@ -1,8 +1,317 @@
 
 
 let globalObservableLogger;
+function setLogger(logger) {
+    globalObservableLogger = logger;
+}
 function getLogger() {
     return globalObservableLogger;
 }
+function logObservable(obs) {
+    if (!globalObservableLogger) {
+        const l = ( new ConsoleObservableLogger());
+        l.addFilteredObj(obs);
+        setLogger(l);
+    }
+    else {
+        if (globalObservableLogger instanceof ConsoleObservableLogger) {
+            globalObservableLogger.addFilteredObj(obs);
+        }
+    }
+}
+class ConsoleObservableLogger {
+    constructor() {
+        this.indentation = 0;
+        this.changedObservablesSets = ( new WeakMap());
+    }
+    addFilteredObj(obj) {
+        if (!this._filteredObjects) {
+            this._filteredObjects = ( new Set());
+        }
+        this._filteredObjects.add(obj);
+    }
+    _isIncluded(obj) {
+        return this._filteredObjects?.has(obj) ?? true;
+    }
+    textToConsoleArgs(text) {
+        return consoleTextToArgs([
+            normalText(repeat('|  ', this.indentation)),
+            text,
+        ]);
+    }
+    formatInfo(info) {
+        if (!info.hadValue) {
+            return [
+                normalText(` `),
+                styled(formatValue(info.newValue, 60), {
+                    color: 'green',
+                }),
+                normalText(` (initial)`),
+            ];
+        }
+        return info.didChange
+            ? [
+                normalText(` `),
+                styled(formatValue(info.oldValue, 70), {
+                    color: 'red',
+                    strikeThrough: true,
+                }),
+                normalText(` `),
+                styled(formatValue(info.newValue, 60), {
+                    color: 'green',
+                }),
+            ]
+            : [normalText(` (unchanged)`)];
+    }
+    handleObservableChanged(observable, info) {
+        if (!this._isIncluded(observable)) {
+            return;
+        }
+        console.log(...this.textToConsoleArgs([
+            formatKind('observable value changed'),
+            styled(observable.debugName, { color: 'BlueViolet' }),
+            ...this.formatInfo(info),
+        ]));
+    }
+    formatChanges(changes) {
+        if (changes.size === 0) {
+            return undefined;
+        }
+        return styled(' (changed deps: ' +
+            ( [...changes].map((o) => o.debugName)).join(', ') +
+            ')', { color: 'gray' });
+    }
+    handleDerivedCreated(derived) {
+        const existingHandleChange = derived.handleChange;
+        this.changedObservablesSets.set(derived, ( new Set()));
+        derived.handleChange = (observable, change) => {
+            this.changedObservablesSets.get(derived).add(observable);
+            return existingHandleChange.apply(derived, [observable, change]);
+        };
+    }
+    handleDerivedRecomputed(derived, info) {
+        if (!this._isIncluded(derived)) {
+            return;
+        }
+        const changedObservables = this.changedObservablesSets.get(derived);
+        if (!changedObservables) {
+            return;
+        }
+        console.log(...this.textToConsoleArgs([
+            formatKind('derived recomputed'),
+            styled(derived.debugName, { color: 'BlueViolet' }),
+            ...this.formatInfo(info),
+            this.formatChanges(changedObservables),
+            { data: [{ fn: derived._debugNameData.referenceFn ?? derived._computeFn }] }
+        ]));
+        changedObservables.clear();
+    }
+    handleDerivedCleared(derived) {
+        if (!this._isIncluded(derived)) {
+            return;
+        }
+        console.log(...this.textToConsoleArgs([
+            formatKind('derived cleared'),
+            styled(derived.debugName, { color: 'BlueViolet' }),
+        ]));
+    }
+    handleFromEventObservableTriggered(observable, info) {
+        if (!this._isIncluded(observable)) {
+            return;
+        }
+        console.log(...this.textToConsoleArgs([
+            formatKind('observable from event triggered'),
+            styled(observable.debugName, { color: 'BlueViolet' }),
+            ...this.formatInfo(info),
+            { data: [{ fn: observable._getValue }] }
+        ]));
+    }
+    handleAutorunCreated(autorun) {
+        if (!this._isIncluded(autorun)) {
+            return;
+        }
+        const existingHandleChange = autorun.handleChange;
+        this.changedObservablesSets.set(autorun, ( new Set()));
+        autorun.handleChange = (observable, change) => {
+            this.changedObservablesSets.get(autorun).add(observable);
+            return existingHandleChange.apply(autorun, [observable, change]);
+        };
+    }
+    handleAutorunTriggered(autorun) {
+        const changedObservables = this.changedObservablesSets.get(autorun);
+        if (!changedObservables) {
+            return;
+        }
+        if (this._isIncluded(autorun)) {
+            console.log(...this.textToConsoleArgs([
+                formatKind('autorun'),
+                styled(autorun.debugName, { color: 'BlueViolet' }),
+                this.formatChanges(changedObservables),
+                { data: [{ fn: autorun._debugNameData.referenceFn ?? autorun._runFn }] }
+            ]));
+        }
+        changedObservables.clear();
+        this.indentation++;
+    }
+    handleAutorunFinished(autorun) {
+        this.indentation--;
+    }
+    handleBeginTransaction(transaction) {
+        let transactionName = transaction.getDebugName();
+        if (transactionName === undefined) {
+            transactionName = '';
+        }
+        if (this._isIncluded(transaction)) {
+            console.log(...this.textToConsoleArgs([
+                formatKind('transaction'),
+                styled(transactionName, { color: 'BlueViolet' }),
+                { data: [{ fn: transaction._fn }] }
+            ]));
+        }
+        this.indentation++;
+    }
+    handleEndTransaction() {
+        this.indentation--;
+    }
+}
+function consoleTextToArgs(text) {
+    const styles = ( new Array());
+    const data = [];
+    let firstArg = '';
+    function process(t) {
+        if ('length' in t) {
+            for (const item of t) {
+                if (item) {
+                    process(item);
+                }
+            }
+        }
+        else if ('text' in t) {
+            firstArg += `%c${t.text}`;
+            styles.push(t.style);
+            if (t.data) {
+                data.push(...t.data);
+            }
+        }
+        else if ('data' in t) {
+            data.push(...t.data);
+        }
+    }
+    process(text);
+    const result = [firstArg, ...styles];
+    result.push(...data);
+    return result;
+}
+function normalText(text) {
+    return styled(text, { color: 'black' });
+}
+function formatKind(kind) {
+    return styled(padStr(`${kind}: `, 10), { color: 'black', bold: true });
+}
+function styled(text, options = {
+    color: 'black',
+}) {
+    function objToCss(styleObj) {
+        return Object.entries(styleObj).reduce((styleString, [propName, propValue]) => {
+            return `${styleString}${propName}:${propValue};`;
+        }, '');
+    }
+    const style = {
+        color: options.color,
+    };
+    if (options.strikeThrough) {
+        style['text-decoration'] = 'line-through';
+    }
+    if (options.bold) {
+        style['font-weight'] = 'bold';
+    }
+    return {
+        text,
+        style: objToCss(style),
+    };
+}
+function formatValue(value, availableLen) {
+    switch (typeof value) {
+        case 'number':
+            return '' + value;
+        case 'string':
+            if (value.length + 2 <= availableLen) {
+                return `"${value}"`;
+            }
+            return `"${value.substr(0, availableLen - 7)}"+...`;
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'undefined':
+            return 'undefined';
+        case 'object':
+            if (value === null) {
+                return 'null';
+            }
+            if (Array.isArray(value)) {
+                return formatArray(value, availableLen);
+            }
+            return formatObject(value, availableLen);
+        case 'symbol':
+            return ( value.toString());
+        case 'function':
+            return `[[Function${value.name ? ' ' + value.name : ''}]]`;
+        default:
+            return '' + value;
+    }
+}
+function formatArray(value, availableLen) {
+    let result = '[ ';
+    let first = true;
+    for (const val of value) {
+        if (!first) {
+            result += ', ';
+        }
+        if (result.length - 5 > availableLen) {
+            result += '...';
+            break;
+        }
+        first = false;
+        result += `${formatValue(val, availableLen - result.length)}`;
+    }
+    result += ' ]';
+    return result;
+}
+function formatObject(value, availableLen) {
+    if (typeof value.toString === 'function' && value.toString !== Object.prototype.toString) {
+        const val = ( value.toString());
+        if (val.length <= availableLen) {
+            return val;
+        }
+        return val.substring(0, availableLen - 3) + '...';
+    }
+    let result = '{ ';
+    let first = true;
+    for (const [key, val] of Object.entries(value)) {
+        if (!first) {
+            result += ', ';
+        }
+        if (result.length - 5 > availableLen) {
+            result += '...';
+            break;
+        }
+        first = false;
+        result += `${key}: ${formatValue(val, availableLen - result.length)}`;
+    }
+    result += ' }';
+    return result;
+}
+function repeat(str, count) {
+    let result = '';
+    for (let i = 1; i <= count; i++) {
+        result += str;
+    }
+    return result;
+}
+function padStr(str, length) {
+    while (str.length < length) {
+        str += ' ';
+    }
+    return str;
+}
 
-export { getLogger };
+export { ConsoleObservableLogger, getLogger, logObservable, setLogger };

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

@@ -1,4 +1,4 @@
-import { BaseObservable, IObservable, IObserver, IReader, ITransaction } from "./base.js";
+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";
 export declare function constObservable<T>(value: T): IObservable<T>;
@@ -32,10 +32,10 @@ export declare namespace observableFromEvent {
     const Observer: typeof FromEventObservable;
     function batchEventsGlobally(tx: ITransaction, fn: () => void): void;
 }
-export declare function observableSignalFromEvent(debugName: string, event: Event<any>): IObservable<void>;
+export declare function observableSignalFromEvent(owner: DebugOwner | string, event: Event<any>): IObservable<void>;
 export declare function observableSignal<TDelta = void>(debugName: string): IObservableSignal<TDelta>;
 export declare function observableSignal<TDelta = void>(owner: object): IObservableSignal<TDelta>;
-export interface IObservableSignal<TChange> extends IObservable<void, TChange> {
+export interface IObservableSignal<TChange> extends IObservableWithChange<void, TChange> {
     trigger(tx: ITransaction | undefined, change: TChange): void;
 }
 export declare function signalFromObservable<T>(owner: DebugOwner | undefined, observable: IObservable<T>): IObservable<void>;
@@ -49,10 +49,10 @@ export declare class KeepAliveObserver implements IObserver {
     private readonly _handleValue;
     private _counter;
     constructor(_forceRecompute: boolean, _handleValue: ((value: any) => void) | undefined);
-    beginUpdate<T>(observable: IObservable<T, void>): void;
-    endUpdate<T>(observable: IObservable<T, void>): void;
-    handlePossibleChange<T>(observable: IObservable<T, unknown>): void;
-    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
+    beginUpdate<T>(observable: IObservable<T>): void;
+    endUpdate<T>(observable: IObservable<T>): void;
+    handlePossibleChange<T>(observable: IObservable<T>): void;
+    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
 }
 export declare function derivedObservableWithCache<T>(owner: DebugOwner, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T>;
 export declare function derivedObservableWithWritableCache<T>(owner: object, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T> & {
@@ -70,6 +70,6 @@ export declare function observableFromValueWithChangeEvent<T>(owner: DebugOwner,
 export declare function latestChangedValue<T extends IObservable<any>[]>(owner: DebugOwner, observables: T): IObservable<ReturnType<T[number]["get"]>>;
 export declare function derivedConstOnceDefined<T>(owner: DebugOwner, fn: (reader: IReader) => T): IObservable<T | undefined>;
 type RemoveUndefined<T> = T extends undefined ? never : T;
-export declare function runOnChange<T, TChange>(observable: IObservable<T, TChange>, cb: (value: T, previousValue: undefined | T, deltas: RemoveUndefined<TChange>[]) => void): IDisposable;
-export declare function runOnChangeWithStore<T, TChange>(observable: IObservable<T, TChange>, cb: (value: T, previousValue: undefined | T, deltas: RemoveUndefined<TChange>[], store: DisposableStore) => void): IDisposable;
+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 {};

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

@@ -7,6 +7,7 @@ import { strictEquals } from '../equals.js';
 import { Event } from '../event.js';
 import { toDisposable, DisposableStore } from '../lifecycle.js';
 import { derivedOpts, derived } from './derived.js';
+import { getLogger } from './logging.js';
 
 function constObservable(value) {
     return ( new ConstObservable(value));
@@ -65,10 +66,13 @@ class FromEventObservable extends BaseObservable {
             const newValue = this._getValue(args);
             const oldValue = this.value;
             const didChange = !this.hasValue || !(this._equalityComparator(oldValue, newValue));
+            let didRunTransaction = false;
             if (didChange) {
                 this.value = newValue;
                 if (this.hasValue) {
+                    didRunTransaction = true;
                     subtransaction(this._getTransaction(), (tx) => {
+                        getLogger()?.handleFromEventObservableTriggered(this, { oldValue, newValue, change: undefined, didChange, hadValue: this.hasValue });
                         for (const o of this.observers) {
                             tx.updateObserver(o, this);
                             o.handleChange(this, undefined);
@@ -80,6 +84,9 @@ class FromEventObservable extends BaseObservable {
                 }
                 this.hasValue = true;
             }
+            if (!didRunTransaction) {
+                getLogger()?.handleFromEventObservableTriggered(this, { oldValue, newValue, change: undefined, didChange, hadValue: this.hasValue });
+            }
         };
     }
     getDebugName() {
@@ -130,13 +137,12 @@ class FromEventObservable extends BaseObservable {
     }
     observableFromEvent.batchEventsGlobally = batchEventsGlobally;
 })(observableFromEvent || (observableFromEvent = {}));
-function observableSignalFromEvent(debugName, event) {
-    return ( new FromEventObservableSignal(debugName, event));
+function observableSignalFromEvent(owner, event) {
+    return ( new FromEventObservableSignal(typeof owner === 'string' ? owner : ( new DebugNameData(owner, undefined, undefined)), event));
 }
 class FromEventObservableSignal extends BaseObservable {
-    constructor(debugName, event) {
+    constructor(debugNameDataOrName, event) {
         super();
-        this.debugName = debugName;
         this.event = event;
         this.handleEvent = () => {
             transaction((tx) => {
@@ -146,6 +152,9 @@ class FromEventObservableSignal extends BaseObservable {
                 }
             }, () => this.debugName);
         };
+        this.debugName = typeof debugNameDataOrName === 'string'
+            ? debugNameDataOrName
+            : debugNameDataOrName.getDebugName(this) ?? 'Observable Signal From Event';
     }
     onFirstObserverAdded() {
         this.subscription = this.event(this.handleEvent);

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

@@ -1136,6 +1136,5 @@ const basename = (platformIsWin32 ? win32.basename : posix.basename);
 const extname = (platformIsWin32 ? win32.extname : posix.extname);
 const parse = (platformIsWin32 ? win32.parse : posix.parse);
 const sep = (platformIsWin32 ? win32.sep : posix.sep);
-const delimiter = (platformIsWin32 ? win32.delimiter : posix.delimiter);
 
-export { basename, delimiter, dirname, extname, isAbsolute, join, normalize, parse, posix, relative, resolve, sep, win32 };
+export { basename, dirname, extname, isAbsolute, join, normalize, parse, posix, relative, resolve, sep, win32 };

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

@@ -99,6 +99,7 @@ export interface IProductConfiguration {
         readonly nlsBaseUrl: string;
     };
     readonly extensionPublisherOrgs?: readonly string[];
+    readonly trustedExtensionPublishers?: readonly string[];
     readonly extensionRecommendations?: IStringDictionary<IExtensionRecommendations>;
     readonly configBasedExtensionTips?: IStringDictionary<IConfigBasedExtensionTip>;
     readonly exeBasedExtensionTips?: IStringDictionary<IExeBasedExtensionTip>;
@@ -300,6 +301,10 @@ export interface IDefaultChatAgent {
     readonly upgradePlanUrl: string;
     readonly providerId: string;
     readonly providerName: string;
+    readonly enterpriseProviderId: string;
+    readonly enterpriseProviderName: string;
+    readonly providerSetting: string;
+    readonly providerUriSetting: string;
     readonly providerScopes: string[][];
     readonly entitlementUrl: string;
     readonly entitlementSignupLimitedUrl: string;

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

@@ -40,7 +40,7 @@ export interface ITransformer<Original, Transformed> {
     data: IDataTransformer<Original, Transformed>;
     error?: IErrorTransformer;
 }
-export declare function newWriteableStream<T>(reducer: IReducer<T>, options?: WriteableStreamOptions): WriteableStream<T>;
+export declare function newWriteableStream<T>(reducer: IReducer<T> | null, options?: WriteableStreamOptions): WriteableStream<T>;
 export interface WriteableStreamOptions {
     highWaterMark?: number;
 }

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

@@ -157,14 +157,22 @@ class WriteableStreamImpl {
         }
     }
     flowData() {
-        if (this.buffer.data.length > 0) {
+        if (this.buffer.data.length === 0) {
+            return;
+        }
+        if (typeof this.reducer === 'function') {
             const fullDataBuffer = this.reducer(this.buffer.data);
             this.emitData(fullDataBuffer);
-            this.buffer.data.length = 0;
-            const pendingWritePromises = [...this.pendingWritePromises];
-            this.pendingWritePromises.length = 0;
-            pendingWritePromises.forEach(pendingWritePromise => pendingWritePromise());
         }
+        else {
+            for (const data of this.buffer.data) {
+                this.emitData(data);
+            }
+        }
+        this.buffer.data.length = 0;
+        const pendingWritePromises = [...this.pendingWritePromises];
+        this.pendingWritePromises.length = 0;
+        pendingWritePromises.forEach(pendingWritePromise => pendingWritePromise());
     }
     flowErrors() {
         if (this.listeners.error.length > 0) {

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

@@ -77,6 +77,7 @@ export declare function containsUnusualLineTerminators(str: string): boolean;
 export declare function isFullWidthCharacter(charCode: number): boolean;
 export declare function isEmojiImprecise(x: number): boolean;
 export declare function lcut(text: string, n: number, prefix?: string): string;
+export declare function rcut(text: string, n: number, suffix?: string): string;
 export declare function forAnsiStringParts(str: string): Generator<{
     isCode: boolean;
     str: string;

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

@@ -165,14 +165,6 @@ function joinStrings(items, separator) {
 function splitLines(str) {
     return str.split(/\r\n|\r|\n/);
 }
-function splitLinesIncludeSeparators(str) {
-    const linesWithSeparators = [];
-    const splitLinesAndSeparators = str.split(/(\r\n|\r|\n)/);
-    for (let i = 0; i < Math.ceil(splitLinesAndSeparators.length / 2); i++) {
-        linesWithSeparators.push(splitLinesAndSeparators[2 * i] + (splitLinesAndSeparators[2 * i + 1] ?? ''));
-    }
-    return linesWithSeparators;
-}
 function firstNonWhitespaceIndex(str) {
     for (let i = 0, len = str.length; i < len; i++) {
         const chCode = str.charCodeAt(i);
@@ -492,6 +484,24 @@ 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@^`{}|~])|(:?\x1b\].*?\x07)/g;
 function* forAnsiStringParts(str) {
     let last = 0;
@@ -832,4 +842,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, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, replaceAsync, rtrim, singleLetterHash, splitLines, splitLinesIncludeSeparators, 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, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, nextCharLength, noBreakWhitespace, prevCharLength, rcut, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, replaceAsync, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };

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

@@ -9,7 +9,8 @@ export declare function isUndefined(obj: unknown): obj is undefined;
 export declare function isDefined<T>(arg: T | null | undefined): arg is T;
 export declare function isUndefinedOrNull(obj: unknown): obj is undefined | null;
 export declare function assertType(condition: unknown, type?: string): asserts condition;
-export declare function assertIsDefined<T>(arg: T | null | undefined): T;
+export declare function assertIsDefined<T>(arg: T | null | undefined): NonNullable<T>;
+export declare function assertDefined<T>(value: T, error: string | NonNullable<Error>): asserts value is NonNullable<T>;
 export declare function assertAllDefined<T1, T2>(t1: T1 | null | undefined, t2: T2 | null | undefined): [
     T1,
     T2

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

@@ -1,4 +1,5 @@
 
+import { assert } from './assert.js';
 
 function isString(str) {
     return (typeof str === 'string');
@@ -42,11 +43,15 @@ function assertType(condition, type) {
     }
 }
 function assertIsDefined(arg) {
-    if (isUndefinedOrNull(arg)) {
-        throw ( new Error('Assertion Failed: argument is undefined or null'));
-    }
+    assert(arg !== null && arg !== undefined, 'Argument is `undefined` or `null`.');
     return arg;
 }
+function assertDefined(value, error) {
+    if (value === null || value === undefined) {
+        const errorToThrow = typeof error === 'string' ? ( new Error(error)) : error;
+        throw errorToThrow;
+    }
+}
 function assertAllDefined(...args) {
     const result = [];
     for (let i = 0; i < args.length; i++) {
@@ -111,4 +116,4 @@ function upcast(x) {
     return x;
 }
 
-export { areFunctions, assertAllDefined, assertIsDefined, assertType, isBoolean, isDefined, isEmptyObject, isFunction, isIterable, isNumber, isObject, isString, isStringArray, isTypedArray, isUndefined, isUndefinedOrNull, upcast, validateConstraint, validateConstraints };
+export { areFunctions, assertAllDefined, assertDefined, assertIsDefined, assertType, isBoolean, isDefined, isEmptyObject, isFunction, isIterable, isNumber, isObject, isString, isStringArray, isTypedArray, isUndefined, isUndefinedOrNull, upcast, validateConstraint, validateConstraints };

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

@@ -4,55 +4,6 @@ const _UUIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{
 function isUUID(value) {
     return _UUIDPattern.test(value);
 }
-const generateUuid = (function () {
-    if (typeof crypto === 'object' && typeof crypto.randomUUID === 'function') {
-        return crypto.randomUUID.bind(crypto);
-    }
-    let getRandomValues;
-    if (typeof crypto === 'object' && typeof crypto.getRandomValues === 'function') {
-        getRandomValues = crypto.getRandomValues.bind(crypto);
-    }
-    else {
-        getRandomValues = function (bucket) {
-            for (let i = 0; i < bucket.length; i++) {
-                bucket[i] = Math.floor(Math.random() * 256);
-            }
-            return bucket;
-        };
-    }
-    const _data = ( new Uint8Array(16));
-    const _hex = [];
-    for (let i = 0; i < 256; i++) {
-        _hex.push(( i.toString(16)).padStart(2, '0'));
-    }
-    return function generateUuid() {
-        getRandomValues(_data);
-        _data[6] = (_data[6] & 0x0f) | 0x40;
-        _data[8] = (_data[8] & 0x3f) | 0x80;
-        let i = 0;
-        let result = '';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += '-';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += '-';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += '-';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += '-';
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        result += _hex[_data[i++]];
-        return result;
-    };
-})();
+const generateUuid = crypto.randomUUID.bind(crypto);
 
 export { generateUuid, isUUID };

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

@@ -16,10 +16,10 @@ export declare class NativeEditContext extends AbstractEditContext {
     readonly domNode: FastDomNode<HTMLDivElement>;
     private readonly _editContext;
     private readonly _screenReaderSupport;
+    private _editContextPrimarySelection;
     private _parent;
     private _decorations;
     private _primarySelection;
-    private _textStartPositionWithinEditor;
     private _targetWindowId;
     private _scrollTop;
     private _scrollLeft;
@@ -51,6 +51,7 @@ export declare class NativeEditContext extends AbstractEditContext {
     private _emitTypeEvent;
     private _onType;
     private _getNewEditContextState;
+    private _editContextStartPosition;
     private _handleTextFormatUpdate;
     private _updateSelectionAndControlBounds;
     private _updateCharacterBounds;