@codingame/monaco-vscode-api 18.4.0 → 19.0.1

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

@@ -2,7 +2,32 @@
 import { decodeBase64 } from './buffer.js';
 
 const WELL_KNOWN_ROUTE = '/.well-known';
+const AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/oauth-protected-resource`;
 const AUTH_SERVER_METADATA_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/oauth-authorization-server`;
+const AUTH_SCOPE_SEPARATOR = ' ';
+var AuthorizationErrorType;
+(function (AuthorizationErrorType) {
+    AuthorizationErrorType["InvalidRequest"] = "invalid_request";
+    AuthorizationErrorType["InvalidClient"] = "invalid_client";
+    AuthorizationErrorType["InvalidGrant"] = "invalid_grant";
+    AuthorizationErrorType["UnauthorizedClient"] = "unauthorized_client";
+    AuthorizationErrorType["UnsupportedGrantType"] = "unsupported_grant_type";
+    AuthorizationErrorType["InvalidScope"] = "invalid_scope";
+})(AuthorizationErrorType || (AuthorizationErrorType = {}));
+var AuthorizationDeviceCodeErrorType;
+(function (AuthorizationDeviceCodeErrorType) {
+    AuthorizationDeviceCodeErrorType["AuthorizationPending"] = "authorization_pending";
+    AuthorizationDeviceCodeErrorType["SlowDown"] = "slow_down";
+    AuthorizationDeviceCodeErrorType["AccessDenied"] = "access_denied";
+    AuthorizationDeviceCodeErrorType["ExpiredToken"] = "expired_token";
+})(AuthorizationDeviceCodeErrorType || (AuthorizationDeviceCodeErrorType = {}));
+var AuthorizationRegistrationErrorType;
+(function (AuthorizationRegistrationErrorType) {
+    AuthorizationRegistrationErrorType["InvalidRedirectUri"] = "invalid_redirect_uri";
+    AuthorizationRegistrationErrorType["InvalidClientMetadata"] = "invalid_client_metadata";
+    AuthorizationRegistrationErrorType["InvalidSoftwareStatement"] = "invalid_software_statement";
+    AuthorizationRegistrationErrorType["UnapprovedSoftwareStatement"] = "unapproved_software_statement";
+})(AuthorizationRegistrationErrorType || (AuthorizationRegistrationErrorType = {}));
 function isAuthorizationProtectedResourceMetadata(obj) {
     if (typeof obj !== 'object' || obj === null) {
         return false;
@@ -31,6 +56,20 @@ function isAuthorizationTokenResponse(obj) {
     const response = obj;
     return response.access_token !== undefined && response.token_type !== undefined;
 }
+function isAuthorizationErrorResponse(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const response = obj;
+    return response.error !== undefined;
+}
+function isAuthorizationRegistrationErrorResponse(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const response = obj;
+    return response.error !== undefined;
+}
 function getDefaultMetadataForUrl(authorizationServer) {
     return {
         issuer: ( authorizationServer.toString()),
@@ -49,9 +88,13 @@ function getMetadataWithDefaultValues(metadata) {
         registration_endpoint: metadata.registration_endpoint ?? ( ( new URL('/register', issuer)).toString()),
     };
 }
+const grantTypesSupported = ['authorization_code', 'refresh_token', 'urn:ietf:params:oauth:grant-type:device_code'];
 const DEFAULT_AUTH_FLOW_PORT = 33418;
-async function fetchDynamicRegistration(registrationEndpoint, clientName) {
-    const response = await fetch(registrationEndpoint, {
+async function fetchDynamicRegistration(serverMetadata, clientName, scopes) {
+    if (!serverMetadata.registration_endpoint) {
+        throw ( new Error('Server does not support dynamic registration'));
+    }
+    const response = await fetch(serverMetadata.registration_endpoint, {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json'
@@ -59,7 +102,9 @@ async function fetchDynamicRegistration(registrationEndpoint, clientName) {
         body: JSON.stringify({
             client_name: clientName,
             client_uri: 'https://code.visualstudio.com',
-            grant_types: ['authorization_code', 'refresh_token', 'urn:ietf:params:oauth:grant-type:device_code'],
+            grant_types: serverMetadata.grant_types_supported
+                ? serverMetadata.grant_types_supported.filter(gt => grantTypesSupported.includes(gt))
+                : grantTypesSupported,
             response_types: ['code'],
             redirect_uris: [
                 'https://insiders.vscode.dev/redirect',
@@ -69,11 +114,25 @@ async function fetchDynamicRegistration(registrationEndpoint, clientName) {
                 `http://localhost:${DEFAULT_AUTH_FLOW_PORT}/`,
                 `http://127.0.0.1:${DEFAULT_AUTH_FLOW_PORT}/`
             ],
-            token_endpoint_auth_method: 'none'
+            scope: scopes?.join(AUTH_SCOPE_SEPARATOR),
+            token_endpoint_auth_method: 'none',
+            application_type: 'native'
         })
     });
     if (!response.ok) {
-        throw ( new Error(`Registration failed: ${response.statusText}`));
+        const result = await response.text();
+        let errorDetails = result;
+        try {
+            const errorResponse = JSON.parse(result);
+            if (isAuthorizationRegistrationErrorResponse(errorResponse)) {
+                errorDetails = `${errorResponse.error}${errorResponse.error_description ? `: ${errorResponse.error_description}` : ''}`;
+            }
+        }
+        catch {
+        }
+        throw ( new Error(
+            `Registration to ${serverMetadata.registration_endpoint} failed: ${errorDetails}`
+        ));
     }
     const registration = await response.json();
     if (isAuthorizationDynamicClientRegistrationResponse(registration)) {
@@ -120,5 +179,17 @@ function getClaimsFromJWT(token) {
         throw ( new Error('Failed to parse JWT token'));
     }
 }
+function getResourceServerBaseUrlFromDiscoveryUrl(discoveryUrl) {
+    const url = ( new URL(discoveryUrl));
+    if (!url.pathname.startsWith(AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH)) {
+        throw ( new Error(
+            `Invalid discovery URL: expected path to start with ${AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH}`
+        ));
+    }
+    const pathWithoutDiscovery = url.pathname.substring(AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH.length);
+    const baseUrl = ( new URL(url.origin));
+    baseUrl.pathname = pathWithoutDiscovery || '/';
+    return ( baseUrl.toString());
+}
 
-export { AUTH_SERVER_METADATA_DISCOVERY_PATH, DEFAULT_AUTH_FLOW_PORT, fetchDynamicRegistration, getClaimsFromJWT, getDefaultMetadataForUrl, getMetadataWithDefaultValues, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader };
+export { AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH, AUTH_SCOPE_SEPARATOR, AUTH_SERVER_METADATA_DISCOVERY_PATH, AuthorizationDeviceCodeErrorType, AuthorizationErrorType, AuthorizationRegistrationErrorType, DEFAULT_AUTH_FLOW_PORT, fetchDynamicRegistration, getClaimsFromJWT, getDefaultMetadataForUrl, getMetadataWithDefaultValues, getResourceServerBaseUrlFromDiscoveryUrl, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationErrorResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationRegistrationErrorResponse, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader };

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

@@ -15,9 +15,9 @@ export { observableFromEventOpts } from "./observables/observableFromEvent.js";
 export { observableSignalFromEvent } from "./observables/observableSignalFromEvent.js";
 export { asyncTransaction, globalTransaction, subtransaction, transaction, TransactionImpl } from "./transaction.js";
 export { observableFromValueWithChangeEvent, ValueWithChangeEventFromObservable } from "./utils/valueWithChangeEvent.js";
-export { runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore } from "./utils/runOnChange.js";
+export { runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, type RemoveUndefined } from "./utils/runOnChange.js";
 export { derivedConstOnceDefined, latestChangedValue } from "./experimental/utils.js";
 export { observableFromEvent } from "./observables/observableFromEvent.js";
 export { observableValue } from "./observables/observableValue.js";
 export { ObservableSet } from "./set.js";
-export { ObservableMap } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/observableInternal/map";
+export { ObservableMap } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/base/common/observableInternal/map";

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

@@ -2,10 +2,17 @@
 
 function getFirstStackFrameOutsideOf(stack, pattern) {
     const lines = stack.split('\n');
-    for (const line of lines.slice(1)) {
+    for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
         if (pattern && pattern.test(line)) {
             continue;
         }
+        const showFramesUpMatch = line.match(/\$show(\d+)FramesUp/);
+        if (showFramesUpMatch) {
+            const n = parseInt(showFramesUpMatch[1], 10);
+            i += (n - 1);
+            continue;
+        }
         const result = parseLine(line);
         if (result) {
             return result;

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

@@ -1,5 +1,4 @@
 
-import './index.js';
 import { observableValueOpts } from './observables/observableValueOpts.js';
 
 class ObservableSet {

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

@@ -33,7 +33,7 @@ function _define() {
                 getMarks() {
                     let timeOrigin = performance.timeOrigin;
                     if (typeof timeOrigin !== 'number') {
-                        timeOrigin = performance.timing.navigationStart || performance.timing.redirectStart || performance.timing.fetchStart;
+                        timeOrigin = (performance.timing.navigationStart || performance.timing.redirectStart || performance.timing.fetchStart) ?? 0;
                     }
                     const result = [{ name: 'code/timeOrigin', startTime: Math.round(timeOrigin) }];
                     for (const entry of performance.getEntriesByType('mark')) {

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

@@ -5,7 +5,7 @@ export interface IBuiltInExtension {
     readonly name: string;
     readonly version: string;
     readonly repo: string;
-    readonly metadata: any;
+    readonly metadata: unknown;
 }
 export interface IProductWalkthrough {
     id: string;
@@ -91,6 +91,7 @@ export interface IProductConfiguration {
     readonly extensionsGallery?: {
         readonly serviceUrl: string;
         readonly controlUrl: string;
+        readonly mcpUrl: string;
         readonly extensionUrlTemplate: string;
         readonly resourceUrlTemplate: string;
         readonly nlsBaseUrl: string;

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

@@ -1,4 +1,3 @@
-import { URI } from "./uri.js";
 export declare function isString(str: unknown): str is string;
 export declare function isStringArray(value: unknown): value is string[];
 export declare function isObject(obj: unknown): obj is Object;
@@ -11,18 +10,18 @@ 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): NonNullable<T>;
+export declare function assertReturnsDefined<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): [
+export declare function assertReturnsAllDefined<T1, T2>(t1: T1 | null | undefined, t2: T2 | null | undefined): [
     T1,
     T2
 ];
-export declare function assertAllDefined<T1, T2, T3>(t1: T1 | null | undefined, t2: T2 | null | undefined, t3: T3 | null | undefined): [
+export declare function assertReturnsAllDefined<T1, T2, T3>(t1: T1 | null | undefined, t2: T2 | null | undefined, t3: T3 | null | undefined): [
     T1,
     T2,
     T3
 ];
-export declare function assertAllDefined<T1, T2, T3, T4>(t1: T1 | null | undefined, t2: T2 | null | undefined, t3: T3 | null | undefined, t4: T4 | null | undefined): [
+export declare function assertReturnsAllDefined<T1, T2, T3, T4>(t1: T1 | null | undefined, t2: T2 | null | undefined, t3: T3 | null | undefined, t4: T4 | null | undefined): [
     T1,
     T2,
     T3,
@@ -58,7 +57,4 @@ export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : Partial<T[P]>;
 };
 export type PartialExcept<T, K extends keyof T> = Partial<Omit<T, K>> & Pick<T, K>;
-export type WithUriValue<T extends object> = T & {
-    value: URI;
-};
 export {};

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

@@ -42,7 +42,7 @@ function assertType(condition, type) {
         throw ( new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type'));
     }
 }
-function assertIsDefined(arg) {
+function assertReturnsDefined(arg) {
     assert(arg !== null && arg !== undefined, 'Argument is `undefined` or `null`.');
     return arg;
 }
@@ -52,7 +52,7 @@ function assertDefined(value, error) {
         throw errorToThrow;
     }
 }
-function assertAllDefined(...args) {
+function assertReturnsAllDefined(...args) {
     const result = [];
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -119,4 +119,4 @@ function upcast(x) {
     return x;
 }
 
-export { areFunctions, assertAllDefined, assertDefined, assertIsDefined, assertType, isBoolean, isDefined, isEmptyObject, isFunction, isIterable, isNumber, isObject, isOneOf, isString, isStringArray, isTypedArray, isUndefined, isUndefinedOrNull, upcast, validateConstraint, validateConstraints };
+export { areFunctions, assertDefined, assertReturnsAllDefined, assertReturnsDefined, assertType, isBoolean, isDefined, isEmptyObject, isFunction, isIterable, isNumber, isObject, isOneOf, isString, isStringArray, isTypedArray, isUndefined, isUndefinedOrNull, upcast, validateConstraint, validateConstraints };

package/vscode/src/vs/base/common/worker/webWorker.js

@@ -232,7 +232,7 @@ class WebWorkerClient extends Disposable {
         super();
         this._localChannels = ( new Map());
         this._remoteChannels = ( new Map());
-        this._worker = worker;
+        this._worker = this._register(worker);
         this._register(this._worker.onMessage((msg) => {
             this._protocol.handleMessage(msg);
         }));

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

@@ -159,6 +159,14 @@ registerEditorSettingMigration('experimental.stickyScroll.maxLineCount', (value,
         }
     }
 });
+registerEditorSettingMigration('editor.experimentalEditContextEnabled', (value, read, write) => {
+    if (typeof value === 'boolean') {
+        write('editor.experimentalEditContextEnabled', undefined);
+        if (typeof read('editor.editContext') === 'undefined') {
+            write('editor.editContext', value);
+        }
+    }
+});
 registerEditorSettingMigration('codeActionsOnSave', (value, read, write) => {
     if (value && typeof value === 'object') {
         let toBeModified = false;

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

@@ -17,6 +17,7 @@ export declare class NativeEditContext extends AbstractEditContext {
     private readonly _imeTextArea;
     private readonly _editContext;
     private readonly _screenReaderSupport;
+    private _previousEditContextSelection;
     private _editContextPrimarySelection;
     private _parent;
     private _decorations;
@@ -39,6 +40,7 @@ export declare class NativeEditContext extends AbstractEditContext {
     onLinesChanged(e: ViewLinesChangedEvent): boolean;
     onLinesDeleted(e: ViewLinesDeletedEvent): boolean;
     onLinesInserted(e: ViewLinesInsertedEvent): boolean;
+    private _updateEditContextOnLineChange;
     onScrollChanged(e: ViewScrollChangedEvent): boolean;
     onZonesChanged(e: ViewZonesChangedEvent): boolean;
     onWillPaste(): void;

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

@@ -17,13 +17,15 @@ 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/text/positionToOffset.js';
+import '../../../../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';
 import { NativeEditContextRegistry } from './nativeEditContextRegistry.js';
 import { isHighSurrogate, isLowSurrogate } from '../../../../../base/common/strings.js';
 import { IME } from '../../../../../base/common/ime.js';
+import { OffsetRange } from '../../../../common/core/ranges/offsetRange.js';
+import { PositionOffsetTransformer } from '../../../../common/core/text/positionToOffsetImpl.js';
 
 registerCss(nativeEditContext);
 var CompositionClassName;
@@ -38,6 +40,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._viewController = _viewController;
         this._visibleRangeProvider = _visibleRangeProvider;
         this._accessibilityService = _accessibilityService;
+        this._previousEditContextSelection = ( new OffsetRange(0, 0));
         this._editContextPrimarySelection = ( new Selection(1, 1, 1, 1));
         this._decorations = [];
         this._primarySelection = ( new Selection(1, 1, 1, 1));
@@ -147,8 +150,8 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         let reenableTracking = false;
         this._register(IME.onDidChange(() => {
             if (IME.enabled && reenableTracking) {
-                this.domNode.focus();
                 this._focusTracker.resume();
+                this.domNode.focus();
                 reenableTracking = false;
             }
             if (!IME.enabled && this.isFocused()) {
@@ -173,7 +176,6 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
     }
     prepareRender(ctx) {
         this._screenReaderSupport.prepareRender(ctx);
-        this._updateEditContext();
         this._updateSelectionAndControlBounds(ctx);
     }
     render(ctx) {
@@ -197,14 +199,23 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         return true;
     }
     onLinesChanged(e) {
+        this._updateEditContextOnLineChange(e.fromLineNumber, e.fromLineNumber + e.count - 1);
         return true;
     }
     onLinesDeleted(e) {
+        this._updateEditContextOnLineChange(e.fromLineNumber, e.toLineNumber);
         return true;
     }
     onLinesInserted(e) {
+        this._updateEditContextOnLineChange(e.fromLineNumber, e.toLineNumber);
         return true;
     }
+    _updateEditContextOnLineChange(fromLineNumber, toLineNumber) {
+        if (this._editContextPrimarySelection.endLineNumber < fromLineNumber || this._editContextPrimarySelection.startLineNumber > toLineNumber) {
+            return;
+        }
+        this._updateEditContext();
+    }
     onScrollChanged(e) {
         this._scrollLeft = e.scrollLeft;
         this._scrollTop = e.scrollTop;
@@ -262,21 +273,15 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._editContext.updateText(0, Number.MAX_SAFE_INTEGER, editContextState.text ?? ' ');
         this._editContext.updateSelection(editContextState.selectionStartOffset, editContextState.selectionEndOffset);
         this._editContextPrimarySelection = editContextState.editContextPrimarySelection;
+        this._previousEditContextSelection = ( new OffsetRange(editContextState.selectionStartOffset, editContextState.selectionEndOffset));
     }
     _emitTypeEvent(viewController, e) {
         if (!this._editContext) {
             return;
         }
-        if (!this._editContextPrimarySelection.equalsSelection(this._primarySelection)) {
-            return;
-        }
-        const model = this._context.viewModel.model;
-        const startPositionOfEditContext = this._editContextStartPosition();
-        const offsetOfStartOfText = model.getOffsetAt(startPositionOfEditContext);
-        const offsetOfSelectionEnd = model.getOffsetAt(this._primarySelection.getEndPosition());
-        const offsetOfSelectionStart = model.getOffsetAt(this._primarySelection.getStartPosition());
-        const selectionEndOffset = offsetOfSelectionEnd - offsetOfStartOfText;
-        const selectionStartOffset = offsetOfSelectionStart - offsetOfStartOfText;
+        const selectionEndOffset = this._previousEditContextSelection.endExclusive;
+        const selectionStartOffset = this._previousEditContextSelection.start;
+        this._previousEditContextSelection = ( new OffsetRange(e.selectionStart, e.selectionEnd));
         let replaceNextCharCnt = 0;
         let replacePrevCharCnt = 0;
         if (e.updateRangeEnd > selectionEndOffset) {
@@ -304,7 +309,6 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
             positionDelta
         };
         this._onType(viewController, typeInput);
-        this._updateEditContext();
     }
     _onType(viewController, typeInput) {
         if (typeInput.replacePrevCharCnt || typeInput.replaceNextCharCnt || typeInput.positionDelta) {

package/vscode/src/vs/editor/browser/controller/editContext/textArea/textAreaEditContext.js

@@ -532,8 +532,8 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
                 if (width > this._contentWidth) {
                     width = this._contentWidth;
                 }
-                const viewPosition = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(( new Position(startPosition.lineNumber, 1)));
-                const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(viewPosition.lineNumber);
+                const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(startPosition.lineNumber);
+                const fontSize = this._context.viewModel.getFontSizeAtPosition(this._primaryCursorPosition);
                 const viewLineData = this._context.viewModel.getViewLineData(startPosition.lineNumber);
                 const startTokenIndex = viewLineData.tokens.findTokenIndexAtOffset(startPosition.column - 1);
                 const endTokenIndex = viewLineData.tokens.findTokenIndexAtOffset(endPosition.column - 1);
@@ -552,7 +552,8 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
                     italic: presentation.italic,
                     bold: presentation.bold,
                     underline: presentation.underline,
-                    strikethrough: presentation.strikethrough
+                    strikethrough: presentation.strikethrough,
+                    fontSize
                 });
             }
             return;
@@ -616,6 +617,7 @@ let TextAreaEditContext = class TextAreaEditContext extends AbstractEditContext
         ta.setWidth(renderData.width);
         ta.setHeight(renderData.height);
         ta.setLineHeight(renderData.height);
+        ta.setFontSize(renderData.fontSize ?? this._fontInfo.fontSize);
         ta.setColor(renderData.color ? Color.Format.CSS.formatHex(renderData.color) : '');
         ta.setFontStyle(renderData.italic ? 'italic' : '');
         if (renderData.bold) {

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

@@ -14,12 +14,14 @@ import { IDiffComputationResult, ILineChange } from "../common/diff/legacyLinesD
 import * as editorCommon from "../common/editorCommon.js";
 import { GlyphMarginLane, ICursorStateComputer, IIdentifiedSingleEditOperation, IModelDecoration, IModelDeltaDecoration, ITextModel, PositionAffinity } from "../common/model.js";
 import { InjectedText } from "../common/modelLineProjectionData.js";
-import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent, ModelLineHeightChangedEvent } from "../common/textModelEvents.js";
+import { IModelContentChangedEvent, IModelDecorationsChangedEvent, IModelLanguageChangedEvent, IModelLanguageConfigurationChangedEvent, IModelOptionsChangedEvent, IModelTokensChangedEvent, ModelFontChangedEvent, ModelLineHeightChangedEvent } from "../common/textModelEvents.js";
 import { IEditorWhitespace, IViewModel } from "../common/viewModel.js";
 import { OverviewRulerZone } from "../common/viewModel/overviewZoneManager.js";
 import { MenuId } from "../../platform/actions/common/actions.js";
 import { IContextKeyService } from "../../platform/contextkey/common/contextkey.service.js";
 import { ServicesAccessor } from "../../platform/instantiation/common/instantiation.js";
+import { TextEdit } from "../common/core/edits/textEdit.js";
+import { TextModelEditReason } from "../common/textModelEditReason.js";
 export interface IViewZone {
     afterLineNumber: number;
     afterColumn?: number;

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlas.d.ts

@@ -2,6 +2,7 @@ import { Event } from "../../../../base/common/event.js";
 import { Disposable } from "../../../../base/common/lifecycle.js";
 import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
 import { IThemeService } from "../../../../platform/theme/common/themeService.service.js";
+import type { DecorationStyleCache } from "../css/decorationStyleCache.js";
 import type { IGlyphRasterizer } from "../raster/raster.js";
 import type { IReadableTextureAtlasPage, ITextureAtlasPageGlyph } from "./atlas.js";
 import { AllocatorType } from "./textureAtlasPage.js";
@@ -10,6 +11,7 @@ export interface ITextureAtlasOptions {
 }
 export declare class TextureAtlas extends Disposable {
     private readonly _maxTextureSize;
+    private readonly _decorationStyleCache;
     private readonly _themeService;
     private readonly _instantiationService;
     private _colorMap?;
@@ -23,7 +25,7 @@ export declare class TextureAtlas extends Disposable {
     private readonly _glyphPageIndex;
     private readonly _onDidDeleteGlyphs;
     readonly onDidDeleteGlyphs: Event<void>;
-    constructor(_maxTextureSize: number, options: ITextureAtlasOptions | undefined, _themeService: IThemeService, _instantiationService: IInstantiationService);
+    constructor(_maxTextureSize: number, options: ITextureAtlasOptions | undefined, _decorationStyleCache: DecorationStyleCache, _themeService: IThemeService, _instantiationService: IInstantiationService);
     private _initFirstPage;
     clear(): void;
     getGlyph(rasterizer: IGlyphRasterizer, chars: string, tokenMetadata: number, decorationStyleSetId: number, x: number): Readonly<ITextureAtlasPageGlyph>;

package/vscode/src/vs/editor/browser/gpu/atlas/textureAtlas.js

@@ -19,9 +19,10 @@ let TextureAtlas = class TextureAtlas extends Disposable {
     static { this.maximumPageCount = 16; }
     get pages() { return this._pages; }
     constructor(
-    _maxTextureSize, options, _themeService, _instantiationService) {
+    _maxTextureSize, options, _decorationStyleCache, _themeService, _instantiationService) {
         super();
         this._maxTextureSize = _maxTextureSize;
+        this._decorationStyleCache = _decorationStyleCache;
         this._themeService = _themeService;
         this._instantiationService = _instantiationService;
         this._warmUpTask = this._register(( new MutableDisposable()));
@@ -45,7 +46,7 @@ let TextureAtlas = class TextureAtlas extends Disposable {
     _initFirstPage() {
         const firstPage = this._instantiationService.createInstance(TextureAtlasPage, 0, this.pageSize, this._allocatorType);
         this._pages.push(firstPage);
-        const nullRasterizer = ( new GlyphRasterizer(1, '', 1));
+        const nullRasterizer = ( new GlyphRasterizer(1, '', 1, this._decorationStyleCache));
         firstPage.getGlyph(nullRasterizer, '', 0, 0);
         nullRasterizer.dispose();
     }
@@ -130,8 +131,8 @@ let TextureAtlas = class TextureAtlas extends Disposable {
     }
 };
 TextureAtlas = TextureAtlas_1 = ( __decorate([
-    ( __param(2, IThemeService)),
-    ( __param(3, IInstantiationService))
+    ( __param(3, IThemeService)),
+    ( __param(4, IInstantiationService))
 ], TextureAtlas));
 
 export { TextureAtlas };

package/vscode/src/vs/editor/browser/gpu/raster/glyphRasterizer.d.ts

@@ -1,9 +1,11 @@
 import { Disposable } from "../../../../base/common/lifecycle.js";
+import type { DecorationStyleCache } from "../css/decorationStyleCache.js";
 import { type IGlyphRasterizer, type IRasterizedGlyph } from "./raster.js";
 export declare class GlyphRasterizer extends Disposable implements IGlyphRasterizer {
     readonly fontSize: number;
     readonly fontFamily: string;
     readonly devicePixelRatio: number;
+    private readonly _decorationStyleCache;
     readonly id: number;
     get cacheKey(): string;
     private _canvas;
@@ -12,7 +14,7 @@ export declare class GlyphRasterizer extends Disposable implements IGlyphRasteri
     private _workGlyph;
     private _workGlyphConfig;
     private _antiAliasing;
-    constructor(fontSize: number, fontFamily: string, devicePixelRatio: number);
+    constructor(fontSize: number, fontFamily: string, devicePixelRatio: number, _decorationStyleCache: DecorationStyleCache);
     rasterizeGlyph(chars: string, tokenMetadata: number, decorationStyleSetId: number, colorMap: string[]): Readonly<IRasterizedGlyph>;
     _rasterizeGlyph(chars: string, tokenMetadata: number, decorationStyleSetId: number, colorMap: string[]): Readonly<IRasterizedGlyph>;
     private _clearColor;

package/vscode/src/vs/editor/browser/gpu/raster/glyphRasterizer.js

@@ -6,18 +6,18 @@ import { isMacintosh } from '../../../../base/common/platform.js';
 import { StringBuilder } from '../../../common/core/stringBuilder.js';
 import { TokenMetadata, FontStyle } from '../../../common/encodedTokenAttributes.js';
 import { ensureNonNullable } from '../gpuUtils.js';
-import { ViewGpuContext } from '../viewGpuContext.js';
 
 let nextId = 0;
 class GlyphRasterizer extends Disposable {
     get cacheKey() {
         return `${this.fontFamily}_${this.fontSize}px`;
     }
-    constructor(fontSize, fontFamily, devicePixelRatio) {
+    constructor(fontSize, fontFamily, devicePixelRatio, _decorationStyleCache) {
         super();
         this.fontSize = fontSize;
         this.fontFamily = fontFamily;
         this.devicePixelRatio = devicePixelRatio;
+        this._decorationStyleCache = _decorationStyleCache;
         this.id = nextId++;
         this._workGlyph = {
             source: null,
@@ -76,7 +76,7 @@ class GlyphRasterizer extends Disposable {
         const xSubPixelXOffset = (tokenMetadata & 0b1111) / 10;
         const bgId = TokenMetadata.getBackground(tokenMetadata);
         const bg = colorMap[bgId];
-        const decorationStyleSet = ViewGpuContext.decorationStyleCache.getStyleSet(decorationStyleSetId);
+        const decorationStyleSet = this._decorationStyleCache.getStyleSet(decorationStyleSetId);
         if (this._antiAliasing === 'subpixel') {
             this._ctx.fillStyle = bg;
             this._ctx.fillRect(0, 0, this._canvas.width, this._canvas.height);

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

@@ -19,7 +19,6 @@ import { Event } from '../../../base/common/event.js';
 import { EditorOption } from '../../common/config/editorOptions.js';
 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 { observableValue } from '../../../base/common/observableInternal/observables/observableValue.js';
 import { runOnChange } from '../../../base/common/observableInternal/utils/runOnChange.js';
@@ -49,7 +48,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
         this._instantiationService = _instantiationService;
         this._notificationService = _notificationService;
         this.configurationService = configurationService;
-        this.maxGpuCols = ViewportRenderStrategy.maxSupportedColumns;
+        this.maxGpuCols = 2000;
         this.canvas = createFastDomNode(document.createElement('canvas'));
         this.canvas.setClassName('editorCanvas');
         this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
@@ -70,7 +69,7 @@ let ViewGpuContext = class ViewGpuContext extends Disposable {
             }).then(ref => {
                 ViewGpuContext_1.deviceSync = ref.object;
                 if (!ViewGpuContext_1._atlas) {
-                    ViewGpuContext_1._atlas = this._instantiationService.createInstance(TextureAtlas, ref.object.limits.maxTextureDimension2D, undefined);
+                    ViewGpuContext_1._atlas = this._instantiationService.createInstance(TextureAtlas, ref.object.limits.maxTextureDimension2D, undefined, ViewGpuContext_1.decorationStyleCache);
                 }
                 return ref.object;
             });

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

@@ -52,6 +52,7 @@ export declare class ObservableCodeEditor extends Disposable {
     readonly layoutInfoVerticalScrollbarWidth: IObservable<number>;
     readonly contentWidth: IObservable<number>;
     readonly contentHeight: IObservable<number>;
+    readonly domNode: IObservableWithChange<HTMLElement | null, void>;
     getOption<T extends EditorOption>(id: T): IObservable<FindComputedEditorOptionValueById<T>>;
     setDecorations(decorations: IObservable<IModelDeltaDecoration[]>): IDisposable;
     private _widgetCounter;
@@ -61,6 +62,11 @@ export declare class ObservableCodeEditor extends Disposable {
     observePosition(position: IObservable<Position | null>, store: DisposableStore): IObservable<Point | null>;
     readonly openedPeekWidgets: import("../../base/common/observable.js").ISettableObservable<number, void>;
     isTargetHovered(predicate: (target: IEditorMouseEvent) => boolean, store: DisposableStore): IObservable<boolean>;
+    observeLineHeightForPosition(position: IObservable<Position> | Position): IObservable<number>;
+    observeLineHeightForPosition(position: IObservable<null>): IObservable<null>;
+    observeLineHeightForLine(lineNumber: IObservable<number> | number): IObservable<number>;
+    observeLineHeightForLine(lineNumber: IObservable<null>): IObservable<null>;
+    observeLineHeightsForLineRange(lineNumber: IObservable<LineRange> | LineRange): IObservable<number[]>;
 }
 interface IObservableOverlayWidget {
     get domNode(): HTMLElement;