@codingame/monaco-vscode-api 24.3.0 → 25.0.0

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

@@ -24,9 +24,12 @@ export declare namespace Event {
      * returned event causes this utility to leak a listener on the original event.
      *
      * @param event The event source for the new event.
+     * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not
+     * specified, some events could go missing. Use this if it's important that all events are processed, even if the
+     * listener gets disposed before the debounced event fires.
      * @param disposable A disposable store to add the new EventEmitter to.
      */
-    function defer(event: Event<unknown>, disposable?: DisposableStore): Event<void>;
+    function defer(event: Event<unknown>, flushOnListenerRemove?: boolean, disposable?: DisposableStore): Event<void>;
     /**
      * Given an event, returns another event which only fires once.
      *
@@ -120,8 +123,15 @@ export declare namespace Event {
      * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
      * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
      * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param delay The number of milliseconds to debounce.
+     * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not
+     * specified, some events could go missing. Use this if it's important that all events are processed, even if the
+     * listener gets disposed before the debounced event fires.
+     * @param disposable A disposable store to add the new EventEmitter to.
      */
-    function accumulate<T>(event: Event<T>, delay?: number | typeof MicrotaskDelay, disposable?: DisposableStore): Event<T[]>;
+    function accumulate<T>(event: Event<T>, delay?: number | typeof MicrotaskDelay, flushOnListenerRemove?: boolean, disposable?: DisposableStore): Event<T[]>;
     /**
      * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate
      * event objects from different sources do not fire the same event object.

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

@@ -9,8 +9,8 @@ import { StopWatch } from './stopwatch.js';
 var Event;
 (function (Event) {
     Event.None = () => Disposable.None;
-    function defer(event, disposable) {
-        return debounce(event, () => void 0, 0, undefined, true, undefined, disposable);
+    function defer(event, flushOnListenerRemove, disposable) {
+        return debounce(event, () => void 0, 0, undefined, flushOnListenerRemove ?? true, undefined, disposable);
     }
     Event.defer = defer;
     function once(event) {
@@ -148,14 +148,14 @@ var Event;
         return emitter.event;
     }
     Event.debounce = debounce;
-    function accumulate(event, delay = 0, disposable) {
+    function accumulate(event, delay = 0, flushOnListenerRemove, disposable) {
         return Event.debounce(event, (last, e) => {
             if (!last) {
                 return [e];
             }
             last.push(e);
             return last;
-        }, delay, undefined, true, undefined, disposable);
+        }, delay, undefined, flushOnListenerRemove ?? true, undefined, disposable);
     }
     Event.accumulate = accumulate;
     function latch(event, equals = (a, b) => a === b, disposable) {

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

@@ -59,7 +59,7 @@ export interface IPreparedQueryPiece {
     pathNormalized: string;
     /**
      * In addition to the normalized path, will have
-     * whitespace and wildcards removed.
+     * whitespace, wildcards, quotes, ellipsis, and trailing hash characters removed.
      */
     normalized: string;
     normalizedLowercase: string;

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

@@ -151,7 +151,7 @@ function doScoreFuzzy2Multiple(target, query, patternStart, wordStart) {
     return [totalScore, normalizeMatches(totalMatches)];
 }
 function doScoreFuzzy2Single(target, query, patternStart, wordStart) {
-    const score = fuzzyScore(query.original, query.originalLowercase, patternStart, target, target.toLowerCase(), wordStart, { firstMatchCanBeWeak: true, boostFullMatch: true });
+    const score = fuzzyScore(query.normalized, query.normalizedLowercase, patternStart, target, target.toLowerCase(), wordStart, { firstMatchCanBeWeak: true, boostFullMatch: true });
     if (!score) {
         return NO_SCORE2;
     }
@@ -470,7 +470,7 @@ function normalizeQuery(original) {
     else {
         pathNormalized = original.replace(/\\/g, sep);
     }
-    const normalized = pathNormalized.replace(/[\*\u2026\s"]/g, '');
+    const normalized = pathNormalized.replace(/[\*\u2026\s"]/g, '').replace(/(?<=.)#$/, '');
     return {
         pathNormalized,
         normalized,

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

@@ -4,15 +4,15 @@ import { ParseErrorCode } from './json.js';
 
 function getParseErrorMessage(errorCode) {
     switch (errorCode) {
-        case ParseErrorCode.InvalidSymbol: return localize(109, 'Invalid symbol');
-        case ParseErrorCode.InvalidNumberFormat: return localize(110, 'Invalid number format');
-        case ParseErrorCode.PropertyNameExpected: return localize(111, 'Property name expected');
-        case ParseErrorCode.ValueExpected: return localize(112, 'Value expected');
-        case ParseErrorCode.ColonExpected: return localize(113, 'Colon expected');
-        case ParseErrorCode.CommaExpected: return localize(114, 'Comma expected');
-        case ParseErrorCode.CloseBraceExpected: return localize(115, 'Closing brace expected');
-        case ParseErrorCode.CloseBracketExpected: return localize(116, 'Closing bracket expected');
-        case ParseErrorCode.EndOfFileExpected: return localize(117, 'End of file expected');
+        case ParseErrorCode.InvalidSymbol: return localize(111, 'Invalid symbol');
+        case ParseErrorCode.InvalidNumberFormat: return localize(112, 'Invalid number format');
+        case ParseErrorCode.PropertyNameExpected: return localize(113, 'Property name expected');
+        case ParseErrorCode.ValueExpected: return localize(114, 'Value expected');
+        case ParseErrorCode.ColonExpected: return localize(115, 'Colon expected');
+        case ParseErrorCode.CommaExpected: return localize(116, 'Comma expected');
+        case ParseErrorCode.CloseBraceExpected: return localize(117, 'Closing brace expected');
+        case ParseErrorCode.CloseBracketExpected: return localize(118, 'Closing bracket expected');
+        case ParseErrorCode.EndOfFileExpected: return localize(119, 'End of file expected');
         default:
             return '';
     }

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

@@ -32,35 +32,35 @@ const UILabelProvider = ( new ModifierLabelProvider({
     metaKey: '⌘',
     separator: '',
 }, {
-    ctrlKey: ( localize(118, "Ctrl")),
-    shiftKey: ( localize(119, "Shift")),
-    altKey: ( localize(120, "Alt")),
-    metaKey: ( localize(121, "Windows")),
+    ctrlKey: ( localize(120, "Ctrl")),
+    shiftKey: ( localize(121, "Shift")),
+    altKey: ( localize(122, "Alt")),
+    metaKey: ( localize(123, "Windows")),
     separator: '+',
 }, {
-    ctrlKey: ( localize(118, "Ctrl")),
-    shiftKey: ( localize(119, "Shift")),
-    altKey: ( localize(120, "Alt")),
-    metaKey: ( localize(122, "Super")),
+    ctrlKey: ( localize(120, "Ctrl")),
+    shiftKey: ( localize(121, "Shift")),
+    altKey: ( localize(122, "Alt")),
+    metaKey: ( localize(124, "Super")),
     separator: '+',
 }));
 const AriaLabelProvider = ( new ModifierLabelProvider({
-    ctrlKey: ( localize(123, "Control")),
-    shiftKey: ( localize(124, "Shift")),
-    altKey: ( localize(125, "Option")),
-    metaKey: ( localize(126, "Command")),
+    ctrlKey: ( localize(125, "Control")),
+    shiftKey: ( localize(126, "Shift")),
+    altKey: ( localize(127, "Option")),
+    metaKey: ( localize(128, "Command")),
     separator: '+',
 }, {
-    ctrlKey: ( localize(123, "Control")),
-    shiftKey: ( localize(124, "Shift")),
-    altKey: ( localize(127, "Alt")),
-    metaKey: ( localize(128, "Windows")),
+    ctrlKey: ( localize(125, "Control")),
+    shiftKey: ( localize(126, "Shift")),
+    altKey: ( localize(129, "Alt")),
+    metaKey: ( localize(130, "Windows")),
     separator: '+',
 }, {
-    ctrlKey: ( localize(123, "Control")),
-    shiftKey: ( localize(124, "Shift")),
-    altKey: ( localize(127, "Alt")),
-    metaKey: ( localize(129, "Super")),
+    ctrlKey: ( localize(125, "Control")),
+    shiftKey: ( localize(126, "Shift")),
+    altKey: ( localize(129, "Alt")),
+    metaKey: ( localize(131, "Super")),
     separator: '+',
 }));
 const ElectronAcceleratorLabelProvider = ( new ModifierLabelProvider({

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

@@ -23,6 +23,6 @@ export declare enum MarshalledId {
     LanguageModelThinkingPart = 22,
     LanguageModelPromptTsxPart = 23,
     LanguageModelDataPart = 24,
-    ChatSessionContext = 25,
+    AgentSessionContext = 25,
     ChatResponsePullRequestPart = 26
 }

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

@@ -26,7 +26,7 @@ var MarshalledId;
     MarshalledId[MarshalledId["LanguageModelThinkingPart"] = 22] = "LanguageModelThinkingPart";
     MarshalledId[MarshalledId["LanguageModelPromptTsxPart"] = 23] = "LanguageModelPromptTsxPart";
     MarshalledId[MarshalledId["LanguageModelDataPart"] = 24] = "LanguageModelDataPart";
-    MarshalledId[MarshalledId["ChatSessionContext"] = 25] = "ChatSessionContext";
+    MarshalledId[MarshalledId["AgentSessionContext"] = 25] = "AgentSessionContext";
     MarshalledId[MarshalledId["ChatResponsePullRequestPart"] = 26] = "ChatResponsePullRequestPart";
 })(MarshalledId || (MarshalledId = {}));
 

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

@@ -670,10 +670,14 @@ export interface IFetchResourceMetadataOptions {
  * @param targetResource The target resource URL to compare origins with (e.g., the MCP server URL)
  * @param resourceMetadataUrl Optional URL to fetch the resource metadata from. If not provided, will try well-known URIs.
  * @param options Configuration options for the fetch operation
- * @returns Promise that resolves to the validated resource metadata
- * @throws Error if the fetch fails, returns non-200 status, or the response is invalid
+ * @returns Promise that resolves to an object containing the validated resource metadata and any errors encountered during discovery
+ * @throws Error if the fetch fails, returns non-200 status, or the response is invalid on all attempted URLs
  */
-export declare function fetchResourceMetadata(targetResource: string, resourceMetadataUrl: string | undefined, options?: IFetchResourceMetadataOptions): Promise<IAuthorizationProtectedResourceMetadata>;
+export declare function fetchResourceMetadata(targetResource: string, resourceMetadataUrl: string | undefined, options?: IFetchResourceMetadataOptions): Promise<{
+    metadata: IAuthorizationProtectedResourceMetadata;
+    discoveryUrl: string;
+    errors: Error[];
+}>;
 export interface IFetchAuthorizationServerMetadataOptions {
     /**
      * Headers to include in the requests
@@ -706,5 +710,9 @@ export interface IFetchAuthorizationServerMetadataOptions {
  *
  * @see https://datatracker.ietf.org/doc/html/rfc8414#section-3
  */
-export declare function fetchAuthorizationServerMetadata(authorizationServer: string, options?: IFetchAuthorizationServerMetadataOptions): Promise<IAuthorizationServerMetadata>;
+export declare function fetchAuthorizationServerMetadata(authorizationServer: string, options?: IFetchAuthorizationServerMetadataOptions): Promise<{
+    metadata: IAuthorizationServerMetadata;
+    discoveryUrl: string;
+    errors: Error[];
+}>;
 export {};

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

@@ -274,73 +274,76 @@ function scopesMatch(scopes1, scopes2) {
 async function fetchResourceMetadata(targetResource, resourceMetadataUrl, options = {}) {
     const { sameOriginHeaders = {}, fetch: fetchImpl = fetch } = options;
     const targetResourceUrlObj = ( new URL(targetResource));
-    let urlsToTry;
-    if (!resourceMetadataUrl) {
-        const pathComponent = targetResourceUrlObj.pathname === '/' ? undefined : targetResourceUrlObj.pathname;
-        const rootUrl = `${targetResourceUrlObj.origin}${AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH}`;
-        if (pathComponent) {
-            urlsToTry = [
-                `${rootUrl}${pathComponent}`,
-                rootUrl
-            ];
+    const fetchPrm = async (prmUrl, validateUrl) => {
+        let headers = {
+            'Accept': 'application/json'
+        };
+        const resourceMetadataUrlObj = ( new URL(prmUrl));
+        if (resourceMetadataUrlObj.origin === targetResourceUrlObj.origin) {
+            headers = {
+                ...headers,
+                ...sameOriginHeaders
+            };
+        }
+        const response = await fetchImpl(prmUrl, { method: 'GET', headers });
+        if (response.status !== 200) {
+            let errorText;
+            try {
+                errorText = await response.text();
+            }
+            catch {
+                errorText = response.statusText;
+            }
+            throw ( new Error(
+                `Failed to fetch resource metadata from ${prmUrl}: ${response.status} ${errorText}`
+            ));
+        }
+        const body = await response.json();
+        if (isAuthorizationProtectedResourceMetadata(body)) {
+            const prmValue = ( ( new URL(body.resource)).toString());
+            const expectedResource = ( ( new URL(validateUrl)).toString());
+            if (prmValue !== expectedResource) {
+                throw ( new Error(
+                    `Protected Resource Metadata 'resource' property value "${prmValue}" does not match expected value "${expectedResource}" for URL ${prmUrl}. Per RFC 9728, these MUST match. See https://datatracker.ietf.org/doc/html/rfc9728#PRConfigurationValidation`
+                ));
+            }
+            return body;
         }
         else {
-            urlsToTry = [rootUrl];
+            throw ( new Error(
+                `Invalid resource metadata from ${prmUrl}. Expected to follow shape of https://datatracker.ietf.org/doc/html/rfc9728#name-protected-resource-metadata (Hints: is scopes_supported an array? Is resource a string?). Current payload: ${JSON.stringify(body)}`
+            ));
         }
-    }
-    else {
-        urlsToTry = [resourceMetadataUrl];
-    }
+    };
     const errors = [];
-    for (const urlToTry of urlsToTry) {
+    if (resourceMetadataUrl) {
         try {
-            let headers = {
-                'Accept': 'application/json'
-            };
-            const resourceMetadataUrlObj = ( new URL(urlToTry));
-            if (resourceMetadataUrlObj.origin === targetResourceUrlObj.origin) {
-                headers = {
-                    ...headers,
-                    ...sameOriginHeaders
-                };
-            }
-            const response = await fetchImpl(urlToTry, { method: 'GET', headers });
-            if (response.status !== 200) {
-                let errorText;
-                try {
-                    errorText = await response.text();
-                }
-                catch {
-                    errorText = response.statusText;
-                }
-                errors.push(( new Error(
-                    `Failed to fetch resource metadata from ${urlToTry}: ${response.status} ${errorText}`
-                )));
-                continue;
-            }
-            const body = await response.json();
-            if (isAuthorizationProtectedResourceMetadata(body)) {
-                const prmValue = ( ( new URL(body.resource)).toString());
-                const targetValue = ( targetResourceUrlObj.toString());
-                if (prmValue !== targetValue) {
-                    throw ( new Error(
-                        `Protected Resource Metadata resource property value "${prmValue}" (length: ${prmValue.length}) does not match target server url "${targetValue}" (length: ${targetValue.length}). These MUST match to follow OAuth spec https://datatracker.ietf.org/doc/html/rfc9728#PRConfigurationValidation`
-                    ));
-                }
-                return body;
-            }
-            else {
-                errors.push(( new Error(
-                    `Invalid resource metadata from ${urlToTry}. Expected to follow shape of https://datatracker.ietf.org/doc/html/rfc9728#name-protected-resource-metadata (Hints: is scopes_supported an array? Is resource a string?). Current payload: ${JSON.stringify(body)}`
-                )));
-                continue;
-            }
+            const metadata = await fetchPrm(resourceMetadataUrl, targetResource);
+            return { metadata, discoveryUrl: resourceMetadataUrl, errors };
         }
         catch (e) {
             errors.push(e instanceof Error ? e : ( new Error(String(e))));
-            continue;
         }
     }
+    const hasPathComponent = targetResourceUrlObj.pathname !== '/';
+    const rootUrl = `${targetResourceUrlObj.origin}${AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH}`;
+    if (hasPathComponent) {
+        const pathAppendedUrl = `${rootUrl}${targetResourceUrlObj.pathname}`;
+        try {
+            const metadata = await fetchPrm(pathAppendedUrl, targetResource);
+            return { metadata, discoveryUrl: pathAppendedUrl, errors };
+        }
+        catch (e) {
+            errors.push(e instanceof Error ? e : ( new Error(String(e))));
+        }
+    }
+    try {
+        const metadata = await fetchPrm(rootUrl, targetResourceUrlObj.origin);
+        return { metadata, discoveryUrl: rootUrl, errors };
+    }
+    catch (e) {
+        errors.push(e instanceof Error ? e : ( new Error(String(e))));
+    }
     if (errors.length === 1) {
         throw errors[0];
     }
@@ -401,19 +404,19 @@ async function fetchAuthorizationServerMetadata(authorizationServer, options = {
     const pathToFetch = ( ( new URL(AUTH_SERVER_METADATA_DISCOVERY_PATH, authorizationServer)).toString()) + extraPath;
     let metadata = await doFetch(pathToFetch);
     if (metadata) {
-        return metadata;
+        return { metadata, discoveryUrl: pathToFetch, errors };
     }
     const openidPathInsertionUrl = ( ( new URL(OPENID_CONNECT_DISCOVERY_PATH, authorizationServer)).toString()) + extraPath;
     metadata = await doFetch(openidPathInsertionUrl);
     if (metadata) {
-        return metadata;
+        return { metadata, discoveryUrl: openidPathInsertionUrl, errors };
     }
     const openidPathAdditionUrl = authorizationServer.endsWith('/')
         ? authorizationServer + OPENID_CONNECT_DISCOVERY_PATH.substring(1)
         : authorizationServer + OPENID_CONNECT_DISCOVERY_PATH;
     metadata = await doFetch(openidPathAdditionUrl);
     if (metadata) {
-        return metadata;
+        return { metadata, discoveryUrl: openidPathAdditionUrl, errors };
     }
     if (errors.length === 1) {
         throw errors[0];

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

@@ -1,6 +1,6 @@
 
 import { onUnexpectedError } from '../errors.js';
-import '../arrays.js';
+import '../equals.js';
 import '../event.js';
 import '../lifecycle.js';
 

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

@@ -1,6 +1,6 @@
 
 import { BugIndicatingError } from '../errors.js';
-import '../arrays.js';
+import '../equals.js';
 import '../event.js';
 import '../lifecycle.js';
 

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

@@ -1,6 +1,6 @@
 
 import { BugIndicatingError } from '../../errors.js';
-import '../../arrays.js';
+import '../../equals.js';
 import '../../event.js';
 import { DisposableStore } from '../../lifecycle.js';
 import { getDebugName, DebugNameData } from '../debugName.js';

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

@@ -1,6 +1,6 @@
 
 import '../errors.js';
-import '../arrays.js';
+import '../equals.js';
 import '../event.js';
 import '../lifecycle.js';
 import { setLogObservableFn, addLogger } from './logging/logging.js';

package/vscode/src/vs/base/common/observableInternal/observables/derivedImpl.js

@@ -1,7 +1,7 @@
 
 import { BaseObservable } from './baseObservable.js';
 import { assertFn } from '../../assert.js';
-import '../../arrays.js';
+import '../../equals.js';
 import { onBugIndicatingError, BugIndicatingError } from '../../errors.js';
 import '../../event.js';
 import { DisposableStore } from '../../lifecycle.js';

package/vscode/src/vs/base/common/observableInternal/observables/observableFromEvent.d.ts

@@ -7,6 +7,7 @@ export declare function observableFromEvent<T, TArgs = unknown>(owner: DebugOwne
 export declare function observableFromEvent<T, TArgs = unknown>(event: Event<TArgs>, getValue: (args: TArgs | undefined) => T): IObservable<T>;
 export declare function observableFromEventOpts<T, TArgs = unknown>(options: IDebugNameData & {
     equalsFn?: EqualityComparer<T>;
+    getTransaction?: () => ITransaction | undefined;
 }, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T, debugLocation?: DebugLocation): IObservable<T>;
 export declare class FromEventObservable<TArgs, T> extends BaseObservable<T> {
     private readonly _debugNameData;

package/vscode/src/vs/base/common/observableInternal/observables/observableFromEvent.js

@@ -23,7 +23,7 @@ function observableFromEvent(...args) {
     return ( new FromEventObservable(( new DebugNameData(owner, undefined, getValue)), event, getValue, () => FromEventObservable.globalTransaction, strictEquals, debugLocation ?? DebugLocation.ofCaller()));
 }
 function observableFromEventOpts(options, event, getValue, debugLocation = DebugLocation.ofCaller()) {
-    return ( new FromEventObservable(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? getValue)), event, getValue, () => FromEventObservable.globalTransaction, options.equalsFn ?? strictEquals, debugLocation));
+    return ( new FromEventObservable(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? getValue)), event, getValue, () => options.getTransaction?.() ?? FromEventObservable.globalTransaction, options.equalsFn ?? strictEquals, debugLocation));
 }
 class FromEventObservable extends BaseObservable {
     constructor(_debugNameData, event, _getValue, _getTransaction, _equalityComparator, debugLocation) {

package/vscode/src/vs/base/common/observableInternal/reactions/autorun.js

@@ -1,6 +1,6 @@
 
 import '../../errors.js';
-import '../../arrays.js';
+import '../../equals.js';
 import '../../event.js';
 import { DisposableStore, toDisposable } from '../../lifecycle.js';
 import { DebugNameData } from '../debugName.js';

package/vscode/src/vs/base/common/observableInternal/reactions/autorunImpl.d.ts

@@ -26,6 +26,7 @@ export declare class AutorunObserver<TChangeSummary = any> implements IObserver,
     private _dependenciesToBeRemoved;
     private _changeSummary;
     private _isRunning;
+    private _iteration;
     get debugName(): string;
     constructor(_debugNameData: DebugNameData, _runFn: (reader: IReaderWithStore, changeSummary: TChangeSummary) => void, _changeTracker: IChangeTracker<TChangeSummary> | undefined, debugLocation: DebugLocation);
     dispose(): void;
@@ -50,4 +51,5 @@ export declare class AutorunObserver<TChangeSummary = any> implements IObserver,
         stateStr: string;
     };
     debugRerun(): void;
+    private _checkIterations;
 }

package/vscode/src/vs/base/common/observableInternal/reactions/autorunImpl.js

@@ -1,6 +1,6 @@
 
 import { assertFn } from '../../assert.js';
-import '../../arrays.js';
+import '../../equals.js';
 import { onBugIndicatingError, BugIndicatingError } from '../../errors.js';
 import '../../event.js';
 import { trackDisposable, markAsDisposed, DisposableStore } from '../../lifecycle.js';
@@ -34,6 +34,7 @@ class AutorunObserver {
         this._dependencies = ( new Set());
         this._dependenciesToBeRemoved = ( new Set());
         this._isRunning = false;
+        this._iteration = 0;
         this._store = undefined;
         this._delayedStore = undefined;
         this._changeSummary = this._changeTracker?.createChangeSummary(undefined);
@@ -110,6 +111,7 @@ class AutorunObserver {
     }
     beginUpdate(_observable) {
         if (this._state === AutorunState.upToDate) {
+            this._checkIterations();
             this._state = AutorunState.dependenciesMightHaveChanged;
         }
         this._updateCount++;
@@ -117,7 +119,11 @@ class AutorunObserver {
     endUpdate(_observable) {
         try {
             if (this._updateCount === 1) {
+                this._iteration = 1;
                 do {
+                    if (this._checkIterations()) {
+                        return;
+                    }
                     if (this._state === AutorunState.dependenciesMightHaveChanged) {
                         this._state = AutorunState.upToDate;
                         for (const d of this._dependencies) {
@@ -127,6 +133,7 @@ class AutorunObserver {
                             }
                         }
                     }
+                    this._iteration++;
                     if (this._state !== AutorunState.upToDate) {
                         this._run();
                     }
@@ -140,6 +147,7 @@ class AutorunObserver {
     }
     handlePossibleChange(observable) {
         if (this._state === AutorunState.upToDate && this._isDependency(observable)) {
+            this._checkIterations();
             this._state = AutorunState.dependenciesMightHaveChanged;
         }
     }
@@ -153,6 +161,7 @@ class AutorunObserver {
                     didChange: (o) => o === observable,
                 }, this._changeSummary) : true;
                 if (shouldReact) {
+                    this._checkIterations();
                     this._state = AutorunState.stale;
                 }
             }
@@ -217,6 +226,13 @@ class AutorunObserver {
             this._state = AutorunState.stale;
         }
     }
+    _checkIterations() {
+        if (this._iteration > 100) {
+            onBugIndicatingError(( new BugIndicatingError(`Autorun '${this.debugName}' is stuck in an infinite update loop.`)));
+            return true;
+        }
+        return false;
+    }
 }
 
 export { AutorunObserver, AutorunState };

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

@@ -1,7 +1,7 @@
 
 import '../../errors.js';
 import { cancelOnDispose } from '../../cancellation.js';
-import '../../arrays.js';
+import '../../equals.js';
 import '../../event.js';
 import { DisposableStore } from '../../lifecycle.js';
 import { autorunWithStoreHandleChanges } from '../reactions/autorun.js';

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

@@ -2,7 +2,7 @@
 import { autorun } from '../reactions/autorun.js';
 import { observableValue } from '../observables/observableValue.js';
 import '../../errors.js';
-import '../../arrays.js';
+import '../../equals.js';
 import '../../event.js';
 import { toDisposable, DisposableStore } from '../../lifecycle.js';
 import { derivedOpts, derived } from '../observables/derived.js';

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

@@ -1,7 +1,7 @@
 
 import { CancellationError } from '../../errors.js';
 import '../../cancellation.js';
-import '../../arrays.js';
+import '../../equals.js';
 import '../../event.js';
 import '../../lifecycle.js';
 import { autorun } from '../reactions/autorun.js';

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

@@ -1,6 +1,6 @@
 
 import '../../errors.js';
-import '../../arrays.js';
+import '../../equals.js';
 import { Event } from '../../event.js';
 import '../../lifecycle.js';
 import { observableFromEvent } from '../observables/observableFromEvent.js';

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

@@ -448,7 +448,8 @@ function containsUnusualLineTerminators(str) {
 function isFullWidthCharacter(charCode) {
     return ((charCode >= 0x2E80 && charCode <= 0xD7AF)
         || (charCode >= 0xF900 && charCode <= 0xFAFF)
-        || (charCode >= 0xFF01 && charCode <= 0xFF5E));
+        || (charCode >= 0xFF01 && charCode <= 0xFF5E)
+        || (charCode >= 0xFFE0 && charCode <= 0xFFE6));
 }
 function isEmojiImprecise(x) {
     return ((x >= 0x1F1E6 && x <= 0x1F1FF) || (x === 8986) || (x === 8987) || (x === 9200)

package/vscode/src/vs/base/parts/ipc/common/ipc.js

@@ -497,6 +497,7 @@ class ChannelClient {
                     this.activeRequests.delete(emitter);
                     this.sendRequest({ id, type: RequestType.EventDispose });
                 }
+                this.handlers.delete(id);
             }
         }));
         const handler = (res) => emitter.fire(res.data);

package/vscode/src/vs/editor/browser/controller/dragScrolling.js

@@ -97,6 +97,7 @@ class TopBottomDragScrollingOperation extends DragScrollingOperation {
         this._viewHelper.renderNow();
         const viewportData = this._context.viewLayout.getLinesViewportData();
         const edgeLineNumber = (this._position.outsidePosition === 'above' ? viewportData.startLineNumber : viewportData.endLineNumber);
+        const cannotScrollAnymore = (this._position.outsidePosition === 'above' ? viewportData.startLineNumber === 1 : viewportData.endLineNumber === this._context.viewModel.getLineCount());
         let mouseTarget;
         {
             const editorPos = createEditorPagePosition(this._viewHelper.viewDomNode);
@@ -108,7 +109,7 @@ class TopBottomDragScrollingOperation extends DragScrollingOperation {
             const relativePos = createCoordinatesRelativeToEditor(this._viewHelper.viewDomNode, editorPos, pos);
             mouseTarget = this._mouseTargetFactory.createMouseTarget(this._viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
         }
-        if (!mouseTarget.position || mouseTarget.position.lineNumber !== edgeLineNumber) {
+        if (!mouseTarget.position || mouseTarget.position.lineNumber !== edgeLineNumber || cannotScrollAnymore) {
             if (this._position.outsidePosition === 'above') {
                 mouseTarget = MouseTarget.createOutsideEditor(this._position.mouseColumn, ( new Position(edgeLineNumber, 1)), 'above', this._position.outsideDistance);
             }

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

@@ -90,7 +90,7 @@ let ScreenReaderSupport = class ScreenReaderSupport extends Disposable {
         this._domNode.domNode.setAttribute('aria-required', options.get(EditorOption.ariaRequired) ? 'true' : 'false');
         this._domNode.domNode.setAttribute('aria-multiline', 'true');
         this._domNode.domNode.setAttribute('aria-autocomplete', options.get(EditorOption.readOnly) ? 'none' : 'both');
-        this._domNode.domNode.setAttribute('aria-roledescription', ( localize(130, "editor")));
+        this._domNode.domNode.setAttribute('aria-roledescription', ( localize(132, "editor")));
         this._domNode.domNode.setAttribute('aria-label', ariaLabelForScreenReaderContent(options, this._keybindingService));
         const tabSize = this._context.viewModel.model.getOptions().tabSize;
         const spaceWidth = options.get(EditorOption.fontInfo).spaceWidth;