Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

lib/vscode/build/.cachesalt

@@ -0,0 +1 @@
+2020-10-05T20:24:23.714Z

lib/vscode/build/.gitattributes

@@ -0,0 +1,3 @@
+* text eol=lf
+*.exe binary
+*.dll binary

lib/vscode/build/.gitignore

@@ -0,0 +1,3 @@
+azure-pipelines/**/*.js
+darwin/**/*.js
+lib/**/*.js

lib/vscode/build/.moduleignore

@@ -0,0 +1,38 @@
+
+# additional cleanup rules for node modules, .gitignore style
+
+**/docs/**
+**/example/**
+**/examples/**
+**/test/**
+**/tests/**
+
+**/History.md
+**/CHANGELOG.md
+**/README.md
+**/readme.md
+**/readme.markdown
+
+**/*.ts
+!typescript/**/*.d.ts
+
+jschardet/dist/**
+
+es6-promise/lib/**
+
+vscode-textmate/webpack.config.js
+
+zone.js/dist/**
+!zone.js/dist/zone-node.js
+
+# https://github.com/xtermjs/xterm.js/issues/3137
+xterm/src/**
+xterm/tsconfig.all.json
+
+# https://github.com/xtermjs/xterm.js/issues/3138
+xterm-addon-*/src/**
+xterm-addon-*/fixtures/**
+xterm-addon-*/out/**
+xterm-addon-*/out-test/**
+
+

lib/vscode/build/.nativeignore

@@ -0,0 +1,102 @@
+# cleanup rules for native node modules, .gitignore style
+
+nan/**
+*/node_modules/nan/**
+
+fsevents/binding.gyp
+fsevents/fsevents.cc
+fsevents/build/**
+fsevents/src/**
+fsevents/test/**
+!fsevents/**/*.node
+
+vscode-sqlite3/binding.gyp
+vscode-sqlite3/benchmark/**
+vscode-sqlite3/cloudformation/**
+vscode-sqlite3/deps/**
+vscode-sqlite3/test/**
+vscode-sqlite3/build/**
+vscode-sqlite3/src/**
+!vscode-sqlite3/build/Release/*.node
+
+windows-mutex/binding.gyp
+windows-mutex/build/**
+windows-mutex/src/**
+!windows-mutex/**/*.node
+
+native-keymap/binding.gyp
+native-keymap/build/**
+native-keymap/src/**
+native-keymap/deps/**
+!native-keymap/build/Release/*.node
+
+native-is-elevated/binding.gyp
+native-is-elevated/build/**
+native-is-elevated/src/**
+native-is-elevated/deps/**
+!native-is-elevated/build/Release/*.node
+
+native-watchdog/binding.gyp
+native-watchdog/build/**
+native-watchdog/src/**
+!native-watchdog/build/Release/*.node
+
+spdlog/binding.gyp
+spdlog/build/**
+spdlog/deps/**
+spdlog/src/**
+spdlog/test/**
+spdlog/*.yml
+!spdlog/build/Release/*.node
+
+jschardet/dist/**
+
+windows-foreground-love/binding.gyp
+windows-foreground-love/build/**
+windows-foreground-love/src/**
+!windows-foreground-love/**/*.node
+
+windows-process-tree/binding.gyp
+windows-process-tree/build/**
+windows-process-tree/src/**
+!windows-process-tree/**/*.node
+
+keytar/binding.gyp
+keytar/build/**
+keytar/src/**
+keytar/script/**
+keytar/node_modules/**
+!keytar/**/*.node
+
+node-pty/binding.gyp
+node-pty/build/**
+node-pty/src/**
+node-pty/tools/**
+node-pty/deps/**
+node-pty/scripts/**
+!node-pty/build/Release/*.exe
+!node-pty/build/Release/*.dll
+!node-pty/build/Release/*.node
+
+vscode-nsfw/binding.gyp
+vscode-nsfw/build/**
+vscode-nsfw/src/**
+vscode-nsfw/openpa/**
+vscode-nsfw/includes/**
+!vscode-nsfw/build/Release/*.node
+!vscode-nsfw/**/*.a
+
+vsda/build/**
+vsda/ci/**
+vsda/src/**
+vsda/.gitignore
+vsda/binding.gyp
+vsda/README.md
+vsda/targets
+!vsda/build/Release/vsda.node
+
+vscode-windows-ca-certs/**/*
+!vscode-windows-ca-certs/package.json
+!vscode-windows-ca-certs/**/*.node
+
+node-addon-api/**/*

lib/vscode/build/.webignore

