@codingame/monaco-vscode-api 15.0.3 → 16.0.0

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

@@ -17,9 +17,9 @@ export declare class FromEventObservable<TArgs, T> extends BaseObservable<T> {
     private readonly _getTransaction;
     private readonly _equalityComparator;
     static globalTransaction: ITransaction | undefined;
-    private value;
-    private hasValue;
-    private subscription;
+    private _value;
+    private _hasValue;
+    private _subscription;
     constructor(_debugNameData: DebugNameData, event: Event<TArgs>, _getValue: (args: TArgs | undefined) => T, _getTransaction: () => ITransaction | undefined, _equalityComparator: EqualityComparer<T>);
     private getDebugName;
     get debugName(): string;
@@ -27,6 +27,7 @@ export declare class FromEventObservable<TArgs, T> extends BaseObservable<T> {
     private readonly handleEvent;
     protected onLastObserverRemoved(): void;
     get(): T;
+    debugSetValue(value: unknown): void;
 }
 export declare namespace observableFromEvent {
     const Observer: typeof FromEventObservable;

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

@@ -64,18 +64,18 @@ class FromEventObservable extends BaseObservable {
         this._getValue = _getValue;
         this._getTransaction = _getTransaction;
         this._equalityComparator = _equalityComparator;
-        this.hasValue = false;
+        this._hasValue = false;
         this.handleEvent = (args) => {
             const newValue = this._getValue(args);
-            const oldValue = this.value;
-            const didChange = !this.hasValue || !(this._equalityComparator(oldValue, newValue));
+            const oldValue = this._value;
+            const didChange = !this._hasValue || !(this._equalityComparator(oldValue, newValue));
             let didRunTransaction = false;
             if (didChange) {
-                this.value = newValue;
-                if (this.hasValue) {
+                this._value = newValue;
+                if (this._hasValue) {
                     didRunTransaction = true;
                     subtransaction(this._getTransaction(), (tx) => {
-                        getLogger()?.handleObservableUpdated(this, { oldValue, newValue, change: undefined, didChange, hadValue: this.hasValue });
+                        getLogger()?.handleObservableUpdated(this, { oldValue, newValue, change: undefined, didChange, hadValue: this._hasValue });
                         for (const o of this._observers) {
                             tx.updateObserver(o, this);
                             o.handleChange(this, undefined);
@@ -85,10 +85,10 @@ class FromEventObservable extends BaseObservable {
                         return 'Event fired' + (name ? `: ${name}` : '');
                     });
                 }
-                this.hasValue = true;
+                this._hasValue = true;
             }
             if (!didRunTransaction) {
-                getLogger()?.handleObservableUpdated(this, { oldValue, newValue, change: undefined, didChange, hadValue: this.hasValue });
+                getLogger()?.handleObservableUpdated(this, { oldValue, newValue, change: undefined, didChange, hadValue: this._hasValue });
             }
         };
     }
@@ -100,26 +100,29 @@ class FromEventObservable extends BaseObservable {
         return 'From Event' + (name ? `: ${name}` : '');
     }
     onFirstObserverAdded() {
-        this.subscription = this.event(this.handleEvent);
+        this._subscription = this.event(this.handleEvent);
     }
     onLastObserverRemoved() {
-        this.subscription.dispose();
-        this.subscription = undefined;
-        this.hasValue = false;
-        this.value = undefined;
+        this._subscription.dispose();
+        this._subscription = undefined;
+        this._hasValue = false;
+        this._value = undefined;
     }
     get() {
-        if (this.subscription) {
-            if (!this.hasValue) {
+        if (this._subscription) {
+            if (!this._hasValue) {
                 this.handleEvent(undefined);
             }
-            return this.value;
+            return this._value;
         }
         else {
             const value = this._getValue(undefined);
             return value;
         }
     }
+    debugSetValue(value) {
+        this._value = value;
+    }
 }
 (function (observableFromEvent) {
     observableFromEvent.Observer = FromEventObservable;

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

@@ -0,0 +1,8 @@
+export type PolicyName = string;
+export interface IPolicy {
+    readonly name: PolicyName;
+    readonly minimumVersion: `${number}.${number}`;
+    readonly description?: string;
+    readonly previewFeature?: boolean;
+    readonly defaultValue?: string | number | boolean;
+}

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

@@ -1,5 +1,6 @@
 import { IStringDictionary } from "./collections.js";
 import { PlatformName } from "./platform.js";
+import { IPolicy } from "./policy.js";
 export interface IBuiltInExtension {
     readonly name: string;
     readonly version: string;
@@ -89,12 +90,11 @@ export interface IProductConfiguration {
     };
     readonly extensionsGallery?: {
         readonly serviceUrl: string;
-        readonly itemUrl: string;
-        readonly publisherUrl: string;
-        readonly resourceUrlTemplate: string;
-        readonly extensionUrlTemplate: string;
         readonly controlUrl: string;
+        readonly extensionUrlTemplate: string;
+        readonly resourceUrlTemplate: string;
         readonly nlsBaseUrl: string;
+        readonly accessSKUs?: string[];
     };
     readonly extensionPublisherOrgs?: readonly string[];
     readonly trustedExtensionPublishers?: readonly string[];
@@ -179,15 +179,28 @@ export interface IProductConfiguration {
     };
     readonly msftInternalDomains?: string[];
     readonly linkProtectionTrustedDomains?: readonly string[];
+    readonly defaultAccount?: {
+        readonly authenticationProvider: {
+            readonly id: string;
+            readonly enterpriseProviderId: string;
+            readonly enterpriseProviderConfig: string;
+            readonly scopes: string[];
+        };
+        readonly tokenEntitlementUrl: string;
+        readonly chatEntitlementUrl: string;
+    };
     readonly "configurationSync.store"?: ConfigurationSyncStore;
     readonly "editSessions.store"?: Omit<ConfigurationSyncStore, "insidersUrl" | "stableUrl">;
     readonly darwinUniversalAssetId?: string;
+    readonly darwinBundleIdentifier?: string;
     readonly profileTemplatesUrl?: string;
     readonly commonlyUsedSettings?: string[];
     readonly aiGeneratedWorkspaceTrust?: IAiGeneratedWorkspaceTrust;
     readonly defaultChatAgent?: IDefaultChatAgent;
     readonly chatParticipantRegistry?: string;
     readonly emergencyAlertUrl?: string;
+    readonly remoteDefaultExtensionsIfInstalledLocally?: string[];
+    readonly extensionConfigurationPolicy?: IStringDictionary<IPolicy>;
 }
 export interface ITunnelApplicationConfig {
     authenticationProviders: IStringDictionary<{
@@ -301,9 +314,17 @@ export interface IDefaultChatAgent {
     readonly providerName: string;
     readonly enterpriseProviderId: string;
     readonly enterpriseProviderName: string;
-    readonly providerSetting: string;
     readonly providerUriSetting: string;
     readonly providerScopes: string[][];
     readonly entitlementUrl: string;
     readonly entitlementSignupLimitedUrl: string;
+    readonly chatQuotaExceededContext: string;
+    readonly completionsQuotaExceededContext: string;
+    readonly walkthroughCommand: string;
+    readonly completionsMenuCommand: string;
+    readonly completionsRefreshTokenCommand: string;
+    readonly chatRefreshTokenCommand: string;
+    readonly completionsAdvancedSetting: string;
+    readonly completionsEnablementSetting: string;
+    readonly nextEditSuggestionsSetting: string;
 }

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

@@ -199,20 +199,6 @@ function getIndentationLength(str) {
     }
     return idx;
 }
-function replaceAsync(str, search, replacer) {
-    const parts = [];
-    let last = 0;
-    for (const match of str.matchAll(search)) {
-        parts.push(str.slice(last, match.index));
-        if (match.index === undefined) {
-            throw ( new Error('match.index should be defined'));
-        }
-        last = match.index + match[0].length;
-        parts.push(replacer(match[0], ...match.slice(1), match.index, str, match.groups));
-    }
-    parts.push(str.slice(last));
-    return Promise.all(parts).then(p => p.join(''));
-}
 function compare(a, b) {
     if (a < b) {
         return -1;
@@ -502,10 +488,17 @@ function rcut(text, n, suffix = '') {
     }
     return result.trim().replace(/b$/, '') + suffix;
 }
-const CSI_SEQUENCE = /(?:(?:\x1b\[|\x9B)[=?>!]?[\d;:]*["$#'* ]?[a-zA-Z@^`{}|~])|(:?\x1b\].*?\x07)/g;
+const CSI_SEQUENCE = /(?:\x1b\[|\x9b)[=?>!]?[\d;:]*["$#'* ]?[a-zA-Z@^`{}|~]/;
+const OSC_SEQUENCE = /(?:\x1b\]|\x9d).*?(?:\x1b\\|\x07|\x9c)/;
+const ESC_SEQUENCE = /\x1b(?:[ #%\(\)\*\+\-\.\/]?[a-zA-Z0-9\|}~@])/;
+const CONTROL_SEQUENCES = ( new RegExp('(?:' + [
+    CSI_SEQUENCE.source,
+    OSC_SEQUENCE.source,
+    ESC_SEQUENCE.source,
+].join('|') + ')', 'g'));
 function* forAnsiStringParts(str) {
     let last = 0;
-    for (const match of str.matchAll(CSI_SEQUENCE)) {
+    for (const match of str.matchAll(CONTROL_SEQUENCES)) {
         if (last !== match.index) {
             yield { isCode: false, str: str.substring(last, match.index) };
         }
@@ -518,7 +511,7 @@ function* forAnsiStringParts(str) {
 }
 function removeAnsiEscapeCodes(str) {
     if (str) {
-        str = str.replace(CSI_SEQUENCE, '');
+        str = str.replace(CONTROL_SEQUENCES, '');
     }
     return str;
 }
@@ -843,4 +836,4 @@ class InvisibleCharacters {
     }
 }
 
-export { AmbiguousCharacters, CodePointIterator, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getIndentationLength, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, nextCharLength, noBreakWhitespace, prevCharLength, rcut, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, replaceAsync, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };
+export { AmbiguousCharacters, CodePointIterator, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getIndentationLength, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, nextCharLength, noBreakWhitespace, prevCharLength, rcut, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };

package/vscode/src/vs/base/common/worker/{simpleWorker.d.ts → webWorker.d.ts}

@@ -1,20 +1,11 @@
+import { Event } from "../event.js";
 import { Disposable, IDisposable } from "../lifecycle.js";
-import { URI } from "../uri.js";
-export interface IWorker extends IDisposable {
+export interface IWebWorker extends IDisposable {
     getId(): number;
+    onMessage: Event<Message>;
+    onError: Event<any>;
     postMessage(message: Message, transfer: ArrayBuffer[]): void;
 }
-export interface IWorkerCallback {
-    (message: Message): void;
-}
-export interface IWorkerFactory {
-    create(modules: IWorkerDescriptor, callback: IWorkerCallback, onErrorCallback: (err: any) => void): IWorker;
-}
-export interface IWorkerDescriptor {
-    readonly moduleId: string;
-    readonly esmModuleLocation: URI | undefined;
-    readonly label: string | undefined;
-}
 export declare function logOnceWebWorkerWarning(err: any): void;
 declare enum MessageType {
     Request = 0,
@@ -62,49 +53,48 @@ declare class UnsubscribeEventMessage {
     readonly type = MessageType.UnsubscribeEvent;
     constructor(vsWorker: number, req: string);
 }
-type Message = RequestMessage | ReplyMessage | SubscribeEventMessage | EventMessage | UnsubscribeEventMessage;
+export type Message = RequestMessage | ReplyMessage | SubscribeEventMessage | EventMessage | UnsubscribeEventMessage;
 type ProxiedMethodName = (`$${string}` | `on${string}`);
 export type Proxied<T> = {
     [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (K extends ProxiedMethodName ? (...args: A) => Promise<Awaited<R>> : never) : never;
 };
-export interface IWorkerClient<W> {
-    proxy: Proxied<W>;
+export interface IWebWorkerClient<TProxy> {
+    proxy: Proxied<TProxy>;
     dispose(): void;
     setChannel<T extends object>(channel: string, handler: T): void;
     getChannel<T extends object>(channel: string): Proxied<T>;
 }
-export interface IWorkerServer {
+export interface IWebWorkerServer {
     setChannel<T extends object>(channel: string, handler: T): void;
     getChannel<T extends object>(channel: string): Proxied<T>;
 }
-export declare class SimpleWorkerClient<W extends object> extends Disposable implements IWorkerClient<W> {
+export declare class WebWorkerClient<W extends object> extends Disposable implements IWebWorkerClient<W> {
     private readonly _worker;
     private readonly _onModuleLoaded;
     private readonly _protocol;
     readonly proxy: Proxied<W>;
     private readonly _localChannels;
     private readonly _remoteChannels;
-    constructor(workerFactory: IWorkerFactory, workerDescriptor: IWorkerDescriptor);
+    constructor(worker: IWebWorker);
     private _handleMessage;
     private _handleEvent;
     setChannel<T extends object>(channel: string, handler: T): void;
     getChannel<T extends object>(channel: string): Proxied<T>;
     private _onError;
 }
-export interface IRequestHandler {
+export interface IWebWorkerServerRequestHandler {
     _requestHandlerBrand: any;
     [prop: string]: any;
 }
-export interface IRequestHandlerFactory {
-    (workerServer: IWorkerServer): IRequestHandler;
+export interface IWebWorkerServerRequestHandlerFactory<T extends IWebWorkerServerRequestHandler> {
+    (workerServer: IWebWorkerServer): T;
 }
-export declare class SimpleWorkerServer implements IWorkerServer {
-    private _requestHandlerFactory;
-    private _requestHandler;
+export declare class WebWorkerServer<T extends IWebWorkerServerRequestHandler> implements IWebWorkerServer {
+    readonly requestHandler: T;
     private _protocol;
     private readonly _localChannels;
     private readonly _remoteChannels;
-    constructor(postMessage: (msg: Message, transfer?: ArrayBuffer[]) => void, requestHandlerFactory: IRequestHandlerFactory | null);
+    constructor(postMessage: (msg: Message, transfer?: ArrayBuffer[]) => void, requestHandlerFactory: IWebWorkerServerRequestHandlerFactory<T>);
     onmessage(msg: any): void;
     private _handleMessage;
     private _handleEvent;
@@ -112,5 +102,4 @@ export declare class SimpleWorkerServer implements IWorkerServer {
     getChannel<T extends object>(channel: string): Proxied<T>;
     private initialize;
 }
-export declare function create(postMessage: (msg: Message, transfer?: ArrayBuffer[]) => void): SimpleWorkerServer;
 export {};

package/vscode/src/vs/base/common/worker/{simpleWorker.js → webWorker.js}

@@ -71,7 +71,7 @@ class UnsubscribeEventMessage {
         this.type = MessageType.UnsubscribeEvent;
     }
 }
-class SimpleWorkerProtocol {
+class WebWorkerProtocol {
     constructor(handler) {
         this._workerId = -1;
         this._handler = handler;
@@ -227,21 +227,20 @@ class SimpleWorkerProtocol {
         this._handler.sendMessage(msg, transfer);
     }
 }
-class SimpleWorkerClient extends Disposable {
-    constructor(workerFactory, workerDescriptor) {
+class WebWorkerClient extends Disposable {
+    constructor(worker) {
         super();
         this._localChannels = ( new Map());
         this._remoteChannels = ( new Map());
-        this._worker = this._register(workerFactory.create({
-            moduleId: 'vs/base/common/worker/simpleWorker',
-            esmModuleLocation: workerDescriptor.esmModuleLocation,
-            label: workerDescriptor.label
-        }, (msg) => {
+        this._worker = worker;
+        this._register(this._worker.onMessage((msg) => {
             this._protocol.handleMessage(msg);
-        }, (err) => {
+        }));
+        this._register(this._worker.onError((err) => {
+            logOnceWebWorkerWarning(err);
             onUnexpectedError(err);
         }));
-        this._protocol = ( new SimpleWorkerProtocol({
+        this._protocol = ( new WebWorkerProtocol({
             sendMessage: (msg, transfer) => {
                 this._worker.postMessage(msg, transfer);
             },
@@ -253,18 +252,12 @@ class SimpleWorkerClient extends Disposable {
             }
         }));
         this._protocol.setWorkerId(this._worker.getId());
-        let loaderConfiguration = null;
-        if (typeof globalThis.requirejs !== 'undefined') {
-            loaderConfiguration = globalThis.requirejs.s.contexts._.config;
-        }
         this._onModuleLoaded = this._protocol.sendMessage(DEFAULT_CHANNEL, INITIALIZE, [
             this._worker.getId(),
-            JSON.parse(JSON.stringify(loaderConfiguration)),
-            workerDescriptor.moduleId,
         ]);
         this.proxy = this._protocol.createProxyToRemoteChannel(DEFAULT_CHANNEL, async () => { await this._onModuleLoaded; });
         this._onModuleLoaded.catch((e) => {
-            this._onError('Worker failed to load ' + workerDescriptor.moduleId, e);
+            this._onError('Worker failed to load ', e);
         });
     }
     _handleMessage(channelName, method, args) {
@@ -326,28 +319,27 @@ function propertyIsEvent(name) {
 function propertyIsDynamicEvent(name) {
     return /^onDynamic/.test(name) && isUpperAsciiLetter(name.charCodeAt(9));
 }
-class SimpleWorkerServer {
+class WebWorkerServer {
     constructor(postMessage, requestHandlerFactory) {
         this._localChannels = ( new Map());
         this._remoteChannels = ( new Map());
-        this._requestHandlerFactory = requestHandlerFactory;
-        this._requestHandler = null;
-        this._protocol = ( new SimpleWorkerProtocol({
+        this._protocol = ( new WebWorkerProtocol({
             sendMessage: (msg, transfer) => {
                 postMessage(msg, transfer);
             },
             handleMessage: (channel, method, args) => this._handleMessage(channel, method, args),
             handleEvent: (channel, eventName, arg) => this._handleEvent(channel, eventName, arg)
         }));
+        this.requestHandler = requestHandlerFactory(this);
     }
     onmessage(msg) {
         this._protocol.handleMessage(msg);
     }
     _handleMessage(channel, method, args) {
         if (channel === DEFAULT_CHANNEL && method === INITIALIZE) {
-            return this.initialize(args[0], args[1], args[2]);
+            return this.initialize(args[0]);
         }
-        const requestHandler = (channel === DEFAULT_CHANNEL ? this._requestHandler : this._localChannels.get(channel));
+        const requestHandler = (channel === DEFAULT_CHANNEL ? this.requestHandler : this._localChannels.get(channel));
         if (!requestHandler) {
             return Promise.reject(( new Error(`Missing channel ${channel} on worker thread`)));
         }
@@ -362,7 +354,7 @@ class SimpleWorkerServer {
         }
     }
     _handleEvent(channel, eventName, arg) {
-        const requestHandler = (channel === DEFAULT_CHANNEL ? this._requestHandler : this._localChannels.get(channel));
+        const requestHandler = (channel === DEFAULT_CHANNEL ? this.requestHandler : this._localChannels.get(channel));
         if (!requestHandler) {
             throw ( new Error(`Missing channel ${channel} on worker thread`));
         }
@@ -392,29 +384,9 @@ class SimpleWorkerServer {
         }
         return this._remoteChannels.get(channel);
     }
-    async initialize(workerId, loaderConfig, moduleId) {
+    async initialize(workerId) {
         this._protocol.setWorkerId(workerId);
-        if (this._requestHandlerFactory) {
-            this._requestHandler = this._requestHandlerFactory(this);
-            return;
-        }
-        if (loaderConfig) {
-            if (typeof loaderConfig.baseUrl !== 'undefined') {
-                delete loaderConfig['baseUrl'];
-            }
-            if (typeof loaderConfig.paths !== 'undefined') {
-                if (typeof loaderConfig.paths.vs !== 'undefined') {
-                    delete loaderConfig.paths['vs'];
-                }
-            }
-            if (typeof loaderConfig.trustedTypesPolicy !== 'undefined') {
-                delete loaderConfig['trustedTypesPolicy'];
-            }
-            loaderConfig.catchError = true;
-            globalThis.require.config(loaderConfig);
-        }
-        return Promise.reject(( new Error(`Unexpected usage`)));
     }
 }
 
-export { SimpleWorkerClient, SimpleWorkerServer, logOnceWebWorkerWarning };
+export { WebWorkerClient, WebWorkerServer, logOnceWebWorkerWarning };

package/vscode/src/vs/base/common/worker/webWorkerBootstrap.d.ts

@@ -0,0 +1,3 @@
+import { IWebWorkerServerRequestHandler, IWebWorkerServerRequestHandlerFactory, WebWorkerServer } from "./webWorker.js";
+export declare function initialize<T extends IWebWorkerServerRequestHandler>(factory: IWebWorkerServerRequestHandlerFactory<T>): WebWorkerServer<T>;
+export declare function bootstrapWebWorker(factory: IWebWorkerServerRequestHandlerFactory<any>): void;

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

@@ -0,0 +1,27 @@
+
+import { WebWorkerServer } from './webWorker.js';
+
+let initialized = false;
+function initialize(factory) {
+    if (initialized) {
+        throw ( new Error('WebWorker already initialized!'));
+    }
+    initialized = true;
+    const webWorkerServer = ( new WebWorkerServer(
+        msg => globalThis.postMessage(msg),
+        (workerServer) => factory(workerServer)
+    ));
+    globalThis.onmessage = (e) => {
+        webWorkerServer.onmessage(e.data);
+    };
+    return webWorkerServer;
+}
+function bootstrapWebWorker(factory) {
+    globalThis.onmessage = (_e) => {
+        if (!initialized) {
+            initialize(factory);
+        }
+    };
+}
+
+export { bootstrapWebWorker, initialize };

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

@@ -190,5 +190,11 @@ registerEditorSettingMigration('lightbulb.enabled', (value, read, write) => {
         write('lightbulb.enabled', value ? undefined : 'off');
     }
 });
+registerEditorSettingMigration('inlineSuggest.edits.codeShifting', (value, read, write) => {
+    if (typeof value === 'boolean') {
+        write('inlineSuggest.edits.codeShifting', undefined);
+        write('inlineSuggest.edits.allowCodeShifting', value ? 'always' : 'never');
+    }
+});
 
 export { EditorSettingMigration, migrateOptions };

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

@@ -0,0 +1,39 @@
+.monaco-editor .native-edit-context {
+	margin: 0;
+	padding: 0;
+	position: absolute;
+	overflow-y: scroll;
+	scrollbar-width: none;
+	z-index: -10;
+	white-space: pre-wrap;
+}
+.monaco-editor .native-edit-context-textarea {
+	min-width: 0;
+	min-height: 0;
+	margin: 0;
+	padding: 0;
+	position: absolute;
+	outline: none !important;
+	resize: none;
+	border: none;
+	overflow: hidden;
+	color: transparent;
+	background-color: transparent;
+	z-index: -10;
+}
+.monaco-editor .edit-context-composition-none {
+	background-color: transparent;
+	border-bottom: none;
+}
+.monaco-editor :not(.hc-black, .hc-light) .edit-context-composition-secondary {
+	border-bottom: 1px solid var(--vscode-editor-compositionBorder);
+}
+.monaco-editor :not(.hc-black, .hc-light) .edit-context-composition-primary {
+	border-bottom: 2px solid var(--vscode-editor-compositionBorder);
+}
+.monaco-editor :is(.hc-black, .hc-light) .edit-context-composition-secondary {
+	border: 1px solid var(--vscode-editor-compositionBorder);
+}
+.monaco-editor :is(.hc-black, .hc-light) .edit-context-composition-primary {
+	border: 2px solid var(--vscode-editor-compositionBorder);
+}

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

@@ -12,7 +12,7 @@ import { IEditorAriaOptions } from "../../../editorBrowser.js";
 export declare class NativeEditContext extends AbstractEditContext {
     private readonly _visibleRangeProvider;
     private readonly _accessibilityService;
-    readonly textArea: FastDomNode<HTMLTextAreaElement>;
+    private readonly _textArea;
     readonly domNode: FastDomNode<HTMLDivElement>;
     private readonly _editContext;
     private readonly _screenReaderSupport;
@@ -40,7 +40,8 @@ export declare class NativeEditContext extends AbstractEditContext {
     onLinesInserted(e: ViewLinesInsertedEvent): boolean;
     onScrollChanged(e: ViewScrollChangedEvent): boolean;
     onZonesChanged(e: ViewZonesChangedEvent): boolean;
-    onWillPaste(): void;
+    executePaste(): boolean;
+    private _onWillPaste;
     writeScreenReaderContent(): void;
     isFocused(): boolean;
     focus(): void;

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

@@ -1,8 +1,8 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import './nativeEditContext.css.js';
+import './nativeEditContext.css';
 import { isFirefox } from '../../../../../base/browser/browser.js';
-import { getWindow, addDisposableListener, getActiveWindow, getWindowId } from '../../../../../base/browser/dom.js';
+import { getWindow, addDisposableListener, getWindowId, getActiveWindow } from '../../../../../base/browser/dom.js';
 import { FastDomNode } from '../../../../../base/browser/fastDomNode.js';
 import { StandardKeyboardEvent } from '../../../../../base/browser/keyboardEvent.js';
 import { KeyCode } from '../../../../../base/common/keyCodes.js';
@@ -41,12 +41,16 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         this._scrollLeft = 0;
         this.domNode = ( new FastDomNode(document.createElement('div')));
         this.domNode.setClassName(`native-edit-context`);
-        this.textArea = ( new FastDomNode(document.createElement('textarea')));
-        this.textArea.setClassName('native-edit-context-textarea');
-        this.textArea.setAttribute('tabindex', '-1');
+        this._textArea = ( new FastDomNode(document.createElement('textarea')));
+        this._textArea.setClassName('native-edit-context-textarea');
+        this._textArea.setAttribute('tabindex', '-1');
+        this.domNode.setAttribute('autocorrect', 'off');
+        this.domNode.setAttribute('autocapitalize', 'off');
+        this.domNode.setAttribute('autocomplete', 'off');
+        this.domNode.setAttribute('spellcheck', 'false');
         this._updateDomAttributes();
         overflowGuardContainer.appendChild(this.domNode);
-        overflowGuardContainer.appendChild(this.textArea);
+        overflowGuardContainer.appendChild(this._textArea);
         this._parent = overflowGuardContainer.domNode;
         this._selectionChangeListener = this._register(( new MutableDisposable()));
         this._focusTracker = this._register(( new FocusTracker(this.domNode.domNode, (newFocusValue) => {
@@ -95,7 +99,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
             viewController.compositionEnd();
             this._context.viewModel.onCompositionEnd();
         }));
-        this._register(addDisposableListener(this.textArea.domNode, 'paste', (e) => {
+        this._register(addDisposableListener(this._textArea.domNode, 'paste', (e) => {
             this._screenReaderSupport.setIgnoreSelectionChangeTime('onPaste');
             e.preventDefault();
             if (!e.clipboardData) {
@@ -123,7 +127,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
     dispose() {
         this.domNode.domNode.blur();
         this.domNode.domNode.remove();
-        this.textArea.domNode.remove();
+        this._textArea.domNode.remove();
         super.dispose();
     }
     setAriaOptions(options) {
@@ -143,6 +147,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
     onCursorStateChanged(e) {
         this._primarySelection = e.modelSelections[0] ?? ( new Selection(1, 1, 1, 1));
         this._screenReaderSupport.onCursorStateChanged(e);
+        this._updateEditContext();
         return true;
     }
     onConfigurationChanged(e) {
@@ -173,14 +178,28 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
     onZonesChanged(e) {
         return true;
     }
-    onWillPaste() {
+    executePaste() {
+        this._onWillPaste();
+        try {
+            this._focusTracker.pause();
+            this._textArea.focus();
+            const result = this._textArea.domNode.ownerDocument.execCommand('paste');
+            this._textArea.domNode.textContent = '';
+            this.domNode.focus();
+            return result;
+        }
+        finally {
+            this._focusTracker.resume();
+        }
+    }
+    _onWillPaste() {
         this._screenReaderSupport.setIgnoreSelectionChangeTime('onWillPaste');
     }
     writeScreenReaderContent() {
         this._screenReaderSupport.writeScreenReaderContent();
     }
     isFocused() {
-        return this._focusTracker.isFocused || (getActiveWindow().document.activeElement === this.textArea.domNode);
+        return this._focusTracker.isFocused;
     }
     focus() {
         this._focusTracker.focus();
@@ -206,7 +225,7 @@ let NativeEditContext = class NativeEditContext extends AbstractEditContext {
         if (!editContextState) {
             return;
         }
-        this._editContext.updateText(0, Number.MAX_SAFE_INTEGER, editContextState.text);
+        this._editContext.updateText(0, Number.MAX_SAFE_INTEGER, editContextState.text ?? ' ');
         this._editContext.updateSelection(editContextState.selectionStartOffset, editContextState.selectionEndOffset);
         this._editContextPrimarySelection = editContextState.editContextPrimarySelection;
     }