@codingame/monaco-vscode-api 21.5.1 → 22.0.0

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

@@ -2,6 +2,7 @@
 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 OPENID_CONNECT_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/openid-configuration`;
 const AUTH_SCOPE_SEPARATOR = ' ';
@@ -129,9 +130,7 @@ async function fetchDynamicRegistration(serverMetadata, clientName, scopes) {
             redirect_uris: [
                 'https://insiders.vscode.dev/redirect',
                 'https://vscode.dev/redirect',
-                'http://localhost/',
                 'http://127.0.0.1/',
-                `http://localhost:${DEFAULT_AUTH_FLOW_PORT}/`,
                 `http://127.0.0.1:${DEFAULT_AUTH_FLOW_PORT}/`
             ],
             scope: scopes?.join(AUTH_SCOPE_SEPARATOR),
@@ -265,5 +264,82 @@ function scopesMatch(scopes1, scopes2) {
     const sortedScopes2 = [...scopes2].sort();
     return sortedScopes1.every((scope, index) => scope === sortedScopes2[index]);
 }
+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
+            ];
+        }
+        else {
+            urlsToTry = [rootUrl];
+        }
+    }
+    else {
+        urlsToTry = [resourceMetadataUrl];
+    }
+    const errors = [];
+    for (const urlToTry of urlsToTry) {
+        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;
+            }
+        }
+        catch (e) {
+            errors.push(e instanceof Error ? e : ( new Error(String(e))));
+            continue;
+        }
+    }
+    if (errors.length === 1) {
+        throw errors[0];
+    }
+    else {
+        throw ( new AggregateError(errors, 'Failed to fetch resource metadata from all attempted URLs'));
+    }
+}
 
-export { AUTH_SCOPE_SEPARATOR, AUTH_SERVER_METADATA_DISCOVERY_PATH, AuthorizationDeviceCodeErrorType, AuthorizationErrorType, AuthorizationRegistrationErrorType, DEFAULT_AUTH_FLOW_PORT, OPENID_CONNECT_DISCOVERY_PATH, fetchDynamicRegistration, getClaimsFromJWT, getDefaultMetadataForUrl, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationErrorResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationRegistrationErrorResponse, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader, scopesMatch };
+export { AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH, AUTH_SCOPE_SEPARATOR, AUTH_SERVER_METADATA_DISCOVERY_PATH, AuthorizationDeviceCodeErrorType, AuthorizationErrorType, AuthorizationRegistrationErrorType, DEFAULT_AUTH_FLOW_PORT, OPENID_CONNECT_DISCOVERY_PATH, fetchDynamicRegistration, fetchResourceMetadata, getClaimsFromJWT, getDefaultMetadataForUrl, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationErrorResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationRegistrationErrorResponse, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader, scopesMatch };

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

@@ -74,6 +74,10 @@ export interface IObservableWithChange<T, TChange = unknown> {
      * A human-readable name for debugging purposes.
      */
     readonly debugName: string;
+    /**
+     * ONLY FOR DEBUGGING!
+    */
+    debugGetDependencyGraph(): string;
     /**
      * This property captures the type of the change object. Do not use it at runtime!
      */

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

@@ -4,6 +4,7 @@ import '../arrays.js';
 import '../event.js';
 import '../lifecycle.js';
 import { setLogObservableFn, addLogger } from './logging/logging.js';
+import { _setDebugGetDependencyGraph } from './observables/baseObservable.js';
 export { DebugLocation } from './debugLocation.js';
 import './reactions/autorunImpl.js';
 export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter } from './observables/derived.js';
@@ -14,7 +15,9 @@ export { observableFromEvent, observableFromEventOpts } from './observables/obse
 import { logObservableToConsole } from './logging/consoleObservableLogger.js';
 import { DevToolsLogger } from './logging/debugger/devToolsLogger.js';
 import { env } from '../process.js';
+import { debugGetDependencyGraph } from './logging/debugGetDependencyGraph.js';
 