@@ -0,0 +1,31 @@
+# cleanup rules for web node modules, .gitignore style
+
+**/*.txt
+**/*.json
+**/*.md
+**/*.d.ts
+**/*.js.map
+**/LICENSE
+**/CONTRIBUTORS
+
+**/docs/**
+**/example/**
+**/examples/**
+
+jschardet/index.js
+jschardet/src/**
+jschardet/dist/jschardet.js
+
+vscode-textmate/webpack.config.js
+
+xterm/src/**
+
+xterm-addon-search/src/**
+xterm-addon-search/out/**
+xterm-addon-search/fixtures/**
+
+xterm-addon-unicode11/src/**
+xterm-addon-unicode11/out/**
+
+xterm-addon-webgl/src/**
+xterm-addon-webgl/out/**

lib/vscode/build/azure-pipelines/common/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+*.js

lib/vscode/build/azure-pipelines/common/createAsset.ts

@@ -0,0 +1,133 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as fs from 'fs';
+import { Readable } from 'stream';
+import * as crypto from 'crypto';
+import * as azure from 'azure-storage';
+import * as mime from 'mime';
+import { CosmosClient } from '@azure/cosmos';
+
+interface Asset {
+	platform: string;
+	type: string;
+	url: string;
+	mooncakeUrl?: string;
+	hash: string;
+	sha256hash: string;
+	size: number;
+	supportsFastUpdate?: boolean;
+}
+
+if (process.argv.length !== 6) {
+	console.error('Usage: node createAsset.js PLATFORM TYPE NAME FILE');
+	process.exit(-1);
+}
+
+function hashStream(hashName: string, stream: Readable): Promise<string> {
+	return new Promise<string>((c, e) => {
+		const shasum = crypto.createHash(hashName);
+
+		stream
+			.on('data', shasum.update.bind(shasum))
+			.on('error', e)
+			.on('close', () => c(shasum.digest('hex')));
+	});
+}
+
+async function doesAssetExist(blobService: azure.BlobService, quality: string, blobName: string): Promise<boolean | undefined> {
+	const existsResult = await new Promise<azure.BlobService.BlobResult>((c, e) => blobService.doesBlobExist(quality, blobName, (err, r) => err ? e(err) : c(r)));
+	return existsResult.exists;
+}
+
+async function uploadBlob(blobService: azure.BlobService, quality: string, blobName: string, filePath: string, fileName: string): Promise<void> {
+	const blobOptions: azure.BlobService.CreateBlockBlobRequestOptions = {
+		contentSettings: {
+			contentType: mime.lookup(filePath),
+			contentDisposition: `attachment; filename="${fileName}"`,
+			cacheControl: 'max-age=31536000, public'
+		}
+	};
+
+	await new Promise<void>((c, e) => blobService.createBlockBlobFromLocalFile(quality, blobName, filePath, blobOptions, err => err ? e(err) : c()));
+}
+
+function getEnv(name: string): string {
+	const result = process.env[name];
+
+	if (typeof result === 'undefined') {
+		throw new Error('Missing env: ' + name);
+	}
+
+	return result;
+}
+
+async function main(): Promise<void> {
+	const [, , platform, type, fileName, filePath] = process.argv;
+	const quality = getEnv('VSCODE_QUALITY');
+	const commit = getEnv('BUILD_SOURCEVERSION');
+
+	console.log('Creating asset...');
+
+	const stat = await new Promise<fs.Stats>((c, e) => fs.stat(filePath, (err, stat) => err ? e(err) : c(stat)));
+	const size = stat.size;
+
+	console.log('Size:', size);
+
+	const stream = fs.createReadStream(filePath);
+	const [sha1hash, sha256hash] = await Promise.all([hashStream('sha1', stream), hashStream('sha256', stream)]);
+
+	console.log('SHA1:', sha1hash);
+	console.log('SHA256:', sha256hash);
+
+	const blobName = commit + '/' + fileName;
+	const storageAccount = process.env['AZURE_STORAGE_ACCOUNT_2']!;
+
+	const blobService = azure.createBlobService(storageAccount, process.env['AZURE_STORAGE_ACCESS_KEY_2']!)
+		.withFilter(new azure.ExponentialRetryPolicyFilter(20));
+
+	const blobExists = await doesAssetExist(blobService, quality, blobName);
+
+	if (blobExists) {
+		console.log(`Blob ${quality}, ${blobName} already exists, not publishing again.`);
+		return;
+	}
+
+	console.log('Uploading blobs to Azure storage...');
+
+	await uploadBlob(blobService, quality, blobName, filePath, fileName);
+
+	console.log('Blobs successfully uploaded.');
+
+	const asset: Asset = {
+		platform,
+		type,
+		url: `${process.env['AZURE_CDN_URL']}/${quality}/${blobName}`,
+		hash: sha1hash,
+		sha256hash,
+		size
+	};
+
+	// Remove this if we ever need to rollback fast updates for windows
+	if (/win32/.test(platform)) {
+		asset.supportsFastUpdate = true;
+	}
+
+	console.log('Asset:', JSON.stringify(asset, null, '  '));
+
+	const client = new CosmosClient({ endpoint: process.env['AZURE_DOCUMENTDB_ENDPOINT']!, key: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
+	const scripts = client.database('builds').container(quality).scripts;
+	await scripts.storedProcedure('createAsset').execute('', [commit, asset, true]);
+}
+
+main().then(() => {
+	console.log('Asset successfully created');
+	process.exit(0);
+}, err => {
+	console.error(err);
+	process.exit(1);
+});

lib/vscode/build/azure-pipelines/common/createBuild.ts

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { CosmosClient } from '@azure/cosmos';
+
+if (process.argv.length !== 3) {
+	console.error('Usage: node createBuild.js VERSION');
+	process.exit(-1);
+}
+
+function getEnv(name: string): string {
+	const result = process.env[name];
+
+	if (typeof result === 'undefined') {
+		throw new Error('Missing env: ' + name);
+	}
+
+	return result;
+}
+
+async function main(): Promise<void> {
+	const [, , _version] = process.argv;
+	const quality = getEnv('VSCODE_QUALITY');
+	const commit = getEnv('BUILD_SOURCEVERSION');
+	const queuedBy = getEnv('BUILD_QUEUEDBY');
+	const sourceBranch = getEnv('BUILD_SOURCEBRANCH');
+	const version = _version + (quality === 'stable' ? '' : `-${quality}`);
+
+	console.log('Creating build...');
+	console.log('Quality:', quality);
+	console.log('Version:', version);
+	console.log('Commit:', commit);
+
+	const build = {
+		id: commit,
+		timestamp: (new Date()).getTime(),
+		version,
+		isReleased: false,
+		sourceBranch,
+		queuedBy,
+		assets: [],
+		updates: {}
+	};
+
+	const client = new CosmosClient({ endpoint: process.env['AZURE_DOCUMENTDB_ENDPOINT']!, key: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
+	const scripts = client.database('builds').container(quality).scripts;
+	await scripts.storedProcedure('createBuild').execute('', [{ ...build, _partitionKey: '' }]);
+}
+
+main().then(() => {
+	console.log('Build successfully created');
+	process.exit(0);
+}, err => {
+	console.error(err);
+	process.exit(1);
+});

lib/vscode/build/azure-pipelines/common/extract-telemetry.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -e
+
+cd $BUILD_STAGINGDIRECTORY
+mkdir extraction
+cd extraction
+git clone --depth 1 https://github.com/microsoft/vscode-extension-telemetry.git
+git clone --depth 1 https://github.com/microsoft/vscode-chrome-debug-core.git
+git clone --depth 1 https://github.com/microsoft/vscode-node-debug2.git
+git clone --depth 1 https://github.com/microsoft/vscode-node-debug.git
+git clone --depth 1 https://github.com/microsoft/vscode-html-languageservice.git
+git clone --depth 1 https://github.com/microsoft/vscode-json-languageservice.git
+node $BUILD_SOURCESDIRECTORY/build/node_modules/.bin/vscode-telemetry-extractor --sourceDir $BUILD_SOURCESDIRECTORY --excludedDir $BUILD_SOURCESDIRECTORY/extensions --outputDir . --applyEndpoints
+node $BUILD_SOURCESDIRECTORY/build/node_modules/.bin/vscode-telemetry-extractor --config $BUILD_SOURCESDIRECTORY/build/azure-pipelines/common/telemetry-config.json -o .
+mkdir -p $BUILD_SOURCESDIRECTORY/.build/telemetry
+mv declarations-resolved.json $BUILD_SOURCESDIRECTORY/.build/telemetry/telemetry-core.json
+mv config-resolved.json $BUILD_SOURCESDIRECTORY/.build/telemetry/telemetry-extensions.json
+cd ..
+rm -rf extraction

lib/vscode/build/azure-pipelines/common/publish-webview.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -e
+REPO="$(pwd)"
+
+# Publish webview contents
+PACKAGEJSON="$REPO/package.json"
+VERSION=$(node -p "require(\"$PACKAGEJSON\").version")
+
+node build/azure-pipelines/common/publish-webview.js "$REPO/src/vs/workbench/contrib/webview/browser/pre/"

lib/vscode/build/azure-pipelines/common/publish-webview.ts

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as azure from 'azure-storage';
+import * as mime from 'mime';
+import * as minimist from 'minimist';
+import { basename, join } from 'path';
+
+const fileNames = [
+	'fake.html',
+	'host.js',
+	'index.html',
+	'main.js',
+	'service-worker.js'
+];
+
+async function assertContainer(blobService: azure.BlobService, container: string): Promise<void> {
+	await new Promise<void>((c, e) => blobService.createContainerIfNotExists(container, { publicAccessLevel: 'blob' }, err => err ? e(err) : c()));
+}
+
+async function doesBlobExist(blobService: azure.BlobService, container: string, blobName: string): Promise<boolean | undefined> {
+	const existsResult = await new Promise<azure.BlobService.BlobResult>((c, e) => blobService.doesBlobExist(container, blobName, (err, r) => err ? e(err) : c(r)));
+	return existsResult.exists;
+}
+
+async function uploadBlob(blobService: azure.BlobService, container: string, blobName: string, file: string): Promise<void> {
+	const blobOptions: azure.BlobService.CreateBlockBlobRequestOptions = {
+		contentSettings: {
+			contentType: mime.lookup(file),
+			cacheControl: 'max-age=31536000, public'
+		}
+	};
+
+	await new Promise<void>((c, e) => blobService.createBlockBlobFromLocalFile(container, blobName, file, blobOptions, err => err ? e(err) : c()));
+}
+
+async function publish(commit: string, files: readonly string[]): Promise<void> {
+
+	console.log('Publishing...');
+	console.log('Commit:', commit);
+	const storageAccount = process.env['AZURE_WEBVIEW_STORAGE_ACCOUNT']!;
+
+	const blobService = azure.createBlobService(storageAccount, process.env['AZURE_WEBVIEW_STORAGE_ACCESS_KEY']!)
+		.withFilter(new azure.ExponentialRetryPolicyFilter(20));
+
+	await assertContainer(blobService, commit);
+
+	for (const file of files) {
+		const blobName = basename(file);
+		const blobExists = await doesBlobExist(blobService, commit, blobName);
+		if (blobExists) {
+			console.log(`Blob ${commit}, ${blobName} already exists, not publishing again.`);
+			continue;
+		}
+		console.log('Uploading blob to Azure storage...');
+		await uploadBlob(blobService, commit, blobName, file);
+	}
+
+	console.log('Blobs successfully uploaded.');
+}
+
+function main(): void {
+	const commit = process.env['BUILD_SOURCEVERSION'];
+
+	if (!commit) {
+		console.warn('Skipping publish due to missing BUILD_SOURCEVERSION');
+		return;
+	}
+
+	const opts = minimist(process.argv.slice(2));
+	const [directory] = opts._;
+
+	const files = fileNames.map(fileName => join(directory, fileName));
+
+	publish(commit, files).catch(err => {
+		console.error(err);
+		process.exit(1);
+	});
+}
+
+if (process.argv.length < 3) {
+	console.error('Usage: node publish.js <directory>');
+	process.exit(-1);
+}
+main();

lib/vscode/build/azure-pipelines/common/releaseBuild.ts

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import { CosmosClient } from '@azure/cosmos';
+
+function getEnv(name: string): string {
+	const result = process.env[name];
+
+	if (typeof result === 'undefined') {
+		throw new Error('Missing env: ' + name);
+	}
+
+	return result;
+}
+
+interface Config {
+	id: string;
+	frozen: boolean;
+}
+
+function createDefaultConfig(quality: string): Config {
+	return {
+		id: quality,
+		frozen: false
+	};
+}
+
+async function getConfig(client: CosmosClient, quality: string): Promise<Config> {
+	const query = `SELECT TOP 1 * FROM c WHERE c.id = "${quality}"`;
+
+	const res = await client.database('builds').container('config').items.query(query).fetchAll();
+
+	if (res.resources.length === 0) {
+		return createDefaultConfig(quality);
+	}
+
+	return res.resources[0] as Config;
+}
+
+async function main(): Promise<void> {
+	const commit = getEnv('BUILD_SOURCEVERSION');
+	const quality = getEnv('VSCODE_QUALITY');
+
+	const client = new CosmosClient({ endpoint: process.env['AZURE_DOCUMENTDB_ENDPOINT']!, key: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
+	const config = await getConfig(client, quality);
+
+	console.log('Quality config:', config);
+
+	if (config.frozen) {
+		console.log(`Skipping release because quality ${quality} is frozen.`);
+		return;
+	}
+
+	console.log(`Releasing build ${commit}...`);
+
+	const scripts = client.database('builds').container(quality).scripts;
+	await scripts.storedProcedure('releaseBuild').execute('', [commit]);
+}
+
+main().then(() => {
+	console.log('Build successfully released');
+	process.exit(0);
+}, err => {
+	console.error(err);
+	process.exit(1);
+});

lib/vscode/build/azure-pipelines/common/sync-mooncake.ts

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as url from 'url';
+import * as azure from 'azure-storage';
+import * as mime from 'mime';
+import { CosmosClient } from '@azure/cosmos';
+
+function log(...args: any[]) {
+	console.log(...[`[${new Date().toISOString()}]`, ...args]);
+}
+
+function error(...args: any[]) {
+	console.error(...[`[${new Date().toISOString()}]`, ...args]);
+}
+
+if (process.argv.length < 3) {
+	error('Usage: node sync-mooncake.js <quality>');
+	process.exit(-1);
+}
+
+interface Build {
+	assets: Asset[];
+}
+
+interface Asset {
+	platform: string;
+	type: string;
+	url: string;
+	mooncakeUrl: string;
+	hash: string;
+	sha256hash: string;
+	size: number;
+	supportsFastUpdate?: boolean;
+}
+
+async function sync(commit: string, quality: string): Promise<void> {
+	log(`Synchronizing Mooncake assets for ${quality}, ${commit}...`);
+
+	const client = new CosmosClient({ endpoint: process.env['AZURE_DOCUMENTDB_ENDPOINT']!, key: process.env['AZURE_DOCUMENTDB_MASTERKEY'] });
+	const container = client.database('builds').container(quality);
+
+	const query = `SELECT TOP 1 * FROM c WHERE c.id = "${commit}"`;
+	const res = await container.items.query<Build>(query, {}).fetchAll();
+
+	if (res.resources.length !== 1) {
+		throw new Error(`No builds found for ${commit}`);
+	}
+
+	const build = res.resources[0];
+
+	log(`Found build for ${commit}, with ${build.assets.length} assets`);
+
+	const storageAccount = process.env['AZURE_STORAGE_ACCOUNT_2']!;
+
+	const blobService = azure.createBlobService(storageAccount, process.env['AZURE_STORAGE_ACCESS_KEY_2']!)
+		.withFilter(new azure.ExponentialRetryPolicyFilter(20));
+
+	const mooncakeBlobService = azure.createBlobService(storageAccount, process.env['MOONCAKE_STORAGE_ACCESS_KEY']!, `${storageAccount}.blob.core.chinacloudapi.cn`)
+		.withFilter(new azure.ExponentialRetryPolicyFilter(20));
+
+	// mooncake is fussy and far away, this is needed!
+	blobService.defaultClientRequestTimeoutInMs = 10 * 60 * 1000;
+	mooncakeBlobService.defaultClientRequestTimeoutInMs = 10 * 60 * 1000;
+
+	for (const asset of build.assets) {
+		try {
+			const blobPath = url.parse(asset.url).path;
+
+			if (!blobPath) {
+				throw new Error(`Failed to parse URL: ${asset.url}`);
+			}
+
+			const blobName = blobPath.replace(/^\/\w+\//, '');
+
+			log(`Found ${blobName}`);
+
+			if (asset.mooncakeUrl) {
+				log(`  Already in Mooncake ✔️`);
+				continue;
+			}
+
+			const readStream = blobService.createReadStream(quality, blobName, undefined!);
+			const blobOptions: azure.BlobService.CreateBlockBlobRequestOptions = {
+				contentSettings: {
+					contentType: mime.lookup(blobPath),
+					cacheControl: 'max-age=31536000, public'
+				}
+			};
+
+			const writeStream = mooncakeBlobService.createWriteStreamToBlockBlob(quality, blobName, blobOptions, undefined);
+
+			log(`  Uploading to Mooncake...`);
+			await new Promise((c, e) => readStream.pipe(writeStream).on('finish', c).on('error', e));
+
+			log(`  Updating build in DB...`);
+			const mooncakeUrl = `${process.env['MOONCAKE_CDN_URL']}${blobPath}`;
+			await container.scripts.storedProcedure('setAssetMooncakeUrl')
+				.execute('', [commit, asset.platform, asset.type, mooncakeUrl]);
+
+			log(`  Done ✔️`);
+		} catch (err) {
+			error(err);
+		}
+	}
+
+	log(`All done ✔️`);
+}
+
+function main(): void {
+	const commit = process.env['BUILD_SOURCEVERSION'];
+
+	if (!commit) {
+		error('Skipping publish due to missing BUILD_SOURCEVERSION');
+		return;
+	}
+
+	const quality = process.argv[2];
+
+	sync(commit, quality).catch(err => {
+		error(err);
+		process.exit(1);
+	});
+}
+
+main();

lib/vscode/build/azure-pipelines/common/telemetry-config.json

@@ -0,0 +1,72 @@
+[
+	{
+		"eventPrefix": "typescript-language-features/",
+		"sourceDirs": [
+			"../../s/extensions/typescript-language-features"
+		],
+		"excludedDirs": [],
+		"applyEndpoints": true
+	},
+	{
+		"eventPrefix": "git/",
+		"sourceDirs": [
+			"../../s/extensions/git"
+		],
+		"excludedDirs": [],
+		"applyEndpoints": true
+	},
+	{
+		"eventPrefix": "extension-telemetry/",
+		"sourceDirs": [
+			"vscode-extension-telemetry"
+		],
+		"excludedDirs": [],
+		"applyEndpoints": true
+	},
+	{
+		"eventPrefix": "vscode-markdown/",
+		"sourceDirs": [
+			"../../s/extensions/markdown-language-features"
+		],
+		"excludedDirs": [],
+		"applyEndpoints": true
+	},
+	{
+		"eventPrefix": "html-language-features/",
+		"sourceDirs": [
+			"../../s/extensions/html-language-features",
+			"vscode-html-languageservice"
+		],
+		"excludedDirs": [],
+		"applyEndpoints": true
+	},
+	{
+		"eventPrefix": "json-language-features/",
+		"sourceDirs": [
+			"../../s/extensions/json-language-features",
+			"vscode-json-languageservice"
+		],
+		"excludedDirs": [],
+		"applyEndpoints": true
+	},
+	{
+		"eventPrefix": "ms-vscode.node2/",
+		"sourceDirs": [
+			"vscode-chrome-debug-core",
+			"vscode-node-debug2"
+		],
+		"excludedDirs": [],
+		"applyEndpoints": true,
+		"patchDebugEvents": true
+	},
+	{
+		"eventPrefix": "ms-vscode.node/",
+		"sourceDirs": [
+			"vscode-chrome-debug-core",
+			"vscode-node-debug"
+		],
+		"excludedDirs": [],
+		"applyEndpoints": true,
+		"patchDebugEvents": true
+	}
+]

lib/vscode/build/azure-pipelines/darwin/app-entitlements.plist

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+    <true/>
+</dict>
+</plist>

lib/vscode/build/azure-pipelines/darwin/continuous-build-darwin.yml

@@ -0,0 +1,79 @@
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'vscode-build-cache'
+
+- script: |
+    CHILD_CONCURRENCY=1 yarn --frozen-lockfile
+  displayName: Install Dependencies
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'vscode-build-cache'
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    yarn postinstall
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- script: |
+    yarn electron x64
+  displayName: Download Electron
+
+- script: |
+    yarn monaco-compile-check
+  displayName: Run Monaco Editor Checks
+
+- script: |
+    yarn valid-layers-check
+  displayName: Run Valid Layers Checks
+
+- script: |
+    yarn compile
+  displayName: Compile Sources
+
+- script: |
+    yarn download-builtin-extensions
+  displayName: Download Built-in Extensions
+
+- script: |
+    ./scripts/test.sh --tfs "Unit Tests"
+  displayName: Run Unit Tests (Electron)
+
+- script: |
+    yarn test-browser --browser chromium --browser webkit --browser firefox --tfs "Browser Unit Tests"
+  displayName: Run Unit Tests (Browser)
+
+- script: |
+    ./scripts/test-integration.sh --tfs "Integration Tests"
+  displayName: Run Integration Tests (Electron)
+
+- task: PublishPipelineArtifact@0
+  inputs:
+    artifactName: crash-dump-macos
+    targetPath: .build/crashes
+  displayName: 'Publish Crash Reports'
+  continueOnError: true
+  condition: failed()
+
+- task: PublishTestResults@2
+  displayName: Publish Tests Results
+  inputs:
+    testResultsFiles: '*-results.xml'
+    searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
+  condition: succeededOrFailed()

lib/vscode/build/azure-pipelines/darwin/helper-gpu-entitlements.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+</dict>
+</plist>

lib/vscode/build/azure-pipelines/darwin/helper-plugin-entitlements.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+</dict>
+</plist>

lib/vscode/build/azure-pipelines/darwin/helper-renderer-entitlements.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+    <true/>
+</dict>
+</plist>

lib/vscode/build/azure-pipelines/darwin/product-build-darwin.yml

@@ -0,0 +1,270 @@
+steps:
+- script: |
+    mkdir -p .build
+    echo -n $BUILD_SOURCEVERSION > .build/commit
+    echo -n $VSCODE_QUALITY > .build/quality
+  displayName: Prepare cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/commit, .build/quality'
+    targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
+    vstsFeed: 'npm-vscode'
+    platformIndependent: true
+    alias: 'Compilation'
+
+- script: |
+    set -e
+    exit 1
+  displayName: Check RestoreCache
+  condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
+
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- script: |
+    set -e
+
+    cat << EOF > ~/.netrc
+    machine github.com
+    login vscode
+    password $(github-distro-mixin-password)
+    EOF
+
+    git config user.email "vscode@microsoft.com"
+    git config user.name "VSCode"
+  displayName: Prepare tooling
+
+- script: |
+    set -e
+    git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
+    git fetch distro
+    git merge $(node -p "require('./package.json').distro")
+  displayName: Merge distro
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+
+- script: |
+    set -e
+    CHILD_CONCURRENCY=1 yarn --frozen-lockfile
+  displayName: Install dependencies
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    yarn postinstall
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    node build/azure-pipelines/mixin
+  displayName: Mix in quality
+
+- script: |
+    set -e
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+      yarn gulp vscode-darwin-min-ci
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+      yarn gulp vscode-reh-darwin-min-ci
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+      yarn gulp vscode-reh-web-darwin-min-ci
+  displayName: Build
+
+- script: |
+    set -e
+    ./scripts/test.sh --build --tfs "Unit Tests"
+  displayName: Run unit tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    yarn test-browser --build --browser chromium --browser webkit --browser firefox --tfs "Browser Unit Tests"
+  displayName: Run unit tests (Browser)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    # Figure out the full absolute path of the product we just built
+    # including the remote server and configure the integration tests
+    # to run with these builds instead of running out of sources.
+    set -e
+    APP_ROOT=$(agent.builddirectory)/VSCode-darwin
+    APP_NAME="`ls $APP_ROOT | head -n 1`"
+    INTEGRATION_TEST_ELECTRON_PATH="$APP_ROOT/$APP_NAME/Contents/MacOS/Electron" \
+    VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-darwin" \
+    ./scripts/test-integration.sh --build --tfs "Integration Tests"
+  displayName: Run integration tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-web-darwin" \
+    ./resources/server/test/test-web-integration.sh --browser webkit
+  displayName: Run integration tests (Browser)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    APP_ROOT=$(agent.builddirectory)/VSCode-darwin
+    APP_NAME="`ls $APP_ROOT | head -n 1`"
+    INTEGRATION_TEST_ELECTRON_PATH="$APP_ROOT/$APP_NAME/Contents/MacOS/Electron" \
+    VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-darwin" \
+    ./resources/server/test/test-remote-integration.sh
+  displayName: Run remote integration tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    APP_ROOT=$(agent.builddirectory)/VSCode-darwin
+    APP_NAME="`ls $APP_ROOT | head -n 1`"
+    yarn smoketest --build "$APP_ROOT/$APP_NAME"
+  continueOnError: true
+  displayName: Run smoke tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-web-darwin" \
+    yarn smoketest --web --headless
+  continueOnError: true
+  displayName: Run smoke tests (Browser)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- task: PublishPipelineArtifact@0
+  inputs:
+    artifactName: crash-dump-macos
+    targetPath: .build/crashes
+  displayName: 'Publish Crash Reports'
+  continueOnError: true
+  condition: failed()
+
+- task: PublishTestResults@2
+  displayName: Publish Tests Results
+  inputs:
+    testResultsFiles: '*-results.xml'
+    searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
+  condition: succeededOrFailed()
+
+- script: |
+    set -e
+    security create-keychain -p pwd $(agent.tempdirectory)/buildagent.keychain
+    security default-keychain -s $(agent.tempdirectory)/buildagent.keychain
+    security unlock-keychain -p pwd $(agent.tempdirectory)/buildagent.keychain
+    echo "$(macos-developer-certificate)" | base64 -D > $(agent.tempdirectory)/cert.p12
+    security import $(agent.tempdirectory)/cert.p12 -k $(agent.tempdirectory)/buildagent.keychain -P "$(macos-developer-certificate-key)" -T /usr/bin/codesign
+    security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k pwd $(agent.tempdirectory)/buildagent.keychain
+    DEBUG=electron-osx-sign* node build/darwin/sign.js
+  displayName: Set Hardened Entitlements
+
+- script: |
+    set -e
+    pushd $(agent.builddirectory)/VSCode-darwin && zip -r -X -y $(agent.builddirectory)/VSCode-darwin.zip * && popd
+  displayName: Archive build
+
+- task: SFP.build-tasks.custom-build-task-1.EsrpCodeSigning@1
+  inputs:
+    ConnectedServiceName: 'ESRP CodeSign'
+    FolderPath: '$(agent.builddirectory)'
+    Pattern: 'VSCode-darwin.zip'
+    signConfigType: inlineSignParams
+    inlineOperation: |
+      [
+        {
+          "keyCode": "CP-401337-Apple",
+          "operationSetCode": "MacAppDeveloperSign",
+          "parameters": [
+            {
+              "parameterName": "Hardening",
+              "parameterValue": "--options=runtime"
+            }
+          ],
+          "toolName": "sign",
+          "toolVersion": "1.0"
+        }
+      ]
+    SessionTimeout: 60
+  displayName: Codesign
+
+- script: |
+    zip -d $(agent.builddirectory)/VSCode-darwin.zip "*.pkg"
+  displayName: Clean Archive
+
+- script: |
+    APP_ROOT=$(agent.builddirectory)/VSCode-darwin
+    APP_NAME="`ls $APP_ROOT | head -n 1`"
+    BUNDLE_IDENTIFIER=$(node -p "require(\"$APP_ROOT/$APP_NAME/Contents/Resources/app/product.json\").darwinBundleIdentifier")
+    echo "##vso[task.setvariable variable=BundleIdentifier]$BUNDLE_IDENTIFIER"
+  displayName: Export bundle identifier
+
+- task: SFP.build-tasks.custom-build-task-1.EsrpCodeSigning@1
+  inputs:
+    ConnectedServiceName: 'ESRP CodeSign'
+    FolderPath: '$(agent.builddirectory)'
+    Pattern: 'VSCode-darwin.zip'
+    signConfigType: inlineSignParams
+    inlineOperation: |
+      [
+        {
+          "keyCode": "CP-401337-Apple",
+          "operationSetCode": "MacAppNotarize",
+          "parameters": [
+            {
+              "parameterName": "BundleId",
+              "parameterValue": "$(BundleIdentifier)"
+            }
+          ],
+          "toolName": "sign",
+          "toolVersion": "1.0"
+        }
+      ]
+    SessionTimeout: 60
+  displayName: Notarization
+
+- script: |
+    set -e
+    APP_ROOT=$(agent.builddirectory)/VSCode-darwin
+    APP_NAME="`ls $APP_ROOT | head -n 1`"
+    "$APP_ROOT/$APP_NAME/Contents/Resources/app/bin/code" --export-default-configuration=.build
+  displayName: Verify start after signing (export configuration)
+
+- script: |
+    set -e
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+    AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
+    AZURE_STORAGE_ACCESS_KEY="$(ticino-storage-key)" \
+    AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
+    VSCODE_ARCH="$(VSCODE_ARCH)" \
+    ./build/azure-pipelines/darwin/publish.sh
+  displayName: Publish
+
+- script: |
+    AZURE_STORAGE_ACCESS_KEY="$(ticino-storage-key)" \
+    yarn gulp upload-vscode-configuration
+  displayName: Upload configuration (for Bing settings search)
+  continueOnError: true
+
+- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
+  displayName: 'Component Detection'
+  continueOnError: true

lib/vscode/build/azure-pipelines/darwin/publish.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -e
+
+# publish the build
+node build/azure-pipelines/common/createAsset.js \
+	darwin \
+	archive \
+	"VSCode-darwin-$VSCODE_QUALITY.zip" \
+	../VSCode-darwin.zip
+
+if [ "$VSCODE_ARCH" == "x64" ]; then
+	# package Remote Extension Host
+	pushd .. && mv vscode-reh-darwin vscode-server-darwin && zip -Xry vscode-server-darwin.zip vscode-server-darwin && popd
+
+	# publish Remote Extension Host
+	node build/azure-pipelines/common/createAsset.js \
+		server-darwin \
+		archive-unsigned \
+		"vscode-server-darwin.zip" \
+		../vscode-server-darwin.zip
+fi

lib/vscode/build/azure-pipelines/distro-build.yml

@@ -0,0 +1,42 @@
+trigger:
+  branches:
+    include: ['master', 'release/*']
+pr:
+  branches:
+    include: ['master', 'release/*']
+
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- script: |
+    set -e
+
+    cat << EOF > ~/.netrc
+    machine github.com
+    login vscode
+    password $(github-distro-mixin-password)
+    EOF
+
+    git config user.email "vscode@microsoft.com"
+    git config user.name "VSCode"
+
+    git remote add distro "https://github.com/$VSCODE_MIXIN_REPO.git"
+    git fetch distro
+
+    # Push master branch into oss/master
+    git push distro origin/master:refs/heads/oss/master
+
+    # Push every release branch into oss/release
+    git for-each-ref --format="%(refname:short)" refs/remotes/origin/release/* | sed 's/^origin\/\(.*\)$/\0:refs\/heads\/oss\/\1/' | xargs git push distro
+
+    git merge $(node -p "require('./package.json').distro")
+
+  displayName: Sync & Merge Distro

lib/vscode/build/azure-pipelines/exploration-build.yml

@@ -0,0 +1,40 @@
+pool:
+  vmImage: 'Ubuntu-16.04'
+
+trigger:
+  branches:
+    include: ['master']
+pr:
+  branches:
+    include: ['master']
+
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- script: |
+    set -e
+
+    cat << EOF > ~/.netrc
+    machine github.com
+    login vscode
+    password $(github-distro-mixin-password)
+    EOF
+
+    git config user.email "vscode@microsoft.com"
+    git config user.name "VSCode"
+
+    git checkout origin/electron-11.x.y
+    git merge origin/master
+
+    # Push master branch into exploration branch
+    git push origin HEAD:electron-11.x.y
+
+  displayName: Sync & Merge Exploration

lib/vscode/build/azure-pipelines/linux/.gitignore

@@ -0,0 +1 @@
+pat

lib/vscode/build/azure-pipelines/linux/continuous-build-linux.yml

@@ -0,0 +1,92 @@
+steps:
+- script: |
+    set -e
+    sudo apt-get update
+    sudo apt-get install -y libxkbfile-dev pkg-config libsecret-1-dev libxss1 dbus xvfb libgtk-3-0
+    sudo cp build/azure-pipelines/linux/xvfb.init /etc/init.d/xvfb
+    sudo chmod +x /etc/init.d/xvfb
+    sudo update-rc.d xvfb defaults
+    sudo service xvfb start
+
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'vscode-build-cache'
+
+- script: |
+    CHILD_CONCURRENCY=1 yarn --frozen-lockfile
+  displayName: Install Dependencies
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'vscode-build-cache'
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    yarn postinstall
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- script: |
+    yarn electron x64
+  displayName: Download Electron
+
+- script: |
+    yarn gulp hygiene
+  displayName: Run Hygiene Checks
+
+- script: |
+    yarn monaco-compile-check
+  displayName: Run Monaco Editor Checks
+
+- script: |
+    yarn valid-layers-check
+  displayName: Run Valid Layers Checks
+
+- script: |
+    yarn compile
+  displayName: Compile Sources
+
+- script: |
+    yarn download-builtin-extensions
+  displayName: Download Built-in Extensions
+
+- script: |
+    DISPLAY=:10 ./scripts/test.sh --tfs "Unit Tests"
+  displayName: Run Unit Tests (Electron)
+
+- script: |
+    DISPLAY=:10 yarn test-browser --browser chromium --tfs "Browser Unit Tests"
+  displayName: Run Unit Tests (Browser)
+
+- script: |
+    DISPLAY=:10 ./scripts/test-integration.sh --tfs "Integration Tests"
+  displayName: Run Integration Tests (Electron)
+
+- task: PublishPipelineArtifact@0
+  inputs:
+    artifactName: crash-dump-linux
+    targetPath: .build/crashes
+  displayName: 'Publish Crash Reports'
+  continueOnError: true
+  condition: failed()
+
+- task: PublishTestResults@2
+  displayName: Publish Tests Results
+  inputs:
+    testResultsFiles: '*-results.xml'
+    searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
+  condition: succeededOrFailed()

lib/vscode/build/azure-pipelines/linux/multiarch/alpine/build.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/multiarch/alpine/prebuild.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/multiarch/alpine/publish.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/multiarch/arm64/build.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/multiarch/arm64/prebuild.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/multiarch/arm64/publish.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/multiarch/armhf/build.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/multiarch/armhf/prebuild.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/multiarch/armhf/publish.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+echo 'noop'

lib/vscode/build/azure-pipelines/linux/product-build-linux-multiarch.yml

@@ -0,0 +1,115 @@
+steps:
+- script: |
+    mkdir -p .build
+    echo -n $BUILD_SOURCEVERSION > .build/commit
+    echo -n $VSCODE_QUALITY > .build/quality
+  displayName: Prepare cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/commit, .build/quality'
+    targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
+    vstsFeed: 'npm-vscode'
+    platformIndependent: true
+    alias: 'Compilation'
+
+- script: |
+    set -e
+    exit 1
+  displayName: Check RestoreCache
+  condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
+
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- task: Docker@1
+  displayName: 'Pull image'
+  inputs:
+    azureSubscriptionEndpoint: 'vscode-builds-subscription'
+    azureContainerRegistry: vscodehub.azurecr.io
+    command: 'Run an image'
+    imageName: 'vscode-linux-build-agent:$(VSCODE_ARCH)'
+    containerCommand: uname
+
+- script: |
+    set -e
+
+    cat << EOF > ~/.netrc
+    machine github.com
+    login vscode
+    password $(github-distro-mixin-password)
+    EOF
+
+    git config user.email "vscode@microsoft.com"
+    git config user.name "VSCode"
+  displayName: Prepare tooling
+
+- script: |
+    set -e
+    git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
+    git fetch distro
+    git merge $(node -p "require('./package.json').distro")
+  displayName: Merge distro
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+
+- script: |
+    set -e
+    CHILD_CONCURRENCY=1 yarn --frozen-lockfile
+  displayName: Install dependencies
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    yarn postinstall
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    node build/azure-pipelines/mixin
+  displayName: Mix in quality
+
+- script: |
+    set -e
+    CHILD_CONCURRENCY=1 ./build/azure-pipelines/linux/multiarch/$(VSCODE_ARCH)/prebuild.sh
+  displayName: Prebuild
+
+- script: |
+    set -e
+    ./build/azure-pipelines/linux/multiarch/$(VSCODE_ARCH)/build.sh
+  displayName: Build
+
+- script: |
+    set -e
+    AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
+    AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+    ./build/azure-pipelines/linux/multiarch/$(VSCODE_ARCH)/publish.sh
+  displayName: Publish
+
+- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
+  displayName: 'Component Detection'
+  continueOnError: true

lib/vscode/build/azure-pipelines/linux/product-build-linux.yml

@@ -0,0 +1,217 @@
+steps:
+- script: |
+    mkdir -p .build
+    echo -n $BUILD_SOURCEVERSION > .build/commit
+    echo -n $VSCODE_QUALITY > .build/quality
+  displayName: Prepare cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/commit, .build/quality'
+    targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
+    vstsFeed: 'npm-vscode'
+    platformIndependent: true
+    alias: 'Compilation'
+
+- script: |
+    set -e
+    exit 1
+  displayName: Check RestoreCache
+  condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
+
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- script: |
+    set -e
+    cat << EOF > ~/.netrc
+    machine github.com
+    login vscode
+    password $(github-distro-mixin-password)
+    EOF
+
+    git config user.email "vscode@microsoft.com"
+    git config user.name "VSCode"
+  displayName: Prepare tooling
+
+- script: |
+    set -e
+    git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
+    git fetch distro
+    git merge $(node -p "require('./package.json').distro")
+  displayName: Merge distro
+
+- script: |
+    echo -n $VSCODE_ARCH > .build/arch
+  displayName: Prepare arch cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: '.build/arch, build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+
+- script: |
+    set -e
+    CHILD_CONCURRENCY=1 npm_config_arch=$(NPM_ARCH) yarn --frozen-lockfile
+  displayName: Install dependencies
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: '.build/arch, build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    yarn postinstall
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    node build/azure-pipelines/mixin
+  displayName: Mix in quality
+
+- script: |
+    set -e
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+      yarn gulp vscode-linux-$(VSCODE_ARCH)-min-ci
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+      yarn gulp vscode-reh-linux-$(VSCODE_ARCH)-min-ci
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+      yarn gulp vscode-reh-web-linux-$(VSCODE_ARCH)-min-ci
+  displayName: Build
+
+- script: |
+    set -e
+    service xvfb start
+  displayName: Start xvfb
+  condition: and(succeeded(), eq(variables['VSCODE_ARCH'], 'x64'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    DISPLAY=:10 ./scripts/test.sh --build --tfs "Unit Tests"
+  displayName: Run unit tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_ARCH'], 'x64'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    DISPLAY=:10 yarn test-browser --build --browser chromium --tfs "Browser Unit Tests"
+  displayName: Run unit tests (Browser)
+  condition: and(succeeded(), eq(variables['VSCODE_ARCH'], 'x64'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    # Figure out the full absolute path of the product we just built
+    # including the remote server and configure the integration tests
+    # to run with these builds instead of running out of sources.
+    set -e
+    APP_ROOT=$(agent.builddirectory)/VSCode-linux-$(VSCODE_ARCH)
+    APP_NAME=$(node -p "require(\"$APP_ROOT/resources/app/product.json\").applicationName")
+    INTEGRATION_TEST_ELECTRON_PATH="$APP_ROOT/$APP_NAME" \
+    VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-linux-$(VSCODE_ARCH)" \
+    DISPLAY=:10 ./scripts/test-integration.sh --build --tfs "Integration Tests"
+  displayName: Run integration tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_ARCH'], 'x64'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-web-linux-$(VSCODE_ARCH)" \
+    DISPLAY=:10 ./resources/server/test/test-web-integration.sh --browser chromium
+  displayName: Run integration tests (Browser)
+  condition: and(succeeded(), eq(variables['VSCODE_ARCH'], 'x64'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    APP_ROOT=$(agent.builddirectory)/VSCode-linux-$(VSCODE_ARCH)
+    APP_NAME=$(node -p "require(\"$APP_ROOT/resources/app/product.json\").applicationName")
+    INTEGRATION_TEST_ELECTRON_PATH="$APP_ROOT/$APP_NAME" \
+    VSCODE_REMOTE_SERVER_PATH="$(agent.builddirectory)/vscode-reh-linux-$(VSCODE_ARCH)" \
+    DISPLAY=:10 ./resources/server/test/test-remote-integration.sh
+  displayName: Run remote integration tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_ARCH'], 'x64'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- task: PublishPipelineArtifact@0
+  inputs:
+    artifactName: 'crash-dump-linux-$(VSCODE_ARCH)'
+    targetPath: .build/crashes
+  displayName: 'Publish Crash Reports'
+  continueOnError: true
+  condition: failed()
+
+- task: PublishTestResults@2
+  displayName: Publish Tests Results
+  inputs:
+    testResultsFiles: '*-results.xml'
+    searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
+  condition: and(succeededOrFailed(), eq(variables['VSCODE_ARCH'], 'x64'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -e
+    yarn gulp "vscode-linux-$(VSCODE_ARCH)-build-deb"
+    yarn gulp "vscode-linux-$(VSCODE_ARCH)-build-rpm"
+  displayName: Build deb, rpm packages
+
+- script: |
+    set -e
+    yarn gulp "vscode-linux-$(VSCODE_ARCH)-prepare-snap"
+  displayName: Prepare snap package
+  condition: and(succeeded(), eq(variables['VSCODE_ARCH'], 'x64'))
+
+# needed for code signing
+- task: UseDotNet@2
+  displayName: 'Install .NET Core SDK 2.x'
+  inputs:
+    version: 2.x
+
+- task: SFP.build-tasks.custom-build-task-1.EsrpCodeSigning@1
+  inputs:
+    ConnectedServiceName: 'ESRP CodeSign'
+    FolderPath: '.build/linux/rpm'
+    Pattern: '*.rpm'
+    signConfigType: inlineSignParams
+    inlineOperation: |
+      [
+        {
+          "keyCode": "CP-450779-Pgp",
+          "operationSetCode": "LinuxSign",
+          "parameters": [ ],
+          "toolName": "sign",
+          "toolVersion": "1.0"
+        }
+      ]
+    SessionTimeout: 120
+  displayName: Codesign rpm
+
+- script: |
+    set -e
+    AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
+    AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+    VSCODE_ARCH="$(VSCODE_ARCH)" \
+    ./build/azure-pipelines/linux/publish.sh
+  displayName: Publish
+
+- task: PublishPipelineArtifact@0
+  displayName: 'Publish Pipeline Artifact'
+  inputs:
+    artifactName: 'snap-$(VSCODE_ARCH)'
+    targetPath: .build/linux/snap-tarball
+  condition: and(succeeded(), eq(variables['VSCODE_ARCH'], 'x64'))
+
+- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
+  displayName: 'Component Detection'
+  continueOnError: true

lib/vscode/build/azure-pipelines/linux/publish.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+set -e
+REPO="$(pwd)"
+ROOT="$REPO/.."
+
+# Publish tarball
+PLATFORM_LINUX="linux-$VSCODE_ARCH"
+BUILDNAME="VSCode-$PLATFORM_LINUX"
+BUILD_VERSION="$(date +%s)"
+[ -z "$VSCODE_QUALITY" ] && TARBALL_FILENAME="code-$VSCODE_ARCH-$BUILD_VERSION.tar.gz" || TARBALL_FILENAME="code-$VSCODE_QUALITY-$VSCODE_ARCH-$BUILD_VERSION.tar.gz"
+TARBALL_PATH="$ROOT/$TARBALL_FILENAME"
+
+rm -rf $ROOT/code-*.tar.*
+(cd $ROOT && tar -czf $TARBALL_PATH $BUILDNAME)
+
+node build/azure-pipelines/common/createAsset.js "$PLATFORM_LINUX" archive-unsigned "$TARBALL_FILENAME" "$TARBALL_PATH"
+
+# Publish Remote Extension Host
+LEGACY_SERVER_BUILD_NAME="vscode-reh-$PLATFORM_LINUX"
+SERVER_BUILD_NAME="vscode-server-$PLATFORM_LINUX"
+SERVER_TARBALL_FILENAME="vscode-server-$PLATFORM_LINUX.tar.gz"
+SERVER_TARBALL_PATH="$ROOT/$SERVER_TARBALL_FILENAME"
+
+rm -rf $ROOT/vscode-server-*.tar.*
+(cd $ROOT && mv $LEGACY_SERVER_BUILD_NAME $SERVER_BUILD_NAME && tar --owner=0 --group=0 -czf $SERVER_TARBALL_PATH $SERVER_BUILD_NAME)
+
+node build/azure-pipelines/common/createAsset.js "server-$PLATFORM_LINUX" archive-unsigned "$SERVER_TARBALL_FILENAME" "$SERVER_TARBALL_PATH"
+
+# Publish DEB
+case $VSCODE_ARCH in
+	x64) DEB_ARCH="amd64" ;;
+	*) DEB_ARCH="$VSCODE_ARCH" ;;
+esac
+
+PLATFORM_DEB="linux-deb-$VSCODE_ARCH"
+DEB_FILENAME="$(ls $REPO/.build/linux/deb/$DEB_ARCH/deb/)"
+DEB_PATH="$REPO/.build/linux/deb/$DEB_ARCH/deb/$DEB_FILENAME"
+
+node build/azure-pipelines/common/createAsset.js "$PLATFORM_DEB" package "$DEB_FILENAME" "$DEB_PATH"
+
+# Publish RPM
+case $VSCODE_ARCH in
+	x64) RPM_ARCH="x86_64" ;;
+	armhf) RPM_ARCH="armv7hl" ;;
+	arm64) RPM_ARCH="aarch64" ;;
+	*) RPM_ARCH="$VSCODE_ARCH" ;;
+esac
+
+PLATFORM_RPM="linux-rpm-$VSCODE_ARCH"
+RPM_FILENAME="$(ls $REPO/.build/linux/rpm/$RPM_ARCH/ | grep .rpm)"
+RPM_PATH="$REPO/.build/linux/rpm/$RPM_ARCH/$RPM_FILENAME"
+
+node build/azure-pipelines/common/createAsset.js "$PLATFORM_RPM" package "$RPM_FILENAME" "$RPM_PATH"
+
+if [ "$VSCODE_ARCH" == "x64" ]; then
+	# Publish Snap
+	# Pack snap tarball artifact, in order to preserve file perms
+	mkdir -p $REPO/.build/linux/snap-tarball
+	SNAP_TARBALL_PATH="$REPO/.build/linux/snap-tarball/snap-$VSCODE_ARCH.tar.gz"
+	rm -rf $SNAP_TARBALL_PATH
+	(cd .build/linux && tar -czf $SNAP_TARBALL_PATH snap)
+fi

lib/vscode/build/azure-pipelines/linux/snap-build-linux.yml

@@ -0,0 +1,52 @@
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- task: DownloadPipelineArtifact@0
+  displayName: 'Download Pipeline Artifact'
+  inputs:
+    artifactName: snap-x64
+    targetPath: .build/linux/snap-tarball
+
+- script: |
+    set -e
+
+    # Get snapcraft version
+    snapcraft --version
+
+    # Make sure we get latest packages
+    sudo apt-get update
+    sudo apt-get upgrade -y
+
+    # Define variables
+    REPO="$(pwd)"
+    SNAP_ROOT="$REPO/.build/linux/snap/x64"
+
+    # Install build dependencies
+    (cd build && yarn)
+
+    # Unpack snap tarball artifact, in order to preserve file perms
+    SNAP_TARBALL_PATH="$REPO/.build/linux/snap-tarball/snap-x64.tar.gz"
+    (cd .build/linux && tar -xzf $SNAP_TARBALL_PATH)
+
+    # Create snap package
+    BUILD_VERSION="$(date +%s)"
+    SNAP_FILENAME="code-$VSCODE_QUALITY-$BUILD_VERSION.snap"
+    SNAP_PATH="$SNAP_ROOT/$SNAP_FILENAME"
+    (cd $SNAP_ROOT/code-* && sudo --preserve-env snapcraft snap --output "$SNAP_PATH")
+
+    # Publish snap package
+    AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
+    AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
+    node build/azure-pipelines/common/createAsset.js "linux-snap-x64" package "$SNAP_FILENAME" "$SNAP_PATH"

lib/vscode/build/azure-pipelines/linux/xvfb.init

@@ -0,0 +1,53 @@
+#!/bin/bash
+#
+# /etc/rc.d/init.d/xvfbd
+#
+# chkconfig: 345 95 28
+# description: Starts/Stops X Virtual Framebuffer server
+# processname: Xvfb
+#
+### BEGIN INIT INFO
+# Provides:          xvfb
+# Required-Start:    $remote_fs $syslog
+# Required-Stop:     $remote_fs $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Start xvfb at boot time
+# Description:       Enable xvfb provided by daemon.
+### END INIT INFO
+
+[ "${NETWORKING}" = "no" ] && exit 0
+
+PROG="/usr/bin/Xvfb"
+PROG_OPTIONS=":10 -ac -screen 0 1024x768x24"
+PROG_OUTPUT="/tmp/Xvfb.out"
+
+case "$1" in
+	start)
+		echo "Starting : X Virtual Frame Buffer "
+		$PROG $PROG_OPTIONS>>$PROG_OUTPUT 2>&1 &
+		disown -ar
+	;;
+	stop)
+		echo "Shutting down : X Virtual Frame Buffer"
+		killproc $PROG
+		RETVAL=$?
+		[ $RETVAL -eq 0 ] && /bin/rm -f /var/lock/subsys/Xvfb
+		/var/run/Xvfb.pid
+		echo
+	;;
+	restart|reload)
+		$0 stop
+		$0 start
+		RETVAL=$?
+	;;
+	status)
+		status Xvfb
+		RETVAL=$?
+	;;
+	*)
+		echo $"Usage: $0 (start|stop|restart|reload|status)"
+		exit 1
+esac
+
+exit $RETVAL

lib/vscode/build/azure-pipelines/mixin.ts

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as json from 'gulp-json-editor';
+const buffer = require('gulp-buffer');
+import * as filter from 'gulp-filter';
+import * as es from 'event-stream';
+import * as Vinyl from 'vinyl';
+import * as vfs from 'vinyl-fs';
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface IBuiltInExtension {
+	readonly name: string;
+	readonly version: string;
+	readonly repo: string;
+	readonly metadata: any;
+}
+
+interface OSSProduct {
+	readonly builtInExtensions: IBuiltInExtension[];
+	readonly webBuiltInExtensions?: IBuiltInExtension[];
+}
+
+interface Product {
+	readonly builtInExtensions?: IBuiltInExtension[] | { 'include'?: IBuiltInExtension[], 'exclude'?: string[] };
+	readonly webBuiltInExtensions?: IBuiltInExtension[];
+}
+
+function main() {
+	const quality = process.env['VSCODE_QUALITY'];
+
+	if (!quality) {
+		console.log('Missing VSCODE_QUALITY, skipping mixin');
+		return;
+	}
+
+	const productJsonFilter = filter(f => f.relative === 'product.json', { restore: true });
+
+	fancyLog(ansiColors.blue('[mixin]'), `Mixing in sources:`);
+	return vfs
+		.src(`quality/${quality}/**`, { base: `quality/${quality}` })
+		.pipe(filter(f => !f.isDirectory()))
+		.pipe(productJsonFilter)
+		.pipe(buffer())
+		.pipe(json((o: Product) => {
+			const ossProduct = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'product.json'), 'utf8')) as OSSProduct;
+			let builtInExtensions = ossProduct.builtInExtensions;
+
+			if (Array.isArray(o.builtInExtensions)) {
+				fancyLog(ansiColors.blue('[mixin]'), 'Overwriting built-in extensions:', o.builtInExtensions.map(e => e.name));
+
+				builtInExtensions = o.builtInExtensions;
+			} else if (o.builtInExtensions) {
+				const include = o.builtInExtensions['include'] || [];
+				const exclude = o.builtInExtensions['exclude'] || [];
+
+				fancyLog(ansiColors.blue('[mixin]'), 'OSS built-in extensions:', builtInExtensions.map(e => e.name));
+				fancyLog(ansiColors.blue('[mixin]'), 'Including built-in extensions:', include.map(e => e.name));
+				fancyLog(ansiColors.blue('[mixin]'), 'Excluding built-in extensions:', exclude);
+
+				builtInExtensions = builtInExtensions.filter(ext => !include.find(e => e.name === ext.name) && !exclude.find(name => name === ext.name));
+				builtInExtensions = [...builtInExtensions, ...include];
+
+				fancyLog(ansiColors.blue('[mixin]'), 'Final built-in extensions:', builtInExtensions.map(e => e.name));
+			} else {
+				fancyLog(ansiColors.blue('[mixin]'), 'Inheriting OSS built-in extensions', builtInExtensions.map(e => e.name));
+			}
+
+			return { webBuiltInExtensions: ossProduct.webBuiltInExtensions, ...o, builtInExtensions };
+		}))
+		.pipe(productJsonFilter.restore)
+		.pipe(es.mapSync(function (f: Vinyl) {
+			fancyLog(ansiColors.blue('[mixin]'), f.relative, ansiColors.green('✔︎'));
+			return f;
+		}))
+		.pipe(vfs.dest('.'));
+}
+
+main();

lib/vscode/build/azure-pipelines/product-build.yml

@@ -0,0 +1,161 @@
+trigger: none
+pr: none
+
+schedules:
+- cron: "0 5 * * Mon-Fri"
+  displayName: Mon-Fri at 7:00
+  branches:
+    include:
+    - master
+
+resources:
+  containers:
+  - container: vscode-x64
+    image: vscodehub.azurecr.io/vscode-linux-build-agent:x64
+    endpoint: VSCodeHub
+  - container: vscode-arm64
+    image: vscodehub.azurecr.io/vscode-linux-build-agent:stretch-arm64
+    endpoint: VSCodeHub
+  - container: vscode-armhf
+    image: vscodehub.azurecr.io/vscode-linux-build-agent:stretch-armhf
+    endpoint: VSCodeHub
+  - container: snapcraft
+    image: snapcore/snapcraft:stable
+
+stages:
+- stage: Compile
+  jobs:
+  - job: Compile
+    pool:
+      vmImage: 'Ubuntu-16.04'
+    container: vscode-x64
+    steps:
+    - template: product-compile.yml
+
+- stage: Windows
+  dependsOn:
+  - Compile
+  condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'))
+  pool:
+    vmImage: VS2017-Win2016
+  jobs:
+  - job: Windows
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_WIN32'], 'true'))
+    variables:
+      VSCODE_ARCH: x64
+    steps:
+    - template: win32/product-build-win32.yml
+
+  - job: Windows32
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_WIN32_32BIT'], 'true'))
+    variables:
+      VSCODE_ARCH: ia32
+    steps:
+    - template: win32/product-build-win32.yml
+
+  - job: WindowsARM64
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_WIN32_ARM64'], 'true'))
+    variables:
+      VSCODE_ARCH: arm64
+    steps:
+    - template: win32/product-build-win32-arm64.yml
+
+- stage: Linux
+  dependsOn:
+  - Compile
+  condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'))
+  pool:
+    vmImage: 'Ubuntu-16.04'
+  jobs:
+  - job: Linux
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_LINUX'], 'true'))
+    container: vscode-x64
+    variables:
+      VSCODE_ARCH: x64
+      NPM_ARCH: x64
+    steps:
+    - template: linux/product-build-linux.yml
+
+  - job: LinuxSnap
+    dependsOn:
+    - Linux
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_LINUX'], 'true'))
+    container: snapcraft
+    variables:
+      VSCODE_ARCH: x64
+    steps:
+    - template: linux/snap-build-linux.yml
+
+  - job: LinuxArmhf
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_LINUX_ARMHF'], 'true'))
+    container: vscode-armhf
+    variables:
+      VSCODE_ARCH: armhf
+      NPM_ARCH: armv7l
+    steps:
+    - template: linux/product-build-linux.yml
+
+  - job: LinuxArm64
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_LINUX_ARM64'], 'true'))
+    container: vscode-arm64
+    variables:
+      VSCODE_ARCH: arm64
+      NPM_ARCH: arm64
+    steps:
+    - template: linux/product-build-linux.yml
+
+  - job: LinuxAlpine
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_LINUX_ALPINE'], 'true'))
+    variables:
+      VSCODE_ARCH: alpine
+    steps:
+    - template: linux/product-build-linux-multiarch.yml
+
+  - job: LinuxWeb
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_WEB'], 'true'))
+    variables:
+      VSCODE_ARCH: x64
+    steps:
+    - template: web/product-build-web.yml
+
+- stage: macOS
+  dependsOn:
+  - Compile
+  condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'))
+  pool:
+    vmImage: macOS-latest
+  jobs:
+  - job: macOS
+    condition: and(succeeded(), eq(variables['VSCODE_BUILD_MACOS'], 'true'))
+    variables:
+      VSCODE_ARCH: x64
+    steps:
+    - template: darwin/product-build-darwin.yml
+
+- stage: Mooncake
+  dependsOn:
+  - Windows
+  - Linux
+  - macOS
+  condition: and(succeededOrFailed(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'))
+  pool:
+    vmImage: 'Ubuntu-16.04'
+  jobs:
+  - job: SyncMooncake
+    displayName: Sync Mooncake
+    steps:
+    - template: sync-mooncake.yml
+
+- stage: Publish
+  dependsOn:
+  - Windows
+  - Linux
+  - macOS
+  condition: and(succeeded(), eq(variables['VSCODE_COMPILE_ONLY'], 'false'), or(eq(variables['VSCODE_RELEASE'], 'true'), and(or(eq(variables['VSCODE_QUALITY'], 'insider'), eq(variables['VSCODE_QUALITY'], 'exploration')), eq(variables['Build.Reason'], 'Schedule'))))
+  pool:
+    vmImage: 'Ubuntu-16.04'
+  jobs:
+  - job: BuildService
+    displayName: Build Service
+    steps:
+    - template: release.yml

lib/vscode/build/azure-pipelines/product-compile.yml

@@ -0,0 +1,146 @@
+steps:
+- script: |
+    mkdir -p .build
+    echo -n $BUILD_SOURCEVERSION > .build/commit
+    echo -n $VSCODE_QUALITY > .build/quality
+  displayName: Prepare cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/commit, .build/quality'
+    targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
+    vstsFeed: 'npm-vscode'
+    platformIndependent: true
+    alias: 'Compilation'
+    dryRun: true
+
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    set -e
+    cat << EOF > ~/.netrc
+    machine github.com
+    login vscode
+    password $(github-distro-mixin-password)
+    EOF
+
+    git config user.email "vscode@microsoft.com"
+    git config user.name "VSCode"
+  displayName: Prepare tooling
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    set -e
+    git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
+    git fetch distro
+    git merge $(node -p "require('./package.json').distro")
+  displayName: Merge distro
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    echo -n $VSCODE_ARCH > .build/arch
+  displayName: Prepare arch cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: '.build/arch, build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    set -e
+    CHILD_CONCURRENCY=1 yarn --frozen-lockfile
+  displayName: Install dependencies
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: '.build/arch, build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'), ne(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    yarn postinstall
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'), eq(variables['CacheRestored'], 'true'))
+
+# Mixin must run before optimize, because the CSS loader will
+# inline small SVGs
+- script: |
+    set -e
+    node build/azure-pipelines/mixin
+  displayName: Mix in quality
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    set -e
+    yarn gulp hygiene
+    yarn monaco-compile-check
+    yarn valid-layers-check
+  displayName: Run hygiene, monaco compile & valid layers checks
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- script: |
+    set -
+    ./build/azure-pipelines/common/extract-telemetry.sh
+  displayName: Extract Telemetry
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    set -e
+    AZURE_WEBVIEW_STORAGE_ACCESS_KEY="$(vscode-webview-storage-key)" \
+    ./build/azure-pipelines/common/publish-webview.sh
+  displayName: Publish Webview
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    set -e
+    yarn gulp compile-build
+    yarn gulp compile-extensions-build
+    yarn gulp minify-vscode
+    yarn gulp minify-vscode-reh
+    yarn gulp minify-vscode-reh-web
+  displayName: Compile
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    set -e
+    AZURE_STORAGE_ACCESS_KEY="$(ticino-storage-key)" \
+      node build/azure-pipelines/upload-sourcemaps
+  displayName: Upload sourcemaps
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- script: |
+    set -e
+    VERSION=`node -p "require(\"./package.json\").version"`
+    AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
+      node build/azure-pipelines/common/createBuild.js $VERSION
+  displayName: Create build
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/commit, .build/quality'
+    targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
+    vstsFeed: 'npm-vscode'
+    platformIndependent: true
+    alias: 'Compilation'
+  condition: and(succeeded(), ne(variables['CacheExists-Compilation'], 'true'))

lib/vscode/build/azure-pipelines/publish-types/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+*.js

lib/vscode/build/azure-pipelines/publish-types/check-version.ts

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as cp from 'child_process';
+
+let tag = '';
+try {
+	tag = cp
+		.execSync('git describe --tags `git rev-list --tags --max-count=1`')
+		.toString()
+		.trim();
+
+	if (!isValidTag(tag)) {
+		throw Error(`Invalid tag ${tag}`);
+	}
+} catch (err) {
+	console.error(err);
+	console.error('Failed to update types');
+	process.exit(1);
+}
+
+function isValidTag(t: string) {
+	if (t.split('.').length !== 3) {
+		return false;
+	}
+
+	const [major, minor, bug] = t.split('.');
+
+	// Only release for tags like 1.34.0
+	if (bug !== '0') {
+		return false;
+	}
+
+	if (isNaN(parseInt(major, 10)) || isNaN(parseInt(minor, 10))) {
+		return false;
+	}
+
+	return true;
+}

lib/vscode/build/azure-pipelines/publish-types/publish-types.yml

@@ -0,0 +1,83 @@
+# Publish @types/vscode for each release
+
+trigger:
+  branches:
+    include: ['refs/tags/*']
+
+pr: none
+
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- bash: |
+    TAG_VERSION=$(git describe --tags `git rev-list --tags --max-count=1`)
+    CHANNEL="G1C14HJ2F"
+
+    if [ "$TAG_VERSION" == "1.999.0" ]; then
+      MESSAGE="<!here>. Someone pushed 1.999.0 tag. Please delete it ASAP from remote and local."
+
+      curl -X POST -H "Authorization: Bearer $(SLACK_TOKEN)" \
+      -H 'Content-type: application/json; charset=utf-8' \
+      --data '{"channel":"'"$CHANNEL"'", "link_names": true, "text":"'"$MESSAGE"'"}' \
+      https://slack.com/api/chat.postMessage
+
+      exit 1
+    fi
+  displayName: Check 1.999.0 tag
+
+- bash: |
+    # Install build dependencies
+    (cd build && yarn)
+    node build/azure-pipelines/publish-types/check-version.js
+  displayName: Check version
+
+- bash: |
+    git config --global user.email "vscode@microsoft.com"
+    git config --global user.name "VSCode"
+
+    git clone https://$(GITHUB_TOKEN)@github.com/DefinitelyTyped/DefinitelyTyped.git --depth=1
+    node build/azure-pipelines/publish-types/update-types.js
+
+    TAG_VERSION=$(git describe --tags `git rev-list --tags --max-count=1`)
+
+    cd DefinitelyTyped
+
+    git diff --color | cat
+    git add -A
+    git status
+    git checkout -b "vscode-types-$TAG_VERSION"
+    git commit -m "VS Code $TAG_VERSION Extension API"
+    git push origin "vscode-types-$TAG_VERSION"
+
+  displayName: Push update to DefinitelyTyped
+
+- bash: |
+    TAG_VERSION=$(git describe --tags `git rev-list --tags --max-count=1`)
+    CHANNEL="G1C14HJ2F"
+
+    MESSAGE="DefinitelyTyped/DefinitelyTyped#vscode-types-$TAG_VERSION created. Endgame master, please open this link, examine changes and create a PR:"
+    LINK="https://github.com/DefinitelyTyped/DefinitelyTyped/compare/vscode-types-$TAG_VERSION?quick_pull=1&body=Updating%20VS%20Code%20Extension%20API.%20See%20https%3A%2F%2Fgithub.com%2Fmicrosoft%2Fvscode%2Fissues%2F70175%20for%20details."
+    MESSAGE2="[@eamodio, @jrieken, @kmaetzel, @egamma]. Please review and merge PR to publish @types/vscode."
+
+    curl -X POST -H "Authorization: Bearer $(SLACK_TOKEN)" \
+    -H 'Content-type: application/json; charset=utf-8' \
+    --data '{"channel":"'"$CHANNEL"'", "link_names": true, "text":"'"$MESSAGE"'"}' \
+    https://slack.com/api/chat.postMessage
+
+    curl -X POST -H "Authorization: Bearer $(SLACK_TOKEN)" \
+    -H 'Content-type: application/json; charset=utf-8' \
+    --data '{"channel":"'"$CHANNEL"'", "link_names": true, "text":"'"$LINK"'"}' \
+    https://slack.com/api/chat.postMessage
+
+    curl -X POST -H "Authorization: Bearer $(SLACK_TOKEN)" \
+    -H 'Content-type: application/json; charset=utf-8' \
+    --data '{"channel":"'"$CHANNEL"'", "link_names": true, "text":"'"$MESSAGE2"'"}' \
+    https://slack.com/api/chat.postMessage
+
+  displayName: Send message on Slack

lib/vscode/build/azure-pipelines/publish-types/update-types.ts

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as fs from 'fs';
+import * as cp from 'child_process';
+import * as path from 'path';
+
+let tag = '';
+try {
+	tag = cp
+		.execSync('git describe --tags `git rev-list --tags --max-count=1`')
+		.toString()
+		.trim();
+
+	const dtsUri = `https://raw.githubusercontent.com/microsoft/vscode/${tag}/src/vs/vscode.d.ts`;
+	const outPath = path.resolve(process.cwd(), 'DefinitelyTyped/types/vscode/index.d.ts');
+	cp.execSync(`curl ${dtsUri} --output ${outPath}`);
+
+	updateDTSFile(outPath, tag);
+
+	console.log(`Done updating vscode.d.ts at ${outPath}`);
+} catch (err) {
+	console.error(err);
+	console.error('Failed to update types');
+	process.exit(1);
+}
+
+function updateDTSFile(outPath: string, tag: string) {
+	const oldContent = fs.readFileSync(outPath, 'utf-8');
+	const newContent = getNewFileContent(oldContent, tag);
+
+	fs.writeFileSync(outPath, newContent);
+}
+
+function repeat(str: string, times: number): string {
+	const result = new Array(times);
+	for (let i = 0; i < times; i++) {
+		result[i] = str;
+	}
+	return result.join('');
+}
+
+function convertTabsToSpaces(str: string): string {
+	return str.replace(/\t/gm, value => repeat('    ', value.length));
+}
+
+function getNewFileContent(content: string, tag: string) {
+	const oldheader = [
+		`/*---------------------------------------------------------------------------------------------`,
+		` *  Copyright (c) Microsoft Corporation. All rights reserved.`,
+		` *  Licensed under the MIT License. See License.txt in the project root for license information.`,
+		` *--------------------------------------------------------------------------------------------*/`
+	].join('\n');
+
+	return convertTabsToSpaces(getNewFileHeader(tag) + content.slice(oldheader.length));
+}
+
+function getNewFileHeader(tag: string) {
+	const [major, minor] = tag.split('.');
+	const shorttag = `${major}.${minor}`;
+
+	const header = [
+		`// Type definitions for Visual Studio Code ${shorttag}`,
+		`// Project: https://github.com/microsoft/vscode`,
+		`// Definitions by: Visual Studio Code Team, Microsoft <https://github.com/microsoft>`,
+		`// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped`,
+		``,
+		`/*---------------------------------------------------------------------------------------------`,
+		` *  Copyright (c) Microsoft Corporation. All rights reserved.`,
+		` *  Licensed under the MIT License.`,
+		` *  See https://github.com/microsoft/vscode/blob/master/LICENSE.txt for license information.`,
+		` *--------------------------------------------------------------------------------------------*/`,
+		``,
+		`/**`,
+		` * Type Definition for Visual Studio Code ${shorttag} Extension API`,
+		` * See https://code.visualstudio.com/api for more information`,
+		` */`
+	].join('\n');
+
+	return header;
+}

lib/vscode/build/azure-pipelines/release.yml

@@ -0,0 +1,22 @@
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: "10.x"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- script: |
+    set -e
+
+    (cd build ; yarn)
+
+    AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
+    node build/azure-pipelines/common/releaseBuild.js

lib/vscode/build/azure-pipelines/sync-mooncake.yml

@@ -0,0 +1,24 @@
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- script: |
+    set -e
+
+    (cd build ; yarn)
+
+    AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
+    AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
+    MOONCAKE_STORAGE_ACCESS_KEY="$(vscode-mooncake-storage-key)" \
+    node build/azure-pipelines/common/sync-mooncake.js "$VSCODE_QUALITY"

