chore(vscode): update to 1.56.0

lib/vscode/src/vs/base/common/actions.ts

@@ -10,7 +10,7 @@ import { Event, Emitter } from 'vs/base/common/event';
 export interface ITelemetryData {
 	readonly from?: string;
 	readonly target?: string;
-	[key: string]: any;
+	[key: string]: unknown;
 }
 
 export type WorkbenchActionExecutedClassification = {
@@ -30,13 +30,14 @@ export interface IAction extends IDisposable {
 	class: string | undefined;
 	enabled: boolean;
 	checked: boolean;
-	run(event?: any): Promise<any>;
+	run(event?: unknown): Promise<unknown>;
 }
 
 export interface IActionRunner extends IDisposable {
-	run(action: IAction, context?: any): Promise<any>;
 	readonly onDidRun: Event<IRunEvent>;
 	readonly onBeforeRun: Event<IRunEvent>;
+
+	run(action: IAction, context?: unknown): Promise<unknown>;
 }
 
 export interface IActionChangeEvent {
@@ -58,9 +59,9 @@ export class Action extends Disposable implements IAction {
 	protected _cssClass: string | undefined;
 	protected _enabled: boolean = true;
 	protected _checked: boolean = false;
-	protected readonly _actionCallback?: (event?: any) => Promise<any>;
+	protected readonly _actionCallback?: (event?: unknown) => Promise<unknown>;
 
-	constructor(id: string, label: string = '', cssClass: string = '', enabled: boolean = true, actionCallback?: (event?: any) => Promise<any>) {
+	constructor(id: string, label: string = '', cssClass: string = '', enabled: boolean = true, actionCallback?: (event?: unknown) => Promise<unknown>) {
 		super();
 		this._id = id;
 		this._label = label;
@@ -148,19 +149,16 @@ export class Action extends Disposable implements IAction {
 		}
 	}
 
-	run(event?: any, _data?: ITelemetryData): Promise<any> {
+	async run(event?: unknown, data?: ITelemetryData): Promise<void> {
 		if (this._actionCallback) {
-			return this._actionCallback(event);
+			await this._actionCallback(event);
 		}
-
-		return Promise.resolve(true);
 	}
 }
 
 export interface IRunEvent {
 	readonly action: IAction;
-	readonly result?: any;
-	readonly error?: any;
+	readonly error?: Error;
 }
 
 export class ActionRunner extends Disposable implements IActionRunner {
@@ -171,24 +169,25 @@ export class ActionRunner extends Disposable implements IActionRunner {
 	private _onDidRun = this._register(new Emitter<IRunEvent>());
 	readonly onDidRun = this._onDidRun.event;
 
-	async run(action: IAction, context?: any): Promise<any> {
+	async run(action: IAction, context?: unknown): Promise<void> {
 		if (!action.enabled) {
-			return Promise.resolve(null);
+			return;
 		}
 
-		this._onBeforeRun.fire({ action: action });
+		this._onBeforeRun.fire({ action });
 
+		let error: Error | undefined = undefined;
 		try {
-			const result = await this.runAction(action, context);
-			this._onDidRun.fire({ action: action, result: result });
-		} catch (error) {
-			this._onDidRun.fire({ action: action, error: error });
+			await this.runAction(action, context);
+		} catch (e) {
+			error = e;
 		}
+
+		this._onDidRun.fire({ action, error });
 	}
 
-	protected runAction(action: IAction, context?: any): Promise<any> {
-		const res = context ? action.run(context) : action.run();
-		return Promise.resolve(res);
+	protected async runAction(action: IAction, context?: unknown): Promise<void> {
+		await action.run(context);
 	}
 }
 
@@ -198,6 +197,7 @@ export class Separator extends Action {
 
 	constructor(label?: string) {
 		super(Separator.ID, label, label ? 'separator text' : 'separator');
+
 		this.checked = false;
 		this.enabled = false;
 	}
@@ -213,6 +213,7 @@ export class SubmenuAction implements IAction {
 	readonly checked: boolean = false;
 
 	private readonly _actions: readonly IAction[];
+	get actions(): readonly IAction[] { return this._actions; }
 
 	constructor(id: string, label: string, actions: readonly IAction[], cssClass?: string) {
 		this.id = id;
@@ -227,15 +228,13 @@ export class SubmenuAction implements IAction {
 		// to bridge into the rendering world.
 	}
 
-	get actions(): readonly IAction[] {
-		return this._actions;
-	}
-
-	async run(): Promise<any> { }
+	async run(): Promise<void> { }
 }
 
 export class EmptySubmenuAction extends Action {
+
 	static readonly ID = 'vs.actions.empty';
+
 	constructor() {
 		super(EmptySubmenuAction.ID, nls.localize('submenu.empty', '(empty)'), undefined, false);
 	}

lib/vscode/src/vs/base/common/async.ts

@@ -381,7 +381,7 @@ export class AutoOpenBarrier extends Barrier {
 		this._timeout = setTimeout(() => this.open(), autoOpenTimeMs);
 	}
 
-	open(): void {
+	override open(): void {
 		clearTimeout(this._timeout);
 		super.open();
 	}
@@ -772,7 +772,7 @@ export class RunOnceWorker<T> extends RunOnceScheduler {
 		}
 	}
 
-	protected doRun(): void {
+	protected override doRun(): void {
 		const units = this.units;
 		this.units = [];
 
@@ -781,7 +781,7 @@ export class RunOnceWorker<T> extends RunOnceScheduler {
 		}
 	}
 
-	dispose(): void {
+	override dispose(): void {
 		this.units = [];
 
 		super.dispose();
@@ -942,7 +942,7 @@ export class TaskSequentializer {
 	}
 
 	setPending(taskId: number, promise: Promise<void>, onCancel?: () => void,): Promise<void> {
-		this._pending = { taskId: taskId, cancel: () => onCancel?.(), promise };
+		this._pending = { taskId, cancel: () => onCancel?.(), promise };
 
 		promise.then(() => this.donePending(taskId), () => this.donePending(taskId));
 
@@ -1179,7 +1179,7 @@ export namespace Promises {
 	 * Interface of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
 	 */
 	interface PromiseWithAllSettled<T> {
-		allSettled<T>(promises: Promise<T>[]): Promise<ReadonlyArray<IResolvedPromise<T> | IRejectedPromise>>;
+		allSettled<T>(promises: Promise<T>[]): Promise<readonly (IResolvedPromise<T> | IRejectedPromise)[]>;
 	}
 
 	/**
@@ -1188,7 +1188,7 @@ export namespace Promises {
 	 * in the order of the original passed in promises array.
 	 * See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
 	 */
-	export async function allSettled<T>(promises: Promise<T>[]): Promise<ReadonlyArray<IResolvedPromise<T> | IRejectedPromise>> {
+	export async function allSettled<T>(promises: Promise<T>[]): Promise<readonly (IResolvedPromise<T> | IRejectedPromise)[]> {
 		if (typeof (Promise as unknown as PromiseWithAllSettled<T>).allSettled === 'function') {
 			return allSettledNative(promises); // in some environments we can benefit from native implementation
 		}
@@ -1196,11 +1196,11 @@ export namespace Promises {
 		return allSettledShim(promises);
 	}
 
-	async function allSettledNative<T>(promises: Promise<T>[]): Promise<ReadonlyArray<IResolvedPromise<T> | IRejectedPromise>> {
+	async function allSettledNative<T>(promises: Promise<T>[]): Promise<readonly (IResolvedPromise<T> | IRejectedPromise)[]> {
 		return (Promise as unknown as PromiseWithAllSettled<T>).allSettled(promises);
 	}
 
-	async function allSettledShim<T>(promises: Promise<T>[]): Promise<ReadonlyArray<IResolvedPromise<T> | IRejectedPromise>> {
+	async function allSettledShim<T>(promises: Promise<T>[]): Promise<readonly (IResolvedPromise<T> | IRejectedPromise)[]> {
 		return Promise.all(promises.map(promise => (promise.then(value => {
 			const fulfilled: IResolvedPromise<T> = { status: 'fulfilled', value };
 

lib/vscode/src/vs/base/common/buffer.ts

@@ -235,3 +235,11 @@ export function streamToBufferReadableStream(stream: streams.ReadableStreamEvent
 export function newWriteableBufferStream(options?: streams.WriteableStreamOptions): streams.WriteableStream<VSBuffer> {
 	return streams.newWriteableStream<VSBuffer>(chunks => VSBuffer.concat(chunks), options);
 }
+
+export function prefixedBufferReadable(prefix: VSBuffer, readable: VSBufferReadable): VSBufferReadable {
+	return streams.prefixedReadable(prefix, readable, chunks => VSBuffer.concat(chunks));
+}
+
+export function prefixedBufferStream(prefix: VSBuffer, stream: VSBufferReadableStream): VSBufferReadableStream {
+	return streams.prefixedStream(prefix, stream, chunks => VSBuffer.concat(chunks));
+}

lib/vscode/src/vs/base/common/codicons.ts

@@ -49,6 +49,16 @@ export function registerCodicon(id: string, def: Codicon): Codicon {
 	return new Codicon(id, def);
 }
 
+// Selects all codicon names encapsulated in the `$()` syntax and wraps the
+// results with spaces so that screen readers can read the text better.
+export function getCodiconAriaLabel(text: string | undefined) {
+	if (!text) {
+		return '';
+	}
+
+	return text.replace(/\$\((.*?)\)/g, (_match, codiconName) => ` ${codiconName} `).trim();
+}
+
 export class Codicon implements CSSIcon {
 	constructor(public readonly id: string, public readonly definition: Codicon | IconDefinition, public description?: string) {
 		_registry.add(this);
@@ -131,7 +141,6 @@ export namespace Codicon {
 	export const tagAdd = new Codicon('tag-add', { fontCharacter: '\\ea66' });
 	export const tagRemove = new Codicon('tag-remove', { fontCharacter: '\\ea66' });
 	export const person = new Codicon('person', { fontCharacter: '\\ea67' });
-	export const personAdd = new Codicon('person-add', { fontCharacter: '\\ea67' });
 	export const personFollow = new Codicon('person-follow', { fontCharacter: '\\ea67' });
 	export const personOutline = new Codicon('person-outline', { fontCharacter: '\\ea67' });
 	export const personFilled = new Codicon('person-filled', { fontCharacter: '\\ea67' });
@@ -550,7 +559,20 @@ export namespace Codicon {
 	export const debugRerun = new Codicon('debug-rerun', { fontCharacter: '\\ebc0' });
 	export const workspaceTrusted = new Codicon('workspace-trusted', { fontCharacter: '\\ebc1' });
 	export const workspaceUntrusted = new Codicon('workspace-untrusted', { fontCharacter: '\\ebc2' });
-	export const workspaceUnknown = new Codicon('workspace-unknown', { fontCharacter: '\\ebc3' });
+	export const workspaceUnspecified = new Codicon('workspace-unspecified', { fontCharacter: '\\ebc3' });
+	export const terminalCmd = new Codicon('terminal-cmd', { fontCharacter: '\\ebc4' });
+	export const terminalDebian = new Codicon('terminal-debian', { fontCharacter: '\\ebc5' });
+	export const terminalLinux = new Codicon('terminal-linux', { fontCharacter: '\\ebc6' });
+	export const terminalPowershell = new Codicon('terminal-powershell', { fontCharacter: '\\ebc7' });
+	export const terminalTmux = new Codicon('terminal-tmux', { fontCharacter: '\\ebc8' });
+	export const terminalUbuntu = new Codicon('terminal-ubuntu', { fontCharacter: '\\ebc9' });
+	export const terminalBash = new Codicon('terminal-bash', { fontCharacter: '\\ebca' });
+	export const arrowSwap = new Codicon('arrow-swap', { fontCharacter: '\\ebcb' });
+	export const copy = new Codicon('copy', { fontCharacter: '\\ebcc' });
+	export const personAdd = new Codicon('person-add', { fontCharacter: '\\ebcd' });
+	export const filterFilled = new Codicon('filter-filled', { fontCharacter: '\\ebce' });
+	export const wand = new Codicon('wand', { fontCharacter: '\\ebcf' });
+	export const debugLineByLine = new Codicon('debug-line-by-line', { fontCharacter: '\\ebd0' });
 
 	export const dropDownButton = new Codicon('drop-down-button', Codicon.chevronDown.definition);
 }

lib/vscode/src/vs/base/common/collections.ts

@@ -66,6 +66,24 @@ export function groupBy<T>(data: T[], groupFn: (element: T) => string): IStringD
 	return result;
 }
 
+/**
+ * Groups the collection into a dictionary based on the provided
+ * group function.
+ */
+export function groupByNumber<T>(data: T[], groupFn: (element: T) => number): Map<number, T[]> {
+	const result = new Map<number, T[]>();
+	for (const element of data) {
+		const key = groupFn(element);
+		let target = result.get(key);
+		if (!target) {
+			target = [];
+			result.set(key, target);
+		}
+		target.push(element);
+	}
+	return result;
+}
+
 export function fromMap<T>(original: Map<string, T>): IStringDictionary<T> {
 	const result: IStringDictionary<T> = Object.create(null);
 	if (original) {

lib/vscode/src/vs/base/common/errors.ts

@@ -229,11 +229,11 @@ export class ExpectedError extends Error {
 }
 
 export interface IErrorOptions {
-	actions?: ReadonlyArray<IAction>;
+	actions?: readonly IAction[];
 }
 
 export interface IErrorWithActions {
-	actions?: ReadonlyArray<IAction>;
+	actions?: readonly IAction[];
 }
 
 export function isErrorWithActions(obj: unknown): obj is IErrorWithActions {

lib/vscode/src/vs/base/common/event.ts

@@ -674,7 +674,7 @@ export class PauseableEmitter<T> extends Emitter<T> {
 		}
 	}
 
-	fire(event: T): void {
+	override fire(event: T): void {
 		if (this._listeners) {
 			if (this._isPaused !== 0) {
 				this._eventQueue.push(event);

lib/vscode/src/vs/base/common/keyCodes.ts

@@ -12,6 +12,8 @@ import { illegalArgument } from 'vs/base/common/errors';
  * But these are "more general", as they should work across browsers & OS`s.
  */
 export const enum KeyCode {
+	DependsOnKbLayout = -1,
+
 	/**
 	 * Placed first to cover the 0 value of the enum.
 	 */

lib/vscode/src/vs/base/common/map.ts

@@ -887,7 +887,7 @@ export class LinkedMap<K, V> implements Map<K, V> {
 			this._tail = undefined;
 		}
 		else if (item === this._head) {
-			// This can only happend if size === 1 which is handle
+			// This can only happen if size === 1 which is handled
 			// by the case above.
 			if (!item.next) {
 				throw new Error('Invalid list');
@@ -896,7 +896,7 @@ export class LinkedMap<K, V> implements Map<K, V> {
 			this._head = item.next;
 		}
 		else if (item === this._tail) {
-			// This can only happend if size === 1 which is handle
+			// This can only happen if size === 1 which is handled
 			// by the case above.
 			if (!item.previous) {
 				throw new Error('Invalid list');
@@ -1028,7 +1028,7 @@ export class LRUCache<K, V> extends LinkedMap<K, V> {
 		this.checkTrim();
 	}
 
-	get(key: K, touch: Touch = Touch.AsNew): V | undefined {
+	override get(key: K, touch: Touch = Touch.AsNew): V | undefined {
 		return super.get(key, touch);
 	}
 
@@ -1036,7 +1036,7 @@ export class LRUCache<K, V> extends LinkedMap<K, V> {
 		return super.get(key, Touch.None);
 	}
 
-	set(key: K, value: V): this {
+	override set(key: K, value: V): this {
 		super.set(key, value, Touch.AsNew);
 		this.checkTrim();
 		return this;
@@ -1048,3 +1048,47 @@ export class LRUCache<K, V> extends LinkedMap<K, V> {
 		}
 	}
 }
+
+/**
+ * Wraps the map in type that only implements readonly properties. Useful
+ * in the extension host to prevent the consumer from making any mutations.
+ */
+export class ReadonlyMapView<K, V> implements ReadonlyMap<K, V>{
+	readonly #source: ReadonlyMap<K, V>;
+
+	public get size() {
+		return this.#source.size;
+	}
+
+	constructor(source: ReadonlyMap<K, V>) {
+		this.#source = source;
+	}
+
+	forEach(callbackfn: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: any): void {
+		this.#source.forEach(callbackfn, thisArg);
+	}
+
+	get(key: K): V | undefined {
+		return this.#source.get(key);
+	}
+
+	has(key: K): boolean {
+		return this.#source.has(key);
+	}
+
+	entries(): IterableIterator<[K, V]> {
+		return this.#source.entries();
+	}
+
+	keys(): IterableIterator<K> {
+		return this.#source.keys();
+	}
+
+	values(): IterableIterator<V> {
+		return this.#source.values();
+	}
+
+	[Symbol.iterator](): IterableIterator<[K, V]> {
+		return this.#source.entries();
+	}
+}

lib/vscode/src/vs/base/common/network.ts

@@ -66,6 +66,8 @@ export namespace Schemas {
 
 	export const vscodeWorkspaceTrust = 'vscode-workspace-trust';
 
+	export const vscodeTerminal = 'vscode-terminal';
+
 	export const webviewPanel = 'webview-panel';
 
 	/**
@@ -73,11 +75,6 @@ export namespace Schemas {
 	 */
 	export const vscodeWebview = 'vscode-webview';
 
-	/**
-	 * Scheme used for loading resources inside of webviews.
-	 */
-	export const vscodeWebviewResource = 'vscode-webview-resource';
-
 	/**
 	 * Scheme used for extension pages
 	 */
@@ -88,6 +85,11 @@ export namespace Schemas {
 	 * files with our custom protocol handler (desktop only).
 	 */
 	export const vscodeFileResource = 'vscode-file';
+
+	/**
+	 * Scheme used for temporary resources
+	 */
+	export const tmp = 'tmp';
 }
 
 class RemoteAuthoritiesImpl {
@@ -162,7 +164,7 @@ class FileAccessImpl {
 		}
 
 		// Only convert the URI if we are in a native context and it has `file:` scheme
-		// and we have explicitly enabled the conversion (sandbox, or ENABLE_VSCODE_BROWSER_CODE_LOADING)
+		// and we have explicitly enabled the conversion (sandbox, or VSCODE_BROWSER_CODE_LOADING)
 		if (platform.isNative && (__forceCodeFileUri || platform.isPreferringBrowserCodeLoad) && uri.scheme === Schemas.file) {
 			return uri.with({
 				scheme: Schemas.vscodeFileResource,

lib/vscode/src/vs/base/common/platform.ts

@@ -24,7 +24,7 @@ interface NLSConfig {
 }
 
 export interface IProcessEnvironment {
-	[key: string]: string;
+	[key: string]: string | undefined;
 }
 
 /**
@@ -53,12 +53,12 @@ declare const self: unknown;
 export const globals: any = (typeof self === 'object' ? self : typeof global === 'object' ? global : {});
 
 let nodeProcess: INodeProcess | undefined = undefined;
-if (typeof process !== 'undefined') {
-	// Native environment (non-sandboxed)
-	nodeProcess = process;
-} else if (typeof globals.vscode !== 'undefined') {
+if (typeof globals.vscode !== 'undefined') {
 	// Native environment (sandboxed)
 	nodeProcess = globals.vscode.process;
+} else if (typeof process !== 'undefined') {
+	// Native environment (non-sandboxed)
+	nodeProcess = process;
 }
 
 const isElectronRenderer = typeof nodeProcess?.versions?.electron === 'string' && nodeProcess.type === 'renderer';
@@ -71,7 +71,7 @@ export const browserCodeLoadingCacheStrategy: 'none' | 'code' | 'bypassHeatCheck
 	}
 
 	// Otherwise, only enabled conditionally
-	const env = nodeProcess?.env['ENABLE_VSCODE_BROWSER_CODE_LOADING'];
+	const env = nodeProcess?.env['VSCODE_BROWSER_CODE_LOADING'];
 	if (typeof env === 'string') {
 		if (env === 'none' || env === 'code' || env === 'bypassHeatCheck' || env === 'bypassHeatCheckAndEagerCompile') {
 			return env;

lib/vscode/src/vs/base/common/process.ts

@@ -6,20 +6,10 @@
 import { isWindows, isMacintosh, setImmediate, globals, INodeProcess } from 'vs/base/common/platform';
 
 let safeProcess: INodeProcess & { nextTick: (callback: (...args: any[]) => void) => void; };
-
-// Native node.js environment
 declare const process: INodeProcess;
-if (typeof process !== 'undefined') {
-	safeProcess = {
-		get platform() { return process.platform; },
-		get env() { return process.env; },
-		cwd() { return process.env['VSCODE_CWD'] || process.cwd(); },
-		nextTick(callback: (...args: any[]) => void): void { return process.nextTick!(callback); }
-	};
-}
 
 // Native sandbox environment
-else if (typeof globals.vscode !== 'undefined') {
+if (typeof globals.vscode !== 'undefined') {
 	const sandboxProcess: INodeProcess = globals.vscode.process;
 	safeProcess = {
 		get platform() { return sandboxProcess.platform; },
@@ -29,6 +19,16 @@ else if (typeof globals.vscode !== 'undefined') {
 	};
 }
 
+// Native node.js environment
+else if (typeof process !== 'undefined') {
+	safeProcess = {
+		get platform() { return process.platform; },
+		get env() { return process.env; },
+		cwd() { return process.env['VSCODE_CWD'] || process.cwd(); },
+		nextTick(callback: (...args: any[]) => void): void { return process.nextTick!(callback); }
+	};
+}
+
 // Web environment
 else {
 	safeProcess = {

lib/vscode/src/vs/base/common/product.ts

@@ -0,0 +1,168 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IStringDictionary } from 'vs/base/common/collections';
+
+export interface IBuiltInExtension {
+	readonly name: string;
+	readonly version: string;
+	readonly repo: string;
+	readonly metadata: any;
+}
+
+export type ConfigurationSyncStore = {
+	url: string,
+	insidersUrl: string,
+	stableUrl: string,
+	canSwitch: boolean,
+	authenticationProviders: IStringDictionary<{ scopes: string[] }>
+};
+
+export type ExtensionUntrustedWorkspaceSupport = {
+	readonly default?: boolean | 'limited',
+	readonly override?: boolean | 'limited'
+};
+
+export interface IProductConfiguration {
+	readonly version: string;
+	readonly date?: string;
+	readonly quality?: string;
+	readonly commit?: string;
+
+	readonly nameShort: string;
+	readonly nameLong: string;
+
+	readonly win32AppUserModelId?: string;
+	readonly win32MutexName?: string;
+	readonly applicationName: string;
+
+	readonly urlProtocol: string;
+	readonly dataFolderName: string; // location for extensions (e.g. ~/.vscode-insiders)
+
+	readonly builtInExtensions?: IBuiltInExtension[];
+
+	readonly downloadUrl?: string;
+	readonly updateUrl?: string;
+	readonly webEndpointUrl?: string;
+	readonly target?: string;
+
+	readonly settingsSearchBuildId?: number;
+	readonly settingsSearchUrl?: string;
+
+	readonly tasConfig?: {
+		endpoint: string;
+		telemetryEventName: string;
+		featuresTelemetryPropertyName: string;
+		assignmentContextTelemetryPropertyName: string;
+	};
+
+	readonly experimentsUrl?: string;
+
+	readonly extensionsGallery?: {
+		readonly serviceUrl: string;
+		readonly itemUrl: string;
+		readonly controlUrl: string;
+		readonly recommendationsUrl: string;
+	};
+
+	readonly extensionTips?: { [id: string]: string; };
+	readonly extensionImportantTips?: IStringDictionary<ImportantExtensionTip>;
+	readonly configBasedExtensionTips?: { [id: string]: IConfigBasedExtensionTip; };
+	readonly exeBasedExtensionTips?: { [id: string]: IExeBasedExtensionTip; };
+	readonly remoteExtensionTips?: { [remoteName: string]: IRemoteExtensionTip; };
+	readonly extensionKeywords?: { [extension: string]: readonly string[]; };
+	readonly keymapExtensionTips?: readonly string[];
+	readonly trustedExtensionUrlPublicKeys?: { [id: string]: string[]; };
+
+	readonly crashReporter?: {
+		readonly companyName: string;
+		readonly productName: string;
+	};
+
+	readonly enableTelemetry?: boolean;
+	readonly aiConfig?: {
+		readonly asimovKey: string;
+	};
+
+	readonly sendASmile?: {
+		readonly reportIssueUrl: string,
+		readonly requestFeatureUrl: string
+	};
+
+	readonly documentationUrl?: string;
+	readonly releaseNotesUrl?: string;
+	readonly keyboardShortcutsUrlMac?: string;
+	readonly keyboardShortcutsUrlLinux?: string;
+	readonly keyboardShortcutsUrlWin?: string;
+	readonly introductoryVideosUrl?: string;
+	readonly tipsAndTricksUrl?: string;
+	readonly newsletterSignupUrl?: string;
+	readonly twitterUrl?: string;
+	readonly requestFeatureUrl?: string;
+	readonly reportIssueUrl?: string;
+	readonly reportMarketplaceIssueUrl?: string;
+	readonly licenseUrl?: string;
+	readonly privacyStatementUrl?: string;
+	readonly telemetryOptOutUrl?: string;
+
+	readonly npsSurveyUrl?: string;
+	readonly cesSurveyUrl?: string;
+	readonly surveys?: readonly ISurveyData[];
+
+	readonly checksums?: { [path: string]: string; };
+	readonly checksumFailMoreInfoUrl?: string;
+
+	readonly appCenter?: IAppCenterConfiguration;
+
+	readonly portable?: string;
+
+	readonly extensionKind?: { readonly [extensionId: string]: ('ui' | 'workspace' | 'web')[]; };
+	readonly extensionSyncedKeys?: { readonly [extensionId: string]: string[]; };
+	readonly extensionAllowedProposedApi?: readonly string[];
+	readonly extensionUntrustedWorkspaceSupport?: { readonly [extensionId: string]: ExtensionUntrustedWorkspaceSupport };
+	readonly extensionVirtualWorkspacesSupport?: { readonly [extensionId: string]: { default?: boolean, override?: boolean } };
+
+	readonly msftInternalDomains?: string[];
+	readonly linkProtectionTrustedDomains?: readonly string[];
+
+	readonly 'configurationSync.store'?: ConfigurationSyncStore;
+
+	readonly darwinUniversalAssetId?: string;
+}
+
+export type ImportantExtensionTip = { name: string; languages?: string[]; pattern?: string; isExtensionPack?: boolean };
+
+export interface IAppCenterConfiguration {
+	readonly 'win32-ia32': string;
+	readonly 'win32-x64': string;
+	readonly 'linux-x64': string;
+	readonly 'darwin': string;
+}
+
+export interface IConfigBasedExtensionTip {
+	configPath: string;
+	configName: string;
+	recommendations: IStringDictionary<{ name: string, remotes?: string[], important?: boolean, isExtensionPack?: boolean }>;
+}
+
+export interface IExeBasedExtensionTip {
+	friendlyName: string;
+	windowsPath?: string;
+	important?: boolean;
+	recommendations: IStringDictionary<{ name: string, important?: boolean, isExtensionPack?: boolean }>;
+}
+
+export interface IRemoteExtensionTip {
+	friendlyName: string;
+	extensionId: string;
+}
+
+export interface ISurveyData {
+	surveyId: string;
+	surveyUrl: string;
+	languageId: string;
+	editCount: number;
+	userProbability: number;
+}

lib/vscode/src/vs/base/common/scanCode.ts

@@ -9,6 +9,7 @@ import { KeyCode } from 'vs/base/common/keyCodes';
  * keyboardEvent.code
  */
 export const enum ScanCode {
+	DependsOnKbLayout = -1,
 	None,
 
 	Hyper,
@@ -468,11 +469,11 @@ export class ScanCodeBinding {
 
 (function () {
 	for (let i = 0; i <= ScanCode.MAX_VALUE; i++) {
-		IMMUTABLE_CODE_TO_KEY_CODE[i] = -1;
+		IMMUTABLE_CODE_TO_KEY_CODE[i] = KeyCode.DependsOnKbLayout;
 	}
 
 	for (let i = 0; i <= KeyCode.MAX_VALUE; i++) {
-		IMMUTABLE_KEY_CODE_TO_CODE[i] = -1;
+		IMMUTABLE_KEY_CODE_TO_CODE[i] = ScanCode.DependsOnKbLayout;
 	}
 
 	function define(code: ScanCode, keyCode: KeyCode): void {

lib/vscode/src/vs/base/common/scrollable.ts

@@ -223,7 +223,7 @@ export class Scrollable extends Disposable {
 		this._smoothScrolling = null;
 	}
 
-	public dispose(): void {
+	public override dispose(): void {
 		if (this._smoothScrolling) {
 			this._smoothScrolling.dispose();
 			this._smoothScrolling = null;

lib/vscode/src/vs/base/common/severity.ts

@@ -18,6 +18,7 @@ namespace Severity {
 	const _warning = 'warning';
 	const _warn = 'warn';
 	const _info = 'info';
+	const _ignore = 'ignore';
 
 	/**
 	 * Parses 'error', 'warning', 'warn', 'info' in call casings
@@ -41,6 +42,15 @@ namespace Severity {
 		}
 		return Severity.Ignore;
 	}
+
+	export function toString(severity: Severity): string {
+		switch (severity) {
+			case Severity.Error: return _error;
+			case Severity.Warning: return _warning;
+			case Severity.Info: return _info;
+			default: return _ignore;
+		}
+	}
 }
 
 export default Severity;

lib/vscode/src/vs/base/common/stream.ts

@@ -142,15 +142,21 @@ export interface ReadableBufferedStream<T> {
 }
 
 export function isReadableStream<T>(obj: unknown): obj is ReadableStream<T> {
-	const candidate = obj as ReadableStream<T>;
+	const candidate = obj as ReadableStream<T> | undefined;
+	if (!candidate) {
+		return false;
+	}
 
-	return candidate && [candidate.on, candidate.pause, candidate.resume, candidate.destroy].every(fn => typeof fn === 'function');
+	return [candidate.on, candidate.pause, candidate.resume, candidate.destroy].every(fn => typeof fn === 'function');
 }
 
 export function isReadableBufferedStream<T>(obj: unknown): obj is ReadableBufferedStream<T> {
-	const candidate = obj as ReadableBufferedStream<T>;
+	const candidate = obj as ReadableBufferedStream<T> | undefined;
+	if (!candidate) {
+		return false;
+	}
 
-	return candidate && isReadableStream(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';
+	return isReadableStream(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';
 }
 
 export interface IReducer<T> {
@@ -625,6 +631,16 @@ export function toStream<T>(t: T, reducer: IReducer<T>): ReadableStream<T> {
 	return stream;
 }
 
+/**
+ * Helper to create an empty stream
+ */
+export function emptyStream(): ReadableStream<never> {
+	const stream = newWriteableStream<never>(() => { throw new Error('not supported'); });
+	stream.end();
+
+	return stream;
+}
+
 /**
  * Helper to convert a T into a Readable<T>.
  */
@@ -658,3 +674,71 @@ export function transform<Original, Transformed>(stream: ReadableStreamEvents<Or
 
 	return target;
 }
+
+/**
+ * Helper to take an existing readable that will
+ * have a prefix injected to the beginning.
+ */
+export function prefixedReadable<T>(prefix: T, readable: Readable<T>, reducer: IReducer<T>): Readable<T> {
+	let prefixHandled = false;
+
+	return {
+		read: () => {
+			const chunk = readable.read();
+
+			// Handle prefix only once
+			if (!prefixHandled) {
+				prefixHandled = true;
+
+				// If we have also a read-result, make
+				// sure to reduce it to a single result
+				if (chunk !== null) {
+					return reducer([prefix, chunk]);
+				}
+
+				// Otherwise, just return prefix directly
+				return prefix;
+			}
+
+			return chunk;
+		}
+	};
+}
+
+/**
+ * Helper to take an existing stream that will
+ * have a prefix injected to the beginning.
+ */
+export function prefixedStream<T>(prefix: T, stream: ReadableStream<T>, reducer: IReducer<T>): ReadableStream<T> {
+	let prefixHandled = false;
+
+	const target = newWriteableStream<T>(reducer);
+
+	listenStream(stream, {
+		onData: data => {
+
+			// Handle prefix only once
+			if (!prefixHandled) {
+				prefixHandled = true;
+
+				return target.write(reducer([prefix, data]));
+			}
+
+			return target.write(data);
+		},
+		onError: error => target.error(error),
+		onEnd: () => {
+
+			// Handle prefix only once
+			if (!prefixHandled) {
+				prefixHandled = true;
+
+				target.write(prefix);
+			}
+
+			target.end();
+		}
+	});
+
+	return target;
+}

lib/vscode/src/vs/base/common/types.ts

@@ -240,19 +240,19 @@ export function withUndefinedAsNull<T>(x: T | undefined): T | null {
 	return typeof x === 'undefined' ? null : x;
 }
 
+type AddFirstParameterToFunction<T, TargetFunctionsReturnType, FirstParameter> = T extends (...args: any[]) => TargetFunctionsReturnType ?
+	// Function: add param to function
+	(firstArg: FirstParameter, ...args: Parameters<T>) => ReturnType<T> :
+
+	// Else: just leave as is
+	T;
+
 /**
  * Allows to add a first parameter to functions of a type.
  */
 export type AddFirstParameterToFunctions<Target, TargetFunctionsReturnType, FirstParameter> = {
-
-	//  For every property
-	[K in keyof Target]:
-
-	// Function: add param to function
-	Target[K] extends (...args: any[]) => TargetFunctionsReturnType ? (firstArg: FirstParameter, ...args: Parameters<Target[K]>) => ReturnType<Target[K]> :
-
-	// Else: just leave as is
-	Target[K]
+	// For every property
+	[K in keyof Target]: AddFirstParameterToFunction<Target[K], TargetFunctionsReturnType, FirstParameter>;
 };
 
 /**
@@ -286,3 +286,7 @@ export function NotImplementedProxy<T>(name: string): { new(): T } {
 		}
 	};
 }
+
+export function assertNever(value: never) {
+	throw new Error('Unreachable');
+}

lib/vscode/src/vs/base/common/uri.ts

@@ -418,14 +418,14 @@ class Uri extends URI {
 	_formatted: string | null = null;
 	_fsPath: string | null = null;
 
-	get fsPath(): string {
+	override get fsPath(): string {
 		if (!this._fsPath) {
 			this._fsPath = uriToFsPath(this, false);
 		}
 		return this._fsPath;
 	}
 
-	toString(skipEncoding: boolean = false): string {
+	override toString(skipEncoding: boolean = false): string {
 		if (!skipEncoding) {
 			if (!this._formatted) {
 				this._formatted = _asFormatted(this, false);
@@ -437,7 +437,7 @@ class Uri extends URI {
 		}
 	}
 
-	toJSON(): UriComponents {
+	override toJSON(): UriComponents {
 		const res = <UriState>{
 			$mid: 1
 		};