@codingame/monaco-vscode-api 17.2.1 → 18.0.0

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

@@ -0,0 +1,200 @@
+
+import { autorun } from '../reactions/autorun.js';
+import '../../errors.js';
+import '../../arrays.js';
+import '../../event.js';
+import { toDisposable, DisposableStore } from '../../lifecycle.js';
+import { observableValue } from '../observables/observableValue.js';
+import { derivedOpts, derived } from '../observables/derived.js';
+import { observableFromEvent } from '../observables/observableFromEvent.js';
+import { observableSignal } from '../observables/observableSignal.js';
+import { _setKeepObserved, _setRecomputeInitiallyAndOnChange } from '../observables/baseObservable.js';
+
+function observableFromPromise(promise) {
+    const observable = observableValue('promiseValue', {});
+    promise.then((value) => {
+        observable.set({ value }, undefined);
+    });
+    return observable;
+}
+function debouncedObservable(observable, debounceMs) {
+    let hasValue = false;
+    let lastValue;
+    let timeout = undefined;
+    return observableFromEvent(cb => {
+        const d = autorun(reader => {
+            const value = observable.read(reader);
+            if (!hasValue) {
+                hasValue = true;
+                lastValue = value;
+            }
+            else {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                timeout = setTimeout(() => {
+                    lastValue = value;
+                    cb();
+                }, debounceMs);
+            }
+        });
+        return {
+            dispose() {
+                d.dispose();
+                hasValue = false;
+                lastValue = undefined;
+            },
+        };
+    }, () => {
+        if (hasValue) {
+            return lastValue;
+        }
+        else {
+            return observable.get();
+        }
+    });
+}
+function wasEventTriggeredRecently(event, timeoutMs, disposableStore) {
+    const observable = observableValue('triggeredRecently', false);
+    let timeout = undefined;
+    disposableStore.add(event(() => {
+        observable.set(true, undefined);
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        timeout = setTimeout(() => {
+            observable.set(false, undefined);
+        }, timeoutMs);
+    }));
+    return observable;
+}
+function keepObserved(observable) {
+    const o = ( new KeepAliveObserver(false, undefined));
+    observable.addObserver(o);
+    return toDisposable(() => {
+        observable.removeObserver(o);
+    });
+}
+_setKeepObserved(keepObserved);
+function recomputeInitiallyAndOnChange(observable, handleValue) {
+    const o = ( new KeepAliveObserver(true, handleValue));
+    observable.addObserver(o);
+    try {
+        o.beginUpdate(observable);
+    }
+    finally {
+        o.endUpdate(observable);
+    }
+    return toDisposable(() => {
+        observable.removeObserver(o);
+    });
+}
+_setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange);
+class KeepAliveObserver {
+    constructor(_forceRecompute, _handleValue) {
+        this._forceRecompute = _forceRecompute;
+        this._handleValue = _handleValue;
+        this._counter = 0;
+    }
+    beginUpdate(observable) {
+        this._counter++;
+    }
+    endUpdate(observable) {
+        if (this._counter === 1 && this._forceRecompute) {
+            if (this._handleValue) {
+                this._handleValue(observable.get());
+            }
+            else {
+                observable.reportChanges();
+            }
+        }
+        this._counter--;
+    }
+    handlePossibleChange(observable) {
+    }
+    handleChange(observable, change) {
+    }
+}
+function derivedObservableWithCache(owner, computeFn) {
+    let lastValue = undefined;
+    const observable = derivedOpts({ owner, debugReferenceFn: computeFn }, reader => {
+        lastValue = computeFn(reader, lastValue);
+        return lastValue;
+    });
+    return observable;
+}
+function derivedObservableWithWritableCache(owner, computeFn) {
+    let lastValue = undefined;
+    const onChange = observableSignal('derivedObservableWithWritableCache');
+    const observable = derived(owner, reader => {
+        onChange.read(reader);
+        lastValue = computeFn(reader, lastValue);
+        return lastValue;
+    });
+    return Object.assign(observable, {
+        clearCache: (tx) => {
+            lastValue = undefined;
+            onChange.trigger(tx);
+        },
+        setCache: (newValue, tx) => {
+            lastValue = newValue;
+            onChange.trigger(tx);
+        }
+    });
+}
+function mapObservableArrayCached(owner, items, map, keySelector) {
+    let m = ( new ArrayMap(map, keySelector));
+    const self = derivedOpts({
+        debugReferenceFn: map,
+        owner,
+        onLastObserverRemoved: () => {
+            m.dispose();
+            m = ( new ArrayMap(map));
+        }
+    }, (reader) => {
+        m.setItems(items.read(reader));
+        return m.getItems();
+    });
+    return self;
+}
+class ArrayMap {
+    constructor(_map, _keySelector) {
+        this._map = _map;
+        this._keySelector = _keySelector;
+        this._cache = ( new Map());
+        this._items = [];
+    }
+    dispose() {
+        this._cache.forEach(entry => entry.store.dispose());
+        this._cache.clear();
+    }
+    setItems(items) {
+        const newItems = [];
+        const itemsToRemove = ( new Set(( this._cache.keys())));
+        for (const item of items) {
+            const key = this._keySelector ? this._keySelector(item) : item;
+            let entry = this._cache.get(key);
+            if (!entry) {
+                const store = ( new DisposableStore());
+                const out = this._map(item, store);
+                entry = { out, store };
+                this._cache.set(key, entry);
+            }
+            else {
+                itemsToRemove.delete(key);
+            }
+            newItems.push(entry.out);
+        }
+        for (const item of itemsToRemove) {
+            const entry = this._cache.get(item);
+            entry.store.dispose();
+            this._cache.delete(item);
+        }
+        this._items = newItems;
+    }
+    getItems() {
+        return this._items;
+    }
+}
+
+export { KeepAliveObserver, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, wasEventTriggeredRecently };