lib/vscode/build/azure-pipelines/upload-cdn.ts

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as path from 'path';
+import * as es from 'event-stream';
+import * as Vinyl from 'vinyl';
+import * as vfs from 'vinyl-fs';
+import * as util from '../lib/util';
+import * as filter from 'gulp-filter';
+import * as gzip from 'gulp-gzip';
+const azure = require('gulp-azure-storage');
+
+const root = path.dirname(path.dirname(__dirname));
+const commit = util.getVersion(root);
+
+function main() {
+	return vfs.src('**', { cwd: '../vscode-web', base: '../vscode-web', dot: true })
+		.pipe(filter(f => !f.isDirectory()))
+		.pipe(gzip({ append: false }))
+		.pipe(es.through(function (data: Vinyl) {
+			console.log('Uploading CDN file:', data.relative); // debug
+			this.emit('data', data);
+		}))
+		.pipe(azure.upload({
+			account: process.env.AZURE_STORAGE_ACCOUNT,
+			key: process.env.AZURE_STORAGE_ACCESS_KEY,
+			container: process.env.VSCODE_QUALITY,
+			prefix: commit + '/',
+			contentSettings: {
+				contentEncoding: 'gzip',
+				cacheControl: 'max-age=31536000, public'
+			}
+		}));
+}
+
+main();

lib/vscode/build/azure-pipelines/upload-sourcemaps.ts

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as path from 'path';
+import * as es from 'event-stream';
+import * as Vinyl from 'vinyl';
+import * as vfs from 'vinyl-fs';
+import * as util from '../lib/util';
+// @ts-ignore
+import * as deps from '../dependencies';
+const azure = require('gulp-azure-storage');
+
+const root = path.dirname(path.dirname(__dirname));
+const commit = util.getVersion(root);
+
+// optionally allow to pass in explicit base/maps to upload
+const [, , base, maps] = process.argv;
+
+function src(base: string, maps = `${base}/**/*.map`) {
+	return vfs.src(maps, { base })
+		.pipe(es.mapSync((f: Vinyl) => {
+			f.path = `${f.base}/core/${f.relative}`;
+			return f;
+		}));
+}
+
+function main() {
+	const sources = [];
+
+	// vscode client maps (default)
+	if (!base) {
+		const vs = src('out-vscode-min'); // client source-maps only
+		sources.push(vs);
+
+		const productionDependencies: { name: string, path: string, version: string }[] = deps.getProductionDependencies(root);
+		const productionDependenciesSrc = productionDependencies.map(d => path.relative(root, d.path)).map(d => `./${d}/**/*.map`);
+		const nodeModules = vfs.src(productionDependenciesSrc, { base: '.' })
+			.pipe(util.cleanNodeModules(path.join(root, 'build', '.moduleignore')));
+		sources.push(nodeModules);
+
+		const extensionsOut = vfs.src(['.build/extensions/**/*.js.map', '!**/node_modules/**'], { base: '.build' });
+		sources.push(extensionsOut);
+	}
+
+	// specific client base/maps
+	else {
+		sources.push(src(base, maps));
+	}
+
+	return es.merge(...sources)
+		.pipe(es.through(function (data: Vinyl) {
+			console.log('Uploading Sourcemap', data.relative); // debug
+			this.emit('data', data);
+		}))
+		.pipe(azure.upload({
+			account: process.env.AZURE_STORAGE_ACCOUNT,
+			key: process.env.AZURE_STORAGE_ACCESS_KEY,
+			container: 'sourcemaps',
+			prefix: commit + '/'
+		}));
+}
+
+main();

lib/vscode/build/azure-pipelines/web/product-build-web.yml

@@ -0,0 +1,113 @@
+steps:
+- script: |
+    mkdir -p .build
+    echo -n $BUILD_SOURCEVERSION > .build/commit
+    echo -n $VSCODE_QUALITY > .build/quality
+  displayName: Prepare cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/commit, .build/quality'
+    targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
+    vstsFeed: 'npm-vscode'
+    platformIndependent: true
+    alias: 'Compilation'
+
+- script: |
+    set -e
+    exit 1
+  displayName: Check RestoreCache
+  condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
+
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- script: |
+    set -e
+    cat << EOF > ~/.netrc
+    machine github.com
+    login vscode
+    password $(github-distro-mixin-password)
+    EOF
+
+    git config user.email "vscode@microsoft.com"
+    git config user.name "VSCode"
+  displayName: Prepare tooling
+
+- script: |
+    set -e
+    git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git"
+    git fetch distro
+    git merge $(node -p "require('./package.json').distro")
+  displayName: Merge distro
+
+# - task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+#   inputs:
+#     keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+#     targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+#     vstsFeed: 'npm-vscode'
+
+- script: |
+    set -e
+    CHILD_CONCURRENCY=1 yarn --frozen-lockfile
+  displayName: Install dependencies
+  # condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+# - task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+#   inputs:
+#     keyfile: 'build/.cachesalt, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+#     targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+#     vstsFeed: 'npm-vscode'
+#   condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+# - script: |
+#     set -e
+#     yarn postinstall
+#   displayName: Run postinstall scripts
+#   condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- script: |
+    set -e
+    node build/azure-pipelines/mixin
+  displayName: Mix in quality
+
+- script: |
+    set -e
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+      yarn gulp vscode-web-min-ci
+  displayName: Build
+
+- script: |
+    set -e
+    AZURE_STORAGE_ACCOUNT="$(web-storage-account)" \
+    AZURE_STORAGE_ACCESS_KEY="$(web-storage-key)" \
+      node build/azure-pipelines/upload-cdn.js
+  displayName: Upload to CDN
+
+  # upload only the workbench.web.api.js source maps because
+  # we just compiled these bits in the previous step and the
+  # general task to upload source maps has already been run
+- script: |
+    set -e
+    AZURE_STORAGE_ACCESS_KEY="$(ticino-storage-key)" \
+      node build/azure-pipelines/upload-sourcemaps out-vscode-web-min out-vscode-web-min/vs/workbench/workbench.web.api.js.map
+  displayName: Upload sourcemaps (Web)
+
+- script: |
+    set -e
+    AZURE_DOCUMENTDB_MASTERKEY="$(builds-docdb-key-readwrite)" \
+    AZURE_STORAGE_ACCESS_KEY_2="$(vscode-storage-key)" \
+    VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)" \
+    ./build/azure-pipelines/web/publish.sh
+  displayName: Publish

lib/vscode/build/azure-pipelines/web/publish.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -e
+REPO="$(pwd)"
+ROOT="$REPO/.."
+
+# Publish Web Client
+WEB_BUILD_NAME="vscode-web"
+WEB_TARBALL_FILENAME="vscode-web.tar.gz"
+WEB_TARBALL_PATH="$ROOT/$WEB_TARBALL_FILENAME"
+
+rm -rf $ROOT/vscode-web.tar.*
+
+(cd $ROOT && tar --owner=0 --group=0 -czf $WEB_TARBALL_PATH $WEB_BUILD_NAME)
+
+node build/azure-pipelines/common/createAsset.js web-standalone archive-unsigned "$WEB_TARBALL_FILENAME" "$WEB_TARBALL_PATH"

lib/vscode/build/azure-pipelines/win32/ESRPClient/NuGet.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+    <packageSources>
+        <add key="ESRP" value="https://microsoft.pkgs.visualstudio.com/_packaging/ESRP/nuget/v3/index.json" />
+    </packageSources>
+</configuration>

lib/vscode/build/azure-pipelines/win32/ESRPClient/packages.config

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Microsoft.ESRPClient" version="1.2.47" />
+</packages>

lib/vscode/build/azure-pipelines/win32/continuous-build-win32.yml

@@ -0,0 +1,87 @@
+steps:
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: UsePythonVersion@0
+  inputs:
+    versionSpec: '2.x'
+    addToPath: true
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'vscode-build-cache'
+
+- powershell: |
+    yarn --frozen-lockfile
+  env:
+    CHILD_CONCURRENCY: "1"
+  displayName: Install Dependencies
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: '.yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'vscode-build-cache'
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { yarn postinstall }
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- powershell: |
+    yarn electron
+  displayName: Download Electron
+
+- powershell: |
+    yarn monaco-compile-check
+  displayName: Run Monaco Editor Checks
+
+- script: |
+    yarn valid-layers-check
+  displayName: Run Valid Layers Checks
+
+- powershell: |
+    yarn compile
+  displayName: Compile Sources
+
+- powershell: |
+    yarn download-builtin-extensions
+  displayName: Download Built-in Extensions
+
+- powershell: |
+    .\scripts\test.bat --tfs "Unit Tests"
+  displayName: Run Unit Tests (Electron)
+
+- powershell: |
+    yarn test-browser --browser chromium --browser firefox --tfs "Browser Unit Tests"
+  displayName: Run Unit Tests (Browser)
+
+- powershell: |
+    .\scripts\test-integration.bat --tfs "Integration Tests"
+  displayName: Run Integration Tests (Electron)
+
+- task: PublishPipelineArtifact@0
+  displayName: 'Publish Crash Reports'
+  inputs:
+    artifactName: crash-dump-windows
+    targetPath: .build\crashes
+  continueOnError: true
+  condition: failed()
+
+- task: PublishTestResults@2
+  displayName: Publish Tests Results
+  inputs:
+    testResultsFiles: '*-results.xml'
+    searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
+  condition: succeededOrFailed()

lib/vscode/build/azure-pipelines/win32/exec.ps1

@@ -0,0 +1,24 @@
+# Taken from psake https://github.com/psake/psake
+
+<#
+.SYNOPSIS
+  This is a helper function that runs a scriptblock and checks the PS variable $lastexitcode
+  to see if an error occcured. If an error is detected then an exception is thrown.
+  This function allows you to run command-line programs without having to
+  explicitly check the $lastexitcode variable.
+
+.EXAMPLE
+  exec { svn info $repository_trunk } "Error executing SVN. Please verify SVN command-line client is installed"
+#>
+function Exec
+{
+	[CmdletBinding()]
+	param(
+		[Parameter(Position=0,Mandatory=1)][scriptblock]$cmd,
+		[Parameter(Position=1,Mandatory=0)][string]$errorMessage = ($msgs.error_bad_command -f $cmd)
+	)
+	& $cmd
+	if ($lastexitcode -ne 0) {
+		throw ("Exec: " + $errorMessage)
+	}
+}

lib/vscode/build/azure-pipelines/win32/import-esrp-auth-cert.ps1

@@ -0,0 +1,14 @@
+param ($CertBase64)
+$ErrorActionPreference = "Stop"
+
+$CertBytes = [System.Convert]::FromBase64String($CertBase64)
+$CertCollection = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2Collection
+$CertCollection.Import($CertBytes, $null, [System.Security.Cryptography.X509Certificates.X509KeyStorageFlags]::Exportable)
+
+$CertStore = New-Object System.Security.Cryptography.X509Certificates.X509Store("My","LocalMachine")
+$CertStore.Open("ReadWrite")
+$CertStore.AddRange($CertCollection)
+$CertStore.Close()
+
+$ESRPAuthCertificateSubjectName = $CertCollection[0].Subject
+Write-Output ("##vso[task.setvariable variable=ESRPAuthCertificateSubjectName;]$ESRPAuthCertificateSubjectName")

lib/vscode/build/azure-pipelines/win32/product-build-win32-arm64.yml

@@ -0,0 +1,192 @@
+steps:
+- powershell: |
+    mkdir .build -ea 0
+    "$env:BUILD_SOURCEVERSION" | Out-File -Encoding ascii -NoNewLine .build\commit
+    "$env:VSCODE_QUALITY" | Out-File -Encoding ascii -NoNewLine .build\quality
+  displayName: Prepare cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/commit, .build/quality'
+    targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
+    vstsFeed: 'npm-vscode'
+    platformIndependent: true
+    alias: 'Compilation'
+
+- powershell: |
+    $ErrorActionPreference = "Stop"
+    exit 1
+  displayName: Check RestoreCache
+  condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
+
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: UsePythonVersion@0
+  inputs:
+    versionSpec: '2.x'
+    addToPath: true
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    "machine github.com`nlogin vscode`npassword $(github-distro-mixin-password)" | Out-File "$env:USERPROFILE\_netrc" -Encoding ASCII
+
+    exec { git config user.email "vscode@microsoft.com" }
+    exec { git config user.name "VSCode" }
+
+    mkdir .build -ea 0
+    "$(VSCODE_ARCH)" | Out-File -Encoding ascii -NoNewLine .build\arch
+  displayName: Prepare tooling
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git" }
+    exec { git fetch distro }
+    exec { git merge $(node -p "require('./package.json').distro") }
+  displayName: Merge distro
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/arch, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    $env:npm_config_arch="$(VSCODE_ARCH)"
+    $env:CHILD_CONCURRENCY="1"
+    exec { yarn --frozen-lockfile }
+  displayName: Install dependencies
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/arch, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { yarn postinstall }
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { node build/azure-pipelines/mixin }
+  displayName: Mix in quality
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    $env:VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)"
+    exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-min-ci" }
+    exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-code-helper" }
+    exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-inno-updater" }
+  displayName: Build
+
+- task: SFP.build-tasks.custom-build-task-1.EsrpCodeSigning@1
+  inputs:
+    ConnectedServiceName: 'ESRP CodeSign'
+    FolderPath: '$(agent.builddirectory)/VSCode-win32-$(VSCODE_ARCH)'
+    Pattern: '*.dll,*.exe,*.node'
+    signConfigType: inlineSignParams
+    inlineOperation: |
+      [
+        {
+          "keyCode": "CP-230012",
+          "operationSetCode": "SigntoolSign",
+          "parameters": [
+            {
+              "parameterName": "OpusName",
+              "parameterValue": "VS Code"
+            },
+            {
+              "parameterName": "OpusInfo",
+              "parameterValue": "https://code.visualstudio.com/"
+            },
+            {
+              "parameterName": "Append",
+              "parameterValue": "/as"
+            },
+            {
+              "parameterName": "FileDigest",
+              "parameterValue": "/fd \"SHA256\""
+            },
+            {
+              "parameterName": "PageHash",
+              "parameterValue": "/NPH"
+            },
+            {
+              "parameterName": "TimeStamp",
+              "parameterValue": "/tr \"http://rfc3161.gtm.corp.microsoft.com/TSS/HttpTspServer\" /td sha256"
+            }
+          ],
+          "toolName": "sign",
+          "toolVersion": "1.0"
+        },
+        {
+          "keyCode": "CP-230012",
+          "operationSetCode": "SigntoolVerify",
+          "parameters": [
+            {
+              "parameterName": "VerifyAll",
+              "parameterValue": "/all"
+            }
+          ],
+          "toolName": "sign",
+          "toolVersion": "1.0"
+        }
+      ]
+    SessionTimeout: 120
+
+- task: NuGetCommand@2
+  displayName: Install ESRPClient.exe
+  inputs:
+    restoreSolution: 'build\azure-pipelines\win32\ESRPClient\packages.config'
+    feedsToUse: config
+    nugetConfigPath: 'build\azure-pipelines\win32\ESRPClient\NuGet.config'
+    externalFeedCredentials: 3fc0b7f7-da09-4ae7-a9c8-d69824b1819b
+    restoreDirectory: packages
+
+- task: ESRPImportCertTask@1
+  displayName: Import ESRP Request Signing Certificate
+  inputs:
+    ESRP: 'ESRP CodeSign'
+
+- task: PowerShell@2
+  inputs:
+    targetType: filePath
+    filePath: .\build\azure-pipelines\win32\import-esrp-auth-cert.ps1
+    arguments: "$(ESRP-SSL-AADAuth)"
+  displayName: Import ESRP Auth Certificate
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    $env:AZURE_STORAGE_ACCESS_KEY_2 = "$(vscode-storage-key)"
+    $env:AZURE_DOCUMENTDB_MASTERKEY = "$(builds-docdb-key-readwrite)"
+    $env:VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)"
+    .\build\azure-pipelines\win32\publish.ps1
+  displayName: Publish
+
+- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
+  displayName: 'Component Detection'
+  continueOnError: true

lib/vscode/build/azure-pipelines/win32/product-build-win32.yml

@@ -0,0 +1,254 @@
+steps:
+- powershell: |
+    mkdir .build -ea 0
+    "$env:BUILD_SOURCEVERSION" | Out-File -Encoding ascii -NoNewLine .build\commit
+    "$env:VSCODE_QUALITY" | Out-File -Encoding ascii -NoNewLine .build\quality
+  displayName: Prepare cache flag
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/commit, .build/quality'
+    targetfolder: '.build, out-build, out-vscode-min, out-vscode-reh-min, out-vscode-reh-web-min'
+    vstsFeed: 'npm-vscode'
+    platformIndependent: true
+    alias: 'Compilation'
+
+- powershell: |
+    $ErrorActionPreference = "Stop"
+    exit 1
+  displayName: Check RestoreCache
+  condition: and(succeeded(), ne(variables['CacheRestored-Compilation'], 'true'))
+
+- task: NodeTool@0
+  inputs:
+    versionSpec: "12.14.1"
+
+- task: geeklearningio.gl-vsts-tasks-yarn.yarn-installer-task.YarnInstaller@2
+  inputs:
+    versionSpec: "1.x"
+
+- task: UsePythonVersion@0
+  inputs:
+    versionSpec: '2.x'
+    addToPath: true
+
+- task: AzureKeyVault@1
+  displayName: 'Azure Key Vault: Get Secrets'
+  inputs:
+    azureSubscription: 'vscode-builds-subscription'
+    KeyVaultName: vscode
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    "machine github.com`nlogin vscode`npassword $(github-distro-mixin-password)" | Out-File "$env:USERPROFILE\_netrc" -Encoding ASCII
+
+    exec { git config user.email "vscode@microsoft.com" }
+    exec { git config user.name "VSCode" }
+
+    mkdir .build -ea 0
+    "$(VSCODE_ARCH)" | Out-File -Encoding ascii -NoNewLine .build\arch
+  displayName: Prepare tooling
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { git remote add distro "https://github.com/$(VSCODE_MIXIN_REPO).git" }
+    exec { git fetch distro }
+    exec { git merge $(node -p "require('./package.json').distro") }
+  displayName: Merge distro
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.RestoreCacheV1.RestoreCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/arch, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    $env:npm_config_arch="$(VSCODE_ARCH)"
+    $env:CHILD_CONCURRENCY="1"
+    exec { yarn --frozen-lockfile }
+  displayName: Install dependencies
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- task: 1ESLighthouseEng.PipelineArtifactCaching.SaveCacheV1.SaveCache@1
+  inputs:
+    keyfile: 'build/.cachesalt, .build/arch, .yarnrc, remote/.yarnrc, **/yarn.lock, !**/node_modules/**/yarn.lock, !**/.*/**/yarn.lock'
+    targetfolder: '**/node_modules, !**/node_modules/**/node_modules'
+    vstsFeed: 'npm-vscode'
+  condition: and(succeeded(), ne(variables['CacheRestored'], 'true'))
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { yarn postinstall }
+  displayName: Run postinstall scripts
+  condition: and(succeeded(), eq(variables['CacheRestored'], 'true'))
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { node build/azure-pipelines/mixin }
+  displayName: Mix in quality
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    $env:VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)"
+    exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-min-ci" }
+    exec { yarn gulp "vscode-reh-win32-$env:VSCODE_ARCH-min-ci" }
+    exec { yarn gulp "vscode-reh-web-win32-$env:VSCODE_ARCH-min-ci" }
+    exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-code-helper" }
+    exec { yarn gulp "vscode-win32-$env:VSCODE_ARCH-inno-updater" }
+  displayName: Build
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { yarn electron $(VSCODE_ARCH) }
+    exec { .\scripts\test.bat --build --tfs "Unit Tests" }
+  displayName: Run unit tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { yarn test-browser --build --browser chromium --browser firefox --tfs "Browser Unit Tests" }
+  displayName: Run unit tests (Browser)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- powershell: |
+    # Figure out the full absolute path of the product we just built
+    # including the remote server and configure the integration tests
+    # to run with these builds instead of running out of sources.
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    $AppRoot = "$(agent.builddirectory)\VSCode-win32-$(VSCODE_ARCH)"
+    $AppProductJson = Get-Content -Raw -Path "$AppRoot\resources\app\product.json" | ConvertFrom-Json
+    $AppNameShort = $AppProductJson.nameShort
+    exec { $env:INTEGRATION_TEST_ELECTRON_PATH = "$AppRoot\$AppNameShort.exe"; $env:VSCODE_REMOTE_SERVER_PATH = "$(agent.builddirectory)\vscode-reh-win32-$(VSCODE_ARCH)"; .\scripts\test-integration.bat --build --tfs "Integration Tests" }
+  displayName: Run integration tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    exec { $env:VSCODE_REMOTE_SERVER_PATH = "$(agent.builddirectory)\vscode-reh-web-win32-$(VSCODE_ARCH)"; .\resources\server\test\test-web-integration.bat --browser firefox }
+  displayName: Run integration tests (Browser)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    $AppRoot = "$(agent.builddirectory)\VSCode-win32-$(VSCODE_ARCH)"
+    $AppProductJson = Get-Content -Raw -Path "$AppRoot\resources\app\product.json" | ConvertFrom-Json
+    $AppNameShort = $AppProductJson.nameShort
+    exec { $env:INTEGRATION_TEST_ELECTRON_PATH = "$AppRoot\$AppNameShort.exe"; $env:VSCODE_REMOTE_SERVER_PATH = "$(agent.builddirectory)\vscode-reh-win32-$(VSCODE_ARCH)"; .\resources\server\test\test-remote-integration.bat }
+  displayName: Run remote integration tests (Electron)
+  condition: and(succeeded(), eq(variables['VSCODE_STEP_ON_IT'], 'false'))
+
+- task: PublishPipelineArtifact@0
+  inputs:
+    artifactName: crash-dump-windows-$(VSCODE_ARCH)
+    targetPath: .build\crashes
+  displayName: 'Publish Crash Reports'
+  continueOnError: true
+  condition: failed()
+
+- task: PublishTestResults@2
+  displayName: Publish Tests Results
+  inputs:
+    testResultsFiles: '*-results.xml'
+    searchFolder: '$(Build.ArtifactStagingDirectory)/test-results'
+  condition: succeededOrFailed()
+
+- task: SFP.build-tasks.custom-build-task-1.EsrpCodeSigning@1
+  inputs:
+    ConnectedServiceName: 'ESRP CodeSign'
+    FolderPath: '$(agent.builddirectory)/VSCode-win32-$(VSCODE_ARCH),$(agent.builddirectory)/vscode-reh-win32-$(VSCODE_ARCH)'
+    Pattern: '*.dll,*.exe,*.node'
+    signConfigType: inlineSignParams
+    inlineOperation: |
+      [
+        {
+          "keyCode": "CP-230012",
+          "operationSetCode": "SigntoolSign",
+          "parameters": [
+            {
+              "parameterName": "OpusName",
+              "parameterValue": "VS Code"
+            },
+            {
+              "parameterName": "OpusInfo",
+              "parameterValue": "https://code.visualstudio.com/"
+            },
+            {
+              "parameterName": "Append",
+              "parameterValue": "/as"
+            },
+            {
+              "parameterName": "FileDigest",
+              "parameterValue": "/fd \"SHA256\""
+            },
+            {
+              "parameterName": "PageHash",
+              "parameterValue": "/NPH"
+            },
+            {
+              "parameterName": "TimeStamp",
+              "parameterValue": "/tr \"http://rfc3161.gtm.corp.microsoft.com/TSS/HttpTspServer\" /td sha256"
+            }
+          ],
+          "toolName": "sign",
+          "toolVersion": "1.0"
+        },
+        {
+          "keyCode": "CP-230012",
+          "operationSetCode": "SigntoolVerify",
+          "parameters": [
+            {
+              "parameterName": "VerifyAll",
+              "parameterValue": "/all"
+            }
+          ],
+          "toolName": "sign",
+          "toolVersion": "1.0"
+        }
+      ]
+    SessionTimeout: 120
+
+- task: NuGetCommand@2
+  displayName: Install ESRPClient.exe
+  inputs:
+    restoreSolution: 'build\azure-pipelines\win32\ESRPClient\packages.config'
+    feedsToUse: config
+    nugetConfigPath: 'build\azure-pipelines\win32\ESRPClient\NuGet.config'
+    externalFeedCredentials: 'ESRP Nuget'
+    restoreDirectory: packages
+
+- task: ESRPImportCertTask@1
+  displayName: Import ESRP Request Signing Certificate
+  inputs:
+    ESRP: 'ESRP CodeSign'
+
+- task: PowerShell@2
+  inputs:
+    targetType: filePath
+    filePath: .\build\azure-pipelines\win32\import-esrp-auth-cert.ps1
+    arguments: "$(ESRP-SSL-AADAuth)"
+  displayName: Import ESRP Auth Certificate
+
+- powershell: |
+    . build/azure-pipelines/win32/exec.ps1
+    $ErrorActionPreference = "Stop"
+    $env:AZURE_STORAGE_ACCESS_KEY_2 = "$(vscode-storage-key)"
+    $env:AZURE_DOCUMENTDB_MASTERKEY = "$(builds-docdb-key-readwrite)"
+    $env:VSCODE_MIXIN_PASSWORD="$(github-distro-mixin-password)"
+    .\build\azure-pipelines\win32\publish.ps1
+  displayName: Publish
+
+- task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
+  displayName: 'Component Detection'
+  continueOnError: true

lib/vscode/build/azure-pipelines/win32/publish.ps1

@@ -0,0 +1,36 @@
+. build/azure-pipelines/win32/exec.ps1
+$ErrorActionPreference = "Stop"
+
+$Arch = "$env:VSCODE_ARCH"
+
+exec { yarn gulp "vscode-win32-$Arch-archive" "vscode-win32-$Arch-system-setup" "vscode-win32-$Arch-user-setup" --sign }
+
+$Repo = "$(pwd)"
+$Root = "$Repo\.."
+$SystemExe = "$Repo\.build\win32-$Arch\system-setup\VSCodeSetup.exe"
+$UserExe = "$Repo\.build\win32-$Arch\user-setup\VSCodeSetup.exe"
+$Zip = "$Repo\.build\win32-$Arch\archive\VSCode-win32-$Arch.zip"
+$LegacyServer = "$Root\vscode-reh-win32-$Arch"
+$Server = "$Root\vscode-server-win32-$Arch"
+$ServerZip = "$Repo\.build\vscode-server-win32-$Arch.zip"
+$Build = "$Root\VSCode-win32-$Arch"
+
+# Create server archive
+if ("$Arch" -ne "arm64") {
+	exec { xcopy $LegacyServer $Server /H /E /I }
+	exec { .\node_modules\7zip\7zip-lite\7z.exe a -tzip $ServerZip $Server -r }
+}
+
+# get version
+$PackageJson = Get-Content -Raw -Path "$Build\resources\app\package.json" | ConvertFrom-Json
+$Version = $PackageJson.version
+
+$AssetPlatform = if ("$Arch" -eq "ia32") { "win32" } else { "win32-$Arch" }
+
+exec { node build/azure-pipelines/common/createAsset.js "$AssetPlatform-archive" archive "VSCode-win32-$Arch-$Version.zip" $Zip }
+exec { node build/azure-pipelines/common/createAsset.js "$AssetPlatform" setup "VSCodeSetup-$Arch-$Version.exe" $SystemExe }
+exec { node build/azure-pipelines/common/createAsset.js "$AssetPlatform-user" setup "VSCodeUserSetup-$Arch-$Version.exe" $UserExe }
+
+if ("$Arch" -ne "arm64") {
+	exec { node build/azure-pipelines/common/createAsset.js "server-$AssetPlatform" archive "vscode-server-win32-$Arch.zip" $ServerZip }
+}

lib/vscode/build/azure-pipelines/win32/sign.ps1

@@ -0,0 +1,71 @@
+function Create-TmpJson($Obj) {
+	$FileName = [System.IO.Path]::GetTempFileName()
+	ConvertTo-Json -Depth 100 $Obj | Out-File -Encoding UTF8 $FileName
+	return $FileName
+}
+
+$Auth = Create-TmpJson @{
+	Version = "1.0.0"
+	AuthenticationType = "AAD_CERT"
+	ClientId = $env:ESRPClientId
+	AuthCert = @{
+		SubjectName = $env:ESRPAuthCertificateSubjectName
+		StoreLocation = "LocalMachine"
+		StoreName = "My"
+		SendX5c = "true"
+	}
+	RequestSigningCert = @{
+		SubjectName = $env:ESRPCertificateSubjectName
+		StoreLocation = "LocalMachine"
+		StoreName = "My"
+	}
+}
+
+$Policy = Create-TmpJson @{
+	Version = "1.0.0"
+}
+
+$Input = Create-TmpJson @{
+	Version = "1.0.0"
+	SignBatches = @(
+		@{
+			SourceLocationType = "UNC"
+			SignRequestFiles = @(
+				@{
+					SourceLocation = $args[0]
+				}
+			)
+			SigningInfo = @{
+				Operations = @(
+					@{
+						KeyCode = "CP-230012"
+						OperationCode = "SigntoolSign"
+						Parameters = @{
+							OpusName = "VS Code"
+							OpusInfo = "https://code.visualstudio.com/"
+							Append = "/as"
+							FileDigest = "/fd `"SHA256`""
+							PageHash = "/NPH"
+							TimeStamp = "/tr `"http://rfc3161.gtm.corp.microsoft.com/TSS/HttpTspServer`" /td sha256"
+						}
+						ToolName = "sign"
+						ToolVersion = "1.0"
+					},
+					@{
+						KeyCode = "CP-230012"
+						OperationCode = "SigntoolVerify"
+						Parameters = @{
+							VerifyAll = "/all"
+						}
+						ToolName = "sign"
+						ToolVersion = "1.0"
+					}
+				)
+			}
+		}
+	)
+}
+
+$Output = [System.IO.Path]::GetTempFileName()
+$ScriptPath = Split-Path -Path $MyInvocation.MyCommand.Definition -Parent
+& "$ScriptPath\ESRPClient\packages\Microsoft.ESRPClient.*\tools\ESRPClient.exe" Sign -a $Auth -p $Policy -i $Input -o $Output

lib/vscode/build/builtin/.eslintrc

@@ -0,0 +1,20 @@
+{
+	"env": {
+		"node": true,
+		"es6": true,
+		"browser": true
+	},
+	"rules": {
+		"no-console": 0,
+		"no-cond-assign": 0,
+		"no-unused-vars": 1,
+		"no-extra-semi": "warn",
+		"semi": "warn"
+	},
+	"extends": "eslint:recommended",
+	"parserOptions": {
+		"ecmaFeatures": {
+			"experimentalObjectRestSpread": true
+		}
+	}
+}

lib/vscode/build/builtin/browser-main.js

@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { remote } = require('electron');
+const dialog = remote.dialog;
+
+const builtInExtensionsPath = path.join(__dirname, '..', '..', 'product.json');
+const controlFilePath = path.join(os.homedir(), '.vscode-oss-dev', 'extensions', 'control.json');
+
+function readJson(filePath) {
+	return JSON.parse(fs.readFileSync(filePath, { encoding: 'utf8' }));
+}
+
+function writeJson(filePath, obj) {
+	fs.writeFileSync(filePath, JSON.stringify(obj, null, 2));
+}
+
+function renderOption(form, id, title, value, checked) {
+	const input = document.createElement('input');
+	input.type = 'radio';
+	input.id = id;
+	input.name = 'choice';
+	input.value = value;
+	input.checked = !!checked;
+	form.appendChild(input);
+
+	const label = document.createElement('label');
+	label.setAttribute('for', id);
+	label.textContent = title;
+	form.appendChild(label);
+
+	return input;
+}
+
+function render(el, state) {
+	function setState(state) {
+		try {
+			writeJson(controlFilePath, state.control);
+		} catch (err) {
+			console.error(err);
+		}
+
+		el.innerHTML = '';
+		render(el, state);
+	}
+
+	const ul = document.createElement('ul');
+	const { builtin, control } = state;
+
+	for (const ext of builtin) {
+		const controlState = control[ext.name] || 'marketplace';
+
+		const li = document.createElement('li');
+		ul.appendChild(li);
+
+		const name = document.createElement('code');
+		name.textContent = ext.name;
+		li.appendChild(name);
+
+		const form = document.createElement('form');
+		li.appendChild(form);
+
+		const marketplaceInput = renderOption(form, `marketplace-${ext.name}`, 'Marketplace', 'marketplace', controlState === 'marketplace');
+		marketplaceInput.onchange = function () {
+			control[ext.name] = 'marketplace';
+			setState({ builtin, control });
+		};
+
+		const disabledInput = renderOption(form, `disabled-${ext.name}`, 'Disabled', 'disabled', controlState === 'disabled');
+		disabledInput.onchange = function () {
+			control[ext.name] = 'disabled';
+			setState({ builtin, control });
+		};
+
+		let local = undefined;
+
+		if (controlState !== 'marketplace' && controlState !== 'disabled') {
+			local = controlState;
+		}
+
+		const localInput = renderOption(form, `local-${ext.name}`, 'Local', 'local', !!local);
+		localInput.onchange = function () {
+			const result = dialog.showOpenDialog(remote.getCurrentWindow(), {
+				title: 'Choose Folder',
+				properties: ['openDirectory']
+			});
+
+			if (result && result.length >= 1) {
+				control[ext.name] = result[0];
+			}
+
+			setState({ builtin, control });
+		};
+
+		if (local) {
+			const localSpan = document.createElement('code');
+			localSpan.className = 'local';
+			localSpan.textContent = local;
+			form.appendChild(localSpan);
+		}
+	}
+
+	el.appendChild(ul);
+}
+
+function main() {
+	const el = document.getElementById('extensions');
+	const builtin = readJson(builtInExtensionsPath).builtInExtensions;
+	let control;
+
+	try {
+		control = readJson(controlFilePath);
+	} catch (err) {
+		control = {};
+	}
+
+	render(el, { builtin, control });
+}
+
+window.onload = main;

lib/vscode/build/builtin/index.html

@@ -0,0 +1,46 @@
+<!-- Copyright (C) Microsoft Corporation. All rights reserved. -->
+
+<!DOCTYPE html>
+<html>
+
+<head>
+	<meta charset="utf-8" />
+	<meta http-equiv="X-UA-Compatible" content="IE=edge">
+	<title>Manage Built-in Extensions</title>
+	<meta name="viewport" content="width=device-width, initial-scale=1">
+	<script src="browser-main.js"></script>
+	<style>
+		body {
+			font-family: 'Trebuchet MS', 'Lucida Sans Unicode', 'Lucida Grande', 'Lucida Sans', Arial, sans-serif;
+			font-size: 10pt;
+		}
+
+		code {
+			font-family: 'Menlo', 'Courier New', 'Courier', monospace;
+		}
+
+		ul {
+			padding-left: 1em;
+		}
+
+		li {
+			list-style: none;
+			padding: 0.3em 0;
+		}
+
+		label {
+			margin-right: 1em;
+		}
+
+		form {
+			padding: 0.3em 0 0.3em 0.3em;
+		}
+	</style>
+</head>
+
+<body>
+	<h1>Built-in Extensions</h1>
+	<div id="extensions"></div>
+</body>
+
+</html>

lib/vscode/build/builtin/main.js

@@ -0,0 +1,20 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const { app, BrowserWindow } = require('electron');
+const url = require('url');
+const path = require('path');
+
+let window = null;
+
+app.once('ready', () => {
+	window = new BrowserWindow({ width: 800, height: 600, webPreferences: { nodeIntegration: true, webviewTag: true, enableWebSQL: false, nativeWindowOpen: true } });
+	window.setMenuBarVisibility(false);
+	window.loadURL(url.format({ pathname: path.join(__dirname, 'index.html'), protocol: 'file:', slashes: true }));
+	// window.webContents.openDevTools();
+	window.once('closed', () => window = null);
+});
+
+app.on('window-all-closed', () => app.quit());

lib/vscode/build/builtin/package.json

@@ -0,0 +1,5 @@
+{
+	"name": "builtin",
+	"version": "0.1.0",
+	"main": "main.js"
+}

lib/vscode/build/darwin/sign.ts