+_setDebugGetDependencyGraph(debugGetDependencyGraph);
 setLogObservableFn(logObservableToConsole);
 if (env && env['VSCODE_DEV_DEBUG_OBSERVABLES']) {
     addLogger(DevToolsLogger.getInstance());

package/vscode/src/vs/base/common/observableInternal/logging/debugGetDependencyGraph.d.ts

@@ -0,0 +1,4 @@
+import { IObservable, IObserver } from "../base.js";
+export declare function debugGetDependencyGraph(obs: IObservable<any> | IObserver, options?: {
+    debugNamePostProcessor?: (name: string) => string;
+}): string;

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

@@ -0,0 +1,98 @@
+
+import { Derived } from '../observables/derivedImpl.js';
+import { FromEventObservable } from '../observables/observableFromEvent.js';
+import { ObservableValue } from '../observables/observableValue.js';
+import { AutorunObserver } from '../reactions/autorunImpl.js';
+import { formatValue } from './consoleObservableLogger.js';
+
+function debugGetDependencyGraph(obs, options) {
+    const debugNamePostProcessor = options?.debugNamePostProcessor ?? ((str) => str);
+    const info = Info.from(obs, debugNamePostProcessor);
+    if (!info) {
+        return '';
+    }
+    const alreadyListed = ( new Set());
+    return formatObservableInfo(info, 0, alreadyListed).trim();
+}
+function formatObservableInfo(info, indentLevel, alreadyListed) {
+    const indent = '\t\t'.repeat(indentLevel);
+    const lines = [];
+    const isAlreadyListed = ( alreadyListed.has(info.sourceObj));
+    if (isAlreadyListed) {
+        lines.push(`${indent}* ${info.type} ${info.name} (already listed)`);
+        return lines.join('\n');
+    }
+    alreadyListed.add(info.sourceObj);
+    lines.push(`${indent}* ${info.type} ${info.name}:`);
+    lines.push(`${indent}  value: ${formatValue(info.value, 50)}`);
+    lines.push(`${indent}  state: ${info.state}`);
+    if (info.dependencies.length > 0) {
+        lines.push(`${indent}  dependencies:`);
+        for (const dep of info.dependencies) {
+            lines.push(formatObservableInfo(dep, indentLevel + 1, alreadyListed));
+        }
+    }
+    return lines.join('\n');
+}
+class Info {
+    static from(obs, debugNamePostProcessor) {
+        if (obs instanceof AutorunObserver) {
+            const state = obs.debugGetState();
+            return ( new Info(
+                obs,
+                debugNamePostProcessor(obs.debugName),
+                'autorun',
+                undefined,
+                state.stateStr,
+                ( Array.from(state.dependencies).map(dep => Info.from(dep, debugNamePostProcessor) || Info.unknown(dep)))
+            ));
+        }
+        else if (obs instanceof Derived) {
+            const state = obs.debugGetState();
+            return ( new Info(
+                obs,
+                debugNamePostProcessor(obs.debugName),
+                'derived',
+                state.value,
+                state.stateStr,
+                ( Array.from(state.dependencies).map(dep => Info.from(dep, debugNamePostProcessor) || Info.unknown(dep)))
+            ));
+        }
+        else if (obs instanceof ObservableValue) {
+            const state = obs.debugGetState();
+            return ( new Info(
+                obs,
+                debugNamePostProcessor(obs.debugName),
+                'observableValue',
+                state.value,
+                'upToDate',
+                []
+            ));
+        }
+        else if (obs instanceof FromEventObservable) {
+            const state = obs.debugGetState();
+            return ( new Info(
+                obs,
+                debugNamePostProcessor(obs.debugName),
+                'fromEvent',
+                state.value,
+                state.hasValue ? 'upToDate' : 'initial',
+                []
+            ));
+        }
+        return undefined;
+    }
+    static unknown(obs) {
+        return ( new Info(obs, '(unknown)', 'unknown', undefined, 'unknown', []));
+    }
+    constructor(sourceObj, name, type, value, state, dependencies) {
+        this.sourceObj = sourceObj;
+        this.name = name;
+        this.type = type;
+        this.value = value;
+        this.state = state;
+        this.dependencies = dependencies;
+    }
+}
+
+export { debugGetDependencyGraph };

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

@@ -2,6 +2,7 @@ import { IObservableWithChange, IObserver, IReader, IObservable } from "../base.
 import { DisposableStore } from "../commonFacade/deps.js";
 import { DebugLocation } from "../debugLocation.js";
 import { DebugOwner } from "../debugName.js";
+import { debugGetDependencyGraph } from "../logging/debugGetDependencyGraph.js";
 import type { keepObserved, recomputeInitiallyAndOnChange } from "../utils/utils.js";
 import { derivedOpts } from "./derived.js";
 declare let _derived: typeof derivedOpts;
@@ -14,6 +15,8 @@ declare let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange
 export declare function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange): void;
 declare let _keepObserved: typeof keepObserved;
 export declare function _setKeepObserved(keepObserved: typeof _keepObserved): void;