package/vscode/src/vs/base/common/observableInternal/{utilsCancellation.d.ts → utils/utilsCancellation.d.ts}

@@ -1,5 +1,5 @@
-import { IReader, IObservable } from "./base.js";
-import { CancellationToken } from "./commonFacade/cancellation.js";
+import { IReader, IObservable } from "../base.js";
+import { CancellationToken } from "../commonFacade/cancellation.js";
 export declare function waitForState<T>(observable: IObservable<T | null | undefined>): Promise<T>;
 export declare function waitForState<T, TState extends T>(observable: IObservable<T>, predicate: (state: T) => state is TState, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<TState>;
 export declare function waitForState<T>(observable: IObservable<T>, predicate: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T>;

package/vscode/src/vs/base/common/observableInternal/{utilsCancellation.js → utils/utilsCancellation.js}

@@ -1,11 +1,11 @@
 
-import { CancellationError } from '../errors.js';
-import '../cancellation.js';
-import './derived.js';
-import '../arrays.js';
-import '../event.js';
-import '../lifecycle.js';
-import { autorun } from './autorun.js';
+import { CancellationError } from '../../errors.js';
+import '../../cancellation.js';
+import '../../arrays.js';
+import '../../event.js';
+import '../../lifecycle.js';
+import { autorun } from '../reactions/autorun.js';
+import '../observables/derivedImpl.js';
 
 function waitForState(observable, predicate, isError, cancellationToken) {
     if (!predicate) {

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

@@ -0,0 +1,10 @@
+import { IObservable } from "../base.js";
+import { Event, IValueWithChangeEvent } from "../commonFacade/deps.js";
+import { DebugOwner } from "../debugName.js";
+export declare class ValueWithChangeEventFromObservable<T> implements IValueWithChangeEvent<T> {
+    readonly observable: IObservable<T>;
+    constructor(observable: IObservable<T>);
+    get onDidChange(): Event<void>;
+    get value(): T;
+}
+export declare function observableFromValueWithChangeEvent<T>(owner: DebugOwner, value: IValueWithChangeEvent<T>): IObservable<T>;

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

@@ -0,0 +1,26 @@
+
+import '../../errors.js';
+import '../../arrays.js';
+import { Event } from '../../event.js';
+import '../../lifecycle.js';
+import { observableFromEvent } from '../observables/observableFromEvent.js';
+
+class ValueWithChangeEventFromObservable {
+    constructor(observable) {
+        this.observable = observable;
+    }
+    get onDidChange() {
+        return Event.fromObservableLight(this.observable);
+    }
+    get value() {
+        return this.observable.get();
+    }
+}
+function observableFromValueWithChangeEvent(owner, value) {
+    if (value instanceof ValueWithChangeEventFromObservable) {
+        return value.observable;
+    }
+    return observableFromEvent(owner, value.onDidChange, () => value.value);
+}
+
+export { ValueWithChangeEventFromObservable, observableFromValueWithChangeEvent };

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

@@ -109,6 +109,7 @@ export interface IProductConfiguration {
     readonly languageExtensionTips?: readonly string[];
     readonly trustedExtensionUrlPublicKeys?: IStringDictionary<string[]>;
     readonly trustedExtensionAuthAccess?: string[] | IStringDictionary<string[]>;
+    readonly trustedMcpAuthAccess?: string[] | IStringDictionary<string[]>;
     readonly inheritAuthAccountPreference?: IStringDictionary<string[]>;
     readonly trustedExtensionProtocolHandlers?: readonly string[];
     readonly commandPaletteSuggestedCommandIds?: string[];
@@ -307,18 +308,19 @@ export interface IDefaultChatAgent {
     readonly extensionId: string;
     readonly chatExtensionId: string;
     readonly documentationUrl: string;
-    readonly termsStatementUrl: string;
-    readonly privacyStatementUrl: string;
     readonly skusDocumentationUrl: string;
     readonly publicCodeMatchesUrl: string;
     readonly manageSettingsUrl: string;
     readonly managePlanUrl: string;
     readonly manageOverageUrl: string;
     readonly upgradePlanUrl: string;
+    readonly signUpUrl: string;
     readonly providerId: string;
     readonly providerName: string;
     readonly enterpriseProviderId: string;
     readonly enterpriseProviderName: string;
+    readonly alternativeProviderId: string;
+    readonly alternativeProviderName: string;
     readonly providerUriSetting: string;
     readonly providerScopes: string[][];
     readonly entitlementUrl: string;
@@ -329,6 +331,7 @@ export interface IDefaultChatAgent {
     readonly completionsMenuCommand: string;
     readonly completionsRefreshTokenCommand: string;
     readonly chatRefreshTokenCommand: string;
+    readonly generateCommitMessageCommand: string;
     readonly completionsAdvancedSetting: string;
     readonly completionsEnablementSetting: string;
     readonly nextEditSuggestionsSetting: string;

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

@@ -134,3 +134,4 @@ export declare class InvisibleCharacters {
     static containsInvisibleCharacter(str: string): boolean;
     static get codePoints(): ReadonlySet<number>;
 }
+export declare const Ellipsis = "\u2026";

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

@@ -63,13 +63,13 @@ function count(value, substr) {
     }
     return result;
 }
-function truncate(value, maxLength, suffix = '…') {
+function truncate(value, maxLength, suffix = Ellipsis) {
     if (value.length <= maxLength) {
         return value;
     }
     return `${value.substr(0, maxLength)}${suffix}`;
 }
-function truncateMiddle(value, maxLength, suffix = '…') {
+function truncateMiddle(value, maxLength, suffix = Ellipsis) {
     if (value.length <= maxLength) {
         return value;
     }
@@ -165,13 +165,6 @@ 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);
@@ -824,5 +817,6 @@ class InvisibleCharacters {
         return InvisibleCharacters.getData();
     }
 }
+const Ellipsis = '\u2026';
 
-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 };
+export { AmbiguousCharacters, CodePointIterator, Ellipsis, 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, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };

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

@@ -4,7 +4,7 @@ export interface ThemeColor {
     id: string;
 }
 export declare namespace ThemeColor {
-    function isThemeColor(obj: any): obj is ThemeColor;
+    function isThemeColor(obj: unknown): obj is ThemeColor;
 }
 export declare function themeColorFromId(id: ColorIdentifier): {
     id: string;
@@ -21,7 +21,7 @@ export declare namespace ThemeIcon {
     function asClassNameArray(icon: ThemeIcon): string[];
     function asClassName(icon: ThemeIcon): string;
     function asCSSSelector(icon: ThemeIcon): string;
-    function isThemeIcon(obj: any): obj is ThemeIcon;
+    function isThemeIcon(obj: unknown): obj is ThemeIcon;
     function fromString(str: string): ThemeIcon | undefined;
     function fromId(id: string): ThemeIcon;
     function modify(icon: ThemeIcon, modifier: "disabled" | "spin" | undefined): ThemeIcon;

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

@@ -4,7 +4,7 @@ import { Codicon } from './codicons.js';
 var ThemeColor;
 (function (ThemeColor) {
     function isThemeColor(obj) {
-        return obj && typeof obj === 'object' && typeof obj.id === 'string';
+        return !!obj && typeof obj === 'object' && typeof obj.id === 'string';
     }
     ThemeColor.isThemeColor = isThemeColor;
 })(ThemeColor || (ThemeColor = {}));
@@ -42,7 +42,7 @@ var ThemeIcon;
     }
     ThemeIcon.asCSSSelector = asCSSSelector;
     function isThemeIcon(obj) {
-        return obj && typeof obj === 'object' && typeof obj.id === 'string' && (typeof obj.color === 'undefined' || ThemeColor.isThemeColor(obj.color));
+        return !!obj && typeof obj === 'object' && typeof obj.id === 'string' && (typeof obj.color === 'undefined' || ThemeColor.isThemeColor(obj.color));
     }
     ThemeIcon.isThemeIcon = isThemeIcon;
     const _regexFromString = ( new RegExp(

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

@@ -5,6 +5,7 @@ export declare function isObject(obj: unknown): obj is Object;
 export declare function isTypedArray(obj: unknown): obj is Object;
 export declare function isNumber(obj: unknown): obj is number;
 export declare function isIterable<T>(obj: unknown): obj is Iterable<T>;
+export declare function isAsyncIterable<T>(obj: unknown): obj is AsyncIterable<T>;
 export declare function isBoolean(obj: unknown): obj is boolean;
 export declare function isUndefined(obj: unknown): obj is undefined;
 export declare function isDefined<T>(arg: T | null | undefined): arg is T;
@@ -27,7 +28,7 @@ export declare function assertAllDefined<T1, T2, T3, T4>(t1: T1 | null | undefin
     T3,
     T4
 ];
-export declare function assertOneOf<TType, TSubtype extends TType>(item: TType, list: readonly TSubtype[], errorPrefix: string): asserts item is TSubtype;
+export declare const isOneOf: <TType, TSubtype extends TType>(value: TType, validValues: readonly TSubtype[]) => value is TSubtype;
 export declare function typeCheck<T = never>(_thing: NoInfer<T>): void;
 export declare function isEmptyObject(obj: unknown): obj is object;
 export declare function isFunction(obj: unknown): obj is Function;

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

@@ -63,9 +63,9 @@ function assertAllDefined(...args) {
     }
     return result;
 }
-function assertOneOf(item, list, errorPrefix) {
-    assert(list.includes(item), `${errorPrefix}: Expected '${item}' to be one of [${list.join(', ')}].`);
-}
+const isOneOf = (value, validValues) => {
+    return validValues.includes(value);
+};
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 function isEmptyObject(obj) {
     if (!isObject(obj)) {
@@ -119,4 +119,4 @@ function upcast(x) {
     return x;
 }
 
-export { areFunctions, assertAllDefined, assertDefined, assertIsDefined, assertOneOf, 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, isOneOf, isString, isStringArray, isTypedArray, isUndefined, isUndefinedOrNull, upcast, validateConstraint, validateConstraints };

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

@@ -1,5 +1,5 @@
 export declare class URI implements UriComponents {
-    static isUri(thing: any): thing is URI;
+    static isUri(thing: unknown): thing is URI;
     readonly scheme: string;
     readonly authority: string;
     readonly path: string;
@@ -33,7 +33,7 @@ export interface UriComponents {
     query?: string;
     fragment?: string;
 }
-export declare function isUriComponents(thing: any): thing is UriComponents;
+export declare function isUriComponents(thing: unknown): thing is UriComponents;
 export declare function uriToFsPath(uri: URI, keepDriveLetterCasing: boolean): string;
 export type UriDto<T> = {
     [K in keyof T]: T[K] extends URI ? UriComponents : UriDto<T[K]>;

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

@@ -62,7 +62,7 @@ class URI {
         if (thing instanceof URI) {
             return true;
         }
-        if (!thing) {
+        if (!thing || typeof thing !== 'object') {
             return false;
         }
         return typeof thing.authority === 'string'

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

@@ -2,7 +2,7 @@ import { Event } from "../../../base/common/event.js";
 import { Disposable } from "../../../base/common/lifecycle.js";
 import { ConfigurationChangedEvent, EditorOption, FindComputedEditorOptionValueById, IComputedEditorOptions, IEditorOptions, IEnvironmentalOptions } from "../../common/config/editorOptions.js";
 import { BareFontInfo, FontInfo, IValidatedEditorOptions } from "../../common/config/fontInfo.js";
-import { IDimension } from "../../common/core/dimension.js";
+import { IDimension } from "../../common/core/2d/dimension.js";
 import { IEditorConfiguration } from "../../common/config/editorConfiguration.js";
 import { AccessibilitySupport } from "../../../platform/accessibility/common/accessibility.js";
 import { IAccessibilityService } from "../../../platform/accessibility/common/accessibility.service.js";

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

@@ -77,7 +77,7 @@ let EditorConfiguration = class EditorConfiguration extends Disposable {
             lineNumbersDigitCount: this._lineNumbersDigitCount,
             emptySelectionClipboard: partialEnv.emptySelectionClipboard,
             pixelRatio: partialEnv.pixelRatio,
-            tabFocusMode: TabFocus.getTabFocusMode(),
+            tabFocusMode: this._validatedOptions.get(EditorOption.tabFocusMode) || TabFocus.getTabFocusMode(),
             inputMode: InputMode.getInputMode(),
             accessibilitySupport: partialEnv.accessibilitySupport,
             glyphMarginDecorationLaneCount: this._glyphMarginDecorationLaneCount,

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

@@ -1,5 +1,5 @@
 import { Disposable } from "../../../base/common/lifecycle.js";
-import { IDimension } from "../../common/core/dimension.js";
+import { IDimension } from "../../common/core/2d/dimension.js";
 import { Event } from "../../../base/common/event.js";
 export declare class ElementSizeObserver extends Disposable {
     private _onDidChange;

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

@@ -17,7 +17,7 @@ import { ScreenReaderSupport } from './screenReaderSupport.js';
 import { Range } from '../../../../common/core/range.js';
 import { Selection } from '../../../../common/core/selection.js';
 import { Position } from '../../../../common/core/position.js';
-import { PositionOffsetTransformer } from '../../../../common/core/positionToOffset.js';
+import { PositionOffsetTransformer } from '../../../../common/core/text/positionToOffset.js';
 import { MutableDisposable } from '../../../../../base/common/lifecycle.js';
 import { EditContext } from './editContextFactory.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';

package/vscode/src/vs/editor/browser/controller/editContext/native/screenReaderSupport.js

@@ -66,8 +66,9 @@ let ScreenReaderSupport = class ScreenReaderSupport {
         const spaceWidth = options.get(EditorOption.fontInfo).spaceWidth;
         this._domNode.domNode.style.tabSize = `${tabSize * spaceWidth}px`;
         const wordWrapOverride2 = options.get(EditorOption.wordWrapOverride2);
-        const wordWrapValue = wordWrapOverride2 !== 'inherit' ? wordWrapOverride2 : options.get(EditorOption.wordWrap);
-        this._domNode.domNode.style.textWrap = wordWrapValue === 'off' ? 'nowrap' : 'wrap';
+        const wordWrapOverride1 = (wordWrapOverride2 === 'inherit' ? options.get(EditorOption.wordWrapOverride1) : wordWrapOverride2);
+        const wordWrap = (wordWrapOverride1 === 'inherit' ? options.get(EditorOption.wordWrap) : wordWrapOverride1);
+        this._domNode.domNode.style.textWrap = wordWrap === 'off' ? 'nowrap' : 'wrap';
     }
     onCursorStateChanged(e) {
         this._primarySelection = e.selections[0] ?? ( new Selection(1, 1, 1, 1));

package/vscode/src/vs/editor/browser/editorBrowser.d.ts

@@ -4,7 +4,7 @@ import { IBoundarySashes } from "../../base/browser/ui/sash/sash.js";
 import { Event } from "../../base/common/event.js";
 import { IEditorConstructionOptions } from "./config/editorConfiguration.js";
 import { ConfigurationChangedEvent, EditorLayoutInfo, EditorOption, FindComputedEditorOptionValueById, IComputedEditorOptions, IDiffEditorOptions, IEditorOptions, OverviewRulerPosition } from "../common/config/editorOptions.js";
-import { IDimension } from "../common/core/dimension.js";
+import { IDimension } from "../common/core/2d/dimension.js";
 import { IPosition, Position } from "../common/core/position.js";
 import { IRange, Range } from "../common/core/range.js";
 import { Selection } from "../common/core/selection.js";

package/vscode/src/vs/editor/browser/gpu/contentSegmenter.js

@@ -22,7 +22,7 @@ class GraphemeContentSegmenter {
     constructor(lineData) {
         this._segments = [];
         const content = lineData.content;
-        const segmenter = safeIntl.Segmenter(undefined, { granularity: 'grapheme' });
+        const segmenter = safeIntl.Segmenter(undefined, { granularity: 'grapheme' }).value;
         const segmentedContent = Array.from(segmenter.segment(content));
         let segmenterIndex = 0;
         for (let x = 0; x < content.length; x++) {

package/vscode/src/vs/editor/browser/gpu/gpuDisposable.js

@@ -25,7 +25,7 @@ var GPULifecycle;
     function createBuffer(device, descriptor, initialValues) {
         const buffer = device.createBuffer(descriptor);
         if (initialValues) {
-            device.queue.writeBuffer(buffer, 0, isFunction(initialValues) ? initialValues() : initialValues);
+            device.queue.writeBuffer(buffer, 0, (isFunction(initialValues) ? initialValues() : initialValues));
         }
         return wrapDestroyableInDisposable(buffer);
     }

package/vscode/src/vs/editor/browser/gpu/viewGpuContext.js

@@ -21,8 +21,8 @@ import { InlineDecorationType } from '../../common/viewModel.js';
 import { DecorationStyleCache } from './css/decorationStyleCache.js';
 import { ViewportRenderStrategy } from './renderStrategy/viewportRenderStrategy.js';
 import Severity$1 from '../../../base/common/severity.js';
-import { runOnChange } from '../../../base/common/observableInternal/utils.js';
-import { observableValue } from '../../../base/common/observableInternal/base.js';
+import { observableValue } from '../../../base/common/observableInternal/observables/observableValue.js';
+import { runOnChange } from '../../../base/common/observableInternal/utils/runOnChange.js';
 
 var ViewGpuContext_1;
 let ViewGpuContext = class ViewGpuContext extends Disposable {

package/vscode/src/vs/editor/browser/observableCodeEditor.d.ts

@@ -1,15 +1,15 @@
 import { Disposable, DisposableStore, IDisposable } from "../../base/common/lifecycle.js";
 import { IObservable, IObservableWithChange, ITransaction } from "../../base/common/observable.js";
 import { EditorOption, FindComputedEditorOptionValueById } from "../common/config/editorOptions.js";
-import { LineRange } from "../common/core/lineRange.js";
-import { OffsetRange } from "../common/core/offsetRange.js";
+import { LineRange } from "../common/core/ranges/lineRange.js";
+import { OffsetRange } from "../common/core/ranges/offsetRange.js";
 import { Position } from "../common/core/position.js";
 import { Selection } from "../common/core/selection.js";
 import { ICursorSelectionChangedEvent } from "../common/cursorEvents.js";
 import { IModelDeltaDecoration, ITextModel } from "../common/model.js";
 import { IModelContentChangedEvent } from "../common/textModelEvents.js";
 import { ICodeEditor, IContentWidgetPosition, IEditorMouseEvent, IOverlayWidgetPosition, IPasteEvent } from "./editorBrowser.js";
-import { Point } from "./point.js";
+import { Point } from "../common/core/2d/point.js";
 export declare function observableCodeEditor(editor: ICodeEditor): ObservableCodeEditor;
 export declare class ObservableCodeEditor extends Disposable {
     readonly editor: ICodeEditor;
@@ -35,10 +35,10 @@ export declare class ObservableCodeEditor extends Disposable {
     readonly isTextFocused: IObservable<boolean>;
     readonly inComposition: IObservable<boolean>;
     readonly value: import("../../base/common/observable.js").ISettableObservable<string, void>;
-    readonly valueIsEmpty: IObservable<boolean>;
+    readonly valueIsEmpty: IObservableWithChange<boolean, void>;
     readonly cursorSelection: IObservable<Selection | null>;
     readonly cursorPosition: IObservable<Position | null>;
-    readonly cursorLineNumber: IObservable<number | null>;
+    readonly cursorLineNumber: IObservableWithChange<number | null, void>;
     readonly onDidType: import("../../base/common/observable.js").IObservableSignal<string>;
     readonly onDidPaste: import("../../base/common/observable.js").IObservableSignal<IPasteEvent>;
     readonly scrollTop: IObservable<number>;
@@ -47,9 +47,11 @@ export declare class ObservableCodeEditor extends Disposable {
     readonly layoutInfoContentLeft: IObservable<number>;
     readonly layoutInfoDecorationsLeft: IObservable<number>;
     readonly layoutInfoWidth: IObservable<number>;
+    readonly layoutInfoHeight: IObservable<number>;
     readonly layoutInfoMinimap: IObservable<import("../common/config/editorOptions.js").EditorMinimapLayoutInfo>;
     readonly layoutInfoVerticalScrollbarWidth: IObservable<number>;
     readonly contentWidth: IObservable<number>;
+    readonly contentHeight: IObservable<number>;
     getOption<T extends EditorOption>(id: T): IObservable<FindComputedEditorOptionValueById<T>>;
     setDecorations(decorations: IObservable<IModelDeltaDecoration[]>): IDisposable;
     private _widgetCounter;

package/vscode/src/vs/editor/browser/observableCodeEditor.js

@@ -3,16 +3,18 @@ import { equalsIfDefined, itemsEquals } from '../../base/common/equals.js';
 import { Disposable, DisposableStore, toDisposable } from '../../base/common/lifecycle.js';
 import '../../base/common/observableInternal/index.js';
 import { EditorOption } from '../common/config/editorOptions.js';
-import { OffsetRange } from '../common/core/offsetRange.js';
+import { OffsetRange } from '../common/core/ranges/offsetRange.js';
 import { Position } from '../common/core/position.js';
 import { Selection } from '../common/core/selection.js';
 import { ContentWidgetPositionPreference } from './editorBrowser.js';
-import { Point } from './point.js';
-import { TransactionImpl, observableValue } from '../../base/common/observableInternal/base.js';
-import { derivedOpts, derivedWithSetter, derived } from '../../base/common/observableInternal/derived.js';
-import { observableFromEvent, observableSignal } from '../../base/common/observableInternal/utils.js';
-import { autorunOpts, autorun } from '../../base/common/observableInternal/autorun.js';
-import { observableValueOpts } from '../../base/common/observableInternal/api.js';
+import { Point } from '../common/core/2d/point.js';
+import { TransactionImpl } from '../../base/common/observableInternal/transaction.js';
+import { derivedOpts, derivedWithSetter, derived } from '../../base/common/observableInternal/observables/derived.js';
+import { autorunOpts, autorun } from '../../base/common/observableInternal/reactions/autorun.js';
+import { observableValue } from '../../base/common/observableInternal/observables/observableValue.js';
+import { observableFromEvent } from '../../base/common/observableInternal/observables/observableFromEvent.js';
+import { observableValueOpts } from '../../base/common/observableInternal/observables/observableValueOpts.js';
+import { observableSignal } from '../../base/common/observableInternal/observables/observableSignal.js';
 
 function observableCodeEditor(editor) {
     return ObservableCodeEditor.get(editor);
@@ -117,9 +119,11 @@ class ObservableCodeEditor extends Disposable {
         this.layoutInfoContentLeft = ( this.layoutInfo.map(l => l.contentLeft));
         this.layoutInfoDecorationsLeft = ( this.layoutInfo.map(l => l.decorationsLeft));
         this.layoutInfoWidth = ( this.layoutInfo.map(l => l.width));
+        this.layoutInfoHeight = ( this.layoutInfo.map(l => l.height));
         this.layoutInfoMinimap = ( this.layoutInfo.map(l => l.minimap));
         this.layoutInfoVerticalScrollbarWidth = ( this.layoutInfo.map(l => l.verticalScrollbarWidth));
         this.contentWidth = observableFromEvent(this.editor.onDidContentSizeChange, () => this.editor.getContentWidth());
+        this.contentHeight = observableFromEvent(this.editor.onDidContentSizeChange, () => this.editor.getContentHeight());
         this._widgetCounter = 0;
         this.openedPeekWidgets = observableValue(this, 0);
         this._register(this.editor.onBeginUpdate(() => this._beginUpdate()));