@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as codesign from 'electron-osx-sign';
+import * as path from 'path';
+import * as util from '../lib/util';
+import * as product from '../../product.json';
+
+async function main(): Promise<void> {
+	const buildDir = process.env['AGENT_BUILDDIRECTORY'];
+	const tempDir = process.env['AGENT_TEMPDIRECTORY'];
+
+	if (!buildDir) {
+		throw new Error('$AGENT_BUILDDIRECTORY not set');
+	}
+
+	if (!tempDir) {
+		throw new Error('$AGENT_TEMPDIRECTORY not set');
+	}
+
+	const baseDir = path.dirname(__dirname);
+	const appRoot = path.join(buildDir, 'VSCode-darwin');
+	const appName = product.nameLong + '.app';
+	const appFrameworkPath = path.join(appRoot, appName, 'Contents', 'Frameworks');
+	const helperAppBaseName = product.nameShort;
+	const gpuHelperAppName = helperAppBaseName + ' Helper (GPU).app';
+	const pluginHelperAppName = helperAppBaseName + ' Helper (Plugin).app';
+	const rendererHelperAppName = helperAppBaseName + ' Helper (Renderer).app';
+
+	const defaultOpts: codesign.SignOptions = {
+		app: path.join(appRoot, appName),
+		platform: 'darwin',
+		entitlements: path.join(baseDir, 'azure-pipelines', 'darwin', 'app-entitlements.plist'),
+		'entitlements-inherit': path.join(baseDir, 'azure-pipelines', 'darwin', 'app-entitlements.plist'),
+		hardenedRuntime: true,
+		'pre-auto-entitlements': false,
+		'pre-embed-provisioning-profile': false,
+		keychain: path.join(tempDir, 'buildagent.keychain'),
+		version: util.getElectronVersion(),
+		identity: '99FM488X57',
+		'gatekeeper-assess': false
+	};
+
+	const appOpts = {
+		...defaultOpts,
+		// TODO(deepak1556): Incorrectly declared type in electron-osx-sign
+		ignore: (filePath: string) => {
+			return filePath.includes(gpuHelperAppName) ||
+				filePath.includes(pluginHelperAppName) ||
+				filePath.includes(rendererHelperAppName);
+		}
+	};
+
+	const gpuHelperOpts: codesign.SignOptions = {
+		...defaultOpts,
+		app: path.join(appFrameworkPath, gpuHelperAppName),
+		entitlements: path.join(baseDir, 'azure-pipelines', 'darwin', 'helper-gpu-entitlements.plist'),
+		'entitlements-inherit': path.join(baseDir, 'azure-pipelines', 'darwin', 'helper-gpu-entitlements.plist'),
+	};
+
+	const pluginHelperOpts: codesign.SignOptions = {
+		...defaultOpts,
+		app: path.join(appFrameworkPath, pluginHelperAppName),
+		entitlements: path.join(baseDir, 'azure-pipelines', 'darwin', 'helper-plugin-entitlements.plist'),
+		'entitlements-inherit': path.join(baseDir, 'azure-pipelines', 'darwin', 'helper-plugin-entitlements.plist'),
+	};
+
+	const rendererHelperOpts: codesign.SignOptions = {
+		...defaultOpts,
+		app: path.join(appFrameworkPath, rendererHelperAppName),
+		entitlements: path.join(baseDir, 'azure-pipelines', 'darwin', 'helper-renderer-entitlements.plist'),
+		'entitlements-inherit': path.join(baseDir, 'azure-pipelines', 'darwin', 'helper-renderer-entitlements.plist'),
+	};
+
+	await codesign.signAsync(gpuHelperOpts);
+	await codesign.signAsync(pluginHelperOpts);
+	await codesign.signAsync(rendererHelperOpts);
+	await codesign.signAsync(appOpts as any);
+}
+
+if (require.main === module) {
+	main().catch(err => {
+		console.error(err);
+		process.exit(1);
+	});
+}

lib/vscode/build/dependencies.js

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const path = require('path');
+const parseSemver = require('parse-semver');
+const cp = require('child_process');
+const _ = require('underscore');
+
+function asYarnDependency(prefix, tree) {
+	let parseResult;
+
+	try {
+		parseResult = parseSemver(tree.name);
+	} catch (err) {
+		err.message += `: ${tree.name}`;
+		console.warn(`Could not parse semver: ${tree.name}`);
+		return null;
+	}
+
+	// not an actual dependency in disk
+	if (parseResult.version !== parseResult.range) {
+		return null;
+	}
+
+	const name = parseResult.name;
+	const version = parseResult.version;
+	const dependencyPath = path.join(prefix, name);
+	const children = [];
+
+	for (const child of (tree.children || [])) {
+		const dep = asYarnDependency(path.join(prefix, name, 'node_modules'), child);
+
+		if (dep) {
+			children.push(dep);
+		}
+	}
+
+	return { name, version, path: dependencyPath, children };
+}
+
+function getYarnProductionDependencies(cwd) {
+	const raw = cp.execSync('yarn list --json', { cwd, encoding: 'utf8', env: { ...process.env, NODE_ENV: 'production' }, stdio: [null, null, 'inherit'] });
+	const match = /^{"type":"tree".*$/m.exec(raw);
+
+	if (!match || match.length !== 1) {
+		throw new Error('Could not parse result of `yarn list --json`');
+	}
+
+	const trees = JSON.parse(match[0]).data.trees;
+
+	return trees
+		.map(tree => asYarnDependency(path.join(cwd, 'node_modules'), tree))
+		.filter(dep => !!dep);
+}
+
+function getProductionDependencies(cwd) {
+	const result = [];
+	const deps = getYarnProductionDependencies(cwd);
+	const flatten = dep => { result.push({ name: dep.name, version: dep.version, path: dep.path }); dep.children.forEach(flatten); };
+	deps.forEach(flatten);
+
+	return _.uniq(result);
+}
+
+module.exports.getProductionDependencies = getProductionDependencies;
+
+if (require.main === module) {
+	const root = path.dirname(__dirname);
+	console.log(JSON.stringify(getProductionDependencies(root), null, '  '));
+}

lib/vscode/build/gulpfile.compile.js

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const gulp = require('gulp');
+const util = require('./lib/util');
+const task = require('./lib/task');
+const compilation = require('./lib/compilation');
+
+// Full compile, including nls and inline sources in sourcemaps, for build
+const compileBuildTask = task.define('compile-build', task.series(util.rimraf('out-build'), compilation.compileTask('src', 'out-build', true)));
+gulp.task(compileBuildTask);
+exports.compileBuildTask = compileBuildTask;

lib/vscode/build/gulpfile.editor.js

@@ -0,0 +1,477 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const gulp = require('gulp');
+const path = require('path');
+const util = require('./lib/util');
+const task = require('./lib/task');
+const common = require('./lib/optimize');
+const es = require('event-stream');
+const File = require('vinyl');
+const i18n = require('./lib/i18n');
+const standalone = require('./lib/standalone');
+const cp = require('child_process');
+const compilation = require('./lib/compilation');
+const monacoapi = require('./lib/monaco-api');
+const fs = require('fs');
+const webpack = require('webpack');
+const webpackGulp = require('webpack-stream');
+
+let root = path.dirname(__dirname);
+let sha1 = util.getVersion(root);
+let semver = require('./monaco/package.json').version;
+let headerVersion = semver + '(' + sha1 + ')';
+
+// Build
+
+let editorEntryPoints = [
+	{
+		name: 'vs/editor/editor.main',
+		include: [],
+		exclude: ['vs/css', 'vs/nls'],
+		prepend: ['out-editor-build/vs/css.js', 'out-editor-build/vs/nls.js'],
+	},
+	{
+		name: 'vs/base/common/worker/simpleWorker',
+		include: ['vs/editor/common/services/editorSimpleWorker'],
+		prepend: ['vs/loader.js'],
+		append: ['vs/base/worker/workerMain'],
+		dest: 'vs/base/worker/workerMain.js'
+	}
+];
+
+let editorResources = [
+	'out-editor-build/vs/base/browser/ui/codicons/**/*.ttf'
+];
+
+let BUNDLED_FILE_HEADER = [
+	'/*!-----------------------------------------------------------',
+	' * Copyright (c) Microsoft Corporation. All rights reserved.',
+	' * Version: ' + headerVersion,
+	' * Released under the MIT license',
+	' * https://github.com/microsoft/vscode/blob/master/LICENSE.txt',
+	' *-----------------------------------------------------------*/',
+	''
+].join('\n');
+
+const languages = i18n.defaultLanguages.concat([]);  // i18n.defaultLanguages.concat(process.env.VSCODE_QUALITY !== 'stable' ? i18n.extraLanguages : []);
+
+const extractEditorSrcTask = task.define('extract-editor-src', () => {
+	const apiusages = monacoapi.execute().usageContent;
+	const extrausages = fs.readFileSync(path.join(root, 'build', 'monaco', 'monaco.usage.recipe')).toString();
+	standalone.extractEditor({
+		sourcesRoot: path.join(root, 'src'),
+		entryPoints: [
+			'vs/editor/editor.main',
+			'vs/editor/editor.worker',
+			'vs/base/worker/workerMain',
+		],
+		inlineEntryPoints: [
+			apiusages,
+			extrausages
+		],
+		shakeLevel: 2, // 0-Files, 1-InnerFile, 2-ClassMembers
+		importIgnorePattern: /(^vs\/css!)/,
+		destRoot: path.join(root, 'out-editor-src'),
+		redirects: []
+	});
+});
+
+const compileEditorAMDTask = task.define('compile-editor-amd', compilation.compileTask('out-editor-src', 'out-editor-build', true));
+
+const optimizeEditorAMDTask = task.define('optimize-editor-amd', common.optimizeTask({
+	src: 'out-editor-build',
+	entryPoints: editorEntryPoints,
+	resources: editorResources,
+	loaderConfig: {
+		paths: {
+			'vs': 'out-editor-build/vs',
+			'vs/css': 'out-editor-build/vs/css.build',
+			'vs/nls': 'out-editor-build/vs/nls.build',
+			'vscode': 'empty:'
+		}
+	},
+	bundleLoader: false,
+	header: BUNDLED_FILE_HEADER,
+	bundleInfo: true,
+	out: 'out-editor',
+	languages: languages
+}));
+
+const minifyEditorAMDTask = task.define('minify-editor-amd', common.minifyTask('out-editor'));
+
+const createESMSourcesAndResourcesTask = task.define('extract-editor-esm', () => {
+	standalone.createESMSourcesAndResources2({
+		srcFolder: './out-editor-src',
+		outFolder: './out-editor-esm',
+		outResourcesFolder: './out-monaco-editor-core/esm',
+		ignores: [
+			'inlineEntryPoint:0.ts',
+			'inlineEntryPoint:1.ts',
+			'vs/loader.js',
+			'vs/nls.ts',
+			'vs/nls.build.js',
+			'vs/nls.d.ts',
+			'vs/css.js',
+			'vs/css.build.js',
+			'vs/css.d.ts',
+			'vs/base/worker/workerMain.ts',
+		],
+		renames: {
+			'vs/nls.mock.ts': 'vs/nls.ts'
+		}
+	});
+});
+
+const compileEditorESMTask = task.define('compile-editor-esm', () => {
+	const KEEP_PREV_ANALYSIS = false;
+	const FAIL_ON_PURPOSE = false;
+	console.log(`Launching the TS compiler at ${path.join(__dirname, '../out-editor-esm')}...`);
+	let result;
+	if (process.platform === 'win32') {
+		result = cp.spawnSync(`..\\node_modules\\.bin\\tsc.cmd`, {
+			cwd: path.join(__dirname, '../out-editor-esm')
+		});
+	} else {
+		result = cp.spawnSync(`node`, [`../node_modules/.bin/tsc`], {
+			cwd: path.join(__dirname, '../out-editor-esm')
+		});
+	}
+
+	console.log(result.stdout.toString());
+	console.log(result.stderr.toString());
+
+	if (FAIL_ON_PURPOSE || result.status !== 0) {
+		console.log(`The TS Compilation failed, preparing analysis folder...`);
+		const destPath = path.join(__dirname, '../../vscode-monaco-editor-esm-analysis');
+		const keepPrevAnalysis = (KEEP_PREV_ANALYSIS && fs.existsSync(destPath));
+		const cleanDestPath = (keepPrevAnalysis ? Promise.resolve() : util.rimraf(destPath)());
+		return cleanDestPath.then(() => {
+			// build a list of files to copy
+			const files = util.rreddir(path.join(__dirname, '../out-editor-esm'));
+
+			if (!keepPrevAnalysis) {
+				fs.mkdirSync(destPath);
+
+				// initialize a new repository
+				cp.spawnSync(`git`, [`init`], {
+					cwd: destPath
+				});
+
+				// copy files from src
+				for (const file of files) {
+					const srcFilePath = path.join(__dirname, '../src', file);
+					const dstFilePath = path.join(destPath, file);
+					if (fs.existsSync(srcFilePath)) {
+						util.ensureDir(path.dirname(dstFilePath));
+						const contents = fs.readFileSync(srcFilePath).toString().replace(/\r\n|\r|\n/g, '\n');
+						fs.writeFileSync(dstFilePath, contents);
+					}
+				}
+
+				// create an initial commit to diff against
+				cp.spawnSync(`git`, [`add`, `.`], {
+					cwd: destPath
+				});
+
+				// create the commit
+				cp.spawnSync(`git`, [`commit`, `-m`, `"original sources"`, `--no-gpg-sign`], {
+					cwd: destPath
+				});
+			}
+
+			// copy files from tree shaken src
+			for (const file of files) {
+				const srcFilePath = path.join(__dirname, '../out-editor-src', file);
+				const dstFilePath = path.join(destPath, file);
+				if (fs.existsSync(srcFilePath)) {
+					util.ensureDir(path.dirname(dstFilePath));
+					const contents = fs.readFileSync(srcFilePath).toString().replace(/\r\n|\r|\n/g, '\n');
+					fs.writeFileSync(dstFilePath, contents);
+				}
+			}
+
+			console.log(`Open in VS Code the folder at '${destPath}' and you can alayze the compilation error`);
+			throw new Error('Standalone Editor compilation failed. If this is the build machine, simply launch `yarn run gulp editor-distro` on your machine to further analyze the compilation problem.');
+		});
+	}
+});
+
+function toExternalDTS(contents) {
+	let lines = contents.split(/\r\n|\r|\n/);
+	let killNextCloseCurlyBrace = false;
+	for (let i = 0; i < lines.length; i++) {
+		let line = lines[i];
+
+		if (killNextCloseCurlyBrace) {
+			if ('}' === line) {
+				lines[i] = '';
+				killNextCloseCurlyBrace = false;
+				continue;
+			}
+
+			if (line.indexOf('    ') === 0) {
+				lines[i] = line.substr(4);
+			} else if (line.charAt(0) === '\t') {
+				lines[i] = line.substr(1);
+			}
+
+			continue;
+		}
+
+		if ('declare namespace monaco {' === line) {
+			lines[i] = '';
+			killNextCloseCurlyBrace = true;
+			continue;
+		}
+
+		if (line.indexOf('declare namespace monaco.') === 0) {
+			lines[i] = line.replace('declare namespace monaco.', 'export namespace ');
+		}
+
+		if (line.indexOf('declare let MonacoEnvironment') === 0) {
+			lines[i] = `declare global {\n    let MonacoEnvironment: Environment | undefined;\n}`;
+			// lines[i] = line.replace('declare namespace monaco.', 'export namespace ');
+		}
+	}
+	return lines.join('\n').replace(/\n\n\n+/g, '\n\n');
+}
+
+function filterStream(testFunc) {
+	return es.through(function (data) {
+		if (!testFunc(data.relative)) {
+			return;
+		}
+		this.emit('data', data);
+	});
+}
+
+const finalEditorResourcesTask = task.define('final-editor-resources', () => {
+	return es.merge(
+		// other assets
+		es.merge(
+			gulp.src('build/monaco/LICENSE'),
+			gulp.src('build/monaco/ThirdPartyNotices.txt'),
+			gulp.src('src/vs/monaco.d.ts')
+		).pipe(gulp.dest('out-monaco-editor-core')),
+
+		// place the .d.ts in the esm folder
+		gulp.src('src/vs/monaco.d.ts')
+			.pipe(es.through(function (data) {
+				this.emit('data', new File({
+					path: data.path.replace(/monaco\.d\.ts/, 'editor.api.d.ts'),
+					base: data.base,
+					contents: Buffer.from(toExternalDTS(data.contents.toString()))
+				}));
+			}))
+			.pipe(gulp.dest('out-monaco-editor-core/esm/vs/editor')),
+
+		// package.json
+		gulp.src('build/monaco/package.json')
+			.pipe(es.through(function (data) {
+				let json = JSON.parse(data.contents.toString());
+				json.private = false;
+				data.contents = Buffer.from(JSON.stringify(json, null, '  '));
+				this.emit('data', data);
+			}))
+			.pipe(gulp.dest('out-monaco-editor-core')),
+
+		// version.txt
+		gulp.src('build/monaco/version.txt')
+			.pipe(es.through(function (data) {
+				data.contents = Buffer.from(`monaco-editor-core: https://github.com/microsoft/vscode/tree/${sha1}`);
+				this.emit('data', data);
+			}))
+			.pipe(gulp.dest('out-monaco-editor-core')),
+
+		// README.md
+		gulp.src('build/monaco/README-npm.md')
+			.pipe(es.through(function (data) {
+				this.emit('data', new File({
+					path: data.path.replace(/README-npm\.md/, 'README.md'),
+					base: data.base,
+					contents: data.contents
+				}));
+			}))
+			.pipe(gulp.dest('out-monaco-editor-core')),
+
+		// dev folder
+		es.merge(
+			gulp.src('out-editor/**/*')
+		).pipe(gulp.dest('out-monaco-editor-core/dev')),
+
+		// min folder
+		es.merge(
+			gulp.src('out-editor-min/**/*')
+		).pipe(filterStream(function (path) {
+			// no map files
+			return !/(\.js\.map$)|(nls\.metadata\.json$)|(bundleInfo\.json$)/.test(path);
+		})).pipe(es.through(function (data) {
+			// tweak the sourceMappingURL
+			if (!/\.js$/.test(data.path)) {
+				this.emit('data', data);
+				return;
+			}
+
+			let relativePathToMap = path.relative(path.join(data.relative), path.join('min-maps', data.relative + '.map'));
+
+			let strContents = data.contents.toString();
+			let newStr = '//# sourceMappingURL=' + relativePathToMap.replace(/\\/g, '/');
+			strContents = strContents.replace(/\/\/# sourceMappingURL=[^ ]+$/, newStr);
+
+			data.contents = Buffer.from(strContents);
+			this.emit('data', data);
+		})).pipe(gulp.dest('out-monaco-editor-core/min')),
+
+		// min-maps folder
+		es.merge(
+			gulp.src('out-editor-min/**/*')
+		).pipe(filterStream(function (path) {
+			// no map files
+			return /\.js\.map$/.test(path);
+		})).pipe(gulp.dest('out-monaco-editor-core/min-maps'))
+	);
+});
+
+gulp.task('extract-editor-src',
+	task.series(
+		util.rimraf('out-editor-src'),
+		extractEditorSrcTask
+	)
+);
+
+gulp.task('editor-distro',
+	task.series(
+		task.parallel(
+			util.rimraf('out-editor-src'),
+			util.rimraf('out-editor-build'),
+			util.rimraf('out-editor-esm'),
+			util.rimraf('out-monaco-editor-core'),
+			util.rimraf('out-editor'),
+			util.rimraf('out-editor-min')
+		),
+		extractEditorSrcTask,
+		task.parallel(
+			task.series(
+				compileEditorAMDTask,
+				optimizeEditorAMDTask,
+				minifyEditorAMDTask
+			),
+			task.series(
+				createESMSourcesAndResourcesTask,
+				compileEditorESMTask
+			)
+		),
+		finalEditorResourcesTask
+	)
+);
+
+const bundleEditorESMTask = task.define('editor-esm-bundle-webpack', () => {
+	const result = es.through();
+
+	const webpackConfigPath = path.join(root, 'build/monaco/monaco.webpack.config.js');
+
+	const webpackConfig = {
+		...require(webpackConfigPath),
+		...{ mode: 'production' }
+	};
+
+	const webpackDone = (err, stats) => {
+		if (err) {
+			result.emit('error', err);
+			return;
+		}
+		const { compilation } = stats;
+		if (compilation.errors.length > 0) {
+			result.emit('error', compilation.errors.join('\n'));
+		}
+		if (compilation.warnings.length > 0) {
+			result.emit('data', compilation.warnings.join('\n'));
+		}
+	};
+
+	return webpackGulp(webpackConfig, webpack, webpackDone)
+		.pipe(gulp.dest('out-editor-esm-bundle'));
+});
+
+gulp.task('editor-esm-bundle',
+	task.series(
+		task.parallel(
+			util.rimraf('out-editor-src'),
+			util.rimraf('out-editor-esm'),
+			util.rimraf('out-monaco-editor-core'),
+			util.rimraf('out-editor-esm-bundle'),
+		),
+		extractEditorSrcTask,
+		createESMSourcesAndResourcesTask,
+		compileEditorESMTask,
+		bundleEditorESMTask,
+	)
+);
+
+gulp.task('monacodts', task.define('monacodts', () => {
+	const result = monacoapi.execute();
+	fs.writeFileSync(result.filePath, result.content);
+	fs.writeFileSync(path.join(root, 'src/vs/editor/common/standalone/standaloneEnums.ts'), result.enums);
+	return Promise.resolve(true);
+}));
+
+//#region monaco type checking
+
+function createTscCompileTask(watch) {
+	return () => {
+		const createReporter = require('./lib/reporter').createReporter;
+
+		return new Promise((resolve, reject) => {
+			const args = ['./node_modules/.bin/tsc', '-p', './src/tsconfig.monaco.json', '--noEmit'];
+			if (watch) {
+				args.push('-w');
+			}
+			const child = cp.spawn(`node`, args, {
+				cwd: path.join(__dirname, '..'),
+				// stdio: [null, 'pipe', 'inherit']
+			});
+			let errors = [];
+			let reporter = createReporter();
+			let report;
+			// eslint-disable-next-line no-control-regex
+			let magic = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g; // https://stackoverflow.com/questions/25245716/remove-all-ansi-colors-styles-from-strings
+
+			child.stdout.on('data', data => {
+				let str = String(data);
+				str = str.replace(magic, '').trim();
+				if (str.indexOf('Starting compilation') >= 0 || str.indexOf('File change detected') >= 0) {
+					errors.length = 0;
+					report = reporter.end(false);
+
+				} else if (str.indexOf('Compilation complete') >= 0) {
+					report.end();
+
+				} else if (str) {
+					let match = /(.*\(\d+,\d+\): )(.*: )(.*)/.exec(str);
+					if (match) {
+						// trying to massage the message so that it matches the gulp-tsb error messages
+						// e.g. src/vs/base/common/strings.ts(663,5): error TS2322: Type '1234' is not assignable to type 'string'.
+						let fullpath = path.join(root, match[1]);
+						let message = match[3];
+						reporter(fullpath + message);
+					} else {
+						reporter(str);
+					}
+				}
+			});
+			child.on('exit', resolve);
+			child.on('error', reject);
+		});
+	};
+}
+
+const monacoTypecheckWatchTask = task.define('monaco-typecheck-watch', createTscCompileTask(true));
+exports.monacoTypecheckWatchTask = monacoTypecheckWatchTask;
+
+const monacoTypecheckTask = task.define('monaco-typecheck', createTscCompileTask(false));
+exports.monacoTypecheckTask = monacoTypecheckTask;
+
+//#endregion

lib/vscode/build/gulpfile.extensions.js

@@ -0,0 +1,248 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// Increase max listeners for event emitters
+require('events').EventEmitter.defaultMaxListeners = 100;
+
+const gulp = require('gulp');
+const path = require('path');
+const nodeUtil = require('util');
+const tsb = require('gulp-tsb');
+const es = require('event-stream');
+const filter = require('gulp-filter');
+const webpack = require('webpack');
+const util = require('./lib/util');
+const task = require('./lib/task');
+const watcher = require('./lib/watch');
+const createReporter = require('./lib/reporter').createReporter;
+const glob = require('glob');
+const sourcemaps = require('gulp-sourcemaps');
+const nlsDev = require('vscode-nls-dev');
+const root = path.dirname(__dirname);
+const commit = util.getVersion(root);
+const plumber = require('gulp-plumber');
+const fancyLog = require('fancy-log');
+const ansiColors = require('ansi-colors');
+const ext = require('./lib/extensions');
+
+const extensionsPath = path.join(path.dirname(__dirname), 'extensions');
+
+const compilations = glob.sync('**/tsconfig.json', {
+	cwd: extensionsPath,
+	ignore: ['**/out/**', '**/node_modules/**']
+});
+
+const getBaseUrl = out => `https://ticino.blob.core.windows.net/sourcemaps/${commit}/${out}`;
+
+const tasks = compilations.map(function (tsconfigFile) {
+	const absolutePath = path.join(extensionsPath, tsconfigFile);
+	const relativeDirname = path.dirname(tsconfigFile);
+
+	const overrideOptions = {};
+	overrideOptions.sourceMap = true;
+
+	const name = relativeDirname.replace(/\//g, '-');
+
+	const root = path.join('extensions', relativeDirname);
+	const srcBase = path.join(root, 'src');
+	const src = path.join(srcBase, '**');
+	const srcOpts = { cwd: path.dirname(__dirname), base: srcBase };
+
+	const out = path.join(root, 'out');
+	const baseUrl = getBaseUrl(out);
+
+	let headerId, headerOut;
+	let index = relativeDirname.indexOf('/');
+	if (index < 0) {
+		headerId = 'vscode.' + relativeDirname;
+		headerOut = 'out';
+	} else {
+		headerId = 'vscode.' + relativeDirname.substr(0, index);
+		headerOut = relativeDirname.substr(index + 1) + '/out';
+	}
+
+	function createPipeline(build, emitError) {
+		const reporter = createReporter();
+
+		overrideOptions.inlineSources = Boolean(build);
+		overrideOptions.base = path.dirname(absolutePath);
+
+		const compilation = tsb.create(absolutePath, overrideOptions, false, err => reporter(err.toString()));
+
+		const pipeline = function () {
+			const input = es.through();
+			const tsFilter = filter(['**/*.ts', '!**/lib/lib*.d.ts', '!**/node_modules/**'], { restore: true });
+			const output = input
+				.pipe(plumber({
+					errorHandler: function (err) {
+						if (err && !err.__reporter__) {
+							reporter(err);
+						}
+					}
+				}))
+				.pipe(tsFilter)
+				.pipe(util.loadSourcemaps())
+				.pipe(compilation())
+				.pipe(build ? nlsDev.rewriteLocalizeCalls() : es.through())
+				.pipe(build ? util.stripSourceMappingURL() : es.through())
+				.pipe(sourcemaps.write('.', {
+					sourceMappingURL: !build ? null : f => `${baseUrl}/${f.relative}.map`,
+					addComment: !!build,
+					includeContent: !!build,
+					sourceRoot: '../src'
+				}))
+				.pipe(tsFilter.restore)
+				.pipe(build ? nlsDev.bundleMetaDataFiles(headerId, headerOut) : es.through())
+				// Filter out *.nls.json file. We needed them only to bundle meta data file.
+				.pipe(filter(['**', '!**/*.nls.json']))
+				.pipe(reporter.end(emitError));
+
+			return es.duplex(input, output);
+		};
+
+		// add src-stream for project files
+		pipeline.tsProjectSrc = () => {
+			return compilation.src(srcOpts);
+		};
+		return pipeline;
+	}
+
+	const cleanTask = task.define(`clean-extension-${name}`, util.rimraf(out));
+
+	const compileTask = task.define(`compile-extension:${name}`, task.series(cleanTask, () => {
+		const pipeline = createPipeline(false, true);
+		const nonts = gulp.src(src, srcOpts).pipe(filter(['**', '!**/*.ts']));
+		const input = es.merge(nonts, pipeline.tsProjectSrc());
+
+		return input
+			.pipe(pipeline())
+			.pipe(gulp.dest(out));
+	}));
+
+	const watchTask = task.define(`watch-extension:${name}`, task.series(cleanTask, () => {
+		const pipeline = createPipeline(false);
+		const nonts = gulp.src(src, srcOpts).pipe(filter(['**', '!**/*.ts']));
+		const input = es.merge(nonts, pipeline.tsProjectSrc());
+		const watchInput = watcher(src, { ...srcOpts, ...{ readDelay: 200 } });
+
+		return watchInput
+			.pipe(util.incremental(pipeline, input))
+			.pipe(gulp.dest(out));
+	}));
+
+	const compileBuildTask = task.define(`compile-build-extension-${name}`, task.series(cleanTask, () => {
+		const pipeline = createPipeline(true, true);
+		const nonts = gulp.src(src, srcOpts).pipe(filter(['**', '!**/*.ts']));
+		const input = es.merge(nonts, pipeline.tsProjectSrc());
+
+		return input
+			.pipe(pipeline())
+			.pipe(gulp.dest(out));
+	}));
+
+	// Tasks
+	gulp.task(compileTask);
+	gulp.task(watchTask);
+
+	return { compileTask, watchTask, compileBuildTask };
+});
+
+const compileExtensionsTask = task.define('compile-extensions', task.parallel(...tasks.map(t => t.compileTask)));
+gulp.task(compileExtensionsTask);
+exports.compileExtensionsTask = compileExtensionsTask;
+
+const watchExtensionsTask = task.define('watch-extensions', task.parallel(...tasks.map(t => t.watchTask)));
+gulp.task(watchExtensionsTask);
+exports.watchExtensionsTask = watchExtensionsTask;
+
+const compileExtensionsBuildLegacyTask = task.define('compile-extensions-build-legacy', task.parallel(...tasks.map(t => t.compileBuildTask)));
+gulp.task(compileExtensionsBuildLegacyTask);
+
+// Azure Pipelines
+
+const cleanExtensionsBuildTask = task.define('clean-extensions-build', util.rimraf('.build/extensions'));
+const compileExtensionsBuildTask = task.define('compile-extensions-build', task.series(
+	cleanExtensionsBuildTask,
+	task.define('bundle-extensions-build', () => ext.packageLocalExtensionsStream(false).pipe(gulp.dest('.build'))),
+	task.define('bundle-marketplace-extensions-build', () => ext.packageMarketplaceExtensionsStream(false).pipe(gulp.dest('.build'))),
+));
+
+gulp.task(compileExtensionsBuildTask);
+exports.compileExtensionsBuildTask = compileExtensionsBuildTask;
+
+const compileWebExtensionsTask = task.define('compile-web', () => buildWebExtensions(false));
+gulp.task(compileWebExtensionsTask);
+exports.compileWebExtensionsTask = compileWebExtensionsTask;
+
+const watchWebExtensionsTask = task.define('watch-web', () => buildWebExtensions(true));
+gulp.task(watchWebExtensionsTask);
+exports.watchWebExtensionsTask = watchWebExtensionsTask;
+
+async function buildWebExtensions(isWatch) {
+
+	const webpackConfigLocations = await nodeUtil.promisify(glob)(
+		path.join(extensionsPath, '**', 'extension-browser.webpack.config.js'),
+		{ ignore: ['**/node_modules'] }
+	);
+
+	const webpackConfigs = [];
+
+	for (const webpackConfigPath of webpackConfigLocations) {
+		const configOrFnOrArray = require(webpackConfigPath);
+		function addConfig(configOrFn) {
+			if (typeof configOrFn === 'function') {
+				webpackConfigs.push(configOrFn({}, {}));
+			} else {
+				webpackConfigs.push(configOrFn);
+			}
+		}
+		addConfig(configOrFnOrArray);
+	}
+	function reporter(fullStats) {
+		if (Array.isArray(fullStats.children)) {
+			for (const stats of fullStats.children) {
+				const outputPath = stats.outputPath;
+				if (outputPath) {
+					const relativePath = path.relative(extensionsPath, outputPath).replace(/\\/g, '/');
+					const match = relativePath.match(/[^\/]+(\/server|\/client)?/);
+					fancyLog(`Finished ${ansiColors.green('packaging web extension')} ${ansiColors.cyan(match[0])} with ${stats.errors.length} errors.`);
+				}
+				if (Array.isArray(stats.errors)) {
+					stats.errors.forEach(error => {
+						fancyLog.error(error);
+					});
+				}
+				if (Array.isArray(stats.warnings)) {
+					stats.warnings.forEach(warning => {
+						fancyLog.warn(warning);
+					});
+				}
+			}
+		}
+	}
+	return new Promise((resolve, reject) => {
+		if (isWatch) {
+			webpack(webpackConfigs).watch({}, (err, stats) => {
+				if (err) {
+					reject();
+				} else {
+					reporter(stats.toJson());
+				}
+			});
+		} else {
+			webpack(webpackConfigs).run((err, stats) => {
+				if (err) {
+					fancyLog.error(err);
+					reject();
+				} else {
+					reporter(stats.toJson());
+					resolve();
+				}
+			});
+		}
+	});
+}
+
+

lib/vscode/build/gulpfile.hygiene.js

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const gulp = require('gulp');
+const filter = require('gulp-filter');
+const es = require('event-stream');
+const gulpeslint = require('gulp-eslint');
+const vfs = require('vinyl-fs');
+const path = require('path');
+const task = require('./lib/task');
+const { all, jsHygieneFilter, tsHygieneFilter, hygiene } = require('./hygiene');
+
+gulp.task('eslint', () => {
+	return vfs
+		.src(all, { base: '.', follow: true, allowEmpty: true })
+		.pipe(filter(jsHygieneFilter.concat(tsHygieneFilter)))
+		.pipe(
+			gulpeslint({
+				configFile: '.eslintrc.json',
+				rulePaths: ['./build/lib/eslint'],
+			})
+		)
+		.pipe(gulpeslint.formatEach('compact'))
+		.pipe(
+			gulpeslint.results((results) => {
+				if (results.warningCount > 0 || results.errorCount > 0) {
+					throw new Error('eslint failed with warnings and/or errors');
+				}
+			})
+		);
+});
+
+function checkPackageJSON(actualPath) {
+	const actual = require(path.join(__dirname, '..', actualPath));
+	const rootPackageJSON = require('../package.json');
+
+	for (let depName in actual.dependencies) {
+		const depVersion = actual.dependencies[depName];
+		const rootDepVersion = rootPackageJSON.dependencies[depName];
+		if (!rootDepVersion) {
+			// missing in root is allowed
+			continue;
+		}
+		if (depVersion !== rootDepVersion) {
+			this.emit(
+				'error',
+				`The dependency ${depName} in '${actualPath}' (${depVersion}) is different than in the root package.json (${rootDepVersion})`
+			);
+		}
+	}
+}
+
+const checkPackageJSONTask = task.define('check-package-json', () => {
+	return gulp.src('package.json').pipe(
+		es.through(function () {
+			checkPackageJSON.call(this, 'remote/package.json');
+			checkPackageJSON.call(this, 'remote/web/package.json');
+		})
+	);
+});
+gulp.task(checkPackageJSONTask);
+
+gulp.task(
+	'hygiene',
+	task.series(checkPackageJSONTask, () => hygiene())
+);

lib/vscode/build/gulpfile.reh.js

@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const gulp = require('gulp');
+
+const path = require('path');
+const es = require('event-stream');
+const util = require('./lib/util');
+const task = require('./lib/task');
+const vfs = require('vinyl-fs');
+const flatmap = require('gulp-flatmap');
+const gunzip = require('gulp-gunzip');
+const untar = require('gulp-untar');
+const File = require('vinyl');
+const fs = require('fs');
+const remote = require('gulp-remote-retry-src');
+const rename = require('gulp-rename');
+const filter = require('gulp-filter');
+const cp = require('child_process');
+
+const REPO_ROOT = path.dirname(__dirname);
+
+const BUILD_TARGETS = [
+	{ platform: 'win32', arch: 'ia32', pkgTarget: 'node8-win-x86' },
+	{ platform: 'win32', arch: 'x64', pkgTarget: 'node8-win-x64' },
+	{ platform: 'darwin', arch: null, pkgTarget: 'node8-macos-x64' },
+	{ platform: 'linux', arch: 'ia32', pkgTarget: 'node8-linux-x86' },
+	{ platform: 'linux', arch: 'x64', pkgTarget: 'node8-linux-x64' },
+	{ platform: 'linux', arch: 'armhf', pkgTarget: 'node8-linux-armv7' },
+	{ platform: 'linux', arch: 'arm64', pkgTarget: 'node8-linux-arm64' },
+	{ platform: 'linux', arch: 'alpine', pkgTarget: 'node8-linux-alpine' },
+];
+
+const noop = () => { return Promise.resolve(); };
+
+BUILD_TARGETS.forEach(({ platform, arch }) => {
+	for (const target of ['reh', 'reh-web']) {
+		gulp.task(`vscode-${target}-${platform}${ arch ? `-${arch}` : '' }-min`, noop);
+	}
+});
+
+function getNodeVersion() {
+	const yarnrc = fs.readFileSync(path.join(REPO_ROOT, 'remote', '.yarnrc'), 'utf8');
+	const target = /^target "(.*)"$/m.exec(yarnrc)[1];
+	return target;
+}
+
+const nodeVersion = getNodeVersion();
+
+BUILD_TARGETS.forEach(({ platform, arch }) => {
+	if (platform === 'darwin') {
+		arch = 'x64';
+	}
+
+	gulp.task(task.define(`node-${platform}-${arch}`, () => {
+		const nodePath = path.join('.build', 'node', `v${nodeVersion}`, `${platform}-${arch}`);
+
+		if (!fs.existsSync(nodePath)) {
+			util.rimraf(nodePath);
+
+			return nodejs(platform, arch)
+				.pipe(vfs.dest(nodePath));
+		}
+
+		return Promise.resolve(null);
+	}));
+});
+
+const defaultNodeTask = gulp.task(`node-${process.platform}-${process.arch}`);
+
+if (defaultNodeTask) {
+	gulp.task(task.define('node', defaultNodeTask));
+}
+
+function nodejs(platform, arch) {
+	if (arch === 'ia32') {
+		arch = 'x86';
+	}
+
+	if (platform === 'win32') {
+		return remote(`/dist/v${nodeVersion}/win-${arch}/node.exe`, { base: 'https://nodejs.org' })
+			.pipe(rename('node.exe'));
+	}
+
+	if (arch === 'alpine') {
+		const contents = cp.execSync(`docker run --rm node:${nodeVersion}-alpine /bin/sh -c 'cat \`which node\`'`, { maxBuffer: 100 * 1024 * 1024, encoding: 'buffer' });
+		return es.readArray([new File({ path: 'node', contents, stat: { mode: parseInt('755', 8) } })]);
+	}
+
+	if (platform === 'darwin') {
+		arch = 'x64';
+	}
+
+	if (arch === 'armhf') {
+		arch = 'armv7l';
+	}
+
+	return remote(`/dist/v${nodeVersion}/node-v${nodeVersion}-${platform}-${arch}.tar.gz`, { base: 'https://nodejs.org' })
+		.pipe(flatmap(stream => stream.pipe(gunzip()).pipe(untar())))
+		.pipe(filter('**/node'))
+		.pipe(util.setExecutableBit('**'))
+		.pipe(rename('node'));
+}
+
+function mixinServer(watch) {
+	const packageJSONPath = path.join(path.dirname(__dirname), 'package.json');
+	function exec(cmdLine) {
+		console.log(cmdLine);
+		cp.execSync(cmdLine, { stdio: 'inherit' });
+	}
+	function checkout() {
+		const packageJSON = JSON.parse(fs.readFileSync(packageJSONPath).toString());
+		exec('git fetch distro');
+		exec(`git checkout ${packageJSON['distro']} -- src/vs/server resources/server`);
+		exec('git reset HEAD src/vs/server resources/server');
+	}
+	checkout();
+	if (watch) {
+		console.log('Enter watch mode (observing package.json)');
+		const watcher = fs.watch(packageJSONPath);
+		watcher.addListener('change', () => {
+			try {
+				checkout();
+			} catch (e) {
+				console.log(e);
+			}
+		});
+	}
+	return Promise.resolve();
+}
+
+gulp.task(task.define('mixin-server', () => mixinServer(false)));
+gulp.task(task.define('mixin-server-watch', () => mixinServer(true)));

lib/vscode/build/gulpfile.vscode.js

@@ -0,0 +1,546 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const gulp = require('gulp');
+const fs = require('fs');
+const os = require('os');
+const cp = require('child_process');
+const path = require('path');
+const es = require('event-stream');
+const azure = require('gulp-azure-storage');
+const electron = require('gulp-atom-electron');
+const vfs = require('vinyl-fs');
+const rename = require('gulp-rename');
+const replace = require('gulp-replace');
+const filter = require('gulp-filter');
+const json = require('gulp-json-editor');
+const _ = require('underscore');
+const util = require('./lib/util');
+const task = require('./lib/task');
+const buildfile = require('../src/buildfile');
+const common = require('./lib/optimize');
+const root = path.dirname(__dirname);
+const commit = util.getVersion(root);
+const packageJson = require('../package.json');
+const product = require('../product.json');
+const crypto = require('crypto');
+const i18n = require('./lib/i18n');
+const deps = require('./dependencies');
+const { config } = require('./lib/electron');
+const createAsar = require('./lib/asar').createAsar;
+const minimist = require('minimist');
+const { compileBuildTask } = require('./gulpfile.compile');
+const { compileExtensionsBuildTask } = require('./gulpfile.extensions');
+
+const productionDependencies = deps.getProductionDependencies(path.dirname(__dirname));
+
+// Build
+const vscodeEntryPoints = _.flatten([
+	buildfile.entrypoint('vs/workbench/workbench.desktop.main'),
+	buildfile.base,
+	buildfile.workerExtensionHost,
+	buildfile.workerNotebook,
+	buildfile.workbenchDesktop,
+	buildfile.code
+]);
+
+const vscodeResources = [
+	'out-build/main.js',
+	'out-build/cli.js',
+	'out-build/driver.js',
+	'out-build/bootstrap.js',
+	'out-build/bootstrap-fork.js',
+	'out-build/bootstrap-amd.js',
+	'out-build/bootstrap-node.js',
+	'out-build/bootstrap-window.js',
+	'out-build/paths.js',
+	'out-build/vs/**/*.{svg,png,html}',
+	'!out-build/vs/code/browser/**/*.html',
+	'!out-build/vs/editor/standalone/**/*.svg',
+	'out-build/vs/base/common/performance.js',
+	'out-build/vs/base/node/languagePacks.js',
+	'out-build/vs/base/node/{stdForkStart.js,terminateProcess.sh,cpuUsage.sh,ps.sh}',
+	'out-build/vs/base/browser/ui/codicons/codicon/**',
+	'out-build/vs/base/parts/sandbox/electron-browser/preload.js',
+	'out-build/vs/workbench/browser/media/*-theme.css',
+	'out-build/vs/workbench/contrib/debug/**/*.json',
+	'out-build/vs/workbench/contrib/externalTerminal/**/*.scpt',
+	'out-build/vs/workbench/contrib/webview/browser/pre/*.js',
+	'out-build/vs/workbench/contrib/webview/electron-browser/pre/*.js',
+	'out-build/vs/workbench/services/extensions/worker/extensionHostWorkerMain.js',
+	'out-build/vs/**/markdown.css',
+	'out-build/vs/workbench/contrib/tasks/**/*.json',
+	'out-build/vs/platform/files/**/*.exe',
+	'out-build/vs/platform/files/**/*.md',
+	'out-build/vs/code/electron-browser/workbench/**',
+	'out-build/vs/code/electron-browser/sharedProcess/sharedProcess.js',
+	'out-build/vs/code/electron-sandbox/issue/issueReporter.js',
+	'out-build/vs/code/electron-sandbox/processExplorer/processExplorer.js',
+	'out-build/vs/code/electron-sandbox/proxy/auth.js',
+	'!**/test/**'
+];
+
+const optimizeVSCodeTask = task.define('optimize-vscode', task.series(
+	util.rimraf('out-vscode'),
+	common.optimizeTask({
+		src: 'out-build',
+		entryPoints: vscodeEntryPoints,
+		resources: vscodeResources,
+		loaderConfig: common.loaderConfig(),
+		out: 'out-vscode',
+		bundleInfo: undefined
+	})
+));
+gulp.task(optimizeVSCodeTask);
+
+const sourceMappingURLBase = `https://ticino.blob.core.windows.net/sourcemaps/${commit}`;
+const minifyVSCodeTask = task.define('minify-vscode', task.series(
+	optimizeVSCodeTask,
+	util.rimraf('out-vscode-min'),
+	common.minifyTask('out-vscode', `${sourceMappingURLBase}/core`)
+));
+gulp.task(minifyVSCodeTask);
+
+/**
+ * Compute checksums for some files.
+ *
+ * @param {string} out The out folder to read the file from.
+ * @param {string[]} filenames The paths to compute a checksum for.
+ * @return {Object} A map of paths to checksums.
+ */
+function computeChecksums(out, filenames) {
+	let result = {};
+	filenames.forEach(function (filename) {
+		let fullPath = path.join(process.cwd(), out, filename);
+		result[filename] = computeChecksum(fullPath);
+	});
+	return result;
+}
+
+/**
+ * Compute checksum for a file.
+ *
+ * @param {string} filename The absolute path to a filename.
+ * @return {string} The checksum for `filename`.
+ */
+function computeChecksum(filename) {
+	let contents = fs.readFileSync(filename);
+
+	let hash = crypto
+		.createHash('md5')
+		.update(contents)
+		.digest('base64')
+		.replace(/=+$/, '');
+
+	return hash;
+}
+
+function packageTask(platform, arch, sourceFolderName, destinationFolderName, opts) {
+	opts = opts || {};
+
+	const destination = path.join(path.dirname(root), destinationFolderName);
+	platform = platform || process.platform;
+
+	return () => {
+		const out = sourceFolderName;
+
+		const checksums = computeChecksums(out, [
+			'vs/base/parts/sandbox/electron-browser/preload.js',
+			'vs/workbench/workbench.desktop.main.js',
+			'vs/workbench/workbench.desktop.main.css',
+			'vs/workbench/services/extensions/node/extensionHostProcess.js',
+			'vs/code/electron-browser/workbench/workbench.html',
+			'vs/code/electron-browser/workbench/workbench.js'
+		]);
+
+		const src = gulp.src(out + '/**', { base: '.' })
+			.pipe(rename(function (path) { path.dirname = path.dirname.replace(new RegExp('^' + out), 'out'); }))
+			.pipe(util.setExecutableBit(['**/*.sh']));
+
+		const extensions = gulp.src('.build/extensions/**', { base: '.build', dot: true });
+
+		const sources = es.merge(src, extensions)
+			.pipe(filter(['**', '!**/*.js.map'], { dot: true }));
+
+		let version = packageJson.version;
+		const quality = product.quality;
+
+		if (quality && quality !== 'stable') {
+			version += '-' + quality;
+		}
+
+		const name = product.nameShort;
+		const packageJsonUpdates = { name, version };
+
+		// for linux url handling
+		if (platform === 'linux') {
+			packageJsonUpdates.desktopName = `${product.applicationName}-url-handler.desktop`;
+		}
+
+		const packageJsonStream = gulp.src(['package.json'], { base: '.' })
+			.pipe(json(packageJsonUpdates));
+
+		const date = new Date().toISOString();
+		const productJsonUpdate = { commit, date, checksums };
+
+		if (shouldSetupSettingsSearch()) {
+			productJsonUpdate.settingsSearchBuildId = getSettingsSearchBuildId(packageJson);
+		}
+
+		const productJsonStream = gulp.src(['product.json'], { base: '.' })
+			.pipe(json(productJsonUpdate));
+
+		const license = gulp.src(['LICENSES.chromium.html', product.licenseFileName, 'ThirdPartyNotices.txt', 'licenses/**'], { base: '.', allowEmpty: true });
+
+		// TODO the API should be copied to `out` during compile, not here
+		const api = gulp.src('src/vs/vscode.d.ts').pipe(rename('out/vs/vscode.d.ts'));
+
+		const telemetry = gulp.src('.build/telemetry/**', { base: '.build/telemetry', dot: true });
+
+		const jsFilter = util.filter(data => !data.isDirectory() &&/\.js$/.test(data.path));
+		const root = path.resolve(path.join(__dirname, '..'));
+		const dependenciesSrc = _.flatten(productionDependencies.map(d => path.relative(root, d.path)).map(d => [`${d}/**`, `!${d}/**/{test,tests}/**`]));
+
+		const deps = gulp.src(dependenciesSrc, { base: '.', dot: true })
+			.pipe(filter(['**', '!**/package-lock.json', '!**/yarn.lock', '!**/*.js.map']))
+			.pipe(util.cleanNodeModules(path.join(__dirname, '.nativeignore')))
+			.pipe(util.cleanNodeModules(path.join(__dirname, '.moduleignore')))
+			.pipe(jsFilter)
+			.pipe(util.rewriteSourceMappingURL(sourceMappingURLBase))
+			.pipe(jsFilter.restore)
+			.pipe(createAsar(path.join(process.cwd(), 'node_modules'), ['**/*.node', '**/vscode-ripgrep/bin/*', '**/node-pty/build/Release/*', '**/*.wasm'], 'node_modules.asar'));
+
+		let all = es.merge(
+			packageJsonStream,
+			productJsonStream,
+			license,
+			api,
+			telemetry,
+			sources,
+			deps
+		);
+
+		if (platform === 'win32') {
+			all = es.merge(all, gulp.src([
+				'resources/win32/bower.ico',
+				'resources/win32/c.ico',
+				'resources/win32/config.ico',
+				'resources/win32/cpp.ico',
+				'resources/win32/csharp.ico',
+				'resources/win32/css.ico',
+				'resources/win32/default.ico',
+				'resources/win32/go.ico',
+				'resources/win32/html.ico',
+				'resources/win32/jade.ico',
+				'resources/win32/java.ico',
+				'resources/win32/javascript.ico',
+				'resources/win32/json.ico',
+				'resources/win32/less.ico',
+				'resources/win32/markdown.ico',
+				'resources/win32/php.ico',
+				'resources/win32/powershell.ico',
+				'resources/win32/python.ico',
+				'resources/win32/react.ico',
+				'resources/win32/ruby.ico',
+				'resources/win32/sass.ico',
+				'resources/win32/shell.ico',
+				'resources/win32/sql.ico',
+				'resources/win32/typescript.ico',
+				'resources/win32/vue.ico',
+				'resources/win32/xml.ico',
+				'resources/win32/yaml.ico',
+				'resources/win32/code_70x70.png',
+				'resources/win32/code_150x150.png'
+			], { base: '.' }));
+		} else if (platform === 'linux') {
+			all = es.merge(all, gulp.src('resources/linux/code.png', { base: '.' }));
+		} else if (platform === 'darwin') {
+			const shortcut = gulp.src('resources/darwin/bin/code.sh')
+				.pipe(rename('bin/code'));
+
+			all = es.merge(all, shortcut);
+		}
+
+		let result = all
+			.pipe(util.skipDirectories())
+			.pipe(util.fixWin32DirectoryPermissions())
+			.pipe(electron(_.extend({}, config, { platform, arch: arch === 'armhf' ? 'arm' : arch, ffmpegChromium: true })))
+			.pipe(filter(['**', '!LICENSE', '!LICENSES.chromium.html', '!version'], { dot: true }));
+
+		if (platform === 'linux') {
+			result = es.merge(result, gulp.src('resources/completions/bash/code', { base: '.' })
+				.pipe(replace('@@APPNAME@@', product.applicationName))
+				.pipe(rename(function (f) { f.basename = product.applicationName; })));
+
+			result = es.merge(result, gulp.src('resources/completions/zsh/_code', { base: '.' })
+				.pipe(replace('@@APPNAME@@', product.applicationName))
+				.pipe(rename(function (f) { f.basename = '_' + product.applicationName; })));
+		}
+
+		if (platform === 'win32') {
+			result = es.merge(result, gulp.src('resources/win32/bin/code.js', { base: 'resources/win32', allowEmpty: true }));
+
+			result = es.merge(result, gulp.src('resources/win32/bin/code.cmd', { base: 'resources/win32' })
+				.pipe(replace('@@NAME@@', product.nameShort))
+				.pipe(rename(function (f) { f.basename = product.applicationName; })));
+
+			result = es.merge(result, gulp.src('resources/win32/bin/code.sh', { base: 'resources/win32' })
+				.pipe(replace('@@NAME@@', product.nameShort))
+				.pipe(replace('@@PRODNAME@@', product.nameLong))
+				.pipe(replace('@@VERSION@@', version))
+				.pipe(replace('@@COMMIT@@', commit))
+				.pipe(replace('@@APPNAME@@', product.applicationName))
+				.pipe(replace('@@DATAFOLDER@@', product.dataFolderName))
+				.pipe(replace('@@QUALITY@@', quality))
+				.pipe(rename(function (f) { f.basename = product.applicationName; f.extname = ''; })));
+
+			result = es.merge(result, gulp.src('resources/win32/VisualElementsManifest.xml', { base: 'resources/win32' })
+				.pipe(rename(product.nameShort + '.VisualElementsManifest.xml')));
+		} else if (platform === 'linux') {
+			result = es.merge(result, gulp.src('resources/linux/bin/code.sh', { base: '.' })
+				.pipe(replace('@@PRODNAME@@', product.nameLong))
+				.pipe(replace('@@NAME@@', product.applicationName))
+				.pipe(rename('bin/' + product.applicationName)));
+		}
+
+		// submit all stats that have been collected
+		// during the build phase
+		if (opts.stats) {
+			result.on('end', () => {
+				const { submitAllStats } = require('./lib/stats');
+				submitAllStats(product, commit).then(() => console.log('Submitted bundle stats!'));
+			});
+		}
+
+		return result.pipe(vfs.dest(destination));
+	};
+}
+
+const buildRoot = path.dirname(root);
+
+const BUILD_TARGETS = [
+	{ platform: 'win32', arch: 'ia32' },
+	{ platform: 'win32', arch: 'x64' },
+	{ platform: 'win32', arch: 'arm64' },
+	{ platform: 'darwin', arch: null, opts: { stats: true } },
+	{ platform: 'linux', arch: 'ia32' },
+	{ platform: 'linux', arch: 'x64' },
+	{ platform: 'linux', arch: 'armhf' },
+	{ platform: 'linux', arch: 'arm64' },
+];
+BUILD_TARGETS.forEach(buildTarget => {
+	const dashed = (str) => (str ? `-${str}` : ``);
+	const platform = buildTarget.platform;
+	const arch = buildTarget.arch;
+	const opts = buildTarget.opts;
+
+	['', 'min'].forEach(minified => {
+		const sourceFolderName = `out-vscode${dashed(minified)}`;
+		const destinationFolderName = `VSCode${dashed(platform)}${dashed(arch)}`;
+
+		const vscodeTaskCI = task.define(`vscode${dashed(platform)}${dashed(arch)}${dashed(minified)}-ci`, task.series(
+			util.rimraf(path.join(buildRoot, destinationFolderName)),
+			packageTask(platform, arch, sourceFolderName, destinationFolderName, opts)
+		));
+		gulp.task(vscodeTaskCI);
+
+		const vscodeTask = task.define(`vscode${dashed(platform)}${dashed(arch)}${dashed(minified)}`, task.series(
+			compileBuildTask,
+			compileExtensionsBuildTask,
+			minified ? minifyVSCodeTask : optimizeVSCodeTask,
+			vscodeTaskCI
+		));
+		gulp.task(vscodeTask);
+	});
+});
+
+// Transifex Localizations
+
+const innoSetupConfig = {
+	'zh-cn': { codePage: 'CP936', defaultInfo: { name: 'Simplified Chinese', id: '$0804', } },
+	'zh-tw': { codePage: 'CP950', defaultInfo: { name: 'Traditional Chinese', id: '$0404' } },
+	'ko': { codePage: 'CP949', defaultInfo: { name: 'Korean', id: '$0412' } },
+	'ja': { codePage: 'CP932' },
+	'de': { codePage: 'CP1252' },
+	'fr': { codePage: 'CP1252' },
+	'es': { codePage: 'CP1252' },
+	'ru': { codePage: 'CP1251' },
+	'it': { codePage: 'CP1252' },
+	'pt-br': { codePage: 'CP1252' },
+	'hu': { codePage: 'CP1250' },
+	'tr': { codePage: 'CP1254' }
+};
+
+const apiHostname = process.env.TRANSIFEX_API_URL;
+const apiName = process.env.TRANSIFEX_API_NAME;
+const apiToken = process.env.TRANSIFEX_API_TOKEN;
+
+gulp.task(task.define(
+	'vscode-translations-push',
+	task.series(
+		compileBuildTask,
+		compileExtensionsBuildTask,
+		optimizeVSCodeTask,
+		function () {
+			const pathToMetadata = './out-vscode/nls.metadata.json';
+			const pathToExtensions = '.build/extensions/*';
+			const pathToSetup = 'build/win32/**/{Default.isl,messages.en.isl}';
+
+			return es.merge(
+				gulp.src(pathToMetadata).pipe(i18n.createXlfFilesForCoreBundle()),
+				gulp.src(pathToSetup).pipe(i18n.createXlfFilesForIsl()),
+				gulp.src(pathToExtensions).pipe(i18n.createXlfFilesForExtensions())
+			).pipe(i18n.findObsoleteResources(apiHostname, apiName, apiToken)
+			).pipe(i18n.pushXlfFiles(apiHostname, apiName, apiToken));
+		}
+	)
+));
+
+gulp.task(task.define(
+	'vscode-translations-export',
+	task.series(
+		compileBuildTask,
+		compileExtensionsBuildTask,
+		optimizeVSCodeTask,
+		function () {
+			const pathToMetadata = './out-vscode/nls.metadata.json';
+			const pathToExtensions = '.build/extensions/*';
+			const pathToSetup = 'build/win32/**/{Default.isl,messages.en.isl}';
+
+			return es.merge(
+				gulp.src(pathToMetadata).pipe(i18n.createXlfFilesForCoreBundle()),
+				gulp.src(pathToSetup).pipe(i18n.createXlfFilesForIsl()),
+				gulp.src(pathToExtensions).pipe(i18n.createXlfFilesForExtensions())
+			).pipe(vfs.dest('../vscode-translations-export'));
+		}
+	)
+));
+
+gulp.task('vscode-translations-pull', function () {
+	return es.merge([...i18n.defaultLanguages, ...i18n.extraLanguages].map(language => {
+		let includeDefault = !!innoSetupConfig[language.id].defaultInfo;
+		return i18n.pullSetupXlfFiles(apiHostname, apiName, apiToken, language, includeDefault).pipe(vfs.dest(`../vscode-translations-import/${language.id}/setup`));
+	}));
+});
+
+gulp.task('vscode-translations-import', function () {
+	let options = minimist(process.argv.slice(2), {
+		string: 'location',
+		default: {
+			location: '../vscode-translations-import'
+		}
+	});
+	return es.merge([...i18n.defaultLanguages, ...i18n.extraLanguages].map(language => {
+		let id = language.transifexId || language.id;
+		return gulp.src(`${options.location}/${id}/setup/*/*.xlf`)
+			.pipe(i18n.prepareIslFiles(language, innoSetupConfig[language.id]))
+			.pipe(vfs.dest(`./build/win32/i18n`));
+	}));
+});
+
+// This task is only run for the MacOS build
+const generateVSCodeConfigurationTask = task.define('generate-vscode-configuration', () => {
+	return new Promise((resolve, reject) => {
+		const buildDir = process.env['AGENT_BUILDDIRECTORY'];
+		if (!buildDir) {
+			return reject(new Error('$AGENT_BUILDDIRECTORY not set'));
+		}
+
+		if (process.env.VSCODE_QUALITY !== 'insider' && process.env.VSCODE_QUALITY !== 'stable') {
+			return resolve();
+		}
+
+		const userDataDir = path.join(os.tmpdir(), 'tmpuserdata');
+		const extensionsDir = path.join(os.tmpdir(), 'tmpextdir');
+		const appName = process.env.VSCODE_QUALITY === 'insider' ? 'Visual\\ Studio\\ Code\\ -\\ Insiders.app' : 'Visual\\ Studio\\ Code.app';
+		const appPath = path.join(buildDir, `VSCode-darwin/${appName}/Contents/Resources/app/bin/code`);
+		const codeProc = cp.exec(
+			`${appPath} --export-default-configuration='${allConfigDetailsPath}' --wait --user-data-dir='${userDataDir}' --extensions-dir='${extensionsDir}'`,
+			(err, stdout, stderr) => {
+				clearTimeout(timer);
+				if (err) {
+					console.log(`err: ${err} ${err.message} ${err.toString()}`);
+					reject(err);
+				}
+
+				if (stdout) {
+					console.log(`stdout: ${stdout}`);
+				}
+
+				if (stderr) {
+					console.log(`stderr: ${stderr}`);
+				}
+
+				resolve();
+			}
+		);
+		const timer = setTimeout(() => {
+			codeProc.kill();
+			reject(new Error('export-default-configuration process timed out'));
+		}, 12 * 1000);
+
+		codeProc.on('error', err => {
+			clearTimeout(timer);
+			reject(err);
+		});
+	});
+});
+
+const allConfigDetailsPath = path.join(os.tmpdir(), 'configuration.json');
+gulp.task(task.define(
+	'upload-vscode-configuration',
+	task.series(
+		generateVSCodeConfigurationTask,
+		() => {
+			if (!shouldSetupSettingsSearch()) {
+				const branch = process.env.BUILD_SOURCEBRANCH;
+				console.log(`Only runs on master and release branches, not ${branch}`);
+				return;
+			}
+
+			if (!fs.existsSync(allConfigDetailsPath)) {
+				throw new Error(`configuration file at ${allConfigDetailsPath} does not exist`);
+			}
+
+			const settingsSearchBuildId = getSettingsSearchBuildId(packageJson);
+			if (!settingsSearchBuildId) {
+				throw new Error('Failed to compute build number');
+			}
+
+			return gulp.src(allConfigDetailsPath)
+				.pipe(azure.upload({
+					account: process.env.AZURE_STORAGE_ACCOUNT,
+					key: process.env.AZURE_STORAGE_ACCESS_KEY,
+					container: 'configuration',
+					prefix: `${settingsSearchBuildId}/${commit}/`
+				}));
+		}
+	)
+));
+
+function shouldSetupSettingsSearch() {
+	const branch = process.env.BUILD_SOURCEBRANCH;
+	return branch && (/\/master$/.test(branch) || branch.indexOf('/release/') >= 0);
+}
+
+function getSettingsSearchBuildId(packageJson) {
+	try {
+		const branch = process.env.BUILD_SOURCEBRANCH;
+		const branchId = branch.indexOf('/release/') >= 0 ? 0 :
+			/\/master$/.test(branch) ? 1 :
+				2; // Some unexpected branch
+
+		const out = cp.execSync(`git rev-list HEAD --count`);
+		const count = parseInt(out.toString());
+
+		// <version number><commit count><branchId (avoid unlikely conflicts)>
+		// 1.25.1, 1,234,567 commits, master = 1250112345671
+		return util.versionStringToNumber(packageJson.version) * 1e8 + count * 10 + branchId;
+	} catch (e) {
+		throw new Error('Could not determine build number: ' + e.toString());
+	}
+}

lib/vscode/build/gulpfile.vscode.linux.js

@@ -0,0 +1,278 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const gulp = require('gulp');
+const replace = require('gulp-replace');
+const rename = require('gulp-rename');
+const shell = require('gulp-shell');
+const es = require('event-stream');
+const vfs = require('vinyl-fs');
+const util = require('./lib/util');
+const task = require('./lib/task');
+const packageJson = require('../package.json');
+const product = require('../product.json');
+const rpmDependencies = require('../resources/linux/rpm/dependencies.json');
+const path = require('path');
+const root = path.dirname(__dirname);
+const commit = util.getVersion(root);
+
+const linuxPackageRevision = Math.floor(new Date().getTime() / 1000);
+
+function getDebPackageArch(arch) {
+	return { x64: 'amd64', armhf: 'armhf', arm64: 'arm64' }[arch];
+}
+
+function prepareDebPackage(arch) {
+	const binaryDir = '../VSCode-linux-' + arch;
+	const debArch = getDebPackageArch(arch);
+	const destination = '.build/linux/deb/' + debArch + '/' + product.applicationName + '-' + debArch;
+
+	return function () {
+		const desktop = gulp.src('resources/linux/code.desktop', { base: '.' })
+			.pipe(rename('usr/share/applications/' + product.applicationName + '.desktop'));
+
+		const desktopUrlHandler = gulp.src('resources/linux/code-url-handler.desktop', { base: '.' })
+			.pipe(rename('usr/share/applications/' + product.applicationName + '-url-handler.desktop'));
+
+		const desktops = es.merge(desktop, desktopUrlHandler)
+			.pipe(replace('@@NAME_LONG@@', product.nameLong))
+			.pipe(replace('@@NAME_SHORT@@', product.nameShort))
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(replace('@@EXEC@@', `/usr/share/${product.applicationName}/${product.applicationName}`))
+			.pipe(replace('@@ICON@@', product.linuxIconName))
+			.pipe(replace('@@URLPROTOCOL@@', product.urlProtocol));
+
+		const appdata = gulp.src('resources/linux/code.appdata.xml', { base: '.' })
+			.pipe(replace('@@NAME_LONG@@', product.nameLong))
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(replace('@@LICENSE@@', product.licenseName))
+			.pipe(rename('usr/share/appdata/' + product.applicationName + '.appdata.xml'));
+
+		const workspaceMime = gulp.src('resources/linux/code-workspace.xml', { base: '.' })
+			.pipe(replace('@@NAME_LONG@@', product.nameLong))
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(rename('usr/share/mime/packages/' + product.applicationName + '-workspace.xml'));
+
+		const icon = gulp.src('resources/linux/code.png', { base: '.' })
+			.pipe(rename('usr/share/pixmaps/' + product.linuxIconName + '.png'));
+
+		const bash_completion = gulp.src('resources/completions/bash/code')
+			.pipe(replace('@@APPNAME@@', product.applicationName))
+			.pipe(rename('usr/share/bash-completion/completions/' + product.applicationName));
+
+		const zsh_completion = gulp.src('resources/completions/zsh/_code')
+			.pipe(replace('@@APPNAME@@', product.applicationName))
+			.pipe(rename('usr/share/zsh/vendor-completions/_' + product.applicationName));
+
+		const code = gulp.src(binaryDir + '/**/*', { base: binaryDir })
+			.pipe(rename(function (p) { p.dirname = 'usr/share/' + product.applicationName + '/' + p.dirname; }));
+
+		let size = 0;
+		const control = code.pipe(es.through(
+			function (f) { size += f.isDirectory() ? 4096 : f.contents.length; },
+			function () {
+				const that = this;
+				gulp.src('resources/linux/debian/control.template', { base: '.' })
+					.pipe(replace('@@NAME@@', product.applicationName))
+					.pipe(replace('@@VERSION@@', packageJson.version + '-' + linuxPackageRevision))
+					.pipe(replace('@@ARCHITECTURE@@', debArch))
+					.pipe(replace('@@INSTALLEDSIZE@@', Math.ceil(size / 1024)))
+					.pipe(rename('DEBIAN/control'))
+					.pipe(es.through(function (f) { that.emit('data', f); }, function () { that.emit('end'); }));
+			}));
+
+		const prerm = gulp.src('resources/linux/debian/prerm.template', { base: '.' })
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(rename('DEBIAN/prerm'));
+
+		const postrm = gulp.src('resources/linux/debian/postrm.template', { base: '.' })
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(rename('DEBIAN/postrm'));
+
+		const postinst = gulp.src('resources/linux/debian/postinst.template', { base: '.' })
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(replace('@@ARCHITECTURE@@', debArch))
+			.pipe(replace('@@QUALITY@@', product.quality || '@@QUALITY@@'))
+			.pipe(replace('@@UPDATEURL@@', product.updateUrl || '@@UPDATEURL@@'))
+			.pipe(rename('DEBIAN/postinst'));
+
+		const all = es.merge(control, postinst, postrm, prerm, desktops, appdata, workspaceMime, icon, bash_completion, zsh_completion, code);
+
+		return all.pipe(vfs.dest(destination));
+	};
+}
+
+function buildDebPackage(arch) {
+	const debArch = getDebPackageArch(arch);
+	return shell.task([
+		'chmod 755 ' + product.applicationName + '-' + debArch + '/DEBIAN/postinst ' + product.applicationName + '-' + debArch + '/DEBIAN/prerm ' + product.applicationName + '-' + debArch + '/DEBIAN/postrm',
+		'mkdir -p deb',
+		'fakeroot dpkg-deb -b ' + product.applicationName + '-' + debArch + ' deb'
+	], { cwd: '.build/linux/deb/' + debArch });
+}
+
+function getRpmBuildPath(rpmArch) {
+	return '.build/linux/rpm/' + rpmArch + '/rpmbuild';
+}
+
+function getRpmPackageArch(arch) {
+	return { x64: 'x86_64', armhf: 'armv7hl', arm64: 'aarch64' }[arch];
+}
+
+function prepareRpmPackage(arch) {
+	const binaryDir = '../VSCode-linux-' + arch;
+	const rpmArch = getRpmPackageArch(arch);
+
+	return function () {
+		const desktop = gulp.src('resources/linux/code.desktop', { base: '.' })
+			.pipe(rename('BUILD/usr/share/applications/' + product.applicationName + '.desktop'));
+
+		const desktopUrlHandler = gulp.src('resources/linux/code-url-handler.desktop', { base: '.' })
+			.pipe(rename('BUILD/usr/share/applications/' + product.applicationName + '-url-handler.desktop'));
+
+		const desktops = es.merge(desktop, desktopUrlHandler)
+			.pipe(replace('@@NAME_LONG@@', product.nameLong))
+			.pipe(replace('@@NAME_SHORT@@', product.nameShort))
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(replace('@@EXEC@@', `/usr/share/${product.applicationName}/${product.applicationName}`))
+			.pipe(replace('@@ICON@@', product.linuxIconName))
+			.pipe(replace('@@URLPROTOCOL@@', product.urlProtocol));
+
+		const appdata = gulp.src('resources/linux/code.appdata.xml', { base: '.' })
+			.pipe(replace('@@NAME_LONG@@', product.nameLong))
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(replace('@@LICENSE@@', product.licenseName))
+			.pipe(rename('usr/share/appdata/' + product.applicationName + '.appdata.xml'));
+
+		const workspaceMime = gulp.src('resources/linux/code-workspace.xml', { base: '.' })
+			.pipe(replace('@@NAME_LONG@@', product.nameLong))
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(rename('BUILD/usr/share/mime/packages/' + product.applicationName + '-workspace.xml'));
+
+		const icon = gulp.src('resources/linux/code.png', { base: '.' })
+			.pipe(rename('BUILD/usr/share/pixmaps/' + product.linuxIconName + '.png'));
+
+		const bash_completion = gulp.src('resources/completions/bash/code')
+			.pipe(replace('@@APPNAME@@', product.applicationName))
+			.pipe(rename('BUILD/usr/share/bash-completion/completions/' + product.applicationName));
+
+		const zsh_completion = gulp.src('resources/completions/zsh/_code')
+			.pipe(replace('@@APPNAME@@', product.applicationName))
+			.pipe(rename('BUILD/usr/share/zsh/site-functions/_' + product.applicationName));
+
+		const code = gulp.src(binaryDir + '/**/*', { base: binaryDir })
+			.pipe(rename(function (p) { p.dirname = 'BUILD/usr/share/' + product.applicationName + '/' + p.dirname; }));
+
+		const spec = gulp.src('resources/linux/rpm/code.spec.template', { base: '.' })
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(replace('@@NAME_LONG@@', product.nameLong))
+			.pipe(replace('@@ICON@@', product.linuxIconName))
+			.pipe(replace('@@VERSION@@', packageJson.version))
+			.pipe(replace('@@RELEASE@@', linuxPackageRevision))
+			.pipe(replace('@@ARCHITECTURE@@', rpmArch))
+			.pipe(replace('@@LICENSE@@', product.licenseName))
+			.pipe(replace('@@QUALITY@@', product.quality || '@@QUALITY@@'))
+			.pipe(replace('@@UPDATEURL@@', product.updateUrl || '@@UPDATEURL@@'))
+			.pipe(replace('@@DEPENDENCIES@@', rpmDependencies[rpmArch].join(', ')))
+			.pipe(rename('SPECS/' + product.applicationName + '.spec'));
+
+		const specIcon = gulp.src('resources/linux/rpm/code.xpm', { base: '.' })
+			.pipe(rename('SOURCES/' + product.applicationName + '.xpm'));
+
+		const all = es.merge(code, desktops, appdata, workspaceMime, icon, bash_completion, zsh_completion, spec, specIcon);
+
+		return all.pipe(vfs.dest(getRpmBuildPath(rpmArch)));
+	};
+}
+
+function buildRpmPackage(arch) {
+	const rpmArch = getRpmPackageArch(arch);
+	const rpmBuildPath = getRpmBuildPath(rpmArch);
+	const rpmOut = rpmBuildPath + '/RPMS/' + rpmArch;
+	const destination = '.build/linux/rpm/' + rpmArch;
+
+	return shell.task([
+		'mkdir -p ' + destination,
+		'HOME="$(pwd)/' + destination + '" fakeroot rpmbuild -bb ' + rpmBuildPath + '/SPECS/' + product.applicationName + '.spec --target=' + rpmArch,
+		'cp "' + rpmOut + '/$(ls ' + rpmOut + ')" ' + destination + '/'
+	]);
+}
+
+function getSnapBuildPath(arch) {
+	return `.build/linux/snap/${arch}/${product.applicationName}-${arch}`;
+}
+
+function prepareSnapPackage(arch) {
+	const binaryDir = '../VSCode-linux-' + arch;
+	const destination = getSnapBuildPath(arch);
+
+	return function () {
+		// A desktop file that is placed in snap/gui will be placed into meta/gui verbatim.
+		const desktop = gulp.src('resources/linux/code.desktop', { base: '.' })
+			.pipe(rename(`snap/gui/${product.applicationName}.desktop`));
+
+		// A desktop file that is placed in snap/gui will be placed into meta/gui verbatim.
+		const desktopUrlHandler = gulp.src('resources/linux/code-url-handler.desktop', { base: '.' })
+			.pipe(rename(`snap/gui/${product.applicationName}-url-handler.desktop`));
+
+		const desktops = es.merge(desktop, desktopUrlHandler)
+			.pipe(replace('@@NAME_LONG@@', product.nameLong))
+			.pipe(replace('@@NAME_SHORT@@', product.nameShort))
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(replace('@@EXEC@@', `${product.applicationName} --force-user-env`))
+			.pipe(replace('@@ICON@@', `\${SNAP}/meta/gui/${product.linuxIconName}.png`))
+			.pipe(replace('@@URLPROTOCOL@@', product.urlProtocol));
+
+		// An icon that is placed in snap/gui will be placed into meta/gui verbatim.
+		const icon = gulp.src('resources/linux/code.png', { base: '.' })
+			.pipe(rename(`snap/gui/${product.linuxIconName}.png`));
+
+		const code = gulp.src(binaryDir + '/**/*', { base: binaryDir })
+			.pipe(rename(function (p) { p.dirname = `usr/share/${product.applicationName}/${p.dirname}`; }));
+
+		const snapcraft = gulp.src('resources/linux/snap/snapcraft.yaml', { base: '.' })
+			.pipe(replace('@@NAME@@', product.applicationName))
+			.pipe(replace('@@VERSION@@', commit.substr(0, 8)))
+			.pipe(rename('snap/snapcraft.yaml'));
+
+		const electronLaunch = gulp.src('resources/linux/snap/electron-launch', { base: '.' })
+			.pipe(rename('electron-launch'));
+
+		const all = es.merge(desktops, icon, code, snapcraft, electronLaunch);
+
+		return all.pipe(vfs.dest(destination));
+	};
+}
+
+function buildSnapPackage(arch) {
+	const snapBuildPath = getSnapBuildPath(arch);
+	// Default target for snapcraft runs: pull, build, stage and prime, and finally assembles the snap.
+	return shell.task(`cd ${snapBuildPath} && snapcraft`);
+}
+
+const BUILD_TARGETS = [
+	{ arch: 'x64' },
+	{ arch: 'armhf' },
+	{ arch: 'arm64' },
+];
+
+BUILD_TARGETS.forEach(({ arch }) => {
+	const debArch = getDebPackageArch(arch);
+	const prepareDebTask = task.define(`vscode-linux-${arch}-prepare-deb`, task.series(util.rimraf(`.build/linux/deb/${debArch}`), prepareDebPackage(arch)));
+	const buildDebTask = task.define(`vscode-linux-${arch}-build-deb`, task.series(prepareDebTask, buildDebPackage(arch)));
+	gulp.task(buildDebTask);
+
+	const rpmArch = getRpmPackageArch(arch);
+	const prepareRpmTask = task.define(`vscode-linux-${arch}-prepare-rpm`, task.series(util.rimraf(`.build/linux/rpm/${rpmArch}`), prepareRpmPackage(arch)));
+	const buildRpmTask = task.define(`vscode-linux-${arch}-build-rpm`, task.series(prepareRpmTask, buildRpmPackage(arch)));
+	gulp.task(buildRpmTask);
+
+	const prepareSnapTask = task.define(`vscode-linux-${arch}-prepare-snap`, task.series(util.rimraf(`.build/linux/snap/${arch}`), prepareSnapPackage(arch)));
+	gulp.task(prepareSnapTask);
+	const buildSnapTask = task.define(`vscode-linux-${arch}-build-snap`, task.series(prepareSnapTask, buildSnapPackage(arch)));
+	gulp.task(buildSnapTask);
+});

lib/vscode/build/gulpfile.vscode.web.js

@@ -0,0 +1,16 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const gulp = require('gulp');
+
+const noop = () => { return Promise.resolve(); };
+
+gulp.task('minify-vscode-web', noop);
+gulp.task('vscode-web', noop);
+gulp.task('vscode-web-min', noop);
+gulp.task('vscode-web-ci', noop);
+gulp.task('vscode-web-min-ci', noop);

lib/vscode/build/gulpfile.vscode.win32.js

@@ -0,0 +1,163 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+const gulp = require('gulp');
+const path = require('path');
+const fs = require('fs');
+const assert = require('assert');
+const cp = require('child_process');
+const _7z = require('7zip')['7z'];
+const util = require('./lib/util');
+const task = require('./lib/task');
+const pkg = require('../package.json');
+const product = require('../product.json');
+const vfs = require('vinyl-fs');
+const rcedit = require('rcedit');
+const mkdirp = require('mkdirp');
+
+const repoPath = path.dirname(__dirname);
+const buildPath = arch => path.join(path.dirname(repoPath), `VSCode-win32-${arch}`);
+const zipDir = arch => path.join(repoPath, '.build', `win32-${arch}`, 'archive');
+const zipPath = arch => path.join(zipDir(arch), `VSCode-win32-${arch}.zip`);
+const setupDir = (arch, target) => path.join(repoPath, '.build', `win32-${arch}`, `${target}-setup`);
+const issPath = path.join(__dirname, 'win32', 'code.iss');
+const innoSetupPath = path.join(path.dirname(path.dirname(require.resolve('innosetup'))), 'bin', 'ISCC.exe');
+const signPS1 = path.join(repoPath, 'build', 'azure-pipelines', 'win32', 'sign.ps1');
+
+function packageInnoSetup(iss, options, cb) {
+	options = options || {};
+
+	const definitions = options.definitions || {};
+
+	if (process.argv.some(arg => arg === '--debug-inno')) {
+		definitions['Debug'] = 'true';
+	}
+
+	if (process.argv.some(arg => arg === '--sign')) {
+		definitions['Sign'] = 'true';
+	}
+
+	const keys = Object.keys(definitions);
+
+	keys.forEach(key => assert(typeof definitions[key] === 'string', `Missing value for '${key}' in Inno Setup package step`));
+
+	const defs = keys.map(key => `/d${key}=${definitions[key]}`);
+	const args = [
+		iss,
+		...defs,
+		`/sesrp=powershell.exe -ExecutionPolicy bypass ${signPS1} $f`
+	];
+
+	cp.spawn(innoSetupPath, args, { stdio: ['ignore', 'inherit', 'inherit'] })
+		.on('error', cb)
+		.on('exit', code => {
+			if (code === 0) {
+				cb(null);
+			} else {
+				cb(new Error(`InnoSetup returned exit code: ${code}`));
+			}
+		});
+}
+
+function buildWin32Setup(arch, target) {
+	if (target !== 'system' && target !== 'user') {
+		throw new Error('Invalid setup target');
+	}
+
+	return cb => {
+		const ia32AppId = target === 'system' ? product.win32AppId : product.win32UserAppId;
+		const x64AppId = target === 'system' ? product.win32x64AppId : product.win32x64UserAppId;
+		const arm64AppId = target === 'system' ? product.win32arm64AppId : product.win32arm64UserAppId;
+
+		const sourcePath = buildPath(arch);
+		const outputPath = setupDir(arch, target);
+		mkdirp.sync(outputPath);
+
+		const originalProductJsonPath = path.join(sourcePath, 'resources/app/product.json');
+		const productJsonPath = path.join(outputPath, 'product.json');
+		const productJson = JSON.parse(fs.readFileSync(originalProductJsonPath, 'utf8'));
+		productJson['target'] = target;
+		fs.writeFileSync(productJsonPath, JSON.stringify(productJson, undefined, '\t'));
+
+		const definitions = {
+			NameLong: product.nameLong,
+			NameShort: product.nameShort,
+			DirName: product.win32DirName,
+			Version: pkg.version,
+			RawVersion: pkg.version.replace(/-\w+$/, ''),
+			NameVersion: product.win32NameVersion + (target === 'user' ? ' (User)' : ''),
+			ExeBasename: product.nameShort,
+			RegValueName: product.win32RegValueName,
+			ShellNameShort: product.win32ShellNameShort,
+			AppMutex: product.win32MutexName,
+			Arch: arch,
+			AppId: { 'ia32': ia32AppId, 'x64': x64AppId, 'arm64': arm64AppId }[arch],
+			IncompatibleTargetAppId: { 'ia32': product.win32AppId, 'x64': product.win32x64AppId, 'arm64': product.win32arm64AppId }[arch],
+			IncompatibleArchAppId: { 'ia32': x64AppId, 'x64': ia32AppId, 'arm64': ia32AppId }[arch],
+			AppUserId: product.win32AppUserModelId,
+			ArchitecturesAllowed: { 'ia32': '', 'x64': 'x64', 'arm64': 'arm64' }[arch],
+			ArchitecturesInstallIn64BitMode: { 'ia32': '', 'x64': 'x64', 'arm64': 'arm64' }[arch],
+			SourceDir: sourcePath,
+			RepoDir: repoPath,
+			OutputDir: outputPath,
+			InstallTarget: target,
+			ProductJsonPath: productJsonPath
+		};
+
+		packageInnoSetup(issPath, { definitions }, cb);
+	};
+}
+
+function defineWin32SetupTasks(arch, target) {
+	const cleanTask = util.rimraf(setupDir(arch, target));
+	gulp.task(task.define(`vscode-win32-${arch}-${target}-setup`, task.series(cleanTask, buildWin32Setup(arch, target))));
+}
+
+defineWin32SetupTasks('ia32', 'system');
+defineWin32SetupTasks('x64', 'system');
+defineWin32SetupTasks('arm64', 'system');
+defineWin32SetupTasks('ia32', 'user');
+defineWin32SetupTasks('x64', 'user');
+defineWin32SetupTasks('arm64', 'user');
+
+function archiveWin32Setup(arch) {
+	return cb => {
+		const args = ['a', '-tzip', zipPath(arch), '-x!CodeSignSummary*.md', '.', '-r'];
+
+		cp.spawn(_7z, args, { stdio: 'inherit', cwd: buildPath(arch) })
+			.on('error', cb)
+			.on('exit', () => cb(null));
+	};
+}
+
+gulp.task(task.define('vscode-win32-ia32-archive', task.series(util.rimraf(zipDir('ia32')), archiveWin32Setup('ia32'))));
+gulp.task(task.define('vscode-win32-x64-archive', task.series(util.rimraf(zipDir('x64')), archiveWin32Setup('x64'))));
+gulp.task(task.define('vscode-win32-arm64-archive', task.series(util.rimraf(zipDir('arm64')), archiveWin32Setup('arm64'))));
+
+function copyInnoUpdater(arch) {
+	return () => {
+		return gulp.src('build/win32/{inno_updater.exe,vcruntime140.dll}', { base: 'build/win32' })
+			.pipe(vfs.dest(path.join(buildPath(arch), 'tools')));
+	};
+}
+
+function updateIcon(executablePath) {
+	return cb => {
+		const icon = path.join(repoPath, 'resources', 'win32', 'code.ico');
+		rcedit(executablePath, { icon }, cb);
+	};
+}
+
+gulp.task(task.define('vscode-win32-ia32-inno-updater', task.series(copyInnoUpdater('ia32'), updateIcon(path.join(buildPath('ia32'), 'tools', 'inno_updater.exe')))));
+gulp.task(task.define('vscode-win32-x64-inno-updater', task.series(copyInnoUpdater('x64'), updateIcon(path.join(buildPath('x64'), 'tools', 'inno_updater.exe')))));
+gulp.task(task.define('vscode-win32-arm64-inno-updater', task.series(copyInnoUpdater('arm64'), updateIcon(path.join(buildPath('arm64'), 'tools', 'inno_updater.exe')))));
+
+// CodeHelper.exe icon
+
+gulp.task(task.define('vscode-win32-ia32-code-helper', task.series(updateIcon(path.join(buildPath('ia32'), 'resources', 'app', 'out', 'vs', 'platform', 'files', 'node', 'watcher', 'win32', 'CodeHelper.exe')))));
+gulp.task(task.define('vscode-win32-x64-code-helper', task.series(updateIcon(path.join(buildPath('x64'), 'resources', 'app', 'out', 'vs', 'platform', 'files', 'node', 'watcher', 'win32', 'CodeHelper.exe')))));
+gulp.task(task.define('vscode-win32-arm64-code-helper', task.series(updateIcon(path.join(buildPath('arm64'), 'resources', 'app', 'out', 'vs', 'platform', 'files', 'node', 'watcher', 'win32', 'CodeHelper.exe')))));

lib/vscode/build/hygiene.js

@@ -0,0 +1,412 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const filter = require('gulp-filter');
+const es = require('event-stream');
+const gulpeslint = require('gulp-eslint');
+const tsfmt = require('typescript-formatter');
+const VinylFile = require('vinyl');
+const vfs = require('vinyl-fs');
+const path = require('path');
+const fs = require('fs');
+const pall = require('p-all');
+
+/**
+ * Hygiene works by creating cascading subsets of all our files and
+ * passing them through a sequence of checks. Here are the current subsets,
+ * named according to the checks performed on them. Each subset contains
+ * the following one, as described in mathematical notation:
+ *
+ * all ⊃ eol ⊇ indentation ⊃ copyright ⊃ typescript
+ */
+
+const all = [
+	'*',
+	'build/**/*',
+	'extensions/**/*',
+	'scripts/**/*',
+	'src/**/*',
+	'test/**/*',
+	'!test/**/out/**',
+	'!**/node_modules/**',
+];
+module.exports.all = all;
+
+const indentationFilter = [
+	'**',
+
+	// except specific files
+	'!**/ThirdPartyNotices.txt',
+	'!**/LICENSE.{txt,rtf}',
+	'!LICENSES.chromium.html',
+	'!**/LICENSE',
+	'!src/vs/nls.js',
+	'!src/vs/nls.build.js',
+	'!src/vs/css.js',
+	'!src/vs/css.build.js',
+	'!src/vs/loader.js',
+	'!src/vs/base/common/insane/insane.js',
+	'!src/vs/base/common/marked/marked.js',
+	'!src/vs/base/common/semver/semver.js',
+	'!src/vs/base/node/terminateProcess.sh',
+	'!src/vs/base/node/cpuUsage.sh',
+	'!test/unit/assert.js',
+	'!resources/linux/snap/electron-launch',
+
+	// except specific folders
+	'!test/automation/out/**',
+	'!test/smoke/out/**',
+	'!extensions/typescript-language-features/test-workspace/**',
+	'!extensions/vscode-api-tests/testWorkspace/**',
+	'!extensions/vscode-api-tests/testWorkspace2/**',
+	'!build/monaco/**',
+	'!build/win32/**',
+
+	// except multiple specific files
+	'!**/package.json',
+	'!**/yarn.lock',
+	'!**/yarn-error.log',
+
+	// except multiple specific folders
+	'!**/codicon/**',
+	'!**/fixtures/**',
+	'!**/lib/**',
+	'!extensions/**/out/**',
+	'!extensions/**/snippets/**',
+	'!extensions/**/syntaxes/**',
+	'!extensions/**/themes/**',
+	'!extensions/**/colorize-fixtures/**',
+
+	// except specific file types
+	'!src/vs/*/**/*.d.ts',
+	'!src/typings/**/*.d.ts',
+	'!extensions/**/*.d.ts',
+	'!**/*.{svg,exe,png,bmp,scpt,bat,cmd,cur,ttf,woff,eot,md,ps1,template,yaml,yml,d.ts.recipe,ico,icns,plist}',
+	'!build/{lib,download,darwin}/**/*.js',
+	'!build/**/*.sh',
+	'!build/azure-pipelines/**/*.js',
+	'!build/azure-pipelines/**/*.config',
+	'!**/Dockerfile',
+	'!**/Dockerfile.*',
+	'!**/*.Dockerfile',
+	'!**/*.dockerfile',
+	'!extensions/markdown-language-features/media/*.js',
+];
+
+const copyrightFilter = [
+	'**',
+	'!**/*.desktop',
+	'!**/*.json',
+	'!**/*.html',
+	'!**/*.template',
+	'!**/*.md',
+	'!**/*.bat',
+	'!**/*.cmd',
+	'!**/*.ico',
+	'!**/*.icns',
+	'!**/*.xml',
+	'!**/*.sh',
+	'!**/*.txt',
+	'!**/*.xpm',
+	'!**/*.opts',
+	'!**/*.disabled',
+	'!**/*.code-workspace',
+	'!**/*.js.map',
+	'!build/**/*.init',
+	'!resources/linux/snap/snapcraft.yaml',
+	'!resources/win32/bin/code.js',
+	'!resources/web/code-web.js',
+	'!resources/completions/**',
+	'!extensions/markdown-language-features/media/highlight.css',
+	'!extensions/html-language-features/server/src/modes/typescript/*',
+	'!extensions/*/server/bin/*',
+	'!src/vs/editor/test/node/classification/typescript-test.ts',
+];
+
+const jsHygieneFilter = [
+	'src/**/*.js',
+	'build/gulpfile.*.js',
+	'!src/vs/loader.js',
+	'!src/vs/css.js',
+	'!src/vs/nls.js',
+	'!src/vs/css.build.js',
+	'!src/vs/nls.build.js',
+	'!src/**/insane.js',
+	'!src/**/marked.js',
+	'!src/**/semver.js',
+	'!**/test/**',
+];
+module.exports.jsHygieneFilter = jsHygieneFilter;
+
+const tsHygieneFilter = [
+	'src/**/*.ts',
+	'test/**/*.ts',
+	'extensions/**/*.ts',
+	'!**/fixtures/**',
+	'!**/typings/**',
+	'!**/node_modules/**',
+	'!extensions/typescript-basics/test/colorize-fixtures/**',
+	'!extensions/vscode-api-tests/testWorkspace/**',
+	'!extensions/vscode-api-tests/testWorkspace2/**',
+	'!extensions/**/*.test.ts',
+	'!extensions/html-language-features/server/lib/jquery.d.ts',
+];
+module.exports.tsHygieneFilter = tsHygieneFilter;
+
+const copyrightHeaderLines = [
+	'/*---------------------------------------------------------------------------------------------',
+	' *  Copyright (c) Microsoft Corporation. All rights reserved.',
+	' *  Licensed under the MIT License. See License.txt in the project root for license information.',
+	' *--------------------------------------------------------------------------------------------*/',
+];
+
+function hygiene(some) {
+	let errorCount = 0;
+
+	const productJson = es.through(function (file) {
+		const product = JSON.parse(file.contents.toString('utf8'));
+
+		if (product.extensionsGallery) {
+			console.error(`product.json: Contains 'extensionsGallery'`);
+			errorCount++;
+		}
+
+		this.emit('data', file);
+	});
+
+	const indentation = es.through(function (file) {
+		const lines = file.contents.toString('utf8').split(/\r\n|\r|\n/);
+		file.__lines = lines;
+
+		lines.forEach((line, i) => {
+			if (/^\s*$/.test(line)) {
+				// empty or whitespace lines are OK
+			} else if (/^[\t]*[^\s]/.test(line)) {
+				// good indent
+			} else if (/^[\t]* \*/.test(line)) {
+				// block comment using an extra space
+			} else {
+				console.error(
+					file.relative + '(' + (i + 1) + ',1): Bad whitespace indentation'
+				);
+				errorCount++;
+			}
+		});
+
+		this.emit('data', file);
+	});
+
+	const copyrights = es.through(function (file) {
+		const lines = file.__lines;
+
+		for (let i = 0; i < copyrightHeaderLines.length; i++) {
+			if (lines[i] !== copyrightHeaderLines[i]) {
+				console.error(file.relative + ': Missing or bad copyright statement');
+				errorCount++;
+				break;
+			}
+		}
+
+		this.emit('data', file);
+	});
+
+	const formatting = es.map(function (file, cb) {
+		tsfmt
+			.processString(file.path, file.contents.toString('utf8'), {
+				verify: false,
+				tsfmt: true,
+				// verbose: true,
+				// keep checkJS happy
+				editorconfig: undefined,
+				replace: undefined,
+				tsconfig: undefined,
+				tsconfigFile: undefined,
+				tsfmtFile: undefined,
+				vscode: undefined,
+				vscodeFile: undefined,
+			})
+			.then(
+				(result) => {
+					let original = result.src.replace(/\r\n/gm, '\n');
+					let formatted = result.dest.replace(/\r\n/gm, '\n');
+
+					if (original !== formatted) {
+						console.error(
+							`File not formatted. Run the 'Format Document' command to fix it:`,
+							file.relative
+						);
+						errorCount++;
+					}
+					cb(null, file);
+				},
+				(err) => {
+					cb(err);
+				}
+			);
+	});
+
+	let input;
+
+	if (Array.isArray(some) || typeof some === 'string' || !some) {
+		const options = { base: '.', follow: true, allowEmpty: true };
+		if (some) {
+			input = vfs.src(some, options).pipe(filter(all)); // split this up to not unnecessarily filter all a second time
+		} else {
+			input = vfs.src(all, options);
+		}
+	} else {
+		input = some;
+	}
+
+	const productJsonFilter = filter('product.json', { restore: true });
+
+	const result = input
+		.pipe(filter((f) => !f.stat.isDirectory()))
+		.pipe(productJsonFilter)
+		.pipe(process.env['BUILD_SOURCEVERSION'] ? es.through() : productJson)
+		.pipe(productJsonFilter.restore)
+		.pipe(filter(indentationFilter))
+		.pipe(indentation)
+		.pipe(filter(copyrightFilter))
+		.pipe(copyrights);
+
+	const typescript = result.pipe(filter(tsHygieneFilter)).pipe(formatting);
+
+	const javascript = result
+		.pipe(filter(jsHygieneFilter.concat(tsHygieneFilter)))
+		.pipe(
+			gulpeslint({
+				configFile: '.eslintrc.json',
+				rulePaths: ['./build/lib/eslint'],
+			})
+		)
+		.pipe(gulpeslint.formatEach('compact'))
+		.pipe(
+			gulpeslint.results((results) => {
+				errorCount += results.warningCount;
+				errorCount += results.errorCount;
+			})
+		);
+
+	let count = 0;
+	return es.merge(typescript, javascript).pipe(
+		es.through(
+			function (data) {
+				count++;
+				if (process.env['TRAVIS'] && count % 10 === 0) {
+					process.stdout.write('.');
+				}
+				this.emit('data', data);
+			},
+			function () {
+				process.stdout.write('\n');
+				if (errorCount > 0) {
+					this.emit(
+						'error',
+						'Hygiene failed with ' +
+						errorCount +
+						` errors. Check 'build / gulpfile.hygiene.js'.`
+					);
+				} else {
+					this.emit('end');
+				}
+			}
+		)
+	);
+}
+
+module.exports.hygiene = hygiene;
+
+function createGitIndexVinyls(paths) {
+	const cp = require('child_process');
+	const repositoryPath = process.cwd();
+
+	const fns = paths.map((relativePath) => () =>
+		new Promise((c, e) => {
+			const fullPath = path.join(repositoryPath, relativePath);
+
+			fs.stat(fullPath, (err, stat) => {
+				if (err && err.code === 'ENOENT') {
+					// ignore deletions
+					return c(null);
+				} else if (err) {
+					return e(err);
+				}
+
+				cp.exec(
+					`git show :${relativePath}`,
+					{ maxBuffer: 2000 * 1024, encoding: 'buffer' },
+					(err, out) => {
+						if (err) {
+							return e(err);
+						}
+
+						c(
+							new VinylFile({
+								path: fullPath,
+								base: repositoryPath,
+								contents: out,
+								stat,
+							})
+						);
+					}
+				);
+			});
+		})
+	);
+
+	return pall(fns, { concurrency: 4 }).then((r) => r.filter((p) => !!p));
+}
+
+// this allows us to run hygiene as a git pre-commit hook
+if (require.main === module) {
+	const cp = require('child_process');
+
+	process.on('unhandledRejection', (reason, p) => {
+		console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
+		process.exit(1);
+	});
+
+	if (process.argv.length > 2) {
+		hygiene(process.argv.slice(2)).on('error', (err) => {
+			console.error();
+			console.error(err);
+			process.exit(1);
+		});
+	} else {
+		cp.exec(
+			'git diff --cached --name-only',
+			{ maxBuffer: 2000 * 1024 },
+			(err, out) => {
+				if (err) {
+					console.error();
+					console.error(err);
+					process.exit(1);
+				}
+
+				const some = out.split(/\r?\n/).filter((l) => !!l);
+
+				if (some.length > 0) {
+					console.log('Reading git index versions...');
+
+					createGitIndexVinyls(some)
+						.then(
+							(vinyls) =>
+								new Promise((c, e) =>
+									hygiene(es.readArray(vinyls))
+										.on('end', () => c())
+										.on('error', e)
+								)
+						)
+						.catch((err) => {
+							console.error();
+							console.error(err);
+							process.exit(1);
+						});
+				}
+			}
+		);
+	}
+}

lib/vscode/build/jsconfig.json

@@ -0,0 +1,15 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"target": "es2017",
+		"jsx": "preserve",
+		"checkJs": true
+	},
+	"include": [
+		"**/*.js"
+	],
+	"exclude": [
+		"node_modules",
+		"**/node_modules/*"
+	]
+}

lib/vscode/build/lib/asar.ts

@@ -0,0 +1,138 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as path from 'path';
+import * as es from 'event-stream';
+const pickle = require('chromium-pickle-js');
+const Filesystem = <typeof AsarFilesystem>require('asar/lib/filesystem');
+import * as VinylFile from 'vinyl';
+import * as minimatch from 'minimatch';
+
+declare class AsarFilesystem {
+	readonly header: unknown;
+	constructor(src: string);
+	insertDirectory(path: string, shouldUnpack?: boolean): unknown;
+	insertFile(path: string, shouldUnpack: boolean, file: { stat: { size: number; mode: number; }; }, options: {}): Promise<void>;
+}
+
+export function createAsar(folderPath: string, unpackGlobs: string[], destFilename: string): NodeJS.ReadWriteStream {
+
+	const shouldUnpackFile = (file: VinylFile): boolean => {
+		for (let i = 0; i < unpackGlobs.length; i++) {
+			if (minimatch(file.relative, unpackGlobs[i])) {
+				return true;
+			}
+		}
+		return false;
+	};
+
+	const filesystem = new Filesystem(folderPath);
+	const out: Buffer[] = [];
+
+	// Keep track of pending inserts
+	let pendingInserts = 0;
+	let onFileInserted = () => { pendingInserts--; };
+
+	// Do not insert twice the same directory
+	const seenDir: { [key: string]: boolean; } = {};
+	const insertDirectoryRecursive = (dir: string) => {
+		if (seenDir[dir]) {
+			return;
+		}
+
+		let lastSlash = dir.lastIndexOf('/');
+		if (lastSlash === -1) {
+			lastSlash = dir.lastIndexOf('\\');
+		}
+		if (lastSlash !== -1) {
+			insertDirectoryRecursive(dir.substring(0, lastSlash));
+		}
+		seenDir[dir] = true;
+		filesystem.insertDirectory(dir);
+	};
+
+	const insertDirectoryForFile = (file: string) => {
+		let lastSlash = file.lastIndexOf('/');
+		if (lastSlash === -1) {
+			lastSlash = file.lastIndexOf('\\');
+		}
+		if (lastSlash !== -1) {
+			insertDirectoryRecursive(file.substring(0, lastSlash));
+		}
+	};
+
+	const insertFile = (relativePath: string, stat: { size: number; mode: number; }, shouldUnpack: boolean) => {
+		insertDirectoryForFile(relativePath);
+		pendingInserts++;
+		// Do not pass `onFileInserted` directly because it gets overwritten below.
+		// Create a closure capturing `onFileInserted`.
+		filesystem.insertFile(relativePath, shouldUnpack, { stat: stat }, {}).then(() => onFileInserted(), () => onFileInserted());
+	};
+
+	return es.through(function (file) {
+		if (file.stat.isDirectory()) {
+			return;
+		}
+		if (!file.stat.isFile()) {
+			throw new Error(`unknown item in stream!`);
+		}
+		const shouldUnpack = shouldUnpackFile(file);
+		insertFile(file.relative, { size: file.contents.length, mode: file.stat.mode }, shouldUnpack);
+
+		if (shouldUnpack) {
+			// The file goes outside of xx.asar, in a folder xx.asar.unpacked
+			const relative = path.relative(folderPath, file.path);
+			this.queue(new VinylFile({
+				base: '.',
+				path: path.join(destFilename + '.unpacked', relative),
+				stat: file.stat,
+				contents: file.contents
+			}));
+		} else {
+			// The file goes inside of xx.asar
+			out.push(file.contents);
+		}
+	}, function () {
+
+		let finish = () => {
+			{
+				const headerPickle = pickle.createEmpty();
+				headerPickle.writeString(JSON.stringify(filesystem.header));
+				const headerBuf = headerPickle.toBuffer();
+
+				const sizePickle = pickle.createEmpty();
+				sizePickle.writeUInt32(headerBuf.length);
+				const sizeBuf = sizePickle.toBuffer();
+
+				out.unshift(headerBuf);
+				out.unshift(sizeBuf);
+			}
+
+			const contents = Buffer.concat(out);
+			out.length = 0;
+
+			this.queue(new VinylFile({
+				base: '.',
+				path: destFilename,
+				contents: contents
+			}));
+			this.queue(null);
+		};
+
+		// Call finish() only when all file inserts have finished...
+		if (pendingInserts === 0) {
+			finish();
+		} else {
+			onFileInserted = () => {
+				pendingInserts--;
+				if (pendingInserts === 0) {
+					finish();
+				}
+			};
+		}
+	});
+}

lib/vscode/build/lib/builtInExtensions.ts

@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as rimraf from 'rimraf';
+import * as es from 'event-stream';
+import * as rename from 'gulp-rename';
+import * as vfs from 'vinyl-fs';
+import * as ext from './extensions';
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+import { Stream } from 'stream';
+
+const mkdirp = require('mkdirp');
+
+interface IExtensionDefinition {
+	name: string;
+	version: string;
+	repo: string;
+	metadata: {
+		id: string;
+		publisherId: {
+			publisherId: string;
+			publisherName: string;
+			displayName: string;
+			flags: string;
+		};
+		publisherDisplayName: string;
+	}
+}
+
+const root = path.dirname(path.dirname(__dirname));
+const productjson = JSON.parse(fs.readFileSync(path.join(__dirname, '../../product.json'), 'utf8'));
+const builtInExtensions = <IExtensionDefinition[]>productjson.builtInExtensions;
+const webBuiltInExtensions = <IExtensionDefinition[]>productjson.webBuiltInExtensions;
+const controlFilePath = path.join(os.homedir(), '.vscode-oss-dev', 'extensions', 'control.json');
+const ENABLE_LOGGING = !process.env['VSCODE_BUILD_BUILTIN_EXTENSIONS_SILENCE_PLEASE'];
+
+function log(...messages: string[]): void {
+	if (ENABLE_LOGGING) {
+		fancyLog(...messages);
+	}
+}
+
+function getExtensionPath(extension: IExtensionDefinition): string {
+	return path.join(root, '.build', 'builtInExtensions', extension.name);
+}
+
+function isUpToDate(extension: IExtensionDefinition): boolean {
+	const packagePath = path.join(getExtensionPath(extension), 'package.json');
+
+	if (!fs.existsSync(packagePath)) {
+		return false;
+	}
+
+	const packageContents = fs.readFileSync(packagePath, { encoding: 'utf8' });
+
+	try {
+		const diskVersion = JSON.parse(packageContents).version;
+		return (diskVersion === extension.version);
+	} catch (err) {
+		return false;
+	}
+}
+
+function syncMarketplaceExtension(extension: IExtensionDefinition): Stream {
+	if (isUpToDate(extension)) {
+		log(ansiColors.blue('[marketplace]'), `${extension.name}@${extension.version}`, ansiColors.green('✔︎'));
+		return es.readArray([]);
+	}
+
+	rimraf.sync(getExtensionPath(extension));
+
+	return ext.fromMarketplace(extension.name, extension.version, extension.metadata)
+		.pipe(rename(p => p.dirname = `${extension.name}/${p.dirname}`))
+		.pipe(vfs.dest('.build/builtInExtensions'))
+		.on('end', () => log(ansiColors.blue('[marketplace]'), extension.name, ansiColors.green('✔︎')));
+}
+
+function syncExtension(extension: IExtensionDefinition, controlState: 'disabled' | 'marketplace'): Stream {
+	switch (controlState) {
+		case 'disabled':
+			log(ansiColors.blue('[disabled]'), ansiColors.gray(extension.name));
+			return es.readArray([]);
+
+		case 'marketplace':
+			return syncMarketplaceExtension(extension);
+
+		default:
+			if (!fs.existsSync(controlState)) {
+				log(ansiColors.red(`Error: Built-in extension '${extension.name}' is configured to run from '${controlState}' but that path does not exist.`));
+				return es.readArray([]);
+
+			} else if (!fs.existsSync(path.join(controlState, 'package.json'))) {
+				log(ansiColors.red(`Error: Built-in extension '${extension.name}' is configured to run from '${controlState}' but there is no 'package.json' file in that directory.`));
+				return es.readArray([]);
+			}
+
+			log(ansiColors.blue('[local]'), `${extension.name}: ${ansiColors.cyan(controlState)}`, ansiColors.green('✔︎'));
+			return es.readArray([]);
+	}
+}
+
+interface IControlFile {
+	[name: string]: 'disabled' | 'marketplace';
+}
+
+function readControlFile(): IControlFile {
+	try {
+		return JSON.parse(fs.readFileSync(controlFilePath, 'utf8'));
+	} catch (err) {
+		return {};
+	}
+}
+
+function writeControlFile(control: IControlFile): void {
+	mkdirp.sync(path.dirname(controlFilePath));
+	fs.writeFileSync(controlFilePath, JSON.stringify(control, null, 2));
+}
+
+export function getBuiltInExtensions(): Promise<void> {
+	log('Syncronizing built-in extensions...');
+	log(`You can manage built-in extensions with the ${ansiColors.cyan('--builtin')} flag`);
+
+	const control = readControlFile();
+	const streams: Stream[] = [];
+
+	for (const extension of [...builtInExtensions, ...webBuiltInExtensions]) {
+		let controlState = control[extension.name] || 'marketplace';
+		control[extension.name] = controlState;
+
+		streams.push(syncExtension(extension, controlState));
+	}
+
+	writeControlFile(control);
+
+	return new Promise((resolve, reject) => {
+		es.merge(streams)
+			.on('error', reject)
+			.on('end', resolve);
+	});
+}
+
+if (require.main === module) {
+	getBuiltInExtensions().then(() => process.exit(0)).catch(err => {
+		console.error(err);
+		process.exit(1);
+	});
+}

lib/vscode/build/lib/bundle.ts

@@ -0,0 +1,648 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as vm from 'vm';
+
+interface IPosition {
+	line: number;
+	col: number;
+}
+
+interface IBuildModuleInfo {
+	id: string;
+	path: string;
+	defineLocation: IPosition;
+	dependencies: string[];
+	shim: string;
+	exports: any;
+}
+
+interface IBuildModuleInfoMap {
+	[moduleId: string]: IBuildModuleInfo;
+}
+
+interface ILoaderPlugin {
+	write(pluginName: string, moduleName: string, write: ILoaderPluginWriteFunc): void;
+	writeFile(pluginName: string, entryPoint: string, req: ILoaderPluginReqFunc, write: (filename: string, contents: string) => void, config: any): void;
+	finishBuild(write: (filename: string, contents: string) => void): void;
+}
+
+interface ILoaderPluginWriteFunc {
+	(something: string): void;
+	getEntryPoint(): string;
+	asModule(moduleId: string, code: string): void;
+}
+
+interface ILoaderPluginReqFunc {
+	(something: string): void;
+	toUrl(something: string): string;
+}
+
+export interface IEntryPoint {
+	name: string;
+	include?: string[];
+	exclude?: string[];
+	prepend?: string[];
+	append?: string[];
+	dest?: string;
+}
+
+interface IEntryPointMap {
+	[moduleId: string]: IEntryPoint;
+}
+
+export interface IGraph {
+	[node: string]: string[];
+}
+
+interface INodeSet {
+	[node: string]: boolean;
+}
+
+export interface IFile {
+	path: string | null;
+	contents: string;
+}
+
+export interface IConcatFile {
+	dest: string;
+	sources: IFile[];
+}
+
+export interface IBundleData {
+	graph: IGraph;
+	bundles: { [moduleId: string]: string[]; };
+}
+
+export interface IBundleResult {
+	files: IConcatFile[];
+	cssInlinedResources: string[];
+	bundleData: IBundleData;
+}
+
+interface IPartialBundleResult {
+	files: IConcatFile[];
+	bundleData: IBundleData;
+}
+
+export interface ILoaderConfig {
+	isBuild?: boolean;
+	paths?: { [path: string]: any; };
+}
+
+/**
+ * Bundle `entryPoints` given config `config`.
+ */
+export function bundle(entryPoints: IEntryPoint[], config: ILoaderConfig, callback: (err: any, result: IBundleResult | null) => void): void {
+	const entryPointsMap: IEntryPointMap = {};
+	entryPoints.forEach((module: IEntryPoint) => {
+		entryPointsMap[module.name] = module;
+	});
+
+	const allMentionedModulesMap: { [modules: string]: boolean; } = {};
+	entryPoints.forEach((module: IEntryPoint) => {
+		allMentionedModulesMap[module.name] = true;
+		(module.include || []).forEach(function (includedModule) {
+			allMentionedModulesMap[includedModule] = true;
+		});
+		(module.exclude || []).forEach(function (excludedModule) {
+			allMentionedModulesMap[excludedModule] = true;
+		});
+	});
+
+
+	const code = require('fs').readFileSync(path.join(__dirname, '../../src/vs/loader.js'));
+	const r: Function = <any>vm.runInThisContext('(function(require, module, exports) { ' + code + '\n});');
+	const loaderModule = { exports: {} };
+	r.call({}, require, loaderModule, loaderModule.exports);
+
+	const loader: any = loaderModule.exports;
+	config.isBuild = true;
+	config.paths = config.paths || {};
+	if (!config.paths['vs/nls']) {
+		config.paths['vs/nls'] = 'out-build/vs/nls.build';
+	}
+	if (!config.paths['vs/css']) {
+		config.paths['vs/css'] = 'out-build/vs/css.build';
+	}
+	loader.config(config);
+
+	loader(['require'], (localRequire: any) => {
+		const resolvePath = (path: string) => {
+			const r = localRequire.toUrl(path);
+			if (!/\.js/.test(r)) {
+				return r + '.js';
+			}
+			return r;
+		};
+		for (const moduleId in entryPointsMap) {
+			const entryPoint = entryPointsMap[moduleId];
+			if (entryPoint.append) {
+				entryPoint.append = entryPoint.append.map(resolvePath);
+			}
+			if (entryPoint.prepend) {
+				entryPoint.prepend = entryPoint.prepend.map(resolvePath);
+			}
+		}
+	});
+
+	loader(Object.keys(allMentionedModulesMap), () => {
+		const modules = <IBuildModuleInfo[]>loader.getBuildInfo();
+		const partialResult = emitEntryPoints(modules, entryPointsMap);
+		const cssInlinedResources = loader('vs/css').getInlinedResources();
+		callback(null, {
+			files: partialResult.files,
+			cssInlinedResources: cssInlinedResources,
+			bundleData: partialResult.bundleData
+		});
+	}, (err: any) => callback(err, null));
+}
+
+function emitEntryPoints(modules: IBuildModuleInfo[], entryPoints: IEntryPointMap): IPartialBundleResult {
+	const modulesMap: IBuildModuleInfoMap = {};
+	modules.forEach((m: IBuildModuleInfo) => {
+		modulesMap[m.id] = m;
+	});
+
+	const modulesGraph: IGraph = {};
+	modules.forEach((m: IBuildModuleInfo) => {
+		modulesGraph[m.id] = m.dependencies;
+	});
+
+	const sortedModules = topologicalSort(modulesGraph);
+
+	let result: IConcatFile[] = [];
+	const usedPlugins: IPluginMap = {};
+	const bundleData: IBundleData = {
+		graph: modulesGraph,
+		bundles: {}
+	};
+
+	Object.keys(entryPoints).forEach((moduleToBundle: string) => {
+		const info = entryPoints[moduleToBundle];
+		const rootNodes = [moduleToBundle].concat(info.include || []);
+		const allDependencies = visit(rootNodes, modulesGraph);
+		const excludes: string[] = ['require', 'exports', 'module'].concat(info.exclude || []);
+
+		excludes.forEach((excludeRoot: string) => {
+			const allExcludes = visit([excludeRoot], modulesGraph);
+			Object.keys(allExcludes).forEach((exclude: string) => {
+				delete allDependencies[exclude];
+			});
+		});
+
+		const includedModules = sortedModules.filter((module: string) => {
+			return allDependencies[module];
+		});
+
+		bundleData.bundles[moduleToBundle] = includedModules;
+
+		const res = emitEntryPoint(
+			modulesMap,
+			modulesGraph,
+			moduleToBundle,
+			includedModules,
+			info.prepend || [],
+			info.append || [],
+			info.dest
+		);
+
+		result = result.concat(res.files);
+		for (const pluginName in res.usedPlugins) {
+			usedPlugins[pluginName] = usedPlugins[pluginName] || res.usedPlugins[pluginName];
+		}
+	});
+
+	Object.keys(usedPlugins).forEach((pluginName: string) => {
+		const plugin = usedPlugins[pluginName];
+		if (typeof plugin.finishBuild === 'function') {
+			const write = (filename: string, contents: string) => {
+				result.push({
+					dest: filename,
+					sources: [{
+						path: null,
+						contents: contents
+					}]
+				});
+			};
+			plugin.finishBuild(write);
+		}
+	});
+
+	return {
+		// TODO@TS 2.1.2
+		files: extractStrings(removeDuplicateTSBoilerplate(result)),
+		bundleData: bundleData
+	};
+}
+
+function extractStrings(destFiles: IConcatFile[]): IConcatFile[] {
+	const parseDefineCall = (moduleMatch: string, depsMatch: string) => {
+		const module = moduleMatch.replace(/^"|"$/g, '');
+		let deps = depsMatch.split(',');
+		deps = deps.map((dep) => {
+			dep = dep.trim();
+			dep = dep.replace(/^"|"$/g, '');
+			dep = dep.replace(/^'|'$/g, '');
+			let prefix: string | null = null;
+			let _path: string | null = null;
+			const pieces = dep.split('!');
+			if (pieces.length > 1) {
+				prefix = pieces[0] + '!';
+				_path = pieces[1];
+			} else {
+				prefix = '';
+				_path = pieces[0];
+			}
+
+			if (/^\.\//.test(_path) || /^\.\.\//.test(_path)) {
+				const res = path.join(path.dirname(module), _path).replace(/\\/g, '/');
+				return prefix + res;
+			}
+			return prefix + _path;
+		});
+		return {
+			module: module,
+			deps: deps
+		};
+	};
+
+	destFiles.forEach((destFile) => {
+		if (!/\.js$/.test(destFile.dest)) {
+			return;
+		}
+		if (/\.nls\.js$/.test(destFile.dest)) {
+			return;
+		}
+
+		// Do one pass to record the usage counts for each module id
+		const useCounts: { [moduleId: string]: number; } = {};
+		destFile.sources.forEach((source) => {
+			const matches = source.contents.match(/define\(("[^"]+"),\s*\[(((, )?("|')[^"']+("|'))+)\]/);
+			if (!matches) {
+				return;
+			}
+
+			const defineCall = parseDefineCall(matches[1], matches[2]);
+			useCounts[defineCall.module] = (useCounts[defineCall.module] || 0) + 1;
+			defineCall.deps.forEach((dep) => {
+				useCounts[dep] = (useCounts[dep] || 0) + 1;
+			});
+		});
+
+		const sortedByUseModules = Object.keys(useCounts);
+		sortedByUseModules.sort((a, b) => {
+			return useCounts[b] - useCounts[a];
+		});
+
+		const replacementMap: { [moduleId: string]: number; } = {};
+		sortedByUseModules.forEach((module, index) => {
+			replacementMap[module] = index;
+		});
+
+		destFile.sources.forEach((source) => {
+			source.contents = source.contents.replace(/define\(("[^"]+"),\s*\[(((, )?("|')[^"']+("|'))+)\]/, (_, moduleMatch, depsMatch) => {
+				const defineCall = parseDefineCall(moduleMatch, depsMatch);
+				return `define(__m[${replacementMap[defineCall.module]}/*${defineCall.module}*/], __M([${defineCall.deps.map(dep => replacementMap[dep] + '/*' + dep + '*/').join(',')}])`;
+			});
+		});
+
+		destFile.sources.unshift({
+			path: null,
+			contents: [
+				'(function() {',
+				`var __m = ${JSON.stringify(sortedByUseModules)};`,
+				`var __M = function(deps) {`,
+				`  var result = [];`,
+				`  for (var i = 0, len = deps.length; i < len; i++) {`,
+				`    result[i] = __m[deps[i]];`,
+				`  }`,
+				`  return result;`,
+				`};`
+			].join('\n')
+		});
+
+		destFile.sources.push({
+			path: null,
+			contents: '}).call(this);'
+		});
+	});
+	return destFiles;
+}
+
+function removeDuplicateTSBoilerplate(destFiles: IConcatFile[]): IConcatFile[] {
+	// Taken from typescript compiler => emitFiles
+	const BOILERPLATE = [
+		{ start: /^var __extends/, end: /^}\)\(\);$/ },
+		{ start: /^var __assign/, end: /^};$/ },
+		{ start: /^var __decorate/, end: /^};$/ },
+		{ start: /^var __metadata/, end: /^};$/ },
+		{ start: /^var __param/, end: /^};$/ },
+		{ start: /^var __awaiter/, end: /^};$/ },
+		{ start: /^var __generator/, end: /^};$/ },
+	];
+
+	destFiles.forEach((destFile) => {
+		const SEEN_BOILERPLATE: boolean[] = [];
+		destFile.sources.forEach((source) => {
+			const lines = source.contents.split(/\r\n|\n|\r/);
+			const newLines: string[] = [];
+			let IS_REMOVING_BOILERPLATE = false, END_BOILERPLATE: RegExp;
+
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i];
+				if (IS_REMOVING_BOILERPLATE) {
+					newLines.push('');
+					if (END_BOILERPLATE!.test(line)) {
+						IS_REMOVING_BOILERPLATE = false;
+					}
+				} else {
+					for (let j = 0; j < BOILERPLATE.length; j++) {
+						const boilerplate = BOILERPLATE[j];
+						if (boilerplate.start.test(line)) {
+							if (SEEN_BOILERPLATE[j]) {
+								IS_REMOVING_BOILERPLATE = true;
+								END_BOILERPLATE = boilerplate.end;
+							} else {
+								SEEN_BOILERPLATE[j] = true;
+							}
+						}
+					}
+					if (IS_REMOVING_BOILERPLATE) {
+						newLines.push('');
+					} else {
+						newLines.push(line);
+					}
+				}
+			}
+			source.contents = newLines.join('\n');
+		});
+	});
+
+	return destFiles;
+}
+
+interface IPluginMap {
+	[moduleId: string]: ILoaderPlugin;
+}
+
+interface IEmitEntryPointResult {
+	files: IConcatFile[];
+	usedPlugins: IPluginMap;
+}
+
+function emitEntryPoint(
+	modulesMap: IBuildModuleInfoMap,
+	deps: IGraph,
+	entryPoint: string,
+	includedModules: string[],
+	prepend: string[],
+	append: string[],
+	dest: string | undefined
+): IEmitEntryPointResult {
+	if (!dest) {
+		dest = entryPoint + '.js';
+	}
+	const mainResult: IConcatFile = {
+		sources: [],
+		dest: dest
+	},
+		results: IConcatFile[] = [mainResult];
+
+	const usedPlugins: IPluginMap = {};
+	const getLoaderPlugin = (pluginName: string): ILoaderPlugin => {
+		if (!usedPlugins[pluginName]) {
+			usedPlugins[pluginName] = modulesMap[pluginName].exports;
+		}
+		return usedPlugins[pluginName];
+	};
+
+	includedModules.forEach((c: string) => {
+		const bangIndex = c.indexOf('!');
+
+		if (bangIndex >= 0) {
+			const pluginName = c.substr(0, bangIndex);
+			const plugin = getLoaderPlugin(pluginName);
+			mainResult.sources.push(emitPlugin(entryPoint, plugin, pluginName, c.substr(bangIndex + 1)));
+			return;
+		}
+
+		const module = modulesMap[c];
+
+		if (module.path === 'empty:') {
+			return;
+		}
+
+		const contents = readFileAndRemoveBOM(module.path);
+
+		if (module.shim) {
+			mainResult.sources.push(emitShimmedModule(c, deps[c], module.shim, module.path, contents));
+		} else {
+			mainResult.sources.push(emitNamedModule(c, module.defineLocation, module.path, contents));
+		}
+	});
+
+	Object.keys(usedPlugins).forEach((pluginName: string) => {
+		const plugin = usedPlugins[pluginName];
+		if (typeof plugin.writeFile === 'function') {
+			const req: ILoaderPluginReqFunc = <any>(() => {
+				throw new Error('no-no!');
+			});
+			req.toUrl = something => something;
+
+			const write = (filename: string, contents: string) => {
+				results.push({
+					dest: filename,
+					sources: [{
+						path: null,
+						contents: contents
+					}]
+				});
+			};
+			plugin.writeFile(pluginName, entryPoint, req, write, {});
+		}
+	});
+
+	const toIFile = (path: string): IFile => {
+		const contents = readFileAndRemoveBOM(path);
+		return {
+			path: path,
+			contents: contents
+		};
+	};
+
+	const toPrepend = (prepend || []).map(toIFile);
+	const toAppend = (append || []).map(toIFile);
+
+	mainResult.sources = toPrepend.concat(mainResult.sources).concat(toAppend);
+
+	return {
+		files: results,
+		usedPlugins: usedPlugins
+	};
+}
+
+function readFileAndRemoveBOM(path: string): string {
+	const BOM_CHAR_CODE = 65279;
+	let contents = fs.readFileSync(path, 'utf8');
+	// Remove BOM
+	if (contents.charCodeAt(0) === BOM_CHAR_CODE) {
+		contents = contents.substring(1);
+	}
+	return contents;
+}
+
+function emitPlugin(entryPoint: string, plugin: ILoaderPlugin, pluginName: string, moduleName: string): IFile {
+	let result = '';
+	if (typeof plugin.write === 'function') {
+		const write: ILoaderPluginWriteFunc = <any>((what: string) => {
+			result += what;
+		});
+		write.getEntryPoint = () => {
+			return entryPoint;
+		};
+		write.asModule = (moduleId: string, code: string) => {
+			code = code.replace(/^define\(/, 'define("' + moduleId + '",');
+			result += code;
+		};
+		plugin.write(pluginName, moduleName, write);
+	}
+	return {
+		path: null,
+		contents: result
+	};
+}
+
+function emitNamedModule(moduleId: string, defineCallPosition: IPosition, path: string, contents: string): IFile {
+
+	// `defineCallPosition` is the position in code: |define()
+	const defineCallOffset = positionToOffset(contents, defineCallPosition.line, defineCallPosition.col);
+
+	// `parensOffset` is the position in code: define|()
+	const parensOffset = contents.indexOf('(', defineCallOffset);
+
+	const insertStr = '"' + moduleId + '", ';
+
+	return {
+		path: path,
+		contents: contents.substr(0, parensOffset + 1) + insertStr + contents.substr(parensOffset + 1)
+	};
+}
+
+function emitShimmedModule(moduleId: string, myDeps: string[], factory: string, path: string, contents: string): IFile {
+	const strDeps = (myDeps.length > 0 ? '"' + myDeps.join('", "') + '"' : '');
+	const strDefine = 'define("' + moduleId + '", [' + strDeps + '], ' + factory + ');';
+	return {
+		path: path,
+		contents: contents + '\n;\n' + strDefine
+	};
+}
+
+/**
+ * Convert a position (line:col) to (offset) in string `str`
+ */
+function positionToOffset(str: string, desiredLine: number, desiredCol: number): number {
+	if (desiredLine === 1) {
+		return desiredCol - 1;
+	}
+
+	let line = 1;
+	let lastNewLineOffset = -1;
+
+	do {
+		if (desiredLine === line) {
+			return lastNewLineOffset + 1 + desiredCol - 1;
+		}
+		lastNewLineOffset = str.indexOf('\n', lastNewLineOffset + 1);
+		line++;
+	} while (lastNewLineOffset >= 0);
+
+	return -1;
+}
+
+
+/**
+ * Return a set of reachable nodes in `graph` starting from `rootNodes`
+ */
+function visit(rootNodes: string[], graph: IGraph): INodeSet {
+	const result: INodeSet = {};
+	const queue = rootNodes;
+
+	rootNodes.forEach((node) => {
+		result[node] = true;
+	});
+
+	while (queue.length > 0) {
+		const el = queue.shift();
+		const myEdges = graph[el!] || [];
+		myEdges.forEach((toNode) => {
+			if (!result[toNode]) {
+				result[toNode] = true;
+				queue.push(toNode);
+			}
+		});
+	}
+
+	return result;
+}
+
+/**
+ * Perform a topological sort on `graph`
+ */
+function topologicalSort(graph: IGraph): string[] {
+
+	const allNodes: INodeSet = {},
+		outgoingEdgeCount: { [node: string]: number; } = {},
+		inverseEdges: IGraph = {};
+
+	Object.keys(graph).forEach((fromNode: string) => {
+		allNodes[fromNode] = true;
+		outgoingEdgeCount[fromNode] = graph[fromNode].length;
+
+		graph[fromNode].forEach((toNode) => {
+			allNodes[toNode] = true;
+			outgoingEdgeCount[toNode] = outgoingEdgeCount[toNode] || 0;
+
+			inverseEdges[toNode] = inverseEdges[toNode] || [];
+			inverseEdges[toNode].push(fromNode);
+		});
+	});
+
+	// https://en.wikipedia.org/wiki/Topological_sorting
+	const S: string[] = [],
+		L: string[] = [];
+
+	Object.keys(allNodes).forEach((node: string) => {
+		if (outgoingEdgeCount[node] === 0) {
+			delete outgoingEdgeCount[node];
+			S.push(node);
+		}
+	});
+
+	while (S.length > 0) {
+		// Ensure the exact same order all the time with the same inputs
+		S.sort();
+
+		const n: string = S.shift()!;
+		L.push(n);
+
+		const myInverseEdges = inverseEdges[n] || [];
+		myInverseEdges.forEach((m: string) => {
+			outgoingEdgeCount[m]--;
+			if (outgoingEdgeCount[m] === 0) {
+				delete outgoingEdgeCount[m];
+				S.push(m);
+			}
+		});
+	}
+
+	if (Object.keys(outgoingEdgeCount).length > 0) {
+		throw new Error('Cannot do topological sort on cyclic graph, remaining nodes: ' + Object.keys(outgoingEdgeCount));
+	}
+
+	return L;
+}

lib/vscode/build/lib/compilation.ts

@@ -0,0 +1,208 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as es from 'event-stream';
+import * as fs from 'fs';
+import * as gulp from 'gulp';
+import * as bom from 'gulp-bom';
+import * as sourcemaps from 'gulp-sourcemaps';
+import * as tsb from 'gulp-tsb';
+import * as path from 'path';
+import * as monacodts from './monaco-api';
+import * as nls from './nls';
+import { createReporter } from './reporter';
+import * as util from './util';
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+import * as os from 'os';
+import ts = require('typescript');
+
+const watch = require('./watch');
+
+const reporter = createReporter();
+
+function getTypeScriptCompilerOptions(src: string): ts.CompilerOptions {
+	const rootDir = path.join(__dirname, `../../${src}`);
+	let options: ts.CompilerOptions = {};
+	options.verbose = false;
+	options.sourceMap = true;
+	if (process.env['VSCODE_NO_SOURCEMAP']) { // To be used by developers in a hurry
+		options.sourceMap = false;
+	}
+	options.rootDir = rootDir;
+	options.baseUrl = rootDir;
+	options.sourceRoot = util.toFileUri(rootDir);
+	options.newLine = /\r\n/.test(fs.readFileSync(__filename, 'utf8')) ? 0 : 1;
+	return options;
+}
+
+function createCompile(src: string, build: boolean, emitError?: boolean) {
+	const projectPath = path.join(__dirname, '../../', src, 'tsconfig.json');
+	const overrideOptions = { ...getTypeScriptCompilerOptions(src), inlineSources: Boolean(build) };
+
+	const compilation = tsb.create(projectPath, overrideOptions, false, err => reporter(err));
+
+	function pipeline(token?: util.ICancellationToken) {
+
+		const utf8Filter = util.filter(data => /(\/|\\)test(\/|\\).*utf8/.test(data.path));
+		const tsFilter = util.filter(data => /\.ts$/.test(data.path));
+		const noDeclarationsFilter = util.filter(data => !(/\.d\.ts$/.test(data.path)));
+
+		const input = es.through();
+		const output = input
+			.pipe(utf8Filter)
+			.pipe(bom()) // this is required to preserve BOM in test files that loose it otherwise
+			.pipe(utf8Filter.restore)
+			.pipe(tsFilter)
+			.pipe(util.loadSourcemaps())
+			.pipe(compilation(token))
+			.pipe(noDeclarationsFilter)
+			.pipe(build ? nls() : es.through())
+			.pipe(noDeclarationsFilter.restore)
+			.pipe(sourcemaps.write('.', {
+				addComment: false,
+				includeContent: !!build,
+				sourceRoot: overrideOptions.sourceRoot
+			}))
+			.pipe(tsFilter.restore)
+			.pipe(reporter.end(!!emitError));
+
+		return es.duplex(input, output);
+	}
+	pipeline.tsProjectSrc = () => {
+		return compilation.src({ base: src });
+	};
+	return pipeline;
+}
+
+export function compileTask(src: string, out: string, build: boolean): () => NodeJS.ReadWriteStream {
+
+	return function () {
+
+		if (os.totalmem() < 4_000_000_000) {
+			throw new Error('compilation requires 4GB of RAM');
+		}
+
+		const compile = createCompile(src, build, true);
+		const srcPipe = gulp.src(`${src}/**`, { base: `${src}` });
+		let generator = new MonacoGenerator(false);
+		if (src === 'src') {
+			generator.execute();
+		}
+
+		return srcPipe
+			.pipe(generator.stream)
+			.pipe(compile())
+			.pipe(gulp.dest(out));
+	};
+}
+
+export function watchTask(out: string, build: boolean): () => NodeJS.ReadWriteStream {
+
+	return function () {
+		const compile = createCompile('src', build);
+
+		const src = gulp.src('src/**', { base: 'src' });
+		const watchSrc = watch('src/**', { base: 'src', readDelay: 200 });
+
+		let generator = new MonacoGenerator(true);
+		generator.execute();
+
+		return watchSrc
+			.pipe(generator.stream)
+			.pipe(util.incremental(compile, src, true))
+			.pipe(gulp.dest(out));
+	};
+}
+
+const REPO_SRC_FOLDER = path.join(__dirname, '../../src');
+
+class MonacoGenerator {
+	private readonly _isWatch: boolean;
+	public readonly stream: NodeJS.ReadWriteStream;
+
+	private readonly _watchedFiles: { [filePath: string]: boolean; };
+	private readonly _fsProvider: monacodts.FSProvider;
+	private readonly _declarationResolver: monacodts.DeclarationResolver;
+
+	constructor(isWatch: boolean) {
+		this._isWatch = isWatch;
+		this.stream = es.through();
+		this._watchedFiles = {};
+		let onWillReadFile = (moduleId: string, filePath: string) => {
+			if (!this._isWatch) {
+				return;
+			}
+			if (this._watchedFiles[filePath]) {
+				return;
+			}
+			this._watchedFiles[filePath] = true;
+
+			fs.watchFile(filePath, () => {
+				this._declarationResolver.invalidateCache(moduleId);
+				this._executeSoon();
+			});
+		};
+		this._fsProvider = new class extends monacodts.FSProvider {
+			public readFileSync(moduleId: string, filePath: string): Buffer {
+				onWillReadFile(moduleId, filePath);
+				return super.readFileSync(moduleId, filePath);
+			}
+		};
+		this._declarationResolver = new monacodts.DeclarationResolver(this._fsProvider);
+
+		if (this._isWatch) {
+			fs.watchFile(monacodts.RECIPE_PATH, () => {
+				this._executeSoon();
+			});
+		}
+	}
+
+	private _executeSoonTimer: NodeJS.Timer | null = null;
+	private _executeSoon(): void {
+		if (this._executeSoonTimer !== null) {
+			clearTimeout(this._executeSoonTimer);
+			this._executeSoonTimer = null;
+		}
+		this._executeSoonTimer = setTimeout(() => {
+			this._executeSoonTimer = null;
+			this.execute();
+		}, 20);
+	}
+
+	private _run(): monacodts.IMonacoDeclarationResult | null {
+		let r = monacodts.run3(this._declarationResolver);
+		if (!r && !this._isWatch) {
+			// The build must always be able to generate the monaco.d.ts
+			throw new Error(`monaco.d.ts generation error - Cannot continue`);
+		}
+		return r;
+	}
+
+	private _log(message: any, ...rest: any[]): void {
+		fancyLog(ansiColors.cyan('[monaco.d.ts]'), message, ...rest);
+	}
+
+	public execute(): void {
+		const startTime = Date.now();
+		const result = this._run();
+		if (!result) {
+			// nothing really changed
+			return;
+		}
+		if (result.isTheSame) {
+			return;
+		}
+
+		fs.writeFileSync(result.filePath, result.content);
+		fs.writeFileSync(path.join(REPO_SRC_FOLDER, 'vs/editor/common/standalone/standaloneEnums.ts'), result.enums);
+		this._log(`monaco.d.ts is changed - total time took ${Date.now() - startTime} ms`);
+		if (!this._isWatch) {
+			this.stream.emit('error', 'monaco.d.ts is no longer up to date. Please run gulp watch and commit the new file.');
+		}
+	}
+}

lib/vscode/build/lib/electron.ts

@@ -0,0 +1,121 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as vfs from 'vinyl-fs';
+import * as filter from 'gulp-filter';
+import * as json from 'gulp-json-editor';
+import * as _ from 'underscore';
+import * as util from './util';
+
+const electron = require('gulp-atom-electron');
+
+const root = path.dirname(path.dirname(__dirname));
+const product = JSON.parse(fs.readFileSync(path.join(root, 'product.json'), 'utf8'));
+const commit = util.getVersion(root);
+
+const darwinCreditsTemplate = product.darwinCredits && _.template(fs.readFileSync(path.join(root, product.darwinCredits), 'utf8'));
+
+function darwinBundleDocumentType(extensions: string[], icon: string) {
+	return {
+		name: product.nameLong + ' document',
+		role: 'Editor',
+		ostypes: ['TEXT', 'utxt', 'TUTX', '****'],
+		extensions: extensions,
+		iconFile: icon
+	};
+}
+
+export const config = {
+	version: util.getElectronVersion(),
+	productAppName: product.nameLong,
+	companyName: 'Microsoft Corporation',
+	copyright: 'Copyright (C) 2019 Microsoft. All rights reserved',
+	darwinIcon: 'resources/darwin/code.icns',
+	darwinBundleIdentifier: product.darwinBundleIdentifier,
+	darwinApplicationCategoryType: 'public.app-category.developer-tools',
+	darwinHelpBookFolder: 'VS Code HelpBook',
+	darwinHelpBookName: 'VS Code HelpBook',
+	darwinBundleDocumentTypes: [
+		darwinBundleDocumentType(['bat', 'cmd'], 'resources/darwin/bat.icns'),
+		darwinBundleDocumentType(['bowerrc'], 'resources/darwin/bower.icns'),
+		darwinBundleDocumentType(['c', 'h'], 'resources/darwin/c.icns'),
+		darwinBundleDocumentType(['config', 'editorconfig', 'gitattributes', 'gitconfig', 'gitignore', 'ini'], 'resources/darwin/config.icns'),
+		darwinBundleDocumentType(['cc', 'cpp', 'cxx', 'c++', 'hh', 'hpp', 'hxx', 'h++'], 'resources/darwin/cpp.icns'),
+		darwinBundleDocumentType(['cs', 'csx'], 'resources/darwin/csharp.icns'),
+		darwinBundleDocumentType(['css'], 'resources/darwin/css.icns'),
+		darwinBundleDocumentType(['go'], 'resources/darwin/go.icns'),
+		darwinBundleDocumentType(['asp', 'aspx', 'cshtml', 'htm', 'html', 'jshtm', 'jsp', 'phtml', 'shtml'], 'resources/darwin/html.icns'),
+		darwinBundleDocumentType(['jade'], 'resources/darwin/jade.icns'),
+		darwinBundleDocumentType(['jav', 'java'], 'resources/darwin/java.icns'),
+		darwinBundleDocumentType(['js', 'jscsrc', 'jshintrc', 'mjs', 'cjs'], 'resources/darwin/javascript.icns'),
+		darwinBundleDocumentType(['json'], 'resources/darwin/json.icns'),
+		darwinBundleDocumentType(['less'], 'resources/darwin/less.icns'),
+		darwinBundleDocumentType(['markdown', 'md', 'mdoc', 'mdown', 'mdtext', 'mdtxt', 'mdwn', 'mkd', 'mkdn'], 'resources/darwin/markdown.icns'),
+		darwinBundleDocumentType(['php'], 'resources/darwin/php.icns'),
+		darwinBundleDocumentType(['ps1', 'psd1', 'psm1'], 'resources/darwin/powershell.icns'),
+		darwinBundleDocumentType(['py'], 'resources/darwin/python.icns'),
+		darwinBundleDocumentType(['gemspec', 'rb'], 'resources/darwin/ruby.icns'),
+		darwinBundleDocumentType(['scss'], 'resources/darwin/sass.icns'),
+		darwinBundleDocumentType(['bash', 'bash_login', 'bash_logout', 'bash_profile', 'bashrc', 'profile', 'rhistory', 'rprofile', 'sh', 'zlogin', 'zlogout', 'zprofile', 'zsh', 'zshenv', 'zshrc'], 'resources/darwin/shell.icns'),
+		darwinBundleDocumentType(['sql'], 'resources/darwin/sql.icns'),
+		darwinBundleDocumentType(['ts'], 'resources/darwin/typescript.icns'),
+		darwinBundleDocumentType(['tsx', 'jsx'], 'resources/darwin/react.icns'),
+		darwinBundleDocumentType(['vue'], 'resources/darwin/vue.icns'),
+		darwinBundleDocumentType(['ascx', 'csproj', 'dtd', 'wxi', 'wxl', 'wxs', 'xml', 'xaml'], 'resources/darwin/xml.icns'),
+		darwinBundleDocumentType(['eyaml', 'eyml', 'yaml', 'yml'], 'resources/darwin/yaml.icns'),
+		darwinBundleDocumentType(['clj', 'cljs', 'cljx', 'clojure', 'code-workspace', 'coffee', 'containerfile', 'ctp', 'dockerfile', 'dot', 'edn', 'fs', 'fsi', 'fsscript', 'fsx', 'handlebars', 'hbs', 'lua', 'm', 'makefile', 'ml', 'mli', 'pl', 'pl6', 'pm', 'pm6', 'pod', 'pp', 'properties', 'psgi', 'pug', 'r', 'rs', 'rt', 'svg', 'svgz', 't', 'txt', 'vb', 'xcodeproj', 'xcworkspace'], 'resources/darwin/default.icns')
+	],
+	darwinBundleURLTypes: [{
+		role: 'Viewer',
+		name: product.nameLong,
+		urlSchemes: [product.urlProtocol]
+	}],
+	darwinForceDarkModeSupport: true,
+	darwinCredits: darwinCreditsTemplate ? Buffer.from(darwinCreditsTemplate({ commit: commit, date: new Date().toISOString() })) : undefined,
+	linuxExecutableName: product.applicationName,
+	winIcon: 'resources/win32/code.ico',
+	token: process.env['VSCODE_MIXIN_PASSWORD'] || process.env['GITHUB_TOKEN'] || undefined,
+	repo: product.electronRepository || undefined
+};
+
+function getElectron(arch: string): () => NodeJS.ReadWriteStream {
+	return () => {
+		const electronOpts = _.extend({}, config, {
+			platform: process.platform,
+			arch: arch === 'armhf' ? 'arm' : arch,
+			ffmpegChromium: true,
+			keepDefaultApp: true
+		});
+
+		return vfs.src('package.json')
+			.pipe(json({ name: product.nameShort }))
+			.pipe(electron(electronOpts))
+			.pipe(filter(['**', '!**/app/package.json']))
+			.pipe(vfs.dest('.build/electron'));
+	};
+}
+
+async function main(arch = process.arch): Promise<void> {
+	const version = util.getElectronVersion();
+	const electronPath = path.join(root, '.build', 'electron');
+	const versionFile = path.join(electronPath, 'version');
+	const isUpToDate = fs.existsSync(versionFile) && fs.readFileSync(versionFile, 'utf8') === `${version}`;
+
+	if (!isUpToDate) {
+		await util.rimraf(electronPath)();
+		await util.streamToPromise(getElectron(arch)());
+	}
+}
+
+if (require.main === module) {
+	main(process.argv[2]).catch(err => {
+		console.error(err);
+		process.exit(1);
+	});
+}

lib/vscode/build/lib/eslint/code-import-patterns.ts

@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+import { join } from 'path';
+import * as minimatch from 'minimatch';
+import { createImportRuleListener } from './utils';
+
+interface ImportPatternsConfig {
+	target: string;
+	restrictions: string | string[];
+}
+
+export = new class implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			badImport: 'Imports violates \'{{restrictions}}\' restrictions. See https://github.com/microsoft/vscode/wiki/Source-Code-Organization'
+		},
+		docs: {
+			url: 'https://github.com/microsoft/vscode/wiki/Source-Code-Organization'
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		const configs = <ImportPatternsConfig[]>context.options;
+
+		for (const config of configs) {
+			if (minimatch(context.getFilename(), config.target)) {
+				return createImportRuleListener((node, value) => this._checkImport(context, config, node, value));
+			}
+		}
+
+		return {};
+	}
+
+	private _checkImport(context: eslint.Rule.RuleContext, config: ImportPatternsConfig, node: TSESTree.Node, path: string) {
+
+		// resolve relative paths
+		if (path[0] === '.') {
+			path = join(context.getFilename(), path);
+		}
+
+		let restrictions: string[];
+		if (typeof config.restrictions === 'string') {
+			restrictions = [config.restrictions];
+		} else {
+			restrictions = config.restrictions;
+		}
+
+		let matched = false;
+		for (const pattern of restrictions) {
+			if (minimatch(path, pattern)) {
+				matched = true;
+				break;
+			}
+		}
+
+		if (!matched) {
+			// None of the restrictions matched
+			context.report({
+				loc: node.loc,
+				messageId: 'badImport',
+				data: {
+					restrictions: restrictions.join(' or ')
+				}
+			});
+		}
+	}
+};
+

lib/vscode/build/lib/eslint/code-layering.ts

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { join, dirname } from 'path';
+import { createImportRuleListener } from './utils';
+
+type Config = {
+	allowed: Set<string>;
+	disallowed: Set<string>;
+};
+
+export = new class implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			layerbreaker: 'Bad layering. You are not allowed to access {{from}} from here, allowed layers are: [{{allowed}}]'
+		},
+		docs: {
+			url: 'https://github.com/microsoft/vscode/wiki/Source-Code-Organization'
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		const fileDirname = dirname(context.getFilename());
+		const parts = fileDirname.split(/\\|\//);
+		const ruleArgs = <Record<string, string[]>>context.options[0];
+
+		let config: Config | undefined;
+		for (let i = parts.length - 1; i >= 0; i--) {
+			if (ruleArgs[parts[i]]) {
+				config = {
+					allowed: new Set(ruleArgs[parts[i]]).add(parts[i]),
+					disallowed: new Set()
+				};
+				Object.keys(ruleArgs).forEach(key => {
+					if (!config!.allowed.has(key)) {
+						config!.disallowed.add(key);
+					}
+				});
+				break;
+			}
+		}
+
+		if (!config) {
+			// nothing
+			return {};
+		}
+
+		return createImportRuleListener((node, path) => {
+			if (path[0] === '.') {
+				path = join(dirname(context.getFilename()), path);
+			}
+
+			const parts = dirname(path).split(/\\|\//);
+			for (let i = parts.length - 1; i >= 0; i--) {
+				const part = parts[i];
+
+				if (config!.allowed.has(part)) {
+					// GOOD - same layer
+					break;
+				}
+
+				if (config!.disallowed.has(part)) {
+					// BAD - wrong layer
+					context.report({
+						loc: node.loc,
+						messageId: 'layerbreaker',
+						data: {
+							from: part,
+							allowed: [...config!.allowed.keys()].join(', ')
+						}
+					});
+					break;
+				}
+			}
+		});
+	}
+};
+

lib/vscode/build/lib/eslint/code-no-nls-in-standalone-editor.ts

@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { join } from 'path';
+import { createImportRuleListener } from './utils';
+
+export = new class NoNlsInStandaloneEditorRule implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			noNls: 'Not allowed to import vs/nls in standalone editor modules. Use standaloneStrings.ts'
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		const fileName = context.getFilename();
+		if (
+			/vs(\/|\\)editor(\/|\\)standalone(\/|\\)/.test(fileName)
+			|| /vs(\/|\\)editor(\/|\\)common(\/|\\)standalone(\/|\\)/.test(fileName)
+			|| /vs(\/|\\)editor(\/|\\)editor.api/.test(fileName)
+			|| /vs(\/|\\)editor(\/|\\)editor.main/.test(fileName)
+			|| /vs(\/|\\)editor(\/|\\)editor.worker/.test(fileName)
+		) {
+			return createImportRuleListener((node, path) => {
+				// resolve relative paths
+				if (path[0] === '.') {
+					path = join(context.getFilename(), path);
+				}
+
+				if (
+					/vs(\/|\\)nls/.test(path)
+				) {
+					context.report({
+						loc: node.loc,
+						messageId: 'noNls'
+					});
+				}
+			});
+		}
+
+		return {};
+	}
+};
+

lib/vscode/build/lib/eslint/code-no-standalone-editor.ts

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { join } from 'path';
+import { createImportRuleListener } from './utils';
+
+export = new class NoNlsInStandaloneEditorRule implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			badImport: 'Not allowed to import standalone editor modules.'
+		},
+		docs: {
+			url: 'https://github.com/microsoft/vscode/wiki/Source-Code-Organization'
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		if (/vs(\/|\\)editor/.test(context.getFilename())) {
+			// the vs/editor folder is allowed to use the standalone editor
+			return {};
+		}
+
+		return createImportRuleListener((node, path) => {
+
+			// resolve relative paths
+			if (path[0] === '.') {
+				path = join(context.getFilename(), path);
+			}
+
+			if (
+				/vs(\/|\\)editor(\/|\\)standalone(\/|\\)/.test(path)
+				|| /vs(\/|\\)editor(\/|\\)common(\/|\\)standalone(\/|\\)/.test(path)
+				|| /vs(\/|\\)editor(\/|\\)editor.api/.test(path)
+				|| /vs(\/|\\)editor(\/|\\)editor.main/.test(path)
+				|| /vs(\/|\\)editor(\/|\\)editor.worker/.test(path)
+			) {
+				context.report({
+					loc: node.loc,
+					messageId: 'badImport'
+				});
+			}
+		});
+	}
+};
+