+declare let _debugGetDependencyGraph: typeof debugGetDependencyGraph;
+export declare function _setDebugGetDependencyGraph(debugGetDependencyGraph: typeof _debugGetDependencyGraph): void;
 export declare abstract class ConvenientObservable<T, TChange> implements IObservableWithChange<T, TChange> {
     get TChange(): TChange;
     abstract get(): T;
@@ -40,6 +43,7 @@ export declare abstract class ConvenientObservable<T, TChange> implements IObser
     keepObserved(store: DisposableStore): IObservable<T>;
     abstract get debugName(): string;
     protected get debugValue(): T;
+    debugGetDependencyGraph(): string;
 }
 export declare abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
     protected readonly _observers: Set<IObserver>;

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

@@ -15,6 +15,10 @@ let _keepObserved;
 function _setKeepObserved(keepObserved) {
     _keepObserved = keepObserved;
 }
+let _debugGetDependencyGraph;
+function _setDebugGetDependencyGraph(debugGetDependencyGraph) {
+    _debugGetDependencyGraph = debugGetDependencyGraph;
+}
 class ConvenientObservable {
     get TChange() { return null; }
     reportChanges() {
@@ -68,6 +72,9 @@ class ConvenientObservable {
     get debugValue() {
         return this.get();
     }
+    debugGetDependencyGraph() {
+        return _debugGetDependencyGraph(this);
+    }
 }
 class BaseObservable extends ConvenientObservable {
     constructor(debugLocation) {
@@ -109,4 +116,4 @@ class BaseObservable extends ConvenientObservable {
     }
 }
 
-export { BaseObservable, ConvenientObservable, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange };
+export { BaseObservable, ConvenientObservable, _setDebugGetDependencyGraph, _setDerivedOpts, _setKeepObserved, _setRecomputeInitiallyAndOnChange };

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

@@ -67,6 +67,7 @@ export declare class Derived<T, TChangeSummary = any, TChange = void> extends Ba
     removeObserver(observer: IObserver): void;
     debugGetState(): {
         state: DerivedState;
+        stateStr: string;
         updateCount: number;
         isComputing: boolean;
         dependencies: Set<IObservable<any>>;

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

@@ -14,6 +14,15 @@ var DerivedState;
     DerivedState[DerivedState["stale"] = 2] = "stale";
     DerivedState[DerivedState["upToDate"] = 3] = "upToDate";
 })(DerivedState || (DerivedState = {}));
+function derivedStateToString(state) {
+    switch (state) {
+        case DerivedState.initial: return 'initial';
+        case DerivedState.dependenciesMightHaveChanged: return 'dependenciesMightHaveChanged';
+        case DerivedState.stale: return 'stale';
+        case DerivedState.upToDate: return 'upToDate';
+        default: return '<unknown>';
+    }
+}
 class Derived extends BaseObservable {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? '(anonymous)';
@@ -296,6 +305,7 @@ class Derived extends BaseObservable {
     debugGetState() {
         return {
             state: this._state,
+            stateStr: derivedStateToString(this._state),
             updateCount: this._updateCount,
             isComputing: this._isComputing,
             dependencies: this._dependencies,

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

@@ -26,6 +26,10 @@ export declare class FromEventObservable<TArgs, T> extends BaseObservable<T> {
     protected onLastObserverRemoved(): void;
     get(): T;
     debugSetValue(value: unknown): void;
+    debugGetState(): {
+        value: T | undefined;
+        hasValue: boolean;
+    };
 }
 export declare namespace observableFromEvent {
     const Observer: typeof FromEventObservable;

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

@@ -92,6 +92,9 @@ class FromEventObservable extends BaseObservable {
     debugSetValue(value) {
         this._value = value;
     }
+    debugGetState() {
+        return { value: this._value, hasValue: this._hasValue };
+    }
 }
 (function (observableFromEvent) {
     observableFromEvent.Observer = FromEventObservable;

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

@@ -47,6 +47,7 @@ export declare class AutorunObserver<TChangeSummary = any> implements IObserver,
         updateCount: number;
         dependencies: Set<IObservable<any>>;
         state: AutorunState;
+        stateStr: string;
     };
     debugRerun(): void;
 }

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

@@ -12,6 +12,14 @@ var AutorunState;
     AutorunState[AutorunState["stale"] = 2] = "stale";
     AutorunState[AutorunState["upToDate"] = 3] = "upToDate";
 })(AutorunState || (AutorunState = {}));
+function autorunStateToString(state) {
+    switch (state) {
+        case AutorunState.dependenciesMightHaveChanged: return 'dependenciesMightHaveChanged';
+        case AutorunState.stale: return 'stale';
+        case AutorunState.upToDate: return 'upToDate';
+        default: return '<unknown>';
+    }
+}
 class AutorunObserver {
     get debugName() {
         return this._debugNameData.getDebugName(this) ?? '(anonymous)';
@@ -198,6 +206,7 @@ class AutorunObserver {
             updateCount: this._updateCount,
             dependencies: this._dependencies,
             state: this._state,
+            stateStr: autorunStateToString(this._state),
         };
     }
     debugRerun() {

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

@@ -98,7 +98,6 @@ export interface IProductConfiguration {
     readonly extensionsGallery?: {
         readonly serviceUrl: string;
         readonly controlUrl: string;
-        readonly mcpUrl: string;
         readonly extensionUrlTemplate: string;
         readonly resourceUrlTemplate: string;
         readonly nlsBaseUrl: string;
@@ -106,6 +105,12 @@ export interface IProductConfiguration {
     };
     readonly mcpGallery?: {
         readonly serviceUrl: string;
+        readonly itemWebUrl: string;
+        readonly publisherUrl: string;
+        readonly supportUrl: string;
+        readonly privacyPolicyUrl: string;
+        readonly termsOfServiceUrl: string;
+        readonly reportUrl: string;
     };
     readonly extensionPublisherOrgs?: readonly string[];
     readonly trustedExtensionPublishers?: readonly string[];
@@ -359,6 +364,7 @@ export interface IDefaultChatAgent {
     readonly completionsRefreshTokenCommand: string;
     readonly chatRefreshTokenCommand: string;
     readonly generateCommitMessageCommand: string;
+    readonly resolveMergeConflictsCommand: string;
     readonly completionsAdvancedSetting: string;
     readonly completionsEnablementSetting: string;
     readonly nextEditSuggestionsSetting: string;

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

@@ -52,7 +52,6 @@ export declare function ltrim(haystack: string, needle: string): string;
  */
 export declare function rtrim(haystack: string, needle: string): string;
 export declare function convertSimple2RegExpPattern(pattern: string): string;
-export declare function stripWildcards(pattern: string): string;
 export interface RegExpOptions {
     matchCase?: boolean;
     wholeWord?: boolean;

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

@@ -119,9 +119,6 @@ function rtrim(haystack, needle) {
 function convertSimple2RegExpPattern(pattern) {
     return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
 }
-function stripWildcards(pattern) {
-    return pattern.replace(/\*/g, '');
-}
 function createRegExp(searchString, isRegex, options = {}) {
     if (!searchString) {
         throw ( new Error('Cannot create regex from empty string'));
@@ -165,6 +162,14 @@ function joinStrings(items, separator) {
 function splitLines(str) {
     return str.split(/\r\n|\r|\n/);
 }
+function splitLinesIncludeSeparators(str) {
+    const linesWithSeparators = [];
+    const splitLinesAndSeparators = str.split(/(\r\n|\r|\n)/);
+    for (let i = 0; i < Math.ceil(splitLinesAndSeparators.length / 2); i++) {
+        linesWithSeparators.push(splitLinesAndSeparators[2 * i] + (splitLinesAndSeparators[2 * i + 1] ?? ''));
+    }
+    return linesWithSeparators;
+}
 function firstNonWhitespaceIndex(str) {
     for (let i = 0, len = str.length; i < len; i++) {
         const chCode = str.charCodeAt(i);
@@ -827,4 +832,4 @@ function multibyteAwareBtoa(str) {
     return btoa(toBinary(str));
 }
 
-export { AmbiguousCharacters, CodePointIterator, Ellipsis, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, multibyteAwareBtoa, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, startsWithIgnoreCase, startsWithUTF8BOM, stripWildcards, trim, truncate, truncateMiddle, uppercaseFirstLetter };
+export { AmbiguousCharacters, CodePointIterator, Ellipsis, GraphemeBreakType, GraphemeIterator, InvisibleCharacters, UNUSUAL_LINE_TERMINATORS, UTF8_BOM_CHARACTER, commonPrefixLength, commonSuffixLength, compare, compareIgnoreCase, compareSubstring, compareSubstringIgnoreCase, computeCodePoint, containsRTL, containsUnusualLineTerminators, containsUppercaseCharacter, convertSimple2RegExpPattern, count, createRegExp, equalsIgnoreCase, escape, escapeRegExpCharacters, firstNonWhitespaceIndex, forAnsiStringParts, format, format2, fuzzyContains, getCharContainingOffset, getLeadingWhitespace, getLeftDeleteOffset, getNLines, getNextCodePoint, htmlAttributeEncodeValue, isAsciiDigit, isBasicASCII, isEmojiImprecise, isFalsyOrWhitespace, isFullWidthCharacter, isHighSurrogate, isLowSurrogate, isLowerAsciiLetter, isUpperAsciiLetter, joinStrings, lastNonWhitespaceIndex, lcut, ltrim, multibyteAwareBtoa, nextCharLength, noBreakWhitespace, prevCharLength, regExpLeadsToEndlessLoop, removeAnsiEscapeCodes, removeAnsiEscapeCodesFromPrompt, rtrim, singleLetterHash, splitLines, splitLinesIncludeSeparators, startsWithIgnoreCase, startsWithUTF8BOM, trim, truncate, truncateMiddle, uppercaseFirstLetter };

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

@@ -3,6 +3,29 @@ import { VSBuffer } from './buffer.js';
 import { MarshalledId } from './marshallingIds.js';
 import { URI } from './uri.js';
 
+function toJSON(uri) {
+    return uri.toJSON();
+}
+class URITransformer {
+    constructor(uriTransformer) {
+        this._uriTransformer = uriTransformer;
+    }
+    transformIncoming(uri) {
+        const result = this._uriTransformer.transformIncoming(uri);
+        return (result === uri ? uri : toJSON(( URI.from(result))));
+    }
+    transformOutgoing(uri) {
+        const result = this._uriTransformer.transformOutgoing(uri);
+        return (result === uri ? uri : toJSON(( URI.from(result))));
+    }
+    transformOutgoingURI(uri) {
+        const result = this._uriTransformer.transformOutgoing(uri);
+        return (result === uri ? uri : ( URI.from(result)));
+    }
+    transformOutgoingScheme(scheme) {
+        return this._uriTransformer.transformOutgoingScheme(scheme);
+    }
+}
 const DefaultURITransformer = new class {
     transformIncoming(uri) {
         return uri;
@@ -54,4 +77,4 @@ function transformAndReviveIncomingURIs(obj, transformer) {
     return result;
 }
 
-export { DefaultURITransformer, transformAndReviveIncomingURIs, transformIncomingURIs };
+export { DefaultURITransformer, URITransformer, transformAndReviveIncomingURIs, transformIncomingURIs };

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

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { getActiveWindow, addDisposableListener, createElement, isHTMLElement } from '../../../../../base/browser/dom.js';
+import { getActiveElement, addDisposableListener, createElement, getActiveWindow, isHTMLElement } from '../../../../../base/browser/dom.js';
 import { createTrustedTypesPolicy } from '../../../../../base/browser/trustedTypes.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
 import { EditorOption, EditorFontLigatures } from '../../../../common/config/editorOptions.js';
@@ -25,14 +25,14 @@ let RichScreenReaderContent = class RichScreenReaderContent extends Disposable {
         this._selectionChangeListener = this._register(( new MutableDisposable()));
         this._accessibilityPageSize = 1;
         this._ignoreSelectionChangeTime = 0;
-        this._state = ( new RichScreenReaderState([]));
+        this._state = RichScreenReaderState.NULL;
         this._strategy = ( new RichPagedScreenReaderStrategy());
         this._renderedLines = ( new Map());
         this._renderedSelection = ( new Selection(1, 1, 1, 1));
         this.onConfigurationChanged(this._context.configuration.options);
     }
     updateScreenReaderContent(primarySelection) {
-        const focusedElement = getActiveWindow().document.activeElement;
+        const focusedElement = getActiveElement();
         if (!focusedElement || focusedElement !== this._domNode.domNode) {
             return;
         }
@@ -49,7 +49,7 @@ let RichScreenReaderContent = class RichScreenReaderContent extends Disposable {
             }
         }
         else {
-            this._state = ( new RichScreenReaderState([]));
+            this._state = RichScreenReaderState.NULL;
             this._setIgnoreSelectionChangeTime('setValue');
             this._domNode.domNode.textContent = '';
         }
@@ -88,7 +88,7 @@ let RichScreenReaderContent = class RichScreenReaderContent extends Disposable {
     _setSelectionChangeListener() {
         let previousSelectionChangeEventTime = 0;
         return addDisposableListener(this._domNode.domNode.ownerDocument, 'selectionchange', () => {
-            const activeElement = getActiveWindow().document.activeElement;
+            const activeElement = getActiveElement();
             const isFocused = activeElement === this._domNode.domNode;
             if (!isFocused) {
                 return;
@@ -287,19 +287,29 @@ class LineInterval {
     }
 }
 class RichScreenReaderState {
-    constructor(intervals) {
+    constructor(model, intervals) {
         this.intervals = intervals;
-    }
-    equals(other) {
-        if (this.intervals.length !== other.intervals.length) {
-            return false;
-        }
-        for (let i = 0; i < this.intervals.length; i++) {
-            if (this.intervals[i].startLine !== other.intervals[i].startLine || this.intervals[i].endLine !== other.intervals[i].endLine) {
-                return false;
+        let value = '';
+        for (const interval of intervals) {
+            for (let lineNumber = interval.startLine; lineNumber <= interval.endLine; lineNumber++) {
+                value += model.getLineContent(lineNumber) + '\n';
             }
         }
-        return true;
+        this.value = value;
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    static get NULL() {
+        const nullModel = {
+            getLineContent: () => '',
+            getLineCount: () => 1,
+            getLineMaxColumn: () => 1,
+            getValueInRange: () => '',
+            getValueLengthInRange: () => 0,
+            modifyPosition: (position, offset) => position
+        };
+        return ( new RichScreenReaderState(nullModel, []));
     }
 }
 class RichPagedScreenReaderStrategy {
@@ -322,7 +332,7 @@ class RichPagedScreenReaderStrategy {
         if (selectionStartPage + 1 < selectionEndPage) {
             lineIntervals.push({ startLine: selectionEndPageRange.startLine, endLine: selectionEndPageRange.endLine });
         }
-        return ( new RichScreenReaderState(lineIntervals));
+        return ( new RichScreenReaderState(context, lineIntervals));
     }
 }
 

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

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { getActiveWindow, addDisposableListener } from '../../../../../base/browser/dom.js';
+import { getActiveElement, getActiveWindow, addDisposableListener } from '../../../../../base/browser/dom.js';
 import { AccessibilitySupport } from '../../../../../platform/accessibility/common/accessibility.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
 import { EditorOption } from '../../../../common/config/editorOptions.js';
@@ -27,7 +27,7 @@ let SimpleScreenReaderContent = class SimpleScreenReaderContent extends Disposab
     }
     updateScreenReaderContent(primarySelection) {
         const domNode = this._domNode.domNode;
-        const focusedElement = getActiveWindow().document.activeElement;
+        const focusedElement = getActiveElement();
         if (!focusedElement || focusedElement !== domNode) {
             return;
         }
@@ -92,7 +92,7 @@ let SimpleScreenReaderContent = class SimpleScreenReaderContent extends Disposab
             if (!this._state || !isScreenReaderOptimized || !IME.enabled) {
                 return;
             }
-            const activeElement = getActiveWindow().document.activeElement;
+            const activeElement = getActiveElement();
             const isFocused = activeElement === this._domNode.domNode;
             if (!isFocused) {
                 return;

package/vscode/src/vs/editor/browser/services/hoverService/hover.css

@@ -13,7 +13,7 @@
 	max-width: 700px;
 	background: var(--vscode-editorHoverWidget-background);
 	border: 1px solid var(--vscode-editorHoverWidget-border);
-	border-radius: 3px;
+	border-radius: 5px;
 	color: var(--vscode-editorHoverWidget-foreground);
 	box-shadow: 0 2px 8px var(--vscode-widget-shadow);
 }

package/vscode/src/vs/editor/browser/widget/diffEditor/commands.d.ts

@@ -35,7 +35,9 @@ export declare class ShowAllUnchangedRegions extends EditorAction2 {
 }
 export declare class RevertHunkOrSelection extends Action2 {
     constructor();
-    run(accessor: ServicesAccessor, arg: DiffEditorSelectionHunkToolbarContext): unknown;
+    run(accessor: ServicesAccessor, arg?: DiffEditorSelectionHunkToolbarContext): unknown;
+    runViaCursorOrSelection(accessor: ServicesAccessor): unknown;
+    runViaToolbarContext(accessor: ServicesAccessor, arg: DiffEditorSelectionHunkToolbarContext): unknown;
 }
 export declare class AccessibleDiffViewerNext extends Action2 {
     static id: string;

package/vscode/src/vs/editor/browser/widget/diffEditor/commands.js

@@ -152,11 +152,22 @@ class RevertHunkOrSelection extends Action2 {
         super({
             id: 'diffEditor.revert',
             title: ( localize2(161, 'Revert')),
-            f1: false,
+            f1: true,
             category: diffEditorCategory,
+            precondition: ( ContextKeyExpr.has('isInDiffEditor')),
         });
     }
     run(accessor, arg) {
+        return arg ? this.runViaToolbarContext(accessor, arg) : this.runViaCursorOrSelection(accessor);
+    }
+    runViaCursorOrSelection(accessor) {
+        const diffEditor = findFocusedDiffEditor(accessor);
+        if (diffEditor instanceof DiffEditorWidget) {
+            diffEditor.revertFocusedRangeMappings();
+        }
+        return undefined;
+    }
+    runViaToolbarContext(accessor, arg) {
         const diffEditor = findDiffEditor(accessor, arg.originalUri, arg.modifiedUri);
         if (diffEditor instanceof DiffEditorWidget) {
             diffEditor.revertRangeMappings(arg.mapping.innerChanges ?? []);