Merge from vscode 966b87dd4013be1a9c06e2b8334522ec61905cc2 (#4696)

src/vs/base/common/arrays.ts

@@ -364,6 +364,18 @@ export function distinct<T>(array: ReadonlyArray<T>, keyFn?: (t: T) => string):
 	});
 }
 
+export function distinctES6<T>(array: ReadonlyArray<T>): T[] {
+	const seen = new Set<T>();
+	return array.filter(element => {
+		if (seen.has(element)) {
+			return false;
+		}
+
+		seen.add(element);
+		return true;
+	});
+}
+
 export function uniqueFilter<T>(keyFn: (t: T) => string): (t: T) => boolean {
 	const seen: { [key: string]: boolean; } = Object.create(null);
 

src/vs/base/common/async.ts

@@ -765,3 +765,19 @@ export class IdleValue<T> {
 }
 
 //#endregion
+
+export async function retry<T>(task: ITask<Promise<T>>, delay: number, retries: number): Promise<T> {
+	let lastError: Error | undefined;
+
+	for (let i = 0; i < retries; i++) {
+		try {
+			return await task();
+		} catch (error) {
+			lastError = error;
+
+			await timeout(delay);
+		}
+	}
+
+	return Promise.reject(lastError);
+}

src/vs/base/common/buffer.ts

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare var Buffer: any;
+const hasBuffer = (typeof Buffer !== 'undefined');
+
+export class VSBuffer {
+
+	public static alloc(byteLength: number): VSBuffer {
+		if (hasBuffer) {
+			return new VSBuffer(Buffer.allocUnsafe(byteLength));
+		} else {
+			return new VSBuffer(new Uint8Array(byteLength));
+		}
+	}
+
+	public static wrap(actual: Uint8Array): VSBuffer {
+		return new VSBuffer(actual);
+	}
+
+	public static fromString(source: string): VSBuffer {
+		return new VSBuffer(Buffer.from(source));
+	}
+
+	public static concat(buffers: VSBuffer[], totalLength?: number): VSBuffer {
+		if (typeof totalLength === 'undefined') {
+			totalLength = 0;
+			for (let i = 0, len = buffers.length; i < len; i++) {
+				totalLength += buffers[i].byteLength;
+			}
+		}
+
+		const ret = VSBuffer.alloc(totalLength);
+		let offset = 0;
+		for (let i = 0, len = buffers.length; i < len; i++) {
+			const element = buffers[i];
+			ret.set(element, offset);
+			offset += element.byteLength;
+		}
+
+		return ret;
+	}
+
+	public readonly buffer: Uint8Array;
+	public readonly byteLength: number;
+
+	private constructor(buffer: Uint8Array) {
+		this.buffer = buffer;
+		this.byteLength = this.buffer.byteLength;
+	}
+
+	public toString(): string {
+		return this.buffer.toString();
+	}
+
+	public slice(start?: number, end?: number): VSBuffer {
+		return new VSBuffer(this.buffer.slice(start, end));
+	}
+
+	public set(array: VSBuffer, offset?: number): void {
+		this.buffer.set(array.buffer, offset);
+	}
+
+	public readUint32BE(offset: number): number {
+		return readUint32BE(this.buffer, offset);
+	}
+
+	public writeUint32BE(value: number, offset: number): void {
+		writeUint32BE(this.buffer, value, offset);
+	}
+
+	public readUint8(offset: number): number {
+		return readUint8(this.buffer, offset);
+	}
+
+	public writeUint8(value: number, offset: number): void {
+		writeUint8(this.buffer, value, offset);
+	}
+
+}
+
+function readUint32BE(source: Uint8Array, offset: number): number {
+	return (
+		source[offset] * 2 ** 24
+		+ source[offset + 1] * 2 ** 16
+		+ source[offset + 2] * 2 ** 8
+		+ source[offset + 3]
+	);
+}
+
+function writeUint32BE(destination: Uint8Array, value: number, offset: number): void {
+	destination[offset + 3] = value;
+	value = value >>> 8;
+	destination[offset + 2] = value;
+	value = value >>> 8;
+	destination[offset + 1] = value;
+	value = value >>> 8;
+	destination[offset] = value;
+}
+
+function readUint8(source: Uint8Array, offset: number): number {
+	return source[offset];
+}
+
+function writeUint8(destination: Uint8Array, value: number, offset: number): void {
+	destination[offset] = value;
+}

src/vs/base/common/labels.ts

@@ -369,8 +369,8 @@ export function mnemonicMenuLabel(label: string, forceDisableMnemonics?: boolean
  * -   Linux: Supported via _ character (replace && with _)
  * -   macOS: Unsupported (replace && with empty string)
  */
-export function mnemonicButtonLabel(label: string): string {
-	if (isMacintosh) {
+export function mnemonicButtonLabel(label: string, forceDisableMnemonics?: boolean): string {
+	if (isMacintosh || forceDisableMnemonics) {
 		return label.replace(/\(&&\w\)|&&/g, '');
 	}