lib/vscode/build/lib/eslint/code-no-unexternalized-strings.ts

@@ -0,0 +1,126 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/experimental-utils';
+
+function isStringLiteral(node: TSESTree.Node | null | undefined): node is TSESTree.StringLiteral {
+	return !!node && node.type === AST_NODE_TYPES.Literal && typeof node.value === 'string';
+}
+
+function isDoubleQuoted(node: TSESTree.StringLiteral): boolean {
+	return node.raw[0] === '"' && node.raw[node.raw.length - 1] === '"';
+}
+
+export = new class NoUnexternalizedStrings implements eslint.Rule.RuleModule {
+
+	private static _rNlsKeys = /^[_a-zA-Z0-9][ .\-_a-zA-Z0-9]*$/;
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			doubleQuoted: 'Only use double-quoted strings for externalized strings.',
+			badKey: 'The key \'{{key}}\' doesn\'t conform to a valid localize identifier.',
+			duplicateKey: 'Duplicate key \'{{key}}\' with different message value.',
+			badMessage: 'Message argument to \'{{message}}\' must be a string literal.'
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		const externalizedStringLiterals = new Map<string, { call: TSESTree.CallExpression, message: TSESTree.Node }[]>();
+		const doubleQuotedStringLiterals = new Set<TSESTree.Node>();
+
+		function collectDoubleQuotedStrings(node: TSESTree.Literal) {
+			if (isStringLiteral(node) && isDoubleQuoted(node)) {
+				doubleQuotedStringLiterals.add(node);
+			}
+		}
+
+		function visitLocalizeCall(node: TSESTree.CallExpression) {
+
+			// localize(key, message)
+			const [keyNode, messageNode] = (<TSESTree.CallExpression>node).arguments;
+
+			// (1)
+			// extract key so that it can be checked later
+			let key: string | undefined;
+			if (isStringLiteral(keyNode)) {
+				doubleQuotedStringLiterals.delete(keyNode); //todo@joh reconsider
+				key = keyNode.value;
+
+			} else if (keyNode.type === AST_NODE_TYPES.ObjectExpression) {
+				for (let property of keyNode.properties) {
+					if (property.type === AST_NODE_TYPES.Property && !property.computed) {
+						if (property.key.type === AST_NODE_TYPES.Identifier && property.key.name === 'key') {
+							if (isStringLiteral(property.value)) {
+								doubleQuotedStringLiterals.delete(property.value); //todo@joh reconsider
+								key = property.value.value;
+								break;
+							}
+						}
+					}
+				}
+			}
+			if (typeof key === 'string') {
+				let array = externalizedStringLiterals.get(key);
+				if (!array) {
+					array = [];
+					externalizedStringLiterals.set(key, array);
+				}
+				array.push({ call: node, message: messageNode });
+			}
+
+			// (2)
+			// remove message-argument from doubleQuoted list and make
+			// sure it is a string-literal
+			doubleQuotedStringLiterals.delete(messageNode);
+			if (!isStringLiteral(messageNode)) {
+				context.report({
+					loc: messageNode.loc,
+					messageId: 'badMessage',
+					data: { message: context.getSourceCode().getText(<any>node) }
+				});
+			}
+		}
+
+		function reportBadStringsAndBadKeys() {
+			// (1)
+			// report all strings that are in double quotes
+			for (const node of doubleQuotedStringLiterals) {
+				context.report({ loc: node.loc, messageId: 'doubleQuoted' });
+			}
+
+			for (const [key, values] of externalizedStringLiterals) {
+
+				// (2)
+				// report all invalid NLS keys
+				if (!key.match(NoUnexternalizedStrings._rNlsKeys)) {
+					for (let value of values) {
+						context.report({ loc: value.call.loc, messageId: 'badKey', data: { key } });
+					}
+				}
+
+				// (2)
+				// report all invalid duplicates (same key, different message)
+				if (values.length > 1) {
+					for (let i = 1; i < values.length; i++) {
+						if (context.getSourceCode().getText(<any>values[i - 1].message) !== context.getSourceCode().getText(<any>values[i].message)) {
+							context.report({ loc: values[i].call.loc, messageId: 'duplicateKey', data: { key } });
+						}
+					}
+				}
+			}
+		}
+
+		return {
+			['Literal']: (node: any) => collectDoubleQuotedStrings(node),
+			['ExpressionStatement[directive] Literal:exit']: (node: any) => doubleQuotedStringLiterals.delete(node),
+			['CallExpression[callee.type="MemberExpression"][callee.object.name="nls"][callee.property.name="localize"]:exit']: (node: any) => visitLocalizeCall(node),
+			['CallExpression[callee.name="localize"][arguments.length>=2]:exit']: (node: any) => visitLocalizeCall(node),
+			['Program:exit']: reportBadStringsAndBadKeys,
+		};
+	}
+};
+

lib/vscode/build/lib/eslint/code-no-unused-expressions.ts

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// FORKED FROM https://github.com/eslint/eslint/blob/b23ad0d789a909baf8d7c41a35bc53df932eaf30/lib/rules/no-unused-expressions.js
+// and added support for `OptionalCallExpression`, see https://github.com/facebook/create-react-app/issues/8107 and https://github.com/eslint/eslint/issues/12642
+
+/**
+ * @fileoverview Flag expressions in statement position that do not side effect
+ * @author Michael Ficarra
+ */
+
+'use strict';
+
+import * as eslint from 'eslint';
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+import * as ESTree from 'estree';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+	meta: {
+		type: 'suggestion',
+
+		docs: {
+			description: 'disallow unused expressions',
+			category: 'Best Practices',
+			recommended: false,
+			url: 'https://eslint.org/docs/rules/no-unused-expressions'
+		},
+
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					allowShortCircuit: {
+						type: 'boolean',
+						default: false
+					},
+					allowTernary: {
+						type: 'boolean',
+						default: false
+					},
+					allowTaggedTemplates: {
+						type: 'boolean',
+						default: false
+					}
+				},
+				additionalProperties: false
+			}
+		]
+	},
+
+	create(context: eslint.Rule.RuleContext) {
+		const config = context.options[0] || {},
+			allowShortCircuit = config.allowShortCircuit || false,
+			allowTernary = config.allowTernary || false,
+			allowTaggedTemplates = config.allowTaggedTemplates || false;
+
+		// eslint-disable-next-line jsdoc/require-description
+		/**
+		 * @param node any node
+		 * @returns whether the given node structurally represents a directive
+		 */
+		function looksLikeDirective(node: TSESTree.Node): boolean {
+			return node.type === 'ExpressionStatement' &&
+				node.expression.type === 'Literal' && typeof node.expression.value === 'string';
+		}
+
+		// eslint-disable-next-line jsdoc/require-description
+		/**
+		 * @param predicate ([a] -> Boolean) the function used to make the determination
+		 * @param list the input list
+		 * @returns the leading sequence of members in the given list that pass the given predicate
+		 */
+		function takeWhile<T>(predicate: (item: T) => boolean, list: T[]): T[] {
+			for (let i = 0; i < list.length; ++i) {
+				if (!predicate(list[i])) {
+					return list.slice(0, i);
+				}
+			}
+			return list.slice();
+		}
+
+		// eslint-disable-next-line jsdoc/require-description
+		/**
+		 * @param node a Program or BlockStatement node
+		 * @returns the leading sequence of directive nodes in the given node's body
+		 */
+		function directives(node: TSESTree.Program | TSESTree.BlockStatement): TSESTree.Node[] {
+			return takeWhile(looksLikeDirective, node.body);
+		}
+
+		// eslint-disable-next-line jsdoc/require-description
+		/**
+		 * @param node any node
+		 * @param ancestors the given node's ancestors
+		 * @returns whether the given node is considered a directive in its current position
+		 */
+		function isDirective(node: TSESTree.Node, ancestors: TSESTree.Node[]): boolean {
+			const parent = ancestors[ancestors.length - 1],
+				grandparent = ancestors[ancestors.length - 2];
+
+			return (parent.type === 'Program' || parent.type === 'BlockStatement' &&
+				(/Function/u.test(grandparent.type))) &&
+				directives(parent).indexOf(node) >= 0;
+		}
+
+		/**
+		 * Determines whether or not a given node is a valid expression. Recurses on short circuit eval and ternary nodes if enabled by flags.
+		 * @param node any node
+		 * @returns whether the given node is a valid expression
+		 */
+		function isValidExpression(node: TSESTree.Node): boolean {
+			if (allowTernary) {
+
+				// Recursive check for ternary and logical expressions
+				if (node.type === 'ConditionalExpression') {
+					return isValidExpression(node.consequent) && isValidExpression(node.alternate);
+				}
+			}
+
+			if (allowShortCircuit) {
+				if (node.type === 'LogicalExpression') {
+					return isValidExpression(node.right);
+				}
+			}
+
+			if (allowTaggedTemplates && node.type === 'TaggedTemplateExpression') {
+				return true;
+			}
+
+			return /^(?:Assignment|OptionalCall|Call|New|Update|Yield|Await)Expression$/u.test(node.type) ||
+				(node.type === 'UnaryExpression' && ['delete', 'void'].indexOf(node.operator) >= 0);
+		}
+
+		return {
+			ExpressionStatement(node: TSESTree.ExpressionStatement) {
+				if (!isValidExpression(node.expression) && !isDirective(node, <TSESTree.Node[]>context.getAncestors())) {
+					context.report({ node: <ESTree.Node>node, message: 'Expected an assignment or function call and instead saw an expression.' });
+				}
+			}
+		};
+
+	}
+};

lib/vscode/build/lib/eslint/code-translation-remind.ts

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+import { readFileSync } from 'fs';
+import { createImportRuleListener } from './utils';
+
+
+export = new class TranslationRemind implements eslint.Rule.RuleModule {
+
+	private static NLS_MODULE = 'vs/nls';
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			missing: 'Please add \'{{resource}}\' to ./build/lib/i18n.resources.json file to use translations here.'
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+		return createImportRuleListener((node, path) => this._checkImport(context, node, path));
+	}
+
+	private _checkImport(context: eslint.Rule.RuleContext, node: TSESTree.Node, path: string) {
+
+		if (path !== TranslationRemind.NLS_MODULE) {
+			return;
+		}
+
+		const currentFile = context.getFilename();
+		const matchService = currentFile.match(/vs\/workbench\/services\/\w+/);
+		const matchPart = currentFile.match(/vs\/workbench\/contrib\/\w+/);
+		if (!matchService && !matchPart) {
+			return;
+		}
+
+		const resource = matchService ? matchService[0] : matchPart![0];
+		let resourceDefined = false;
+
+		let json;
+		try {
+			json = readFileSync('./build/lib/i18n.resources.json', 'utf8');
+		} catch (e) {
+			console.error('[translation-remind rule]: File with resources to pull from Transifex was not found. Aborting translation resource check for newly defined workbench part/service.');
+			return;
+		}
+		const workbenchResources = JSON.parse(json).workbench;
+
+		workbenchResources.forEach((existingResource: any) => {
+			if (existingResource.name === resource) {
+				resourceDefined = true;
+				return;
+			}
+		});
+
+		if (!resourceDefined) {
+			context.report({
+				loc: node.loc,
+				messageId: 'missing',
+				data: { resource }
+			});
+		}
+	}
+};
+

lib/vscode/build/lib/eslint/utils.ts

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+
+export function createImportRuleListener(validateImport: (node: TSESTree.Literal, value: string) => any): eslint.Rule.RuleListener {
+
+	function _checkImport(node: TSESTree.Node | null) {
+		if (node && node.type === 'Literal' && typeof node.value === 'string') {
+			validateImport(node, node.value);
+		}
+	}
+
+	return {
+		// import ??? from 'module'
+		ImportDeclaration: (node: any) => {
+			_checkImport((<TSESTree.ImportDeclaration>node).source);
+		},
+		// import('module').then(...) OR await import('module')
+		['CallExpression[callee.type="Import"][arguments.length=1] > Literal']: (node: any) => {
+			_checkImport(node);
+		},
+		// import foo = ...
+		['TSImportEqualsDeclaration > TSExternalModuleReference > Literal']: (node: any) => {
+			_checkImport(node);
+		},
+		// export ?? from 'module'
+		ExportAllDeclaration: (node: any) => {
+			_checkImport((<TSESTree.ExportAllDeclaration>node).source);
+		},
+		// export {foo} from 'module'
+		ExportNamedDeclaration: (node: any) => {
+			_checkImport((<TSESTree.ExportNamedDeclaration>node).source);
+		},
+
+	};
+}

lib/vscode/build/lib/eslint/vscode-dts-create-func.ts

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/experimental-utils';
+
+export = new class ApiLiteralOrTypes implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		docs: { url: 'https://github.com/microsoft/vscode/wiki/Extension-API-guidelines#creating-objects' },
+		messages: { sync: '`createXYZ`-functions are constructor-replacements and therefore must return sync', }
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		return {
+			['TSDeclareFunction Identifier[name=/create.*/]']: (node: any) => {
+
+				const decl = <TSESTree.FunctionDeclaration>(<TSESTree.Identifier>node).parent;
+
+				if (decl.returnType?.typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) {
+					return;
+				}
+				if (decl.returnType.typeAnnotation.typeName.type !== AST_NODE_TYPES.Identifier) {
+					return;
+				}
+
+				const ident = decl.returnType.typeAnnotation.typeName.name;
+				if (ident === 'Promise' || ident === 'Thenable') {
+					context.report({
+						node,
+						messageId: 'sync'
+					});
+				}
+			}
+		};
+	}
+};

lib/vscode/build/lib/eslint/vscode-dts-event-naming.ts

@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/experimental-utils';
+
+export = new class ApiEventNaming implements eslint.Rule.RuleModule {
+
+	private static _nameRegExp = /on(Did|Will)([A-Z][a-z]+)([A-Z][a-z]+)?/;
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		docs: {
+			url: 'https://github.com/microsoft/vscode/wiki/Extension-API-guidelines#event-naming'
+		},
+		messages: {
+			naming: 'Event names must follow this patten: `on[Did|Will]<Verb><Subject>`',
+			verb: 'Unknown verb \'{{verb}}\' - is this really a verb? Iff so, then add this verb to the configuration',
+			subject: 'Unknown subject \'{{subject}}\' - This subject has not been used before but it should refer to something in the API',
+			unknown: 'UNKNOWN event declaration, lint-rule needs tweaking'
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		const config = <{ allowed: string[], verbs: string[] }>context.options[0];
+		const allowed = new Set(config.allowed);
+		const verbs = new Set(config.verbs);
+
+		return {
+			['TSTypeAnnotation TSTypeReference Identifier[name="Event"]']: (node: any) => {
+
+				const def = (<TSESTree.Identifier>node).parent?.parent?.parent;
+				const ident = this.getIdent(def);
+
+				if (!ident) {
+					// event on unknown structure...
+					return context.report({
+						node,
+						message: 'unknown'
+					});
+				}
+
+				if (allowed.has(ident.name)) {
+					// configured exception
+					return;
+				}
+
+				const match = ApiEventNaming._nameRegExp.exec(ident.name);
+				if (!match) {
+					context.report({
+						node: ident,
+						messageId: 'naming'
+					});
+					return;
+				}
+
+				// check that <verb> is spelled out (configured) as verb
+				if (!verbs.has(match[2].toLowerCase())) {
+					context.report({
+						node: ident,
+						messageId: 'verb',
+						data: { verb: match[2] }
+					});
+				}
+
+				// check that a subject (if present) has occurred
+				if (match[3]) {
+					const regex = new RegExp(match[3], 'ig');
+					const parts = context.getSourceCode().getText().split(regex);
+					if (parts.length < 3) {
+						context.report({
+							node: ident,
+							messageId: 'subject',
+							data: { subject: match[3] }
+						});
+					}
+				}
+			}
+		};
+	}
+
+	private getIdent(def: TSESTree.Node | undefined): TSESTree.Identifier | undefined {
+		if (!def) {
+			return;
+		}
+
+		if (def.type === AST_NODE_TYPES.Identifier) {
+			return def;
+		} else if ((def.type === AST_NODE_TYPES.TSPropertySignature || def.type === AST_NODE_TYPES.ClassProperty) && def.key.type === AST_NODE_TYPES.Identifier) {
+			return def.key;
+		}
+
+		return this.getIdent(def.parent);
+	}
+};
+

lib/vscode/build/lib/eslint/vscode-dts-interface-naming.ts

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+import { TSESTree } from '@typescript-eslint/experimental-utils';
+
+export = new class ApiInterfaceNaming implements eslint.Rule.RuleModule {
+
+	private static _nameRegExp = /I[A-Z]/;
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		messages: {
+			naming: 'Interfaces must not be prefixed with uppercase `I`',
+		}
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+
+		return {
+			['TSInterfaceDeclaration Identifier']: (node: any) => {
+
+				const name = (<TSESTree.Identifier>node).name;
+				if (ApiInterfaceNaming._nameRegExp.test(name)) {
+					context.report({
+						node,
+						messageId: 'naming'
+					});
+				}
+			}
+		};
+	}
+};
+

lib/vscode/build/lib/eslint/vscode-dts-literal-or-types.ts

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as eslint from 'eslint';
+
+export = new class ApiLiteralOrTypes implements eslint.Rule.RuleModule {
+
+	readonly meta: eslint.Rule.RuleMetaData = {
+		docs: { url: 'https://github.com/microsoft/vscode/wiki/Extension-API-guidelines#enums' },
+		messages: { useEnum: 'Use enums, not literal-or-types', }
+	};
+
+	create(context: eslint.Rule.RuleContext): eslint.Rule.RuleListener {
+		return {
+			['TSTypeAnnotation TSUnionType TSLiteralType']: (node: any) => {
+				if (node.literal?.type === 'TSNullKeyword') {
+					return;
+				}
+				context.report({
+					node: node,
+					messageId: 'useEnum'
+				});
+			}
+		};
+	}
+};

lib/vscode/build/lib/extensions.ts

@@ -0,0 +1,397 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as es from 'event-stream';
+import * as fs from 'fs';
+import * as glob from 'glob';
+import * as gulp from 'gulp';
+import * as path from 'path';
+import { Stream } from 'stream';
+import * as File from 'vinyl';
+import * as vsce from 'vsce';
+import { createStatsStream } from './stats';
+import * as util2 from './util';
+import remote = require('gulp-remote-retry-src');
+const vzip = require('gulp-vinyl-zip');
+import filter = require('gulp-filter');
+import rename = require('gulp-rename');
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+const buffer = require('gulp-buffer');
+import json = require('gulp-json-editor');
+import * as jsoncParser from 'jsonc-parser';
+const webpack = require('webpack');
+const webpackGulp = require('webpack-stream');
+const util = require('./util');
+const root = path.dirname(path.dirname(__dirname));
+const commit = util.getVersion(root);
+const sourceMappingURLBase = `https://ticino.blob.core.windows.net/sourcemaps/${commit}`;
+
+function minifyExtensionResources(input: Stream): Stream {
+	const jsonFilter = filter(['**/*.json', '**/*.code-snippets'], { restore: true });
+	return input
+		.pipe(jsonFilter)
+		.pipe(buffer())
+		.pipe(es.mapSync((f: File) => {
+			const errors: jsoncParser.ParseError[] = [];
+			const value = jsoncParser.parse(f.contents.toString('utf8'), errors);
+			if (errors.length === 0) {
+				// file parsed OK => just stringify to drop whitespace and comments
+				f.contents = Buffer.from(JSON.stringify(value));
+			}
+			return f;
+		}))
+		.pipe(jsonFilter.restore);
+}
+
+function updateExtensionPackageJSON(input: Stream, update: (data: any) => any): Stream {
+	const packageJsonFilter = filter('extensions/*/package.json', { restore: true });
+	return input
+		.pipe(packageJsonFilter)
+		.pipe(buffer())
+		.pipe(es.mapSync((f: File) => {
+			const data = JSON.parse(f.contents.toString('utf8'));
+			f.contents = Buffer.from(JSON.stringify(update(data)));
+			return f;
+		}))
+		.pipe(packageJsonFilter.restore);
+}
+
+function fromLocal(extensionPath: string, forWeb: boolean): Stream {
+	const webpackConfigFileName = forWeb ? 'extension-browser.webpack.config.js' : 'extension.webpack.config.js';
+
+	const isWebPacked = fs.existsSync(path.join(extensionPath, webpackConfigFileName));
+	let input = isWebPacked
+		? fromLocalWebpack(extensionPath, webpackConfigFileName)
+		: fromLocalNormal(extensionPath);
+
+	if (isWebPacked) {
+		input = updateExtensionPackageJSON(input, (data: any) => {
+			delete data.scripts;
+			delete data.dependencies;
+			delete data.devDependencies;
+			if (data.main) {
+				data.main = data.main.replace('/out/', /dist/);
+			}
+			return data;
+		});
+	}
+
+	return input;
+}
+
+
+function fromLocalWebpack(extensionPath: string, webpackConfigFileName: string): Stream {
+	const result = es.through();
+
+	const packagedDependencies: string[] = [];
+	const packageJsonConfig = require(path.join(extensionPath, 'package.json'));
+	if (packageJsonConfig.dependencies) {
+		const webpackRootConfig = require(path.join(extensionPath, webpackConfigFileName));
+		for (const key in webpackRootConfig.externals) {
+			if (key in packageJsonConfig.dependencies) {
+				packagedDependencies.push(key);
+			}
+		}
+	}
+
+	vsce.listFiles({ cwd: extensionPath, packageManager: vsce.PackageManager.Yarn, packagedDependencies }).then(fileNames => {
+		const files = fileNames
+			.map(fileName => path.join(extensionPath, fileName))
+			.map(filePath => new File({
+				path: filePath,
+				stat: fs.statSync(filePath),
+				base: extensionPath,
+				contents: fs.createReadStream(filePath) as any
+			}));
+
+		// check for a webpack configuration files, then invoke webpack
+		// and merge its output with the files stream.
+		const webpackConfigLocations = (<string[]>glob.sync(
+			path.join(extensionPath, '**', webpackConfigFileName),
+			{ ignore: ['**/node_modules'] }
+		));
+
+		const webpackStreams = webpackConfigLocations.map(webpackConfigPath => {
+
+			const webpackDone = (err: any, stats: any) => {
+				fancyLog(`Bundled extension: ${ansiColors.yellow(path.join(path.basename(extensionPath), path.relative(extensionPath, webpackConfigPath)))}...`);
+				if (err) {
+					result.emit('error', err);
+				}
+				const { compilation } = stats;
+				if (compilation.errors.length > 0) {
+					result.emit('error', compilation.errors.join('\n'));
+				}
+				if (compilation.warnings.length > 0) {
+					result.emit('error', compilation.warnings.join('\n'));
+				}
+			};
+
+			const webpackConfig = {
+				...require(webpackConfigPath),
+				...{ mode: 'production' }
+			};
+			const relativeOutputPath = path.relative(extensionPath, webpackConfig.output.path);
+
+			return webpackGulp(webpackConfig, webpack, webpackDone)
+				.pipe(es.through(function (data) {
+					data.stat = data.stat || {};
+					data.base = extensionPath;
+					this.emit('data', data);
+				}))
+				.pipe(es.through(function (data: File) {
+					// source map handling:
+					// * rewrite sourceMappingURL
+					// * save to disk so that upload-task picks this up
+					const contents = (<Buffer>data.contents).toString('utf8');
+					data.contents = Buffer.from(contents.replace(/\n\/\/# sourceMappingURL=(.*)$/gm, function (_m, g1) {
+						return `\n//# sourceMappingURL=${sourceMappingURLBase}/extensions/${path.basename(extensionPath)}/${relativeOutputPath}/${g1}`;
+					}), 'utf8');
+
+					this.emit('data', data);
+				}));
+		});
+
+		es.merge(...webpackStreams, es.readArray(files))
+			// .pipe(es.through(function (data) {
+			// 	// debug
+			// 	console.log('out', data.path, data.contents.length);
+			// 	this.emit('data', data);
+			// }))
+			.pipe(result);
+
+	}).catch(err => {
+		console.error(extensionPath);
+		console.error(packagedDependencies);
+		result.emit('error', err);
+	});
+
+	return result.pipe(createStatsStream(path.basename(extensionPath)));
+}
+
+function fromLocalNormal(extensionPath: string): Stream {
+	const result = es.through();
+
+	vsce.listFiles({ cwd: extensionPath, packageManager: vsce.PackageManager.Yarn })
+		.then(fileNames => {
+			const files = fileNames
+				.map(fileName => path.join(extensionPath, fileName))
+				.map(filePath => new File({
+					path: filePath,
+					stat: fs.statSync(filePath),
+					base: extensionPath,
+					contents: fs.createReadStream(filePath) as any
+				}));
+
+			es.readArray(files).pipe(result);
+		})
+		.catch(err => result.emit('error', err));
+
+	return result.pipe(createStatsStream(path.basename(extensionPath)));
+}
+
+const baseHeaders = {
+	'X-Market-Client-Id': 'VSCode Build',
+	'User-Agent': 'VSCode Build',
+	'X-Market-User-Id': '291C1CD0-051A-4123-9B4B-30D60EF52EE2',
+};
+
+export function fromMarketplace(extensionName: string, version: string, metadata: any): Stream {
+	const [publisher, name] = extensionName.split('.');
+	const url = `https://marketplace.visualstudio.com/_apis/public/gallery/publishers/${publisher}/vsextensions/${name}/${version}/vspackage`;
+
+	fancyLog('Downloading extension:', ansiColors.yellow(`${extensionName}@${version}`), '...');
+
+	const options = {
+		base: url,
+		requestOptions: {
+			gzip: true,
+			headers: baseHeaders
+		}
+	};
+
+	const packageJsonFilter = filter('package.json', { restore: true });
+
+	return remote('', options)
+		.pipe(vzip.src())
+		.pipe(filter('extension/**'))
+		.pipe(rename(p => p.dirname = p.dirname!.replace(/^extension\/?/, '')))
+		.pipe(packageJsonFilter)
+		.pipe(buffer())
+		.pipe(json({ __metadata: metadata }))
+		.pipe(packageJsonFilter.restore);
+}
+const excludedExtensions = [
+	'vscode-api-tests',
+	'vscode-colorize-tests',
+	'vscode-test-resolver',
+	'ms-vscode.node-debug',
+	'ms-vscode.node-debug2',
+	'vscode-notebook-tests',
+	'vscode-custom-editor-tests',
+];
+
+const marketplaceWebExtensions = [
+	'ms-vscode.references-view'
+];
+
+interface IBuiltInExtension {
+	name: string;
+	version: string;
+	repo: string;
+	metadata: any;
+}
+
+const productJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../../product.json'), 'utf8'));
+const builtInExtensions: IBuiltInExtension[] = productJson.builtInExtensions || [];
+const webBuiltInExtensions: IBuiltInExtension[] = productJson.webBuiltInExtensions || [];
+
+type ExtensionKind = 'ui' | 'workspace' | 'web';
+interface IExtensionManifest {
+	main: string;
+	browser: string;
+	extensionKind?: ExtensionKind | ExtensionKind[];
+}
+/**
+ * Loosely based on `getExtensionKind` from `src/vs/workbench/services/extensions/common/extensionsUtil.ts`
+ */
+function isWebExtension(manifest: IExtensionManifest): boolean {
+	if (typeof manifest.extensionKind !== 'undefined') {
+		const extensionKind = Array.isArray(manifest.extensionKind) ? manifest.extensionKind : [manifest.extensionKind];
+		return (extensionKind.indexOf('web') >= 0);
+	}
+	return (!Boolean(manifest.main) || Boolean(manifest.browser));
+}
+
+export function packageLocalExtensionsStream(forWeb: boolean): Stream {
+	const localExtensionsDescriptions = (
+		(<string[]>glob.sync('extensions/*/package.json'))
+			.map(manifestPath => {
+				const absoluteManifestPath = path.join(root, manifestPath);
+				const extensionPath = path.dirname(path.join(root, manifestPath));
+				const extensionName = path.basename(extensionPath);
+				return { name: extensionName, path: extensionPath, manifestPath: absoluteManifestPath };
+			})
+			.filter(({ name }) => excludedExtensions.indexOf(name) === -1)
+			.filter(({ name }) => builtInExtensions.every(b => b.name !== name))
+			.filter(({ manifestPath }) => (forWeb ? isWebExtension(require(manifestPath)) : true))
+	);
+	const localExtensionsStream = minifyExtensionResources(
+		es.merge(
+			...localExtensionsDescriptions.map(extension => {
+				return fromLocal(extension.path, forWeb)
+					.pipe(rename(p => p.dirname = `extensions/${extension.name}/${p.dirname}`));
+			})
+		)
+	);
+
+	let result: Stream;
+	if (forWeb) {
+		result = localExtensionsStream;
+	} else {
+		// also include shared node modules
+		result = es.merge(localExtensionsStream, gulp.src('extensions/node_modules/**', { base: '.' }));
+	}
+
+	return (
+		result
+			.pipe(util2.setExecutableBit(['**/*.sh']))
+	);
+}
+
+export function packageMarketplaceExtensionsStream(forWeb: boolean): Stream {
+	const marketplaceExtensionsDescriptions = [
+		...builtInExtensions.filter(({ name }) => (forWeb ? marketplaceWebExtensions.indexOf(name) >= 0 : true)),
+		...(forWeb ? webBuiltInExtensions : [])
+	];
+	const marketplaceExtensionsStream = minifyExtensionResources(
+		es.merge(
+			...marketplaceExtensionsDescriptions
+				.map(extension => {
+					const input = fromMarketplace(extension.name, extension.version, extension.metadata)
+						.pipe(rename(p => p.dirname = `extensions/${extension.name}/${p.dirname}`));
+					return updateExtensionPackageJSON(input, (data: any) => {
+						delete data.scripts;
+						delete data.dependencies;
+						delete data.devDependencies;
+						return data;
+					});
+				})
+		)
+	);
+
+	return (
+		marketplaceExtensionsStream
+			.pipe(util2.setExecutableBit(['**/*.sh']))
+	);
+}
+
+export interface IScannedBuiltinExtension {
+	extensionPath: string;
+	packageJSON: any;
+	packageNLS?: any;
+	readmePath?: string;
+	changelogPath?: string;
+}
+
+export function scanBuiltinExtensions(extensionsRoot: string, exclude: string[] = []): IScannedBuiltinExtension[] {
+	const scannedExtensions: IScannedBuiltinExtension[] = [];
+
+	try {
+		const extensionsFolders = fs.readdirSync(extensionsRoot);
+		for (const extensionFolder of extensionsFolders) {
+			if (exclude.indexOf(extensionFolder) >= 0) {
+				continue;
+			}
+			const packageJSONPath = path.join(extensionsRoot, extensionFolder, 'package.json');
+			if (!fs.existsSync(packageJSONPath)) {
+				continue;
+			}
+			let packageJSON = JSON.parse(fs.readFileSync(packageJSONPath).toString('utf8'));
+			if (!isWebExtension(packageJSON)) {
+				continue;
+			}
+			const children = fs.readdirSync(path.join(extensionsRoot, extensionFolder));
+			const packageNLSPath = children.filter(child => child === 'package.nls.json')[0];
+			const packageNLS = packageNLSPath ? JSON.parse(fs.readFileSync(path.join(extensionsRoot, extensionFolder, packageNLSPath)).toString()) : undefined;
+			const readme = children.filter(child => /^readme(\.txt|\.md|)$/i.test(child))[0];
+			const changelog = children.filter(child => /^changelog(\.txt|\.md|)$/i.test(child))[0];
+
+			scannedExtensions.push({
+				extensionPath: extensionFolder,
+				packageJSON,
+				packageNLS,
+				readmePath: readme ? path.join(extensionFolder, readme) : undefined,
+				changelogPath: changelog ? path.join(extensionFolder, changelog) : undefined,
+			});
+		}
+		return scannedExtensions;
+	} catch (ex) {
+		return scannedExtensions;
+	}
+}
+
+export function translatePackageJSON(packageJSON: string, packageNLSPath: string) {
+	const CharCode_PC = '%'.charCodeAt(0);
+	const packageNls = JSON.parse(fs.readFileSync(packageNLSPath).toString());
+	const translate = (obj: any) => {
+		for (let key in obj) {
+			const val = obj[key];
+			if (Array.isArray(val)) {
+				val.forEach(translate);
+			} else if (val && typeof val === 'object') {
+				translate(val);
+			} else if (typeof val === 'string' && val.charCodeAt(0) === CharCode_PC && val.charCodeAt(val.length - 1) === CharCode_PC) {
+				const translated = packageNls[val.substr(1, val.length - 2)];
+				if (translated) {
+					obj[key] = translated;
+				}
+			}
+		}
+	};
+	translate(packageJSON);
+	return packageJSON;
+}

lib/vscode/build/lib/git.ts

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import * as path from 'path';
+import * as fs from 'fs';
+
+/**
+ * Returns the sha1 commit version of a repository or undefined in case of failure.
+ */
+export function getVersion(repo: string): string | undefined {
+	const git = path.join(repo, '.git');
+	const headPath = path.join(git, 'HEAD');
+	let head: string;
+
+	try {
+		head = fs.readFileSync(headPath, 'utf8').trim();
+	} catch (e) {
+		return undefined;
+	}
+
+	if (/^[0-9a-f]{40}$/i.test(head)) {
+		return head;
+	}
+
+	const refMatch = /^ref: (.*)$/.exec(head);
+
+	if (!refMatch) {
+		return undefined;
+	}
+
+	const ref = refMatch[1];
+	const refPath = path.join(git, ref);
+
+	try {
+		return fs.readFileSync(refPath, 'utf8').trim();
+	} catch (e) {
+		// noop
+	}
+
+	const packedRefsPath = path.join(git, 'packed-refs');
+	let refsRaw: string;
+
+	try {
+		refsRaw = fs.readFileSync(packedRefsPath, 'utf8').trim();
+	} catch (e) {
+		return undefined;
+	}
+
+	const refsRegex = /^([0-9a-f]{40})\s+(.+)$/gm;
+	let refsMatch: RegExpExecArray | null;
+	let refs: { [ref: string]: string } = {};
+
+	while (refsMatch = refsRegex.exec(refsRaw)) {
+		refs[refsMatch[2]] = refsMatch[1];
+	}
+
+	return refs[ref];
+}

lib/vscode/build/lib/i18n.resources.json

@@ -0,0 +1,370 @@
+{
+	"editor": [
+		{
+			"name": "vs/platform",
+			"project": "vscode-editor"
+		},
+		{
+			"name": "vs/editor/contrib",
+			"project": "vscode-editor"
+		},
+		{
+			"name": "vs/editor",
+			"project": "vscode-editor"
+		},
+		{
+			"name": "vs/base",
+			"project": "vscode-editor"
+		}
+	],
+	"workbench": [
+		{
+			"name": "vs/code",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/api/common",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/backup",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/bulkEdit",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/cli",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/codeEditor",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/callHierarchy",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/codeActions",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/comments",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/debug",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/emmet",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/experiments",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/extensions",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/externalTerminal",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/feedback",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/files",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/html",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/issue",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/keybindings",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/markers",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/localizations",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/logs",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/output",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/performance",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/preferences",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/notebook",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/quickaccess",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/userData",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/remote",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/relauncher",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/sash",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/scm",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/search",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/searchEditor",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/snippets",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/format",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/tags",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/surveys",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/tasks",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/terminal",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/themes",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/trust",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/update",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/url",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/watermark",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/webview",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/webviewPanel",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/workspaces",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/customEditor",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/welcome",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/outline",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/userDataSync",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/views",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/actions",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/authToken",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/bulkEdit",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/commands",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/configuration",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/configurationResolver",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/dialogs",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/editor",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/extensions",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/extensionManagement",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/files",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/log",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/integrity",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/keybinding",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/lifecycle",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/mode",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/progress",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/remote",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/search",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/textfile",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/themes",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/textMate",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/workingCopy",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/workspaces",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/decorations",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/label",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/preferences",
+			"project": "vscode-preferences"
+		},
+		{
+			"name": "vs/workbench/services/notification",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/userData",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/userDataSync",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/views",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/contrib/timeline",
+			"project": "vscode-workbench"
+		},
+		{
+			"name": "vs/workbench/services/authentication",
+			"project": "vscode-workbench"
+		}
+	]
+}