Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'

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"
+		}
+	]
+}

lib/vscode/build/lib/layersChecker.ts

@@ -0,0 +1,331 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { match } from 'minimatch';
+
+//
+// #############################################################################################
+//
+// A custom typescript checker for the specific task of detecting the use of certain types in a
+// layer that does not allow such use. For example:
+// - using DOM globals in common/node/electron-main layer (e.g. HTMLElement)
+// - using node.js globals in common/browser layer (e.g. process)
+//
+// Make changes to below RULES to lift certain files from these checks only if absolutely needed
+//
+// #############################################################################################
+//
+
+// Types we assume are present in all implementations of JS VMs (node.js, browsers)
+// Feel free to add more core types as you see needed if present in node.js and browsers
+const CORE_TYPES = [
+	'require', // from our AMD loader
+	// 'atob',
+	// 'btoa',
+	'setTimeout',
+	'clearTimeout',
+	'setInterval',
+	'clearInterval',
+	'console',
+	'log',
+	'info',
+	'warn',
+	'error',
+	'group',
+	'groupEnd',
+	'table',
+	'assert',
+	'Error',
+	'String',
+	'throws',
+	'stack',
+	'captureStackTrace',
+	'stackTraceLimit',
+	'TextDecoder',
+	'TextEncoder',
+	'encode',
+	'decode',
+	'self',
+	'trimLeft',
+	'trimRight'
+];
+
+// Types that are defined in a common layer but are known to be only
+// available in native environments should not be allowed in browser
+const NATIVE_TYPES = [
+	'NativeParsedArgs',
+	'INativeEnvironmentService',
+	'INativeWindowConfiguration',
+	'ICommonNativeHostService'
+];
+
+const RULES = [
+
+	// Tests: skip
+	{
+		target: '**/vs/**/test/**',
+		skip: true // -> skip all test files
+	},
+
+	// Common: vs/base/common/platform.ts
+	{
+		target: '**/vs/base/common/platform.ts',
+		allowedTypes: [
+			...CORE_TYPES,
+
+			// Safe access to postMessage() and friends
+			'MessageEvent',
+			'data'
+		],
+		disallowedTypes: NATIVE_TYPES,
+		disallowedDefinitions: [
+			'lib.dom.d.ts', // no DOM
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Common: vs/platform/environment/common/argv.ts
+	{
+		target: '**/vs/platform/environment/common/argv.ts',
+		disallowedTypes: [/* Ignore native types that are defined from here */],
+		allowedTypes: CORE_TYPES,
+		disallowedDefinitions: [
+			'lib.dom.d.ts', // no DOM
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Common: vs/platform/environment/common/environment.ts
+	{
+		target: '**/vs/platform/environment/common/environment.ts',
+		disallowedTypes: [/* Ignore native types that are defined from here */],
+		allowedTypes: CORE_TYPES,
+		disallowedDefinitions: [
+			'lib.dom.d.ts', // no DOM
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Common: vs/platform/windows/common/windows.ts
+	{
+		target: '**/vs/platform/windows/common/windows.ts',
+		disallowedTypes: [/* Ignore native types that are defined from here */],
+		allowedTypes: CORE_TYPES,
+		disallowedDefinitions: [
+			'lib.dom.d.ts', // no DOM
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Common: vs/platform/native/common/native.ts
+	{
+		target: '**/vs/platform/native/common/native.ts',
+		disallowedTypes: [/* Ignore native types that are defined from here */],
+		allowedTypes: CORE_TYPES,
+		disallowedDefinitions: [
+			'lib.dom.d.ts', // no DOM
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Common: vs/workbench/api/common/extHostExtensionService.ts
+	{
+		target: '**/vs/workbench/api/common/extHostExtensionService.ts',
+		allowedTypes: [
+			...CORE_TYPES,
+
+			// Safe access to global
+			'global'
+		],
+		disallowedTypes: NATIVE_TYPES,
+		disallowedDefinitions: [
+			'lib.dom.d.ts', // no DOM
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Common
+	{
+		target: '**/vs/**/common/**',
+		allowedTypes: CORE_TYPES,
+		disallowedTypes: NATIVE_TYPES,
+		disallowedDefinitions: [
+			'lib.dom.d.ts', // no DOM
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Browser
+	{
+		target: '**/vs/**/browser/**',
+		allowedTypes: CORE_TYPES,
+		disallowedTypes: NATIVE_TYPES,
+		disallowedDefinitions: [
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Browser (editor contrib)
+	{
+		target: '**/src/vs/editor/contrib/**',
+		allowedTypes: CORE_TYPES,
+		disallowedTypes: NATIVE_TYPES,
+		disallowedDefinitions: [
+			'@types/node'	// no node.js
+		]
+	},
+
+	// node.js
+	{
+		target: '**/vs/**/node/**',
+		allowedTypes: [
+			...CORE_TYPES,
+
+			// --> types from node.d.ts that duplicate from lib.dom.d.ts
+			'URL',
+			'protocol',
+			'hostname',
+			'port',
+			'pathname',
+			'search',
+			'username',
+			'password'
+		],
+		disallowedDefinitions: [
+			'lib.dom.d.ts'	// no DOM
+		]
+	},
+
+	// Electron (sandbox)
+	{
+		target: '**/vs/**/electron-sandbox/**',
+		allowedTypes: CORE_TYPES,
+		disallowedDefinitions: [
+			'@types/node'	// no node.js
+		]
+	},
+
+	// Electron (renderer): skip
+	{
+		target: '**/vs/**/electron-browser/**',
+		skip: true // -> supports all types
+	},
+
+	// Electron (main)
+	{
+		target: '**/vs/**/electron-main/**',
+		allowedTypes: [
+			...CORE_TYPES,
+
+			// --> types from electron.d.ts that duplicate from lib.dom.d.ts
+			'Event',
+			'Request'
+		],
+		disallowedDefinitions: [
+			'lib.dom.d.ts'	// no DOM
+		]
+	}
+];
+
+const TS_CONFIG_PATH = join(__dirname, '../../', 'src', 'tsconfig.json');
+
+interface IRule {
+	target: string;
+	skip?: boolean;
+	allowedTypes?: string[];
+	disallowedDefinitions?: string[];
+	disallowedTypes?: string[];
+}
+
+let hasErrors = false;
+
+function checkFile(program: ts.Program, sourceFile: ts.SourceFile, rule: IRule) {
+	checkNode(sourceFile);
+
+	function checkNode(node: ts.Node): void {
+		if (node.kind !== ts.SyntaxKind.Identifier) {
+			return ts.forEachChild(node, checkNode); // recurse down
+		}
+
+		const text = node.getText(sourceFile);
+
+		if (rule.allowedTypes?.some(allowed => allowed === text)) {
+			return; // override
+		}
+
+		if (rule.disallowedTypes?.some(disallowed => disallowed === text)) {
+			const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+			console.log(`[build/lib/layersChecker.ts]: Reference to '${text}' violates layer '${rule.target}' (${sourceFile.fileName} (${line + 1},${character + 1})`);
+
+			hasErrors = true;
+			return;
+		}
+
+		const checker = program.getTypeChecker();
+		const symbol = checker.getSymbolAtLocation(node);
+		if (symbol) {
+			const declarations = symbol.declarations;
+			if (Array.isArray(declarations)) {
+				for (const declaration of declarations) {
+					if (declaration) {
+						const parent = declaration.parent;
+						if (parent) {
+							const parentSourceFile = parent.getSourceFile();
+							if (parentSourceFile) {
+								const definitionFileName = parentSourceFile.fileName;
+								if (rule.disallowedDefinitions) {
+									for (const disallowedDefinition of rule.disallowedDefinitions) {
+										if (definitionFileName.indexOf(disallowedDefinition) >= 0) {
+											const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+											console.log(`[build/lib/layersChecker.ts]: Reference to '${text}' from '${disallowedDefinition}' violates layer '${rule.target}' (${sourceFile.fileName} (${line + 1},${character + 1})`);
+
+											hasErrors = true;
+											return;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+function createProgram(tsconfigPath: string): ts.Program {
+	const tsConfig = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+
+	const configHostParser: ts.ParseConfigHost = { fileExists: existsSync, readDirectory: ts.sys.readDirectory, readFile: file => readFileSync(file, 'utf8'), useCaseSensitiveFileNames: process.platform === 'linux' };
+	const tsConfigParsed = ts.parseJsonConfigFileContent(tsConfig.config, configHostParser, resolve(dirname(tsconfigPath)), { noEmit: true });
+
+	const compilerHost = ts.createCompilerHost(tsConfigParsed.options, true);
+
+	return ts.createProgram(tsConfigParsed.fileNames, tsConfigParsed.options, compilerHost);
+}
+
+//
+// Create program and start checking
+//
+const program = createProgram(TS_CONFIG_PATH);
+
+for (const sourceFile of program.getSourceFiles()) {
+	for (const rule of RULES) {
+		if (match([sourceFile.fileName], rule.target).length > 0) {
+			if (!rule.skip) {
+				checkFile(program, sourceFile, rule);
+			}
+
+			break;
+		}
+	}
+}
+
+if (hasErrors) {
+	process.exit(1);
+}

lib/vscode/build/lib/monaco-api.ts

@@ -0,0 +1,749 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 ts from 'typescript';
+import * as path from 'path';
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+
+const dtsv = '3';
+
+const tsfmt = require('../../tsfmt.json');
+
+const SRC = path.join(__dirname, '../../src');
+export const RECIPE_PATH = path.join(__dirname, '../monaco/monaco.d.ts.recipe');
+const DECLARATION_PATH = path.join(__dirname, '../../src/vs/monaco.d.ts');
+
+function logErr(message: any, ...rest: any[]): void {
+	fancyLog(ansiColors.yellow(`[monaco.d.ts]`), message, ...rest);
+}
+
+type SourceFileGetter = (moduleId: string) => ts.SourceFile | null;
+
+type TSTopLevelDeclaration = ts.InterfaceDeclaration | ts.EnumDeclaration | ts.ClassDeclaration | ts.TypeAliasDeclaration | ts.FunctionDeclaration | ts.ModuleDeclaration;
+type TSTopLevelDeclare = TSTopLevelDeclaration | ts.VariableStatement;
+
+function isDeclaration(a: TSTopLevelDeclare): a is TSTopLevelDeclaration {
+	return (
+		a.kind === ts.SyntaxKind.InterfaceDeclaration
+		|| a.kind === ts.SyntaxKind.EnumDeclaration
+		|| a.kind === ts.SyntaxKind.ClassDeclaration
+		|| a.kind === ts.SyntaxKind.TypeAliasDeclaration
+		|| a.kind === ts.SyntaxKind.FunctionDeclaration
+		|| a.kind === ts.SyntaxKind.ModuleDeclaration
+	);
+}
+
+function visitTopLevelDeclarations(sourceFile: ts.SourceFile, visitor: (node: TSTopLevelDeclare) => boolean): void {
+	let stop = false;
+
+	let visit = (node: ts.Node): void => {
+		if (stop) {
+			return;
+		}
+
+		switch (node.kind) {
+			case ts.SyntaxKind.InterfaceDeclaration:
+			case ts.SyntaxKind.EnumDeclaration:
+			case ts.SyntaxKind.ClassDeclaration:
+			case ts.SyntaxKind.VariableStatement:
+			case ts.SyntaxKind.TypeAliasDeclaration:
+			case ts.SyntaxKind.FunctionDeclaration:
+			case ts.SyntaxKind.ModuleDeclaration:
+				stop = visitor(<TSTopLevelDeclare>node);
+		}
+
+		if (stop) {
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+
+	visit(sourceFile);
+}
+
+
+function getAllTopLevelDeclarations(sourceFile: ts.SourceFile): TSTopLevelDeclare[] {
+	let all: TSTopLevelDeclare[] = [];
+	visitTopLevelDeclarations(sourceFile, (node) => {
+		if (node.kind === ts.SyntaxKind.InterfaceDeclaration || node.kind === ts.SyntaxKind.ClassDeclaration || node.kind === ts.SyntaxKind.ModuleDeclaration) {
+			let interfaceDeclaration = <ts.InterfaceDeclaration>node;
+			let triviaStart = interfaceDeclaration.pos;
+			let triviaEnd = interfaceDeclaration.name.pos;
+			let triviaText = getNodeText(sourceFile, { pos: triviaStart, end: triviaEnd });
+
+			if (triviaText.indexOf('@internal') === -1) {
+				all.push(node);
+			}
+		} else {
+			let nodeText = getNodeText(sourceFile, node);
+			if (nodeText.indexOf('@internal') === -1) {
+				all.push(node);
+			}
+		}
+		return false /*continue*/;
+	});
+	return all;
+}
+
+
+function getTopLevelDeclaration(sourceFile: ts.SourceFile, typeName: string): TSTopLevelDeclare | null {
+	let result: TSTopLevelDeclare | null = null;
+	visitTopLevelDeclarations(sourceFile, (node) => {
+		if (isDeclaration(node) && node.name) {
+			if (node.name.text === typeName) {
+				result = node;
+				return true /*stop*/;
+			}
+			return false /*continue*/;
+		}
+		// node is ts.VariableStatement
+		if (getNodeText(sourceFile, node).indexOf(typeName) >= 0) {
+			result = node;
+			return true /*stop*/;
+		}
+		return false /*continue*/;
+	});
+	return result;
+}
+
+
+function getNodeText(sourceFile: ts.SourceFile, node: { pos: number; end: number; }): string {
+	return sourceFile.getFullText().substring(node.pos, node.end);
+}
+
+function hasModifier(modifiers: ts.NodeArray<ts.Modifier> | undefined, kind: ts.SyntaxKind): boolean {
+	if (modifiers) {
+		for (let i = 0; i < modifiers.length; i++) {
+			let mod = modifiers[i];
+			if (mod.kind === kind) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+function isStatic(member: ts.ClassElement | ts.TypeElement): boolean {
+	return hasModifier(member.modifiers, ts.SyntaxKind.StaticKeyword);
+}
+
+function isDefaultExport(declaration: ts.InterfaceDeclaration | ts.ClassDeclaration): boolean {
+	return (
+		hasModifier(declaration.modifiers, ts.SyntaxKind.DefaultKeyword)
+		&& hasModifier(declaration.modifiers, ts.SyntaxKind.ExportKeyword)
+	);
+}
+
+function getMassagedTopLevelDeclarationText(sourceFile: ts.SourceFile, declaration: TSTopLevelDeclare, importName: string, usage: string[], enums: IEnumEntry[]): string {
+	let result = getNodeText(sourceFile, declaration);
+	if (declaration.kind === ts.SyntaxKind.InterfaceDeclaration || declaration.kind === ts.SyntaxKind.ClassDeclaration) {
+		let interfaceDeclaration = <ts.InterfaceDeclaration | ts.ClassDeclaration>declaration;
+
+		const staticTypeName = (
+			isDefaultExport(interfaceDeclaration)
+				? `${importName}.default`
+				: `${importName}.${declaration.name!.text}`
+		);
+
+		let instanceTypeName = staticTypeName;
+		const typeParametersCnt = (interfaceDeclaration.typeParameters ? interfaceDeclaration.typeParameters.length : 0);
+		if (typeParametersCnt > 0) {
+			let arr: string[] = [];
+			for (let i = 0; i < typeParametersCnt; i++) {
+				arr.push('any');
+			}
+			instanceTypeName = `${instanceTypeName}<${arr.join(',')}>`;
+		}
+
+		const members: ts.NodeArray<ts.ClassElement | ts.TypeElement> = interfaceDeclaration.members;
+		members.forEach((member) => {
+			try {
+				let memberText = getNodeText(sourceFile, member);
+				if (memberText.indexOf('@internal') >= 0 || memberText.indexOf('private') >= 0) {
+					result = result.replace(memberText, '');
+				} else {
+					const memberName = (<ts.Identifier | ts.StringLiteral>member.name).text;
+					const memberAccess = (memberName.indexOf('.') >= 0 ? `['${memberName}']` : `.${memberName}`);
+					if (isStatic(member)) {
+						usage.push(`a = ${staticTypeName}${memberAccess};`);
+					} else {
+						usage.push(`a = (<${instanceTypeName}>b)${memberAccess};`);
+					}
+				}
+			} catch (err) {
+				// life..
+			}
+		});
+	} else if (declaration.kind === ts.SyntaxKind.VariableStatement) {
+		const jsDoc = result.substr(0, declaration.getLeadingTriviaWidth(sourceFile));
+		if (jsDoc.indexOf('@monacodtsreplace') >= 0) {
+			const jsDocLines = jsDoc.split(/\r\n|\r|\n/);
+			let directives: [RegExp, string][] = [];
+			for (const jsDocLine of jsDocLines) {
+				const m = jsDocLine.match(/^\s*\* \/([^/]+)\/([^/]+)\/$/);
+				if (m) {
+					directives.push([new RegExp(m[1], 'g'), m[2]]);
+				}
+			}
+			// remove the jsdoc
+			result = result.substr(jsDoc.length);
+			if (directives.length > 0) {
+				// apply replace directives
+				const replacer = createReplacerFromDirectives(directives);
+				result = replacer(result);
+			}
+		}
+	}
+	result = result.replace(/export default /g, 'export ');
+	result = result.replace(/export declare /g, 'export ');
+	result = result.replace(/declare /g, '');
+	let lines = result.split(/\r\n|\r|\n/);
+	for (let i = 0; i < lines.length; i++) {
+		if (/\s*\*/.test(lines[i])) {
+			// very likely a comment
+			continue;
+		}
+		lines[i] = lines[i].replace(/"/g, '\'');
+	}
+	result = lines.join('\n');
+
+	if (declaration.kind === ts.SyntaxKind.EnumDeclaration) {
+		result = result.replace(/const enum/, 'enum');
+		enums.push({
+			enumName: declaration.name.getText(sourceFile),
+			text: result
+		});
+	}
+
+	return result;
+}
+
+function format(text: string, endl: string): string {
+	const REALLY_FORMAT = false;
+
+	text = preformat(text, endl);
+	if (!REALLY_FORMAT) {
+		return text;
+	}
+
+	// Parse the source text
+	let sourceFile = ts.createSourceFile('file.ts', text, ts.ScriptTarget.Latest, /*setParentPointers*/ true);
+
+	// Get the formatting edits on the input sources
+	let edits = (<any>ts).formatting.formatDocument(sourceFile, getRuleProvider(tsfmt), tsfmt);
+
+	// Apply the edits on the input code
+	return applyEdits(text, edits);
+
+	function countParensCurly(text: string): number {
+		let cnt = 0;
+		for (let i = 0; i < text.length; i++) {
+			if (text.charAt(i) === '(' || text.charAt(i) === '{') {
+				cnt++;
+			}
+			if (text.charAt(i) === ')' || text.charAt(i) === '}') {
+				cnt--;
+			}
+		}
+		return cnt;
+	}
+
+	function repeatStr(s: string, cnt: number): string {
+		let r = '';
+		for (let i = 0; i < cnt; i++) {
+			r += s;
+		}
+		return r;
+	}
+
+	function preformat(text: string, endl: string): string {
+		let lines = text.split(endl);
+		let inComment = false;
+		let inCommentDeltaIndent = 0;
+		let indent = 0;
+		for (let i = 0; i < lines.length; i++) {
+			let line = lines[i].replace(/\s$/, '');
+			let repeat = false;
+			let lineIndent = 0;
+			do {
+				repeat = false;
+				if (line.substring(0, 4) === '    ') {
+					line = line.substring(4);
+					lineIndent++;
+					repeat = true;
+				}
+				if (line.charAt(0) === '\t') {
+					line = line.substring(1);
+					lineIndent++;
+					repeat = true;
+				}
+			} while (repeat);
+
+			if (line.length === 0) {
+				continue;
+			}
+
+			if (inComment) {
+				if (/\*\//.test(line)) {
+					inComment = false;
+				}
+				lines[i] = repeatStr('\t', lineIndent + inCommentDeltaIndent) + line;
+				continue;
+			}
+
+			if (/\/\*/.test(line)) {
+				inComment = true;
+				inCommentDeltaIndent = indent - lineIndent;
+				lines[i] = repeatStr('\t', indent) + line;
+				continue;
+			}
+
+			const cnt = countParensCurly(line);
+			let shouldUnindentAfter = false;
+			let shouldUnindentBefore = false;
+			if (cnt < 0) {
+				if (/[({]/.test(line)) {
+					shouldUnindentAfter = true;
+				} else {
+					shouldUnindentBefore = true;
+				}
+			} else if (cnt === 0) {
+				shouldUnindentBefore = /^\}/.test(line);
+			}
+			let shouldIndentAfter = false;
+			if (cnt > 0) {
+				shouldIndentAfter = true;
+			} else if (cnt === 0) {
+				shouldIndentAfter = /{$/.test(line);
+			}
+
+			if (shouldUnindentBefore) {
+				indent--;
+			}
+
+			lines[i] = repeatStr('\t', indent) + line;
+
+			if (shouldUnindentAfter) {
+				indent--;
+			}
+			if (shouldIndentAfter) {
+				indent++;
+			}
+		}
+		return lines.join(endl);
+	}
+
+	function getRuleProvider(options: ts.FormatCodeSettings) {
+		// Share this between multiple formatters using the same options.
+		// This represents the bulk of the space the formatter uses.
+		return (ts as any).formatting.getFormatContext(options);
+	}
+
+	function applyEdits(text: string, edits: ts.TextChange[]): string {
+		// Apply edits in reverse on the existing text
+		let result = text;
+		for (let i = edits.length - 1; i >= 0; i--) {
+			let change = edits[i];
+			let head = result.slice(0, change.span.start);
+			let tail = result.slice(change.span.start + change.span.length);
+			result = head + change.newText + tail;
+		}
+		return result;
+	}
+}
+
+function createReplacerFromDirectives(directives: [RegExp, string][]): (str: string) => string {
+	return (str: string) => {
+		for (let i = 0; i < directives.length; i++) {
+			str = str.replace(directives[i][0], directives[i][1]);
+		}
+		return str;
+	};
+}
+
+function createReplacer(data: string): (str: string) => string {
+	data = data || '';
+	let rawDirectives = data.split(';');
+	let directives: [RegExp, string][] = [];
+	rawDirectives.forEach((rawDirective) => {
+		if (rawDirective.length === 0) {
+			return;
+		}
+		let pieces = rawDirective.split('=>');
+		let findStr = pieces[0];
+		let replaceStr = pieces[1];
+
+		findStr = findStr.replace(/[\-\\\{\}\*\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&');
+		findStr = '\\b' + findStr + '\\b';
+		directives.push([new RegExp(findStr, 'g'), replaceStr]);
+	});
+
+	return createReplacerFromDirectives(directives);
+}
+
+interface ITempResult {
+	result: string;
+	usageContent: string;
+	enums: string;
+}
+
+interface IEnumEntry {
+	enumName: string;
+	text: string;
+}
+
+function generateDeclarationFile(recipe: string, sourceFileGetter: SourceFileGetter): ITempResult | null {
+	const endl = /\r\n/.test(recipe) ? '\r\n' : '\n';
+
+	let lines = recipe.split(endl);
+	let result: string[] = [];
+
+	let usageCounter = 0;
+	let usageImports: string[] = [];
+	let usage: string[] = [];
+
+	let failed = false;
+
+	usage.push(`var a: any;`);
+	usage.push(`var b: any;`);
+
+	const generateUsageImport = (moduleId: string) => {
+		let importName = 'm' + (++usageCounter);
+		usageImports.push(`import * as ${importName} from './${moduleId.replace(/\.d\.ts$/, '')}';`);
+		return importName;
+	};
+
+	let enums: IEnumEntry[] = [];
+	let version: string | null = null;
+
+	lines.forEach(line => {
+
+		if (failed) {
+			return;
+		}
+
+		let m0 = line.match(/^\/\/dtsv=(\d+)$/);
+		if (m0) {
+			version = m0[1];
+		}
+
+		let m1 = line.match(/^\s*#include\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+		if (m1) {
+			let moduleId = m1[1];
+			const sourceFile = sourceFileGetter(moduleId);
+			if (!sourceFile) {
+				logErr(`While handling ${line}`);
+				logErr(`Cannot find ${moduleId}`);
+				failed = true;
+				return;
+			}
+
+			const importName = generateUsageImport(moduleId);
+
+			let replacer = createReplacer(m1[2]);
+
+			let typeNames = m1[3].split(/,/);
+			typeNames.forEach((typeName) => {
+				typeName = typeName.trim();
+				if (typeName.length === 0) {
+					return;
+				}
+				let declaration = getTopLevelDeclaration(sourceFile, typeName);
+				if (!declaration) {
+					logErr(`While handling ${line}`);
+					logErr(`Cannot find ${typeName}`);
+					failed = true;
+					return;
+				}
+				result.push(replacer(getMassagedTopLevelDeclarationText(sourceFile, declaration, importName, usage, enums)));
+			});
+			return;
+		}
+
+		let m2 = line.match(/^\s*#includeAll\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+		if (m2) {
+			let moduleId = m2[1];
+			const sourceFile = sourceFileGetter(moduleId);
+			if (!sourceFile) {
+				logErr(`While handling ${line}`);
+				logErr(`Cannot find ${moduleId}`);
+				failed = true;
+				return;
+			}
+
+			const importName = generateUsageImport(moduleId);
+
+			let replacer = createReplacer(m2[2]);
+
+			let typeNames = m2[3].split(/,/);
+			let typesToExcludeMap: { [typeName: string]: boolean; } = {};
+			let typesToExcludeArr: string[] = [];
+			typeNames.forEach((typeName) => {
+				typeName = typeName.trim();
+				if (typeName.length === 0) {
+					return;
+				}
+				typesToExcludeMap[typeName] = true;
+				typesToExcludeArr.push(typeName);
+			});
+
+			getAllTopLevelDeclarations(sourceFile).forEach((declaration) => {
+				if (isDeclaration(declaration) && declaration.name) {
+					if (typesToExcludeMap[declaration.name.text]) {
+						return;
+					}
+				} else {
+					// node is ts.VariableStatement
+					let nodeText = getNodeText(sourceFile, declaration);
+					for (let i = 0; i < typesToExcludeArr.length; i++) {
+						if (nodeText.indexOf(typesToExcludeArr[i]) >= 0) {
+							return;
+						}
+					}
+				}
+				result.push(replacer(getMassagedTopLevelDeclarationText(sourceFile, declaration, importName, usage, enums)));
+			});
+			return;
+		}
+
+		result.push(line);
+	});
+
+	if (failed) {
+		return null;
+	}
+
+	if (version !== dtsv) {
+		if (!version) {
+			logErr(`gulp watch restart required. 'monaco.d.ts.recipe' is written before versioning was introduced.`);
+		} else {
+			logErr(`gulp watch restart required. 'monaco.d.ts.recipe' v${version} does not match runtime v${dtsv}.`);
+		}
+		return null;
+	}
+
+	let resultTxt = result.join(endl);
+	resultTxt = resultTxt.replace(/\bURI\b/g, 'Uri');
+	resultTxt = resultTxt.replace(/\bEvent</g, 'IEvent<');
+	resultTxt = resultTxt.split(/\r\n|\n|\r/).join(endl);
+	resultTxt = format(resultTxt, endl);
+	resultTxt = resultTxt.split(/\r\n|\n|\r/).join(endl);
+
+	enums.sort((e1, e2) => {
+		if (e1.enumName < e2.enumName) {
+			return -1;
+		}
+		if (e1.enumName > e2.enumName) {
+			return 1;
+		}
+		return 0;
+	});
+
+	let resultEnums = [
+		'/*---------------------------------------------------------------------------------------------',
+		' *  Copyright (c) Microsoft Corporation. All rights reserved.',
+		' *  Licensed under the MIT License. See License.txt in the project root for license information.',
+		' *--------------------------------------------------------------------------------------------*/',
+		'',
+		'// THIS IS A GENERATED FILE. DO NOT EDIT DIRECTLY.',
+		''
+	].concat(enums.map(e => e.text)).join(endl);
+	resultEnums = resultEnums.split(/\r\n|\n|\r/).join(endl);
+	resultEnums = format(resultEnums, endl);
+	resultEnums = resultEnums.split(/\r\n|\n|\r/).join(endl);
+
+	return {
+		result: resultTxt,
+		usageContent: `${usageImports.join('\n')}\n\n${usage.join('\n')}`,
+		enums: resultEnums
+	};
+}
+
+export interface IMonacoDeclarationResult {
+	content: string;
+	usageContent: string;
+	enums: string;
+	filePath: string;
+	isTheSame: boolean;
+}
+
+function _run(sourceFileGetter: SourceFileGetter): IMonacoDeclarationResult | null {
+	const recipe = fs.readFileSync(RECIPE_PATH).toString();
+	const t = generateDeclarationFile(recipe, sourceFileGetter);
+	if (!t) {
+		return null;
+	}
+
+	const result = t.result;
+	const usageContent = t.usageContent;
+	const enums = t.enums;
+
+	const currentContent = fs.readFileSync(DECLARATION_PATH).toString();
+	const one = currentContent.replace(/\r\n/gm, '\n');
+	const other = result.replace(/\r\n/gm, '\n');
+	const isTheSame = (one === other);
+
+	return {
+		content: result,
+		usageContent: usageContent,
+		enums: enums,
+		filePath: DECLARATION_PATH,
+		isTheSame
+	};
+}
+
+export class FSProvider {
+	public existsSync(filePath: string): boolean {
+		return fs.existsSync(filePath);
+	}
+	public statSync(filePath: string): fs.Stats {
+		return fs.statSync(filePath);
+	}
+	public readFileSync(_moduleId: string, filePath: string): Buffer {
+		return fs.readFileSync(filePath);
+	}
+}
+
+class CacheEntry {
+	constructor(
+		public readonly sourceFile: ts.SourceFile,
+		public readonly mtime: number
+	) {}
+}
+
+export class DeclarationResolver {
+
+	private _sourceFileCache: { [moduleId: string]: CacheEntry | null; };
+
+	constructor(private readonly _fsProvider: FSProvider) {
+		this._sourceFileCache = Object.create(null);
+	}
+
+	public invalidateCache(moduleId: string): void {
+		this._sourceFileCache[moduleId] = null;
+	}
+
+	public getDeclarationSourceFile(moduleId: string): ts.SourceFile | null {
+		if (this._sourceFileCache[moduleId]) {
+			// Since we cannot trust file watching to invalidate the cache, check also the mtime
+			const fileName = this._getFileName(moduleId);
+			const mtime = this._fsProvider.statSync(fileName).mtime.getTime();
+			if (this._sourceFileCache[moduleId]!.mtime !== mtime) {
+				this._sourceFileCache[moduleId] = null;
+			}
+		}
+		if (!this._sourceFileCache[moduleId]) {
+			this._sourceFileCache[moduleId] = this._getDeclarationSourceFile(moduleId);
+		}
+		return this._sourceFileCache[moduleId] ? this._sourceFileCache[moduleId]!.sourceFile : null;
+	}
+
+	private _getFileName(moduleId: string): string {
+		if (/\.d\.ts$/.test(moduleId)) {
+			return path.join(SRC, moduleId);
+		}
+		return path.join(SRC, `${moduleId}.ts`);
+	}
+
+	private _getDeclarationSourceFile(moduleId: string): CacheEntry | null {
+		const fileName = this._getFileName(moduleId);
+		if (!this._fsProvider.existsSync(fileName)) {
+			return null;
+		}
+		const mtime = this._fsProvider.statSync(fileName).mtime.getTime();
+		if (/\.d\.ts$/.test(moduleId)) {
+			// const mtime = this._fsProvider.statFileSync()
+			const fileContents = this._fsProvider.readFileSync(moduleId, fileName).toString();
+			return new CacheEntry(
+				ts.createSourceFile(fileName, fileContents, ts.ScriptTarget.ES5),
+				mtime
+			);
+		}
+		const fileContents = this._fsProvider.readFileSync(moduleId, fileName).toString();
+		const fileMap: IFileMap = {
+			'file.ts': fileContents
+		};
+		const service = ts.createLanguageService(new TypeScriptLanguageServiceHost({}, fileMap, {}));
+		const text = service.getEmitOutput('file.ts', true, true).outputFiles[0].text;
+		return new CacheEntry(
+			ts.createSourceFile(fileName, text, ts.ScriptTarget.ES5),
+			mtime
+		);
+	}
+}
+
+export function run3(resolver: DeclarationResolver): IMonacoDeclarationResult | null {
+	const sourceFileGetter = (moduleId: string) => resolver.getDeclarationSourceFile(moduleId);
+	return _run(sourceFileGetter);
+}
+
+
+
+
+interface ILibMap { [libName: string]: string; }
+interface IFileMap { [fileName: string]: string; }
+
+class TypeScriptLanguageServiceHost implements ts.LanguageServiceHost {
+
+	private readonly _libs: ILibMap;
+	private readonly _files: IFileMap;
+	private readonly _compilerOptions: ts.CompilerOptions;
+
+	constructor(libs: ILibMap, files: IFileMap, compilerOptions: ts.CompilerOptions) {
+		this._libs = libs;
+		this._files = files;
+		this._compilerOptions = compilerOptions;
+	}
+
+	// --- language service host ---------------
+
+	getCompilationSettings(): ts.CompilerOptions {
+		return this._compilerOptions;
+	}
+	getScriptFileNames(): string[] {
+		return (
+			([] as string[])
+				.concat(Object.keys(this._libs))
+				.concat(Object.keys(this._files))
+		);
+	}
+	getScriptVersion(_fileName: string): string {
+		return '1';
+	}
+	getProjectVersion(): string {
+		return '1';
+	}
+	getScriptSnapshot(fileName: string): ts.IScriptSnapshot {
+		if (this._files.hasOwnProperty(fileName)) {
+			return ts.ScriptSnapshot.fromString(this._files[fileName]);
+		} else if (this._libs.hasOwnProperty(fileName)) {
+			return ts.ScriptSnapshot.fromString(this._libs[fileName]);
+		} else {
+			return ts.ScriptSnapshot.fromString('');
+		}
+	}
+	getScriptKind(_fileName: string): ts.ScriptKind {
+		return ts.ScriptKind.TS;
+	}
+	getCurrentDirectory(): string {
+		return '';
+	}
+	getDefaultLibFileName(_options: ts.CompilerOptions): string {
+		return 'defaultLib:es5';
+	}
+	isDefaultLibFileName(fileName: string): boolean {
+		return fileName === this.getDefaultLibFileName(this._compilerOptions);
+	}
+}
+
+export function execute(): IMonacoDeclarationResult {
+	let r = run3(new DeclarationResolver(new FSProvider()));
+	if (!r) {
+		throw new Error(`monaco.d.ts generation error - Cannot continue`);
+	}
+	return r;
+}

lib/vscode/build/lib/nls.ts

@@ -0,0 +1,468 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import * as lazy from 'lazy.js';
+import { duplex, through } from 'event-stream';
+import * as File from 'vinyl';
+import * as sm from 'source-map';
+import * as  path from 'path';
+
+declare class FileSourceMap extends File {
+	public sourceMap: sm.RawSourceMap;
+}
+
+enum CollectStepResult {
+	Yes,
+	YesAndRecurse,
+	No,
+	NoAndRecurse
+}
+
+function collect(node: ts.Node, fn: (node: ts.Node) => CollectStepResult): ts.Node[] {
+	const result: ts.Node[] = [];
+
+	function loop(node: ts.Node) {
+		const stepResult = fn(node);
+
+		if (stepResult === CollectStepResult.Yes || stepResult === CollectStepResult.YesAndRecurse) {
+			result.push(node);
+		}
+
+		if (stepResult === CollectStepResult.YesAndRecurse || stepResult === CollectStepResult.NoAndRecurse) {
+			ts.forEachChild(node, loop);
+		}
+	}
+
+	loop(node);
+	return result;
+}
+
+function clone<T>(object: T): T {
+	const result = <T>{};
+	for (const id in object) {
+		result[id] = object[id];
+	}
+	return result;
+}
+
+function template(lines: string[]): string {
+	let indent = '', wrap = '';
+
+	if (lines.length > 1) {
+		indent = '\t';
+		wrap = '\n';
+	}
+
+	return `/*---------------------------------------------------------
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------*/
+define([], [${ wrap + lines.map(l => indent + l).join(',\n') + wrap}]);`;
+}
+
+/**
+ * Returns a stream containing the patched JavaScript and source maps.
+ */
+function nls(): NodeJS.ReadWriteStream {
+	const input = through();
+	const output = input.pipe(through(function (f: FileSourceMap) {
+		if (!f.sourceMap) {
+			return this.emit('error', new Error(`File ${f.relative} does not have sourcemaps.`));
+		}
+
+		let source = f.sourceMap.sources[0];
+		if (!source) {
+			return this.emit('error', new Error(`File ${f.relative} does not have a source in the source map.`));
+		}
+
+		const root = f.sourceMap.sourceRoot;
+		if (root) {
+			source = path.join(root, source);
+		}
+
+		const typescript = f.sourceMap.sourcesContent![0];
+		if (!typescript) {
+			return this.emit('error', new Error(`File ${f.relative} does not have the original content in the source map.`));
+		}
+
+		nls.patchFiles(f, typescript).forEach(f => this.emit('data', f));
+	}));
+
+	return duplex(input, output);
+}
+
+function isImportNode(node: ts.Node): boolean {
+	return node.kind === ts.SyntaxKind.ImportDeclaration || node.kind === ts.SyntaxKind.ImportEqualsDeclaration;
+}
+
+module nls {
+
+	export interface INlsStringResult {
+		javascript: string;
+		sourcemap: sm.RawSourceMap;
+		nls?: string;
+		nlsKeys?: string;
+	}
+
+	export interface ISpan {
+		start: ts.LineAndCharacter;
+		end: ts.LineAndCharacter;
+	}
+
+	export interface ILocalizeCall {
+		keySpan: ISpan;
+		key: string;
+		valueSpan: ISpan;
+		value: string;
+	}
+
+	export interface ILocalizeAnalysisResult {
+		localizeCalls: ILocalizeCall[];
+		nlsExpressions: ISpan[];
+	}
+
+	export interface IPatch {
+		span: ISpan;
+		content: string;
+	}
+
+	export function fileFrom(file: File, contents: string, path: string = file.path) {
+		return new File({
+			contents: Buffer.from(contents),
+			base: file.base,
+			cwd: file.cwd,
+			path: path
+		});
+	}
+
+	export function mappedPositionFrom(source: string, lc: ts.LineAndCharacter): sm.MappedPosition {
+		return { source, line: lc.line + 1, column: lc.character };
+	}
+
+	export function lcFrom(position: sm.Position): ts.LineAndCharacter {
+		return { line: position.line - 1, character: position.column };
+	}
+
+	export class SingleFileServiceHost implements ts.LanguageServiceHost {
+
+		private file: ts.IScriptSnapshot;
+		private lib: ts.IScriptSnapshot;
+
+		constructor(private options: ts.CompilerOptions, private filename: string, contents: string) {
+			this.file = ts.ScriptSnapshot.fromString(contents);
+			this.lib = ts.ScriptSnapshot.fromString('');
+		}
+
+		getCompilationSettings = () => this.options;
+		getScriptFileNames = () => [this.filename];
+		getScriptVersion = () => '1';
+		getScriptSnapshot = (name: string) => name === this.filename ? this.file : this.lib;
+		getCurrentDirectory = () => '';
+		getDefaultLibFileName = () => 'lib.d.ts';
+	}
+
+	function isCallExpressionWithinTextSpanCollectStep(textSpan: ts.TextSpan, node: ts.Node): CollectStepResult {
+		if (!ts.textSpanContainsTextSpan({ start: node.pos, length: node.end - node.pos }, textSpan)) {
+			return CollectStepResult.No;
+		}
+
+		return node.kind === ts.SyntaxKind.CallExpression ? CollectStepResult.YesAndRecurse : CollectStepResult.NoAndRecurse;
+	}
+
+	export function analyze(contents: string, options: ts.CompilerOptions = {}): ILocalizeAnalysisResult {
+		const filename = 'file.ts';
+		const serviceHost = new SingleFileServiceHost(Object.assign(clone(options), { noResolve: true }), filename, contents);
+		const service = ts.createLanguageService(serviceHost);
+		const sourceFile = ts.createSourceFile(filename, contents, ts.ScriptTarget.ES5, true);
+
+		// all imports
+		const imports = lazy(collect(sourceFile, n => isImportNode(n) ? CollectStepResult.YesAndRecurse : CollectStepResult.NoAndRecurse));
+
+		// import nls = require('vs/nls');
+		const importEqualsDeclarations = imports
+			.filter(n => n.kind === ts.SyntaxKind.ImportEqualsDeclaration)
+			.map(n => <ts.ImportEqualsDeclaration>n)
+			.filter(d => d.moduleReference.kind === ts.SyntaxKind.ExternalModuleReference)
+			.filter(d => (<ts.ExternalModuleReference>d.moduleReference).expression.getText() === '\'vs/nls\'');
+
+		// import ... from 'vs/nls';
+		const importDeclarations = imports
+			.filter(n => n.kind === ts.SyntaxKind.ImportDeclaration)
+			.map(n => <ts.ImportDeclaration>n)
+			.filter(d => d.moduleSpecifier.kind === ts.SyntaxKind.StringLiteral)
+			.filter(d => d.moduleSpecifier.getText() === '\'vs/nls\'')
+			.filter(d => !!d.importClause && !!d.importClause.namedBindings);
+
+		const nlsExpressions = importEqualsDeclarations
+			.map(d => (<ts.ExternalModuleReference>d.moduleReference).expression)
+			.concat(importDeclarations.map(d => d.moduleSpecifier))
+			.map<ISpan>(d => ({
+				start: ts.getLineAndCharacterOfPosition(sourceFile, d.getStart()),
+				end: ts.getLineAndCharacterOfPosition(sourceFile, d.getEnd())
+			}));
+
+		// `nls.localize(...)` calls
+		const nlsLocalizeCallExpressions = importDeclarations
+			.filter(d => !!(d.importClause && d.importClause.namedBindings && d.importClause.namedBindings.kind === ts.SyntaxKind.NamespaceImport))
+			.map(d => (<ts.NamespaceImport>d.importClause!.namedBindings).name)
+			.concat(importEqualsDeclarations.map(d => d.name))
+
+			// find read-only references to `nls`
+			.map(n => service.getReferencesAtPosition(filename, n.pos + 1))
+			.flatten()
+			.filter(r => !r.isWriteAccess)
+
+			// find the deepest call expressions AST nodes that contain those references
+			.map(r => collect(sourceFile, n => isCallExpressionWithinTextSpanCollectStep(r.textSpan, n)))
+			.map(a => lazy(a).last())
+			.filter(n => !!n)
+			.map(n => <ts.CallExpression>n)
+
+			// only `localize` calls
+			.filter(n => n.expression.kind === ts.SyntaxKind.PropertyAccessExpression && (<ts.PropertyAccessExpression>n.expression).name.getText() === 'localize');
+
+		// `localize` named imports
+		const allLocalizeImportDeclarations = importDeclarations
+			.filter(d => !!(d.importClause && d.importClause.namedBindings && d.importClause.namedBindings.kind === ts.SyntaxKind.NamedImports))
+			.map(d => ([] as any[]).concat((<ts.NamedImports>d.importClause!.namedBindings!).elements))
+			.flatten();
+
+		// `localize` read-only references
+		const localizeReferences = allLocalizeImportDeclarations
+			.filter(d => d.name.getText() === 'localize')
+			.map(n => service.getReferencesAtPosition(filename, n.pos + 1))
+			.flatten()
+			.filter(r => !r.isWriteAccess);
+
+		// custom named `localize` read-only references
+		const namedLocalizeReferences = allLocalizeImportDeclarations
+			.filter(d => d.propertyName && d.propertyName.getText() === 'localize')
+			.map(n => service.getReferencesAtPosition(filename, n.name.pos + 1))
+			.flatten()
+			.filter(r => !r.isWriteAccess);
+
+		// find the deepest call expressions AST nodes that contain those references
+		const localizeCallExpressions = localizeReferences
+			.concat(namedLocalizeReferences)
+			.map(r => collect(sourceFile, n => isCallExpressionWithinTextSpanCollectStep(r.textSpan, n)))
+			.map(a => lazy(a).last())
+			.filter(n => !!n)
+			.map(n => <ts.CallExpression>n);
+
+		// collect everything
+		const localizeCalls = nlsLocalizeCallExpressions
+			.concat(localizeCallExpressions)
+			.map(e => e.arguments)
+			.filter(a => a.length > 1)
+			.sort((a, b) => a[0].getStart() - b[0].getStart())
+			.map<ILocalizeCall>(a => ({
+				keySpan: { start: ts.getLineAndCharacterOfPosition(sourceFile, a[0].getStart()), end: ts.getLineAndCharacterOfPosition(sourceFile, a[0].getEnd()) },
+				key: a[0].getText(),
+				valueSpan: { start: ts.getLineAndCharacterOfPosition(sourceFile, a[1].getStart()), end: ts.getLineAndCharacterOfPosition(sourceFile, a[1].getEnd()) },
+				value: a[1].getText()
+			}));
+
+		return {
+			localizeCalls: localizeCalls.toArray(),
+			nlsExpressions: nlsExpressions.toArray()
+		};
+	}
+
+	export class TextModel {
+
+		private lines: string[];
+		private lineEndings: string[];
+
+		constructor(contents: string) {
+			const regex = /\r\n|\r|\n/g;
+			let index = 0;
+			let match: RegExpExecArray | null;
+
+			this.lines = [];
+			this.lineEndings = [];
+
+			while (match = regex.exec(contents)) {
+				this.lines.push(contents.substring(index, match.index));
+				this.lineEndings.push(match[0]);
+				index = regex.lastIndex;
+			}
+
+			if (contents.length > 0) {
+				this.lines.push(contents.substring(index, contents.length));
+				this.lineEndings.push('');
+			}
+		}
+
+		public get(index: number): string {
+			return this.lines[index];
+		}
+
+		public set(index: number, line: string): void {
+			this.lines[index] = line;
+		}
+
+		public get lineCount(): number {
+			return this.lines.length;
+		}
+
+		/**
+		 * Applies patch(es) to the model.
+		 * Multiple patches must be ordered.
+		 * Does not support patches spanning multiple lines.
+		 */
+		public apply(patch: IPatch): void {
+			const startLineNumber = patch.span.start.line;
+			const endLineNumber = patch.span.end.line;
+
+			const startLine = this.lines[startLineNumber] || '';
+			const endLine = this.lines[endLineNumber] || '';
+
+			this.lines[startLineNumber] = [
+				startLine.substring(0, patch.span.start.character),
+				patch.content,
+				endLine.substring(patch.span.end.character)
+			].join('');
+
+			for (let i = startLineNumber + 1; i <= endLineNumber; i++) {
+				this.lines[i] = '';
+			}
+		}
+
+		public toString(): string {
+			return lazy(this.lines).zip(this.lineEndings)
+				.flatten().toArray().join('');
+		}
+	}
+
+	export function patchJavascript(patches: IPatch[], contents: string, moduleId: string): string {
+		const model = new nls.TextModel(contents);
+
+		// patch the localize calls
+		lazy(patches).reverse().each(p => model.apply(p));
+
+		// patch the 'vs/nls' imports
+		const firstLine = model.get(0);
+		const patchedFirstLine = firstLine.replace(/(['"])vs\/nls\1/g, `$1vs/nls!${moduleId}$1`);
+		model.set(0, patchedFirstLine);
+
+		return model.toString();
+	}
+
+	export function patchSourcemap(patches: IPatch[], rsm: sm.RawSourceMap, smc: sm.SourceMapConsumer): sm.RawSourceMap {
+		const smg = new sm.SourceMapGenerator({
+			file: rsm.file,
+			sourceRoot: rsm.sourceRoot
+		});
+
+		patches = patches.reverse();
+		let currentLine = -1;
+		let currentLineDiff = 0;
+		let source: string | null = null;
+
+		smc.eachMapping(m => {
+			const patch = patches[patches.length - 1];
+			const original = { line: m.originalLine, column: m.originalColumn };
+			const generated = { line: m.generatedLine, column: m.generatedColumn };
+
+			if (currentLine !== generated.line) {
+				currentLineDiff = 0;
+			}
+
+			currentLine = generated.line;
+			generated.column += currentLineDiff;
+
+			if (patch && m.generatedLine - 1 === patch.span.end.line && m.generatedColumn === patch.span.end.character) {
+				const originalLength = patch.span.end.character - patch.span.start.character;
+				const modifiedLength = patch.content.length;
+				const lengthDiff = modifiedLength - originalLength;
+				currentLineDiff += lengthDiff;
+				generated.column += lengthDiff;
+
+				patches.pop();
+			}
+
+			source = rsm.sourceRoot ? path.relative(rsm.sourceRoot, m.source) : m.source;
+			source = source.replace(/\\/g, '/');
+			smg.addMapping({ source, name: m.name, original, generated });
+		}, null, sm.SourceMapConsumer.GENERATED_ORDER);
+
+		if (source) {
+			smg.setSourceContent(source, smc.sourceContentFor(source));
+		}
+
+		return JSON.parse(smg.toString());
+	}
+
+	export function patch(moduleId: string, typescript: string, javascript: string, sourcemap: sm.RawSourceMap): INlsStringResult {
+		const { localizeCalls, nlsExpressions } = analyze(typescript);
+
+		if (localizeCalls.length === 0) {
+			return { javascript, sourcemap };
+		}
+
+		const nlsKeys = template(localizeCalls.map(lc => lc.key));
+		const nls = template(localizeCalls.map(lc => lc.value));
+		const smc = new sm.SourceMapConsumer(sourcemap);
+		const positionFrom = mappedPositionFrom.bind(null, sourcemap.sources[0]);
+		let i = 0;
+
+		// build patches
+		const patches = lazy(localizeCalls)
+			.map(lc => ([
+				{ range: lc.keySpan, content: '' + (i++) },
+				{ range: lc.valueSpan, content: 'null' }
+			]))
+			.flatten()
+			.map<IPatch>(c => {
+				const start = lcFrom(smc.generatedPositionFor(positionFrom(c.range.start)));
+				const end = lcFrom(smc.generatedPositionFor(positionFrom(c.range.end)));
+				return { span: { start, end }, content: c.content };
+			})
+			.toArray();
+
+		javascript = patchJavascript(patches, javascript, moduleId);
+
+		// since imports are not within the sourcemap information,
+		// we must do this MacGyver style
+		if (nlsExpressions.length) {
+			javascript = javascript.replace(/^define\(.*$/m, line => {
+				return line.replace(/(['"])vs\/nls\1/g, `$1vs/nls!${moduleId}$1`);
+			});
+		}
+
+		sourcemap = patchSourcemap(patches, sourcemap, smc);
+
+		return { javascript, sourcemap, nlsKeys, nls };
+	}
+
+	export function patchFiles(javascriptFile: File, typescript: string): File[] {
+		// hack?
+		const moduleId = javascriptFile.relative
+			.replace(/\.js$/, '')
+			.replace(/\\/g, '/');
+
+		const { javascript, sourcemap, nlsKeys, nls } = patch(
+			moduleId,
+			typescript,
+			javascriptFile.contents.toString(),
+			(<any>javascriptFile).sourceMap
+		);
+
+		const result: File[] = [fileFrom(javascriptFile, javascript)];
+		(<any>result[0]).sourceMap = sourcemap;
+
+		if (nlsKeys) {
+			result.push(fileFrom(javascriptFile, nlsKeys, javascriptFile.path.replace(/\.js$/, '.nls.keys.js')));
+		}
+
+		if (nls) {
+			result.push(fileFrom(javascriptFile, nls, javascriptFile.path.replace(/\.js$/, '.nls.js')));
+		}
+
+		return result;
+	}
+}
+
+export = nls;

lib/vscode/build/lib/node.ts

@@ -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.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as path from 'path';
+import * as fs from 'fs';
+
+const root = path.dirname(path.dirname(__dirname));
+const yarnrcPath = path.join(root, 'remote', '.yarnrc');
+const yarnrc = fs.readFileSync(yarnrcPath, 'utf8');
+const version = /^target\s+"([^"]+)"$/m.exec(yarnrc)![1];
+const node = process.platform === 'win32' ? 'node.exe' : 'node';
+const nodePath = path.join(root, '.build', 'node', `v${version}`, `${process.platform}-${process.arch}`, node);
+
+console.log(nodePath);

lib/vscode/build/lib/optimize.ts

@@ -0,0 +1,328 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 gulp from 'gulp';
+import * as concat from 'gulp-concat';
+import * as minifyCSS from 'gulp-cssnano';
+import * as filter from 'gulp-filter';
+import * as flatmap from 'gulp-flatmap';
+import * as sourcemaps from 'gulp-sourcemaps';
+import * as uglify from 'gulp-uglify';
+import * as composer from 'gulp-uglify/composer';
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+import * as path from 'path';
+import * as pump from 'pump';
+import * as terser from 'terser';
+import * as VinylFile from 'vinyl';
+import * as bundle from './bundle';
+import { Language, processNlsFiles } from './i18n';
+import { createStatsStream } from './stats';
+import * as util from './util';
+
+const REPO_ROOT_PATH = path.join(__dirname, '../..');
+
+function log(prefix: string, message: string): void {
+	fancyLog(ansiColors.cyan('[' + prefix + ']'), message);
+}
+
+export function loaderConfig() {
+	const result: any = {
+		paths: {
+			'vs': 'out-build/vs',
+			'vscode': 'empty:'
+		},
+		amdModulesPattern: /^vs\//
+	};
+
+	result['vs/css'] = { inlineResources: true };
+
+	return result;
+}
+
+const IS_OUR_COPYRIGHT_REGEXP = /Copyright \(C\) Microsoft Corporation/i;
+
+function loader(src: string, bundledFileHeader: string, bundleLoader: boolean): NodeJS.ReadWriteStream {
+	let sources = [
+		`${src}/vs/loader.js`
+	];
+	if (bundleLoader) {
+		sources = sources.concat([
+			`${src}/vs/css.js`,
+			`${src}/vs/nls.js`
+		]);
+	}
+
+	let isFirst = true;
+	return (
+		gulp
+			.src(sources, { base: `${src}` })
+			.pipe(es.through(function (data) {
+				if (isFirst) {
+					isFirst = false;
+					this.emit('data', new VinylFile({
+						path: 'fake',
+						base: '.',
+						contents: Buffer.from(bundledFileHeader)
+					}));
+					this.emit('data', data);
+				} else {
+					this.emit('data', data);
+				}
+			}))
+			.pipe(concat('vs/loader.js'))
+	);
+}
+
+function toConcatStream(src: string, bundledFileHeader: string, sources: bundle.IFile[], dest: string, fileContentMapper: (contents: string, path: string) => string): NodeJS.ReadWriteStream {
+	const useSourcemaps = /\.js$/.test(dest) && !/\.nls\.js$/.test(dest);
+
+	// If a bundle ends up including in any of the sources our copyright, then
+	// insert a fake source at the beginning of each bundle with our copyright
+	let containsOurCopyright = false;
+	for (let i = 0, len = sources.length; i < len; i++) {
+		const fileContents = sources[i].contents;
+		if (IS_OUR_COPYRIGHT_REGEXP.test(fileContents)) {
+			containsOurCopyright = true;
+			break;
+		}
+	}
+
+	if (containsOurCopyright) {
+		sources.unshift({
+			path: null,
+			contents: bundledFileHeader
+		});
+	}
+
+	const treatedSources = sources.map(function (source) {
+		const root = source.path ? REPO_ROOT_PATH.replace(/\\/g, '/') : '';
+		const base = source.path ? root + `/${src}` : '.';
+		const path = source.path ? root + '/' + source.path.replace(/\\/g, '/') : 'fake';
+		const contents = source.path ? fileContentMapper(source.contents, path) : source.contents;
+
+		return new VinylFile({
+			path: path,
+			base: base,
+			contents: Buffer.from(contents)
+		});
+	});
+
+	return es.readArray(treatedSources)
+		.pipe(useSourcemaps ? util.loadSourcemaps() : es.through())
+		.pipe(concat(dest))
+		.pipe(createStatsStream(dest));
+}
+
+function toBundleStream(src: string, bundledFileHeader: string, bundles: bundle.IConcatFile[], fileContentMapper: (contents: string, path: string) => string): NodeJS.ReadWriteStream {
+	return es.merge(bundles.map(function (bundle) {
+		return toConcatStream(src, bundledFileHeader, bundle.sources, bundle.dest, fileContentMapper);
+	}));
+}
+
+export interface IOptimizeTaskOpts {
+	/**
+	 * The folder to read files from.
+	 */
+	src: string;
+	/**
+	 * (for AMD files, will get bundled and get Copyright treatment)
+	 */
+	entryPoints: bundle.IEntryPoint[];
+	/**
+	 * (svg, etc.)
+	 */
+	resources: string[];
+	loaderConfig: any;
+	/**
+	 * (true by default - append css and nls to loader)
+	 */
+	bundleLoader?: boolean;
+	/**
+	 * (basically the Copyright treatment)
+	 */
+	header?: string;
+	/**
+	 * (emit bundleInfo.json file)
+	 */
+	bundleInfo: boolean;
+	/**
+	 * (out folder name)
+	 */
+	out: string;
+	/**
+	 * (out folder name)
+	 */
+	languages?: Language[];
+	/**
+	 * File contents interceptor
+	 * @param contents The contens of the file
+	 * @param path The absolute file path, always using `/`, even on Windows
+	 */
+	fileContentMapper?: (contents: string, path: string) => string;
+}
+
+const DEFAULT_FILE_HEADER = [
+	'/*!--------------------------------------------------------',
+	' * Copyright (C) Microsoft Corporation. All rights reserved.',
+	' *--------------------------------------------------------*/'
+].join('\n');
+
+export function optimizeTask(opts: IOptimizeTaskOpts): () => NodeJS.ReadWriteStream {
+	const src = opts.src;
+	const entryPoints = opts.entryPoints;
+	const resources = opts.resources;
+	const loaderConfig = opts.loaderConfig;
+	const bundledFileHeader = opts.header || DEFAULT_FILE_HEADER;
+	const bundleLoader = (typeof opts.bundleLoader === 'undefined' ? true : opts.bundleLoader);
+	const out = opts.out;
+	const fileContentMapper = opts.fileContentMapper || ((contents: string, _path: string) => contents);
+
+	return function () {
+		const bundlesStream = es.through(); // this stream will contain the bundled files
+		const resourcesStream = es.through(); // this stream will contain the resources
+		const bundleInfoStream = es.through(); // this stream will contain bundleInfo.json
+
+		bundle.bundle(entryPoints, loaderConfig, function (err, result) {
+			if (err || !result) { return bundlesStream.emit('error', JSON.stringify(err)); }
+
+			toBundleStream(src, bundledFileHeader, result.files, fileContentMapper).pipe(bundlesStream);
+
+			// Remove css inlined resources
+			const filteredResources = resources.slice();
+			result.cssInlinedResources.forEach(function (resource) {
+				if (process.env['VSCODE_BUILD_VERBOSE']) {
+					log('optimizer', 'excluding inlined: ' + resource);
+				}
+				filteredResources.push('!' + resource);
+			});
+			gulp.src(filteredResources, { base: `${src}`, allowEmpty: true }).pipe(resourcesStream);
+
+			const bundleInfoArray: VinylFile[] = [];
+			if (opts.bundleInfo) {
+				bundleInfoArray.push(new VinylFile({
+					path: 'bundleInfo.json',
+					base: '.',
+					contents: Buffer.from(JSON.stringify(result.bundleData, null, '\t'))
+				}));
+			}
+			es.readArray(bundleInfoArray).pipe(bundleInfoStream);
+		});
+
+		const result = es.merge(
+			loader(src, bundledFileHeader, bundleLoader),
+			bundlesStream,
+			resourcesStream,
+			bundleInfoStream
+		);
+
+		return result
+			.pipe(sourcemaps.write('./', {
+				sourceRoot: undefined,
+				addComment: true,
+				includeContent: true
+			}))
+			.pipe(opts.languages && opts.languages.length ? processNlsFiles({
+				fileHeader: bundledFileHeader,
+				languages: opts.languages
+			}) : es.through())
+			.pipe(gulp.dest(out));
+	};
+}
+
+declare class FileWithCopyright extends VinylFile {
+	public __hasOurCopyright: boolean;
+}
+/**
+ * Wrap around uglify and allow the preserveComments function
+ * to have a file "context" to include our copyright only once per file.
+ */
+function uglifyWithCopyrights(): NodeJS.ReadWriteStream {
+	const preserveComments = (f: FileWithCopyright) => {
+		return (_node: any, comment: { value: string; type: string; }) => {
+			const text = comment.value;
+			const type = comment.type;
+
+			if (/@minifier_do_not_preserve/.test(text)) {
+				return false;
+			}
+
+			const isOurCopyright = IS_OUR_COPYRIGHT_REGEXP.test(text);
+
+			if (isOurCopyright) {
+				if (f.__hasOurCopyright) {
+					return false;
+				}
+				f.__hasOurCopyright = true;
+				return true;
+			}
+
+			if ('comment2' === type) {
+				// check for /*!. Note that text doesn't contain leading /*
+				return (text.length > 0 && text[0] === '!') || /@preserve|license|@cc_on|copyright/i.test(text);
+			} else if ('comment1' === type) {
+				return /license|copyright/i.test(text);
+			}
+			return false;
+		};
+	};
+
+	const minify = (composer as any)(terser);
+	const input = es.through();
+	const output = input
+		.pipe(flatmap((stream, f) => {
+			return stream.pipe(minify({
+				output: {
+					comments: preserveComments(<FileWithCopyright>f),
+					max_line_len: 1024
+				}
+			}));
+		}));
+
+	return es.duplex(input, output);
+}
+
+export function minifyTask(src: string, sourceMapBaseUrl?: string): (cb: any) => void {
+	const sourceMappingURL = sourceMapBaseUrl ? ((f: any) => `${sourceMapBaseUrl}/${f.relative}.map`) : undefined;
+
+	return cb => {
+		const jsFilter = filter('**/*.js', { restore: true });
+		const cssFilter = filter('**/*.css', { restore: true });
+
+		pump(
+			gulp.src([src + '/**', '!' + src + '/**/*.map']),
+			jsFilter,
+			sourcemaps.init({ loadMaps: true }),
+			uglifyWithCopyrights(),
+			jsFilter.restore,
+			cssFilter,
+			minifyCSS({ reduceIdents: false }),
+			cssFilter.restore,
+			(<any>sourcemaps).mapSources((sourcePath: string) => {
+				if (sourcePath === 'bootstrap-fork.js') {
+					return 'bootstrap-fork.orig.js';
+				}
+
+				return sourcePath;
+			}),
+			sourcemaps.write('./', {
+				sourceMappingURL,
+				sourceRoot: undefined,
+				includeContent: true,
+				addComment: true
+			} as any),
+			gulp.dest(src + '-min')
+			, (err: any) => {
+				if (err instanceof (uglify as any).GulpUglifyError) {
+					console.error(`Uglify error in '${err.cause && err.cause.filename}'`);
+				}
+
+				cb(err);
+			});
+	};
+}

lib/vscode/build/lib/preLaunch.ts

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+// @ts-check
+
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+
+const yarn = process.platform === 'win32' ? 'yarn.cmd' : 'yarn';
+const rootDir = path.resolve(__dirname, '..', '..');
+
+function runProcess(command: string, args: ReadonlyArray<string> = []) {
+	return new Promise<void>((resolve, reject) => {
+		const child = spawn(command, args, { cwd: rootDir, stdio: 'inherit', env: process.env });
+		child.on('exit', err => !err ? resolve() : process.exit(err ?? 1));
+		child.on('error', reject);
+	});
+}
+
+async function exists(subdir: string) {
+	try {
+		await fs.stat(path.join(rootDir, subdir));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function ensureNodeModules() {
+	if (!(await exists('node_modules'))) {
+		await runProcess(yarn);
+	}
+}
+
+async function getElectron() {
+	await runProcess(yarn, ['electron']);
+}
+
+async function ensureCompiled() {
+	if (!(await exists('out'))) {
+		await runProcess(yarn, ['compile']);
+	}
+}
+
+async function main() {
+	await ensureNodeModules();
+	await getElectron();
+	await ensureCompiled();
+
+	// Can't require this until after dependencies are installed
+	const { getBuiltInExtensions } = require('./builtInExtensions');
+	await getBuiltInExtensions();
+}
+
+if (require.main === module) {
+	main().catch(err => {
+		console.error(err);
+		process.exit(1);
+	});
+}

lib/vscode/build/lib/reporter.ts

@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 _ from 'underscore';
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const allErrors: string[][] = [];
+let startTime: number | null = null;
+let count = 0;
+
+function onStart(): void {
+	if (count++ > 0) {
+		return;
+	}
+
+	startTime = new Date().getTime();
+	fancyLog(`Starting ${ansiColors.green('compilation')}...`);
+}
+
+function onEnd(): void {
+	if (--count > 0) {
+		return;
+	}
+
+	log();
+}
+
+const buildLogPath = path.join(path.dirname(path.dirname(__dirname)), '.build', 'log');
+
+try {
+	fs.mkdirSync(path.dirname(buildLogPath));
+} catch (err) {
+	// ignore
+}
+
+function log(): void {
+	const errors = _.flatten(allErrors);
+	const seen = new Set<string>();
+
+	errors.map(err => {
+		if (!seen.has(err)) {
+			seen.add(err);
+			fancyLog(`${ansiColors.red('Error')}: ${err}`);
+		}
+	});
+
+	const regex = /^([^(]+)\((\d+),(\d+)\): (.*)$/;
+	const messages = errors
+		.map(err => regex.exec(err))
+		.filter(match => !!match)
+		.map(x => x as string[])
+		.map(([, path, line, column, message]) => ({ path, line: parseInt(line), column: parseInt(column), message }));
+
+	try {
+
+		fs.writeFileSync(buildLogPath, JSON.stringify(messages));
+	} catch (err) {
+		//noop
+	}
+
+	fancyLog(`Finished ${ansiColors.green('compilation')} with ${errors.length} errors after ${ansiColors.magenta((new Date().getTime() - startTime!) + ' ms')}`);
+}
+
+export interface IReporter {
+	(err: string): void;
+	hasErrors(): boolean;
+	end(emitError: boolean): NodeJS.ReadWriteStream;
+}
+
+export function createReporter(): IReporter {
+	const errors: string[] = [];
+	allErrors.push(errors);
+
+	const result = (err: string) => errors.push(err);
+
+	result.hasErrors = () => errors.length > 0;
+
+	result.end = (emitError: boolean): NodeJS.ReadWriteStream => {
+		errors.length = 0;
+		onStart();
+
+		return es.through(undefined, function () {
+			onEnd();
+
+			if (emitError && errors.length > 0) {
+				if (!(errors as any).__logged__) {
+					log();
+				}
+
+				(errors as any).__logged__ = true;
+
+				const err = new Error(`Found ${errors.length} errors`);
+				(err as any).__reporter__ = true;
+				this.emit('error', err);
+			} else {
+				this.emit('end');
+			}
+		});
+	};
+
+	return result;
+}

lib/vscode/build/lib/snapshotLoader.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';
+
+namespace snaps {
+
+	const fs = require('fs');
+	const path = require('path');
+	const os = require('os');
+	const cp = require('child_process');
+
+	const mksnapshot = path.join(__dirname, `../../node_modules/.bin/${process.platform === 'win32' ? 'mksnapshot.cmd' : 'mksnapshot'}`);
+	const product = require('../../product.json');
+	const arch = (process.argv.join('').match(/--arch=(.*)/) || [])[1];
+
+	//
+	let loaderFilepath: string;
+	let startupBlobFilepath: string;
+
+	switch (process.platform) {
+		case 'darwin':
+			loaderFilepath = `VSCode-darwin/${product.nameLong}.app/Contents/Resources/app/out/vs/loader.js`;
+			startupBlobFilepath = `VSCode-darwin/${product.nameLong}.app/Contents/Frameworks/Electron Framework.framework/Resources/snapshot_blob.bin`;
+			break;
+
+		case 'win32':
+		case 'linux':
+			loaderFilepath = `VSCode-${process.platform}-${arch}/resources/app/out/vs/loader.js`;
+			startupBlobFilepath = `VSCode-${process.platform}-${arch}/snapshot_blob.bin`;
+			break;
+
+		default:
+			throw new Error('Unknown platform');
+	}
+
+	loaderFilepath = path.join(__dirname, '../../../', loaderFilepath);
+	startupBlobFilepath = path.join(__dirname, '../../../', startupBlobFilepath);
+
+	snapshotLoader(loaderFilepath, startupBlobFilepath);
+
+	function snapshotLoader(loaderFilepath: string, startupBlobFilepath: string): void {
+
+		const inputFile = fs.readFileSync(loaderFilepath);
+		const wrappedInputFile = `
+		var Monaco_Loader_Init;
+		(function() {
+			var doNotInitLoader = true;
+			${inputFile.toString()};
+			Monaco_Loader_Init = function() {
+				AMDLoader.init();
+				CSSLoaderPlugin.init();
+				NLSLoaderPlugin.init();
+
+				return { define, require };
+			}
+		})();
+		`;
+		const wrappedInputFilepath = path.join(os.tmpdir(), 'wrapped-loader.js');
+		console.log(wrappedInputFilepath);
+		fs.writeFileSync(wrappedInputFilepath, wrappedInputFile);
+
+		cp.execFileSync(mksnapshot, [wrappedInputFilepath, `--startup_blob`, startupBlobFilepath]);
+	}
+}

lib/vscode/build/lib/standalone.ts

@@ -0,0 +1,369 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as ts from 'typescript';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as tss from './treeshaking';
+
+const REPO_ROOT = path.join(__dirname, '../../');
+const SRC_DIR = path.join(REPO_ROOT, 'src');
+
+let dirCache: { [dir: string]: boolean; } = {};
+
+function writeFile(filePath: string, contents: Buffer | string): void {
+	function ensureDirs(dirPath: string): void {
+		if (dirCache[dirPath]) {
+			return;
+		}
+		dirCache[dirPath] = true;
+
+		ensureDirs(path.dirname(dirPath));
+		if (fs.existsSync(dirPath)) {
+			return;
+		}
+		fs.mkdirSync(dirPath);
+	}
+	ensureDirs(path.dirname(filePath));
+	fs.writeFileSync(filePath, contents);
+}
+
+export function extractEditor(options: tss.ITreeShakingOptions & { destRoot: string }): void {
+	const tsConfig = JSON.parse(fs.readFileSync(path.join(options.sourcesRoot, 'tsconfig.monaco.json')).toString());
+	let compilerOptions: { [key: string]: any };
+	if (tsConfig.extends) {
+		compilerOptions = Object.assign({}, require(path.join(options.sourcesRoot, tsConfig.extends)).compilerOptions, tsConfig.compilerOptions);
+		delete tsConfig.extends;
+	} else {
+		compilerOptions = tsConfig.compilerOptions;
+	}
+	tsConfig.compilerOptions = compilerOptions;
+
+	compilerOptions.noEmit = false;
+	compilerOptions.noUnusedLocals = false;
+	compilerOptions.preserveConstEnums = false;
+	compilerOptions.declaration = false;
+	compilerOptions.moduleResolution = ts.ModuleResolutionKind.Classic;
+
+
+	options.compilerOptions = compilerOptions;
+
+	console.log(`Running tree shaker with shakeLevel ${tss.toStringShakeLevel(options.shakeLevel)}`);
+
+	// Take the extra included .d.ts files from `tsconfig.monaco.json`
+	options.typings = (<string[]>tsConfig.include).filter(includedFile => /\.d\.ts$/.test(includedFile));
+
+	// Add extra .d.ts files from `node_modules/@types/`
+	if (Array.isArray(options.compilerOptions?.types)) {
+		options.compilerOptions.types.forEach((type: string) => {
+			options.typings.push(`../node_modules/@types/${type}/index.d.ts`);
+		});
+	}
+
+	let result = tss.shake(options);
+	for (let fileName in result) {
+		if (result.hasOwnProperty(fileName)) {
+			writeFile(path.join(options.destRoot, fileName), result[fileName]);
+		}
+	}
+	let copied: { [fileName: string]: boolean; } = {};
+	const copyFile = (fileName: string) => {
+		if (copied[fileName]) {
+			return;
+		}
+		copied[fileName] = true;
+		const srcPath = path.join(options.sourcesRoot, fileName);
+		const dstPath = path.join(options.destRoot, fileName);
+		writeFile(dstPath, fs.readFileSync(srcPath));
+	};
+	const writeOutputFile = (fileName: string, contents: string | Buffer) => {
+		writeFile(path.join(options.destRoot, fileName), contents);
+	};
+	for (let fileName in result) {
+		if (result.hasOwnProperty(fileName)) {
+			const fileContents = result[fileName];
+			const info = ts.preProcessFile(fileContents);
+
+			for (let i = info.importedFiles.length - 1; i >= 0; i--) {
+				const importedFileName = info.importedFiles[i].fileName;
+
+				let importedFilePath: string;
+				if (/^vs\/css!/.test(importedFileName)) {
+					importedFilePath = importedFileName.substr('vs/css!'.length) + '.css';
+				} else {
+					importedFilePath = importedFileName;
+				}
+				if (/(^\.\/)|(^\.\.\/)/.test(importedFilePath)) {
+					importedFilePath = path.join(path.dirname(fileName), importedFilePath);
+				}
+
+				if (/\.css$/.test(importedFilePath)) {
+					transportCSS(importedFilePath, copyFile, writeOutputFile);
+				} else {
+					if (fs.existsSync(path.join(options.sourcesRoot, importedFilePath + '.js'))) {
+						copyFile(importedFilePath + '.js');
+					}
+				}
+			}
+		}
+	}
+
+	delete tsConfig.compilerOptions.moduleResolution;
+	writeOutputFile('tsconfig.json', JSON.stringify(tsConfig, null, '\t'));
+
+	[
+		'vs/css.build.js',
+		'vs/css.d.ts',
+		'vs/css.js',
+		'vs/loader.js',
+		'vs/nls.build.js',
+		'vs/nls.d.ts',
+		'vs/nls.js',
+		'vs/nls.mock.ts',
+	].forEach(copyFile);
+}
+
+export interface IOptions2 {
+	srcFolder: string;
+	outFolder: string;
+	outResourcesFolder: string;
+	ignores: string[];
+	renames: { [filename: string]: string; };
+}
+
+export function createESMSourcesAndResources2(options: IOptions2): void {
+	const SRC_FOLDER = path.join(REPO_ROOT, options.srcFolder);
+	const OUT_FOLDER = path.join(REPO_ROOT, options.outFolder);
+	const OUT_RESOURCES_FOLDER = path.join(REPO_ROOT, options.outResourcesFolder);
+
+	const getDestAbsoluteFilePath = (file: string): string => {
+		let dest = options.renames[file.replace(/\\/g, '/')] || file;
+		if (dest === 'tsconfig.json') {
+			return path.join(OUT_FOLDER, `tsconfig.json`);
+		}
+		if (/\.ts$/.test(dest)) {
+			return path.join(OUT_FOLDER, dest);
+		}
+		return path.join(OUT_RESOURCES_FOLDER, dest);
+	};
+
+	const allFiles = walkDirRecursive(SRC_FOLDER);
+	for (const file of allFiles) {
+
+		if (options.ignores.indexOf(file.replace(/\\/g, '/')) >= 0) {
+			continue;
+		}
+
+		if (file === 'tsconfig.json') {
+			const tsConfig = JSON.parse(fs.readFileSync(path.join(SRC_FOLDER, file)).toString());
+			tsConfig.compilerOptions.module = 'es6';
+			tsConfig.compilerOptions.outDir = path.join(path.relative(OUT_FOLDER, OUT_RESOURCES_FOLDER), 'vs').replace(/\\/g, '/');
+			write(getDestAbsoluteFilePath(file), JSON.stringify(tsConfig, null, '\t'));
+			continue;
+		}
+
+		if (/\.d\.ts$/.test(file) || /\.css$/.test(file) || /\.js$/.test(file) || /\.ttf$/.test(file)) {
+			// Transport the files directly
+			write(getDestAbsoluteFilePath(file), fs.readFileSync(path.join(SRC_FOLDER, file)));
+			continue;
+		}
+
+		if (/\.ts$/.test(file)) {
+			// Transform the .ts file
+			let fileContents = fs.readFileSync(path.join(SRC_FOLDER, file)).toString();
+
+			const info = ts.preProcessFile(fileContents);
+
+			for (let i = info.importedFiles.length - 1; i >= 0; i--) {
+				const importedFilename = info.importedFiles[i].fileName;
+				const pos = info.importedFiles[i].pos;
+				const end = info.importedFiles[i].end;
+
+				let importedFilepath: string;
+				if (/^vs\/css!/.test(importedFilename)) {
+					importedFilepath = importedFilename.substr('vs/css!'.length) + '.css';
+				} else {
+					importedFilepath = importedFilename;
+				}
+				if (/(^\.\/)|(^\.\.\/)/.test(importedFilepath)) {
+					importedFilepath = path.join(path.dirname(file), importedFilepath);
+				}
+
+				let relativePath: string;
+				if (importedFilepath === path.dirname(file).replace(/\\/g, '/')) {
+					relativePath = '../' + path.basename(path.dirname(file));
+				} else if (importedFilepath === path.dirname(path.dirname(file)).replace(/\\/g, '/')) {
+					relativePath = '../../' + path.basename(path.dirname(path.dirname(file)));
+				} else {
+					relativePath = path.relative(path.dirname(file), importedFilepath);
+				}
+				relativePath = relativePath.replace(/\\/g, '/');
+				if (!/(^\.\/)|(^\.\.\/)/.test(relativePath)) {
+					relativePath = './' + relativePath;
+				}
+				fileContents = (
+					fileContents.substring(0, pos + 1)
+					+ relativePath
+					+ fileContents.substring(end + 1)
+				);
+			}
+
+			fileContents = fileContents.replace(/import ([a-zA-z0-9]+) = require\(('[^']+')\);/g, function (_, m1, m2) {
+				return `import * as ${m1} from ${m2};`;
+			});
+
+			write(getDestAbsoluteFilePath(file), fileContents);
+			continue;
+		}
+
+		console.log(`UNKNOWN FILE: ${file}`);
+	}
+
+
+	function walkDirRecursive(dir: string): string[] {
+		if (dir.charAt(dir.length - 1) !== '/' || dir.charAt(dir.length - 1) !== '\\') {
+			dir += '/';
+		}
+		let result: string[] = [];
+		_walkDirRecursive(dir, result, dir.length);
+		return result;
+	}
+
+	function _walkDirRecursive(dir: string, result: string[], trimPos: number): void {
+		const files = fs.readdirSync(dir);
+		for (let i = 0; i < files.length; i++) {
+			const file = path.join(dir, files[i]);
+			if (fs.statSync(file).isDirectory()) {
+				_walkDirRecursive(file, result, trimPos);
+			} else {
+				result.push(file.substr(trimPos));
+			}
+		}
+	}
+
+	function write(absoluteFilePath: string, contents: string | Buffer): void {
+		if (/(\.ts$)|(\.js$)/.test(absoluteFilePath)) {
+			contents = toggleComments(contents.toString());
+		}
+		writeFile(absoluteFilePath, contents);
+
+		function toggleComments(fileContents: string): string {
+			let lines = fileContents.split(/\r\n|\r|\n/);
+			let mode = 0;
+			for (let i = 0; i < lines.length; i++) {
+				const line = lines[i];
+				if (mode === 0) {
+					if (/\/\/ ESM-comment-begin/.test(line)) {
+						mode = 1;
+						continue;
+					}
+					if (/\/\/ ESM-uncomment-begin/.test(line)) {
+						mode = 2;
+						continue;
+					}
+					continue;
+				}
+
+				if (mode === 1) {
+					if (/\/\/ ESM-comment-end/.test(line)) {
+						mode = 0;
+						continue;
+					}
+					lines[i] = '// ' + line;
+					continue;
+				}
+
+				if (mode === 2) {
+					if (/\/\/ ESM-uncomment-end/.test(line)) {
+						mode = 0;
+						continue;
+					}
+					lines[i] = line.replace(/^(\s*)\/\/ ?/, function (_, indent) {
+						return indent;
+					});
+				}
+			}
+
+			return lines.join('\n');
+		}
+	}
+}
+
+function transportCSS(module: string, enqueue: (module: string) => void, write: (path: string, contents: string | Buffer) => void): boolean {
+
+	if (!/\.css/.test(module)) {
+		return false;
+	}
+
+	const filename = path.join(SRC_DIR, module);
+	const fileContents = fs.readFileSync(filename).toString();
+	const inlineResources = 'base64'; // see https://github.com/microsoft/monaco-editor/issues/148
+
+	const newContents = _rewriteOrInlineUrls(fileContents, inlineResources === 'base64');
+	write(module, newContents);
+	return true;
+
+	function _rewriteOrInlineUrls(contents: string, forceBase64: boolean): string {
+		return _replaceURL(contents, (url) => {
+			const fontMatch = url.match(/^(.*).ttf\?(.*)$/);
+			if (fontMatch) {
+				const relativeFontPath = `${fontMatch[1]}.ttf`; // trim the query parameter
+				const fontPath = path.join(path.dirname(module), relativeFontPath);
+				enqueue(fontPath);
+				return relativeFontPath;
+			}
+
+			const imagePath = path.join(path.dirname(module), url);
+			const fileContents = fs.readFileSync(path.join(SRC_DIR, imagePath));
+			const MIME = /\.svg$/.test(url) ? 'image/svg+xml' : 'image/png';
+			let DATA = ';base64,' + fileContents.toString('base64');
+
+			if (!forceBase64 && /\.svg$/.test(url)) {
+				// .svg => url encode as explained at https://codepen.io/tigt/post/optimizing-svgs-in-data-uris
+				let newText = fileContents.toString()
+					.replace(/"/g, '\'')
+					.replace(/</g, '%3C')
+					.replace(/>/g, '%3E')
+					.replace(/&/g, '%26')
+					.replace(/#/g, '%23')
+					.replace(/\s+/g, ' ');
+				let encodedData = ',' + newText;
+				if (encodedData.length < DATA.length) {
+					DATA = encodedData;
+				}
+			}
+			return '"data:' + MIME + DATA + '"';
+		});
+	}
+
+	function _replaceURL(contents: string, replacer: (url: string) => string): string {
+		// Use ")" as the terminator as quotes are oftentimes not used at all
+		return contents.replace(/url\(\s*([^\)]+)\s*\)?/g, (_: string, ...matches: string[]) => {
+			let url = matches[0];
+			// Eliminate starting quotes (the initial whitespace is not captured)
+			if (url.charAt(0) === '"' || url.charAt(0) === '\'') {
+				url = url.substring(1);
+			}
+			// The ending whitespace is captured
+			while (url.length > 0 && (url.charAt(url.length - 1) === ' ' || url.charAt(url.length - 1) === '\t')) {
+				url = url.substring(0, url.length - 1);
+			}
+			// Eliminate ending quotes
+			if (url.charAt(url.length - 1) === '"' || url.charAt(url.length - 1) === '\'') {
+				url = url.substring(0, url.length - 1);
+			}
+
+			if (!_startsWith(url, 'data:') && !_startsWith(url, 'http://') && !_startsWith(url, 'https://')) {
+				url = replacer(url);
+			}
+
+			return 'url(' + url + ')';
+		});
+	}
+
+	function _startsWith(haystack: string, needle: string): boolean {
+		return haystack.length >= needle.length && haystack.substr(0, needle.length) === needle;
+	}
+}

lib/vscode/build/lib/stats.ts

@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+import * as File from 'vinyl';
+import * as appInsights from 'applicationinsights';
+
+class Entry {
+	constructor(readonly name: string, public totalCount: number, public totalSize: number) { }
+
+	toString(pretty?: boolean): string {
+		if (!pretty) {
+			if (this.totalCount === 1) {
+				return `${this.name}: ${this.totalSize} bytes`;
+			} else {
+				return `${this.name}: ${this.totalCount} files with ${this.totalSize} bytes`;
+			}
+		} else {
+			if (this.totalCount === 1) {
+				return `Stats for '${ansiColors.grey(this.name)}': ${Math.round(this.totalSize / 1204)}KB`;
+
+			} else {
+				const count = this.totalCount < 100
+					? ansiColors.green(this.totalCount.toString())
+					: ansiColors.red(this.totalCount.toString());
+
+				return `Stats for '${ansiColors.grey(this.name)}': ${count} files, ${Math.round(this.totalSize / 1204)}KB`;
+			}
+		}
+	}
+}
+
+const _entries = new Map<string, Entry>();
+
+export function createStatsStream(group: string, log?: boolean): es.ThroughStream {
+
+	const entry = new Entry(group, 0, 0);
+	_entries.set(entry.name, entry);
+
+	return es.through(function (data) {
+		const file = data as File;
+		if (typeof file.path === 'string') {
+			entry.totalCount += 1;
+			if (Buffer.isBuffer(file.contents)) {
+				entry.totalSize += file.contents.length;
+			} else if (file.stat && typeof file.stat.size === 'number') {
+				entry.totalSize += file.stat.size;
+			} else {
+				// funky file...
+			}
+		}
+		this.emit('data', data);
+	}, function () {
+		if (log) {
+			if (entry.totalCount === 1) {
+				fancyLog(`Stats for '${ansiColors.grey(entry.name)}': ${Math.round(entry.totalSize / 1204)}KB`);
+
+			} else {
+				const count = entry.totalCount < 100
+					? ansiColors.green(entry.totalCount.toString())
+					: ansiColors.red(entry.totalCount.toString());
+
+				fancyLog(`Stats for '${ansiColors.grey(entry.name)}': ${count} files, ${Math.round(entry.totalSize / 1204)}KB`);
+			}
+		}
+
+		this.emit('end');
+	});
+}
+
+export function submitAllStats(productJson: any, commit: string): Promise<boolean> {
+
+	const sorted: Entry[] = [];
+	// move entries for single files to the front
+	_entries.forEach(value => {
+		if (value.totalCount === 1) {
+			sorted.unshift(value);
+		} else {
+			sorted.push(value);
+		}
+	});
+
+	// print to console
+	for (const entry of sorted) {
+		console.log(entry.toString(true));
+	}
+
+	// send data as telementry event when the
+	// product is configured to send telemetry
+	if (!productJson || !productJson.aiConfig || typeof productJson.aiConfig.asimovKey !== 'string') {
+		return Promise.resolve(false);
+	}
+
+	return new Promise(resolve => {
+		try {
+
+			const sizes: any = {};
+			const counts: any = {};
+			for (const entry of sorted) {
+				sizes[entry.name] = entry.totalSize;
+				counts[entry.name] = entry.totalCount;
+			}
+
+			appInsights.setup(productJson.aiConfig.asimovKey)
+				.setAutoCollectConsole(false)
+				.setAutoCollectExceptions(false)
+				.setAutoCollectPerformance(false)
+				.setAutoCollectRequests(false)
+				.setAutoCollectDependencies(false)
+				.setAutoDependencyCorrelation(false)
+				.start();
+
+			appInsights.defaultClient.config.endpointUrl = 'https://vortex.data.microsoft.com/collect/v1';
+
+			/* __GDPR__
+				"monacoworkbench/packagemetrics" : {
+					"commit" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+					"size" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" },
+					"count" : {"classification": "SystemMetaData", "purpose": "PerformanceAndHealth" }
+				}
+			*/
+			appInsights.defaultClient.trackEvent({
+				name: 'monacoworkbench/packagemetrics',
+				properties: { commit, size: JSON.stringify(sizes), count: JSON.stringify(counts) }
+			});
+
+
+			appInsights.defaultClient.flush({
+				callback: () => {
+					appInsights.dispose();
+					resolve(true);
+				}
+			});
+
+		} catch (err) {
+			console.error('ERROR sending build stats as telemetry event!');
+			console.error(err);
+			resolve(false);
+		}
+	});
+
+}

lib/vscode/build/lib/task.ts

@@ -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.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import * as fancyLog from 'fancy-log';
+import * as ansiColors from 'ansi-colors';
+
+export interface BaseTask {
+	displayName?: string;
+	taskName?: string;
+	_tasks?: Task[];
+}
+export interface PromiseTask extends BaseTask {
+	(): Promise<void>;
+}
+export interface StreamTask extends BaseTask {
+	(): NodeJS.ReadWriteStream;
+}
+export interface CallbackTask extends BaseTask {
+	(cb?: (err?: any) => void): void;
+}
+
+export type Task = PromiseTask | StreamTask | CallbackTask;
+
+function _isPromise(p: Promise<void> | NodeJS.ReadWriteStream): p is Promise<void> {
+	if (typeof (<any>p).then === 'function') {
+		return true;
+	}
+	return false;
+}
+
+function _renderTime(time: number): string {
+	return `${Math.round(time)} ms`;
+}
+
+async function _execute(task: Task): Promise<void> {
+	const name = task.taskName || task.displayName || `<anonymous>`;
+	if (!task._tasks) {
+		fancyLog('Starting', ansiColors.cyan(name), '...');
+	}
+	const startTime = process.hrtime();
+	await _doExecute(task);
+	const elapsedArr = process.hrtime(startTime);
+	const elapsedNanoseconds = (elapsedArr[0] * 1e9 + elapsedArr[1]);
+	if (!task._tasks) {
+		fancyLog(`Finished`, ansiColors.cyan(name), 'after', ansiColors.magenta(_renderTime(elapsedNanoseconds / 1e6)));
+	}
+}
+
+async function _doExecute(task: Task): Promise<void> {
+	// Always invoke as if it were a callback task
+	return new Promise((resolve, reject) => {
+		if (task.length === 1) {
+			// this is a callback task
+			task((err) => {
+				if (err) {
+					return reject(err);
+				}
+				resolve();
+			});
+			return;
+		}
+
+		const taskResult = task();
+
+		if (typeof taskResult === 'undefined') {
+			// this is a sync task
+			resolve();
+			return;
+		}
+
+		if (_isPromise(taskResult)) {
+			// this is a promise returning task
+			taskResult.then(resolve, reject);
+			return;
+		}
+
+		// this is a stream returning task
+		taskResult.on('end', _ => resolve());
+		taskResult.on('error', err => reject(err));
+	});
+}
+
+export function series(...tasks: Task[]): PromiseTask {
+	const result = async () => {
+		for (let i = 0; i < tasks.length; i++) {
+			await _execute(tasks[i]);
+		}
+	};
+	result._tasks = tasks;
+	return result;
+}
+
+export function parallel(...tasks: Task[]): PromiseTask {
+	const result = async () => {
+		await Promise.all(tasks.map(t => _execute(t)));
+	};
+	result._tasks = tasks;
+	return result;
+}
+
+export function define(name: string, task: Task): Task {
+	if (task._tasks) {
+		// This is a composite task
+		const lastTask = task._tasks[task._tasks.length - 1];
+
+		if (lastTask._tasks || lastTask.taskName) {
+			// This is a composite task without a real task function
+			// => generate a fake task function
+			return define(name, series(task, () => Promise.resolve()));
+		}
+
+		lastTask.taskName = name;
+		task.displayName = name;
+		return task;
+	}
+
+	// This is a simple task
+	task.taskName = name;
+	task.displayName = name;
+	return task;
+}

lib/vscode/build/lib/test/i18n.test.ts

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import assert = require('assert');
+import i18n = require('../i18n');
+
+suite('XLF Parser Tests', () => {
+	const sampleXlf = '<?xml version="1.0" encoding="utf-8"?><xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2"><file original="vs/base/common/keybinding" source-language="en" datatype="plaintext"><body><trans-unit id="key1"><source xml:lang="en">Key #1</source></trans-unit><trans-unit id="key2"><source xml:lang="en">Key #2 &amp;</source></trans-unit></body></file></xliff>';
+	const sampleTranslatedXlf = '<?xml version="1.0" encoding="utf-8"?><xliff version="1.2" xmlns="urn:oasis:names:tc:xliff:document:1.2"><file original="vs/base/common/keybinding" source-language="en" target-language="ru" datatype="plaintext"><body><trans-unit id="key1"><source xml:lang="en">Key #1</source><target>Кнопка #1</target></trans-unit><trans-unit id="key2"><source xml:lang="en">Key #2 &amp;</source><target>Кнопка #2 &amp;</target></trans-unit></body></file></xliff>';
+	const originalFilePath = 'vs/base/common/keybinding';
+	const keys = ['key1', 'key2'];
+	const messages = ['Key #1', 'Key #2 &'];
+	const translatedMessages = { key1: 'Кнопка #1', key2: 'Кнопка #2 &' };
+
+	test('Keys & messages to XLF conversion', () => {
+		const xlf = new i18n.XLF('vscode-workbench');
+		xlf.addFile(originalFilePath, keys, messages);
+		const xlfString = xlf.toString();
+
+		assert.strictEqual(xlfString.replace(/\s{2,}/g, ''), sampleXlf);
+	});
+
+	test('XLF to keys & messages conversion', () => {
+		i18n.XLF.parse(sampleTranslatedXlf).then(function(resolvedFiles) {
+			assert.deepEqual(resolvedFiles[0].messages, translatedMessages);
+			assert.strictEqual(resolvedFiles[0].originalFilePath, originalFilePath);
+		});
+	});
+
+	test('JSON file source path to Transifex resource match', () => {
+		const editorProject: string = 'vscode-editor',
+			workbenchProject: string = 'vscode-workbench';
+
+		const platform: i18n.Resource = { name: 'vs/platform', project: editorProject },
+			editorContrib = { name: 'vs/editor/contrib', project: editorProject },
+			editor = { name: 'vs/editor', project: editorProject },
+			base = { name: 'vs/base', project: editorProject },
+			code = { name: 'vs/code', project: workbenchProject },
+			workbenchParts = { name: 'vs/workbench/contrib/html', project: workbenchProject },
+			workbenchServices = { name: 'vs/workbench/services/textfile', project: workbenchProject },
+			workbench = { name: 'vs/workbench', project: workbenchProject};
+
+		assert.deepEqual(i18n.getResource('vs/platform/actions/browser/menusExtensionPoint'), platform);
+		assert.deepEqual(i18n.getResource('vs/editor/contrib/clipboard/browser/clipboard'), editorContrib);
+		assert.deepEqual(i18n.getResource('vs/editor/common/modes/modesRegistry'), editor);
+		assert.deepEqual(i18n.getResource('vs/base/common/errorMessage'), base);
+		assert.deepEqual(i18n.getResource('vs/code/electron-main/window'), code);
+		assert.deepEqual(i18n.getResource('vs/workbench/contrib/html/browser/webview'), workbenchParts);
+		assert.deepEqual(i18n.getResource('vs/workbench/services/textfile/node/testFileService'), workbenchServices);
+		assert.deepEqual(i18n.getResource('vs/workbench/browser/parts/panel/panelActions'), workbench);
+	});
+});

lib/vscode/build/lib/treeshaking.ts

@@ -0,0 +1,938 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 ts from 'typescript';
+
+const TYPESCRIPT_LIB_FOLDER = path.dirname(require.resolve('typescript/lib/lib.d.ts'));
+
+export const enum ShakeLevel {
+	Files = 0,
+	InnerFile = 1,
+	ClassMembers = 2
+}
+
+export function toStringShakeLevel(shakeLevel: ShakeLevel): string {
+	switch (shakeLevel) {
+		case ShakeLevel.Files:
+			return 'Files (0)';
+		case ShakeLevel.InnerFile:
+			return 'InnerFile (1)';
+		case ShakeLevel.ClassMembers:
+			return 'ClassMembers (2)';
+	}
+}
+
+export interface ITreeShakingOptions {
+	/**
+	 * The full path to the root where sources are.
+	 */
+	sourcesRoot: string;
+	/**
+	 * Module ids.
+	 * e.g. `vs/editor/editor.main` or `index`
+	 */
+	entryPoints: string[];
+	/**
+	 * Inline usages.
+	 */
+	inlineEntryPoints: string[];
+	/**
+	 * Other .d.ts files
+	 */
+	typings: string[];
+	/**
+	 * TypeScript compiler options.
+	 */
+	compilerOptions?: any;
+	/**
+	 * The shake level to perform.
+	 */
+	shakeLevel: ShakeLevel;
+	/**
+	 * regex pattern to ignore certain imports e.g. `vs/css!` imports
+	 */
+	importIgnorePattern: RegExp;
+
+	redirects: { [module: string]: string; };
+}
+
+export interface ITreeShakingResult {
+	[file: string]: string;
+}
+
+function printDiagnostics(options: ITreeShakingOptions, diagnostics: ReadonlyArray<ts.Diagnostic>): void {
+	for (const diag of diagnostics) {
+		let result = '';
+		if (diag.file) {
+			result += `${path.join(options.sourcesRoot, diag.file.fileName)}`;
+		}
+		if (diag.file && diag.start) {
+			let location = diag.file.getLineAndCharacterOfPosition(diag.start);
+			result += `:${location.line + 1}:${location.character}`;
+		}
+		result += ` - ` + JSON.stringify(diag.messageText);
+		console.log(result);
+	}
+}
+
+export function shake(options: ITreeShakingOptions): ITreeShakingResult {
+	const languageService = createTypeScriptLanguageService(options);
+	const program = languageService.getProgram()!;
+
+	const globalDiagnostics = program.getGlobalDiagnostics();
+	if (globalDiagnostics.length > 0) {
+		printDiagnostics(options, globalDiagnostics);
+		throw new Error(`Compilation Errors encountered.`);
+	}
+
+	const syntacticDiagnostics = program.getSyntacticDiagnostics();
+	if (syntacticDiagnostics.length > 0) {
+		printDiagnostics(options, syntacticDiagnostics);
+		throw new Error(`Compilation Errors encountered.`);
+	}
+
+	const semanticDiagnostics = program.getSemanticDiagnostics();
+	if (semanticDiagnostics.length > 0) {
+		printDiagnostics(options, semanticDiagnostics);
+		throw new Error(`Compilation Errors encountered.`);
+	}
+
+	markNodes(languageService, options);
+
+	return generateResult(languageService, options.shakeLevel);
+}
+
+//#region Discovery, LanguageService & Setup
+function createTypeScriptLanguageService(options: ITreeShakingOptions): ts.LanguageService {
+	// Discover referenced files
+	const FILES = discoverAndReadFiles(options);
+
+	// Add fake usage files
+	options.inlineEntryPoints.forEach((inlineEntryPoint, index) => {
+		FILES[`inlineEntryPoint.${index}.ts`] = inlineEntryPoint;
+	});
+
+	// Add additional typings
+	options.typings.forEach((typing) => {
+		const filePath = path.join(options.sourcesRoot, typing);
+		FILES[typing] = fs.readFileSync(filePath).toString();
+	});
+
+	// Resolve libs
+	const RESOLVED_LIBS = processLibFiles(options);
+
+	const compilerOptions = ts.convertCompilerOptionsFromJson(options.compilerOptions, options.sourcesRoot).options;
+
+	const host = new TypeScriptLanguageServiceHost(RESOLVED_LIBS, FILES, compilerOptions);
+	return ts.createLanguageService(host);
+}
+
+/**
+ * Read imports and follow them until all files have been handled
+ */
+function discoverAndReadFiles(options: ITreeShakingOptions): IFileMap {
+	const FILES: IFileMap = {};
+
+	const in_queue: { [module: string]: boolean; } = Object.create(null);
+	const queue: string[] = [];
+
+	const enqueue = (moduleId: string) => {
+		if (in_queue[moduleId]) {
+			return;
+		}
+		in_queue[moduleId] = true;
+		queue.push(moduleId);
+	};
+
+	options.entryPoints.forEach((entryPoint) => enqueue(entryPoint));
+
+	while (queue.length > 0) {
+		const moduleId = queue.shift()!;
+		const dts_filename = path.join(options.sourcesRoot, moduleId + '.d.ts');
+		if (fs.existsSync(dts_filename)) {
+			const dts_filecontents = fs.readFileSync(dts_filename).toString();
+			FILES[`${moduleId}.d.ts`] = dts_filecontents;
+			continue;
+		}
+
+		const js_filename = path.join(options.sourcesRoot, moduleId + '.js');
+		if (fs.existsSync(js_filename)) {
+			// This is an import for a .js file, so ignore it...
+			continue;
+		}
+
+		let ts_filename: string;
+		if (options.redirects[moduleId]) {
+			ts_filename = path.join(options.sourcesRoot, options.redirects[moduleId] + '.ts');
+		} else {
+			ts_filename = path.join(options.sourcesRoot, moduleId + '.ts');
+		}
+		const ts_filecontents = fs.readFileSync(ts_filename).toString();
+		const info = ts.preProcessFile(ts_filecontents);
+		for (let i = info.importedFiles.length - 1; i >= 0; i--) {
+			const importedFileName = info.importedFiles[i].fileName;
+
+			if (options.importIgnorePattern.test(importedFileName)) {
+				// Ignore vs/css! imports
+				continue;
+			}
+
+			let importedModuleId = importedFileName;
+			if (/(^\.\/)|(^\.\.\/)/.test(importedModuleId)) {
+				importedModuleId = path.join(path.dirname(moduleId), importedModuleId);
+			}
+			enqueue(importedModuleId);
+		}
+
+		FILES[`${moduleId}.ts`] = ts_filecontents;
+	}
+
+	return FILES;
+}
+
+/**
+ * Read lib files and follow lib references
+ */
+function processLibFiles(options: ITreeShakingOptions): ILibMap {
+
+	const stack: string[] = [...options.compilerOptions.lib];
+	const result: ILibMap = {};
+
+	while (stack.length > 0) {
+		const filename = `lib.${stack.shift()!.toLowerCase()}.d.ts`;
+		const key = `defaultLib:${filename}`;
+		if (!result[key]) {
+			// add this file
+			const filepath = path.join(TYPESCRIPT_LIB_FOLDER, filename);
+			const sourceText = fs.readFileSync(filepath).toString();
+			result[key] = sourceText;
+
+			// precess dependencies and "recurse"
+			const info = ts.preProcessFile(sourceText);
+			for (let ref of info.libReferenceDirectives) {
+				stack.push(ref.fileName);
+			}
+		}
+	}
+
+	return result;
+}
+
+interface ILibMap { [libName: string]: string; }
+interface IFileMap { [fileName: string]: string; }
+
+/**
+ * A TypeScript language service host
+ */
+class TypeScriptLanguageServiceHost implements ts.LanguageServiceHost {
+
+	private readonly _libs: ILibMap;
+	private readonly _files: IFileMap;
+	private readonly _compilerOptions: ts.CompilerOptions;
+
+	constructor(libs: ILibMap, files: IFileMap, compilerOptions: ts.CompilerOptions) {
+		this._libs = libs;
+		this._files = files;
+		this._compilerOptions = compilerOptions;
+	}
+
+	// --- language service host ---------------
+
+	getCompilationSettings(): ts.CompilerOptions {
+		return this._compilerOptions;
+	}
+	getScriptFileNames(): string[] {
+		return (
+			([] as string[])
+				.concat(Object.keys(this._libs))
+				.concat(Object.keys(this._files))
+		);
+	}
+	getScriptVersion(_fileName: string): string {
+		return '1';
+	}
+	getProjectVersion(): string {
+		return '1';
+	}
+	getScriptSnapshot(fileName: string): ts.IScriptSnapshot {
+		if (this._files.hasOwnProperty(fileName)) {
+			return ts.ScriptSnapshot.fromString(this._files[fileName]);
+		} else if (this._libs.hasOwnProperty(fileName)) {
+			return ts.ScriptSnapshot.fromString(this._libs[fileName]);
+		} else {
+			return ts.ScriptSnapshot.fromString('');
+		}
+	}
+	getScriptKind(_fileName: string): ts.ScriptKind {
+		return ts.ScriptKind.TS;
+	}
+	getCurrentDirectory(): string {
+		return '';
+	}
+	getDefaultLibFileName(_options: ts.CompilerOptions): string {
+		return 'defaultLib:lib.d.ts';
+	}
+	isDefaultLibFileName(fileName: string): boolean {
+		return fileName === this.getDefaultLibFileName(this._compilerOptions);
+	}
+}
+//#endregion
+
+//#region Tree Shaking
+
+const enum NodeColor {
+	White = 0,
+	Gray = 1,
+	Black = 2
+}
+
+function getColor(node: ts.Node): NodeColor {
+	return (<any>node).$$$color || NodeColor.White;
+}
+function setColor(node: ts.Node, color: NodeColor): void {
+	(<any>node).$$$color = color;
+}
+function nodeOrParentIsBlack(node: ts.Node): boolean {
+	while (node) {
+		const color = getColor(node);
+		if (color === NodeColor.Black) {
+			return true;
+		}
+		node = node.parent;
+	}
+	return false;
+}
+function nodeOrChildIsBlack(node: ts.Node): boolean {
+	if (getColor(node) === NodeColor.Black) {
+		return true;
+	}
+	for (const child of node.getChildren()) {
+		if (nodeOrChildIsBlack(child)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function markNodes(languageService: ts.LanguageService, options: ITreeShakingOptions) {
+	const program = languageService.getProgram();
+	if (!program) {
+		throw new Error('Could not get program from language service');
+	}
+
+	if (options.shakeLevel === ShakeLevel.Files) {
+		// Mark all source files Black
+		program.getSourceFiles().forEach((sourceFile) => {
+			setColor(sourceFile, NodeColor.Black);
+		});
+		return;
+	}
+
+	const black_queue: ts.Node[] = [];
+	const gray_queue: ts.Node[] = [];
+	const export_import_queue: ts.Node[] = [];
+	const sourceFilesLoaded: { [fileName: string]: boolean } = {};
+
+	function enqueueTopLevelModuleStatements(sourceFile: ts.SourceFile): void {
+
+		sourceFile.forEachChild((node: ts.Node) => {
+
+			if (ts.isImportDeclaration(node)) {
+				if (!node.importClause && ts.isStringLiteral(node.moduleSpecifier)) {
+					setColor(node, NodeColor.Black);
+					enqueueImport(node, node.moduleSpecifier.text);
+				}
+				return;
+			}
+
+			if (ts.isExportDeclaration(node)) {
+				if (!node.exportClause && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+					// export * from "foo";
+					setColor(node, NodeColor.Black);
+					enqueueImport(node, node.moduleSpecifier.text);
+				}
+				if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+					for (const exportSpecifier of node.exportClause.elements) {
+						export_import_queue.push(exportSpecifier);
+					}
+				}
+				return;
+			}
+
+			if (
+				ts.isExpressionStatement(node)
+				|| ts.isIfStatement(node)
+				|| ts.isIterationStatement(node, true)
+				|| ts.isExportAssignment(node)
+			) {
+				enqueue_black(node);
+			}
+
+			if (ts.isImportEqualsDeclaration(node)) {
+				if (/export/.test(node.getFullText(sourceFile))) {
+					// e.g. "export import Severity = BaseSeverity;"
+					enqueue_black(node);
+				}
+			}
+
+		});
+	}
+
+	function enqueue_gray(node: ts.Node): void {
+		if (nodeOrParentIsBlack(node) || getColor(node) === NodeColor.Gray) {
+			return;
+		}
+		setColor(node, NodeColor.Gray);
+		gray_queue.push(node);
+	}
+
+	function enqueue_black(node: ts.Node): void {
+		const previousColor = getColor(node);
+
+		if (previousColor === NodeColor.Black) {
+			return;
+		}
+
+		if (previousColor === NodeColor.Gray) {
+			// remove from gray queue
+			gray_queue.splice(gray_queue.indexOf(node), 1);
+			setColor(node, NodeColor.White);
+
+			// add to black queue
+			enqueue_black(node);
+
+			// // move from one queue to the other
+			// black_queue.push(node);
+			// setColor(node, NodeColor.Black);
+			return;
+		}
+
+		if (nodeOrParentIsBlack(node)) {
+			return;
+		}
+
+		const fileName = node.getSourceFile().fileName;
+		if (/^defaultLib:/.test(fileName) || /\.d\.ts$/.test(fileName)) {
+			setColor(node, NodeColor.Black);
+			return;
+		}
+
+		const sourceFile = node.getSourceFile();
+		if (!sourceFilesLoaded[sourceFile.fileName]) {
+			sourceFilesLoaded[sourceFile.fileName] = true;
+			enqueueTopLevelModuleStatements(sourceFile);
+		}
+
+		if (ts.isSourceFile(node)) {
+			return;
+		}
+
+		setColor(node, NodeColor.Black);
+		black_queue.push(node);
+
+		if (options.shakeLevel === ShakeLevel.ClassMembers && (ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isPropertySignature(node) || ts.isPropertyDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node))) {
+			const references = languageService.getReferencesAtPosition(node.getSourceFile().fileName, node.name.pos + node.name.getLeadingTriviaWidth());
+			if (references) {
+				for (let i = 0, len = references.length; i < len; i++) {
+					const reference = references[i];
+					const referenceSourceFile = program!.getSourceFile(reference.fileName);
+					if (!referenceSourceFile) {
+						continue;
+					}
+
+					const referenceNode = getTokenAtPosition(referenceSourceFile, reference.textSpan.start, false, false);
+					if (
+						ts.isMethodDeclaration(referenceNode.parent)
+						|| ts.isPropertyDeclaration(referenceNode.parent)
+						|| ts.isGetAccessor(referenceNode.parent)
+						|| ts.isSetAccessor(referenceNode.parent)
+					) {
+						enqueue_gray(referenceNode.parent);
+					}
+				}
+			}
+		}
+	}
+
+	function enqueueFile(filename: string): void {
+		const sourceFile = program!.getSourceFile(filename);
+		if (!sourceFile) {
+			console.warn(`Cannot find source file ${filename}`);
+			return;
+		}
+		enqueue_black(sourceFile);
+	}
+
+	function enqueueImport(node: ts.Node, importText: string): void {
+		if (options.importIgnorePattern.test(importText)) {
+			// this import should be ignored
+			return;
+		}
+
+		const nodeSourceFile = node.getSourceFile();
+		let fullPath: string;
+		if (/(^\.\/)|(^\.\.\/)/.test(importText)) {
+			fullPath = path.join(path.dirname(nodeSourceFile.fileName), importText) + '.ts';
+		} else {
+			fullPath = importText + '.ts';
+		}
+		enqueueFile(fullPath);
+	}
+
+	options.entryPoints.forEach(moduleId => enqueueFile(moduleId + '.ts'));
+	// Add fake usage files
+	options.inlineEntryPoints.forEach((_, index) => enqueueFile(`inlineEntryPoint.${index}.ts`));
+
+	let step = 0;
+
+	const checker = program.getTypeChecker();
+	while (black_queue.length > 0 || gray_queue.length > 0) {
+		++step;
+		let node: ts.Node;
+
+		if (step % 100 === 0) {
+			console.log(`Treeshaking - ${Math.floor(100 * step / (step + black_queue.length + gray_queue.length))}% - ${step}/${step + black_queue.length + gray_queue.length} (${black_queue.length}, ${gray_queue.length})`);
+		}
+
+		if (black_queue.length === 0) {
+			for (let i = 0; i < gray_queue.length; i++) {
+				const node = gray_queue[i];
+				const nodeParent = node.parent;
+				if ((ts.isClassDeclaration(nodeParent) || ts.isInterfaceDeclaration(nodeParent)) && nodeOrChildIsBlack(nodeParent)) {
+					gray_queue.splice(i, 1);
+					black_queue.push(node);
+					setColor(node, NodeColor.Black);
+					i--;
+				}
+			}
+		}
+
+		if (black_queue.length > 0) {
+			node = black_queue.shift()!;
+		} else {
+			// only gray nodes remaining...
+			break;
+		}
+		const nodeSourceFile = node.getSourceFile();
+
+		const loop = (node: ts.Node) => {
+			const [symbol, symbolImportNode] = getRealNodeSymbol(checker, node);
+			if (symbolImportNode) {
+				setColor(symbolImportNode, NodeColor.Black);
+			}
+
+			if (symbol && !nodeIsInItsOwnDeclaration(nodeSourceFile, node, symbol)) {
+				for (let i = 0, len = symbol.declarations.length; i < len; i++) {
+					const declaration = symbol.declarations[i];
+					if (ts.isSourceFile(declaration)) {
+						// Do not enqueue full source files
+						// (they can be the declaration of a module import)
+						continue;
+					}
+
+					if (options.shakeLevel === ShakeLevel.ClassMembers && (ts.isClassDeclaration(declaration) || ts.isInterfaceDeclaration(declaration)) && !isLocalCodeExtendingOrInheritingFromDefaultLibSymbol(program, checker, declaration)) {
+						enqueue_black(declaration.name!);
+
+						for (let j = 0; j < declaration.members.length; j++) {
+							const member = declaration.members[j];
+							const memberName = member.name ? member.name.getText() : null;
+							if (
+								ts.isConstructorDeclaration(member)
+								|| ts.isConstructSignatureDeclaration(member)
+								|| ts.isIndexSignatureDeclaration(member)
+								|| ts.isCallSignatureDeclaration(member)
+								|| memberName === '[Symbol.iterator]'
+								|| memberName === '[Symbol.toStringTag]'
+								|| memberName === 'toJSON'
+								|| memberName === 'toString'
+								|| memberName === 'dispose'// TODO: keeping all `dispose` methods
+								|| /^_(.*)Brand$/.test(memberName || '') // TODO: keeping all members ending with `Brand`...
+							) {
+								enqueue_black(member);
+							}
+						}
+
+						// queue the heritage clauses
+						if (declaration.heritageClauses) {
+							for (let heritageClause of declaration.heritageClauses) {
+								enqueue_black(heritageClause);
+							}
+						}
+					} else {
+						enqueue_black(declaration);
+					}
+				}
+			}
+			node.forEachChild(loop);
+		};
+		node.forEachChild(loop);
+	}
+
+	while (export_import_queue.length > 0) {
+		const node = export_import_queue.shift()!;
+		if (nodeOrParentIsBlack(node)) {
+			continue;
+		}
+		const symbol: ts.Symbol | undefined = (<any>node).symbol;
+		if (!symbol) {
+			continue;
+		}
+		const aliased = checker.getAliasedSymbol(symbol);
+		if (aliased.declarations && aliased.declarations.length > 0) {
+			if (nodeOrParentIsBlack(aliased.declarations[0]) || nodeOrChildIsBlack(aliased.declarations[0])) {
+				setColor(node, NodeColor.Black);
+			}
+		}
+	}
+}
+
+function nodeIsInItsOwnDeclaration(nodeSourceFile: ts.SourceFile, node: ts.Node, symbol: ts.Symbol): boolean {
+	for (let i = 0, len = symbol.declarations.length; i < len; i++) {
+		const declaration = symbol.declarations[i];
+		const declarationSourceFile = declaration.getSourceFile();
+
+		if (nodeSourceFile === declarationSourceFile) {
+			if (declaration.pos <= node.pos && node.end <= declaration.end) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+function generateResult(languageService: ts.LanguageService, shakeLevel: ShakeLevel): ITreeShakingResult {
+	const program = languageService.getProgram();
+	if (!program) {
+		throw new Error('Could not get program from language service');
+	}
+
+	let result: ITreeShakingResult = {};
+	const writeFile = (filePath: string, contents: string): void => {
+		result[filePath] = contents;
+	};
+
+	program.getSourceFiles().forEach((sourceFile) => {
+		const fileName = sourceFile.fileName;
+		if (/^defaultLib:/.test(fileName)) {
+			return;
+		}
+		const destination = fileName;
+		if (/\.d\.ts$/.test(fileName)) {
+			if (nodeOrChildIsBlack(sourceFile)) {
+				writeFile(destination, sourceFile.text);
+			}
+			return;
+		}
+
+		let text = sourceFile.text;
+		let result = '';
+
+		function keep(node: ts.Node): void {
+			result += text.substring(node.pos, node.end);
+		}
+		function write(data: string): void {
+			result += data;
+		}
+
+		function writeMarkedNodes(node: ts.Node): void {
+			if (getColor(node) === NodeColor.Black) {
+				return keep(node);
+			}
+
+			// Always keep certain top-level statements
+			if (ts.isSourceFile(node.parent)) {
+				if (ts.isExpressionStatement(node) && ts.isStringLiteral(node.expression) && node.expression.text === 'use strict') {
+					return keep(node);
+				}
+
+				if (ts.isVariableStatement(node) && nodeOrChildIsBlack(node)) {
+					return keep(node);
+				}
+			}
+
+			// Keep the entire import in import * as X cases
+			if (ts.isImportDeclaration(node)) {
+				if (node.importClause && node.importClause.namedBindings) {
+					if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+						if (getColor(node.importClause.namedBindings) === NodeColor.Black) {
+							return keep(node);
+						}
+					} else {
+						let survivingImports: string[] = [];
+						for (const importNode of node.importClause.namedBindings.elements) {
+							if (getColor(importNode) === NodeColor.Black) {
+								survivingImports.push(importNode.getFullText(sourceFile));
+							}
+						}
+						const leadingTriviaWidth = node.getLeadingTriviaWidth();
+						const leadingTrivia = sourceFile.text.substr(node.pos, leadingTriviaWidth);
+						if (survivingImports.length > 0) {
+							if (node.importClause && node.importClause.name && getColor(node.importClause) === NodeColor.Black) {
+								return write(`${leadingTrivia}import ${node.importClause.name.text}, {${survivingImports.join(',')} } from${node.moduleSpecifier.getFullText(sourceFile)};`);
+							}
+							return write(`${leadingTrivia}import {${survivingImports.join(',')} } from${node.moduleSpecifier.getFullText(sourceFile)};`);
+						} else {
+							if (node.importClause && node.importClause.name && getColor(node.importClause) === NodeColor.Black) {
+								return write(`${leadingTrivia}import ${node.importClause.name.text} from${node.moduleSpecifier.getFullText(sourceFile)};`);
+							}
+						}
+					}
+				} else {
+					if (node.importClause && getColor(node.importClause) === NodeColor.Black) {
+						return keep(node);
+					}
+				}
+			}
+
+			if (ts.isExportDeclaration(node)) {
+				if (node.exportClause && node.moduleSpecifier && ts.isNamedExports(node.exportClause)) {
+					let survivingExports: string[] = [];
+					for (const exportSpecifier of node.exportClause.elements) {
+						if (getColor(exportSpecifier) === NodeColor.Black) {
+							survivingExports.push(exportSpecifier.getFullText(sourceFile));
+						}
+					}
+					const leadingTriviaWidth = node.getLeadingTriviaWidth();
+					const leadingTrivia = sourceFile.text.substr(node.pos, leadingTriviaWidth);
+					if (survivingExports.length > 0) {
+						return write(`${leadingTrivia}export {${survivingExports.join(',')} } from${node.moduleSpecifier.getFullText(sourceFile)};`);
+					}
+				}
+			}
+
+			if (shakeLevel === ShakeLevel.ClassMembers && (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) && nodeOrChildIsBlack(node)) {
+				let toWrite = node.getFullText();
+				for (let i = node.members.length - 1; i >= 0; i--) {
+					const member = node.members[i];
+					if (getColor(member) === NodeColor.Black || !member.name) {
+						// keep method
+						continue;
+					}
+
+					let pos = member.pos - node.pos;
+					let end = member.end - node.pos;
+					toWrite = toWrite.substring(0, pos) + toWrite.substring(end);
+				}
+				return write(toWrite);
+			}
+
+			if (ts.isFunctionDeclaration(node)) {
+				// Do not go inside functions if they haven't been marked
+				return;
+			}
+
+			node.forEachChild(writeMarkedNodes);
+		}
+
+		if (getColor(sourceFile) !== NodeColor.Black) {
+			if (!nodeOrChildIsBlack(sourceFile)) {
+				// none of the elements are reachable => don't write this file at all!
+				return;
+			}
+			sourceFile.forEachChild(writeMarkedNodes);
+			result += sourceFile.endOfFileToken.getFullText(sourceFile);
+		} else {
+			result = text;
+		}
+
+		writeFile(destination, result);
+	});
+
+	return result;
+}
+
+//#endregion
+
+//#region Utils
+
+function isLocalCodeExtendingOrInheritingFromDefaultLibSymbol(program: ts.Program, checker: ts.TypeChecker, declaration: ts.ClassDeclaration | ts.InterfaceDeclaration): boolean {
+	if (!program.isSourceFileDefaultLibrary(declaration.getSourceFile()) && declaration.heritageClauses) {
+		for (const heritageClause of declaration.heritageClauses) {
+			for (const type of heritageClause.types) {
+				const symbol = findSymbolFromHeritageType(checker, type);
+				if (symbol) {
+					const decl = symbol.valueDeclaration || (symbol.declarations && symbol.declarations[0]);
+					if (decl && program.isSourceFileDefaultLibrary(decl.getSourceFile())) {
+						return true;
+					}
+				}
+			}
+		}
+	}
+	return false;
+}
+
+function findSymbolFromHeritageType(checker: ts.TypeChecker, type: ts.ExpressionWithTypeArguments | ts.Expression | ts.PrivateIdentifier): ts.Symbol | null {
+	if (ts.isExpressionWithTypeArguments(type)) {
+		return findSymbolFromHeritageType(checker, type.expression);
+	}
+	if (ts.isIdentifier(type)) {
+		return getRealNodeSymbol(checker, type)[0];
+	}
+	if (ts.isPropertyAccessExpression(type)) {
+		return findSymbolFromHeritageType(checker, type.name);
+	}
+	return null;
+}
+
+/**
+ * Returns the node's symbol and the `import` node (if the symbol resolved from a different module)
+ */
+function getRealNodeSymbol(checker: ts.TypeChecker, node: ts.Node): [ts.Symbol | null, ts.Declaration | null] {
+
+	// Use some TypeScript internals to avoid code duplication
+	type ObjectLiteralElementWithName = ts.ObjectLiteralElement & { name: ts.PropertyName; parent: ts.ObjectLiteralExpression | ts.JsxAttributes };
+	const getPropertySymbolsFromContextualType: (node: ObjectLiteralElementWithName, checker: ts.TypeChecker, contextualType: ts.Type, unionSymbolOk: boolean) => ReadonlyArray<ts.Symbol> = (<any>ts).getPropertySymbolsFromContextualType;
+	const getContainingObjectLiteralElement: (node: ts.Node) => ObjectLiteralElementWithName | undefined = (<any>ts).getContainingObjectLiteralElement;
+	const getNameFromPropertyName: (name: ts.PropertyName) => string | undefined = (<any>ts).getNameFromPropertyName;
+
+	// Go to the original declaration for cases:
+	//
+	//   (1) when the aliased symbol was declared in the location(parent).
+	//   (2) when the aliased symbol is originating from an import.
+	//
+	function shouldSkipAlias(node: ts.Node, declaration: ts.Node): boolean {
+		if (!ts.isShorthandPropertyAssignment(node) && node.kind !== ts.SyntaxKind.Identifier) {
+			return false;
+		}
+		if (node.parent === declaration) {
+			return true;
+		}
+		switch (declaration.kind) {
+			case ts.SyntaxKind.ImportClause:
+			case ts.SyntaxKind.ImportEqualsDeclaration:
+				return true;
+			case ts.SyntaxKind.ImportSpecifier:
+				return declaration.parent.kind === ts.SyntaxKind.NamedImports;
+			default:
+				return false;
+		}
+	}
+
+	if (!ts.isShorthandPropertyAssignment(node)) {
+		if (node.getChildCount() !== 0) {
+			return [null, null];
+		}
+	}
+
+	const { parent } = node;
+
+	let symbol = (
+		ts.isShorthandPropertyAssignment(node)
+			? checker.getShorthandAssignmentValueSymbol(node)
+			: checker.getSymbolAtLocation(node)
+	);
+
+	let importNode: ts.Declaration | null = null;
+	// If this is an alias, and the request came at the declaration location
+	// get the aliased symbol instead. This allows for goto def on an import e.g.
+	//   import {A, B} from "mod";
+	// to jump to the implementation directly.
+	if (symbol && symbol.flags & ts.SymbolFlags.Alias && shouldSkipAlias(node, symbol.declarations[0])) {
+		const aliased = checker.getAliasedSymbol(symbol);
+		if (aliased.declarations) {
+			// We should mark the import as visited
+			importNode = symbol.declarations[0];
+			symbol = aliased;
+		}
+	}
+
+	if (symbol) {
+		// Because name in short-hand property assignment has two different meanings: property name and property value,
+		// using go-to-definition at such position should go to the variable declaration of the property value rather than
+		// go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
+		// is performed at the location of property access, we would like to go to definition of the property in the short-hand
+		// assignment. This case and others are handled by the following code.
+		if (node.parent.kind === ts.SyntaxKind.ShorthandPropertyAssignment) {
+			symbol = checker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
+		}
+
+		// If the node is the name of a BindingElement within an ObjectBindingPattern instead of just returning the
+		// declaration the symbol (which is itself), we should try to get to the original type of the ObjectBindingPattern
+		// and return the property declaration for the referenced property.
+		// For example:
+		//      import('./foo').then(({ b/*goto*/ar }) => undefined); => should get use to the declaration in file "./foo"
+		//
+		//      function bar<T>(onfulfilled: (value: T) => void) { //....}
+		//      interface Test {
+		//          pr/*destination*/op1: number
+		//      }
+		//      bar<Test>(({pr/*goto*/op1})=>{});
+		if (ts.isPropertyName(node) && ts.isBindingElement(parent) && ts.isObjectBindingPattern(parent.parent) &&
+			(node === (parent.propertyName || parent.name))) {
+			const name = getNameFromPropertyName(node);
+			const type = checker.getTypeAtLocation(parent.parent);
+			if (name && type) {
+				if (type.isUnion()) {
+					const prop = type.types[0].getProperty(name);
+					if (prop) {
+						symbol = prop;
+					}
+				} else {
+					const prop = type.getProperty(name);
+					if (prop) {
+						symbol = prop;
+					}
+				}
+			}
+		}
+
+		// If the current location we want to find its definition is in an object literal, try to get the contextual type for the
+		// object literal, lookup the property symbol in the contextual type, and use this for goto-definition.
+		// For example
+		//      interface Props{
+		//          /*first*/prop1: number
+		//          prop2: boolean
+		//      }
+		//      function Foo(arg: Props) {}
+		//      Foo( { pr/*1*/op1: 10, prop2: false })
+		const element = getContainingObjectLiteralElement(node);
+		if (element) {
+			const contextualType = element && checker.getContextualType(element.parent);
+			if (contextualType) {
+				const propertySymbols = getPropertySymbolsFromContextualType(element, checker, contextualType, /*unionSymbolOk*/ false);
+				if (propertySymbols) {
+					symbol = propertySymbols[0];
+				}
+			}
+		}
+	}
+
+	if (symbol && symbol.declarations) {
+		return [symbol, importNode];
+	}
+
+	return [null, null];
+}
+
+/** Get the token whose text contains the position */
+function getTokenAtPosition(sourceFile: ts.SourceFile, position: number, allowPositionInLeadingTrivia: boolean, includeEndPosition: boolean): ts.Node {
+	let current: ts.Node = sourceFile;
+	outer: while (true) {
+		// find the child that contains 'position'
+		for (const child of current.getChildren()) {
+			const start = allowPositionInLeadingTrivia ? child.getFullStart() : child.getStart(sourceFile, /*includeJsDoc*/ true);
+			if (start > position) {
+				// If this child begins after position, then all subsequent children will as well.
+				break;
+			}
+
+			const end = child.getEnd();
+			if (position < end || (position === end && (child.kind === ts.SyntaxKind.EndOfFileToken || includeEndPosition))) {
+				current = child;
+				continue outer;
+			}
+		}
+
+		return current;
+	}
+}
+
+//#endregion

lib/vscode/build/lib/typings/cgmanifest.json

@@ -0,0 +1,16 @@
+{
+	"registrations": [
+		{
+			"component": {
+				"type": "git",
+				"git": {
+					"name": "definitelytyped",
+					"repositoryUrl": "https://github.com/DefinitelyTyped/DefinitelyTyped",
+					"commitHash": "69e3ac6bec3008271f76bbfa7cf69aa9198c4ff0"
+				}
+			},
+			"license": "MIT"
+		}
+	],
+	"version": 1
+}

lib/vscode/build/lib/typings/event-stream.d.ts

@@ -0,0 +1,27 @@
+declare module "event-stream" {
+	import { Stream } from 'stream';
+	import { ThroughStream as _ThroughStream } from 'through';
+	import * as File from 'vinyl';
+
+	export interface ThroughStream extends _ThroughStream {
+		queue(data: File | null): any;
+		push(data: File | null): any;
+		paused: boolean;
+	}
+
+	function merge(streams: Stream[]): ThroughStream;
+	function merge(...streams: Stream[]): ThroughStream;
+	function concat(...stream: Stream[]): ThroughStream;
+	function duplex(istream: Stream, ostream: Stream): ThroughStream;
+
+	function through(write?: (this: ThroughStream, data: any) => void, end?: (this: ThroughStream) => void,
+		opts?: { autoDestroy: boolean; }): ThroughStream;
+
+	function readArray<T>(array: T[]): ThroughStream;
+	function writeArray<T>(cb: (err: Error, array: T[]) => void): ThroughStream;
+
+	function mapSync<I, O>(cb: (data: I) => O): ThroughStream;
+	function map<I, O>(cb: (data: I, cb: (err?: Error, data?: O) => void) => O): ThroughStream;
+
+	function readable(asyncFunction: (this: ThroughStream, ...args: any[]) => any): any;
+}

lib/vscode/build/lib/typings/github-releases.d.ts

@@ -0,0 +1,3 @@
+declare module 'github-releases' {
+
+}

lib/vscode/build/lib/typings/gulp-bom.d.ts

@@ -0,0 +1,12 @@
+
+declare module "gulp-bom" {
+	function f(): NodeJS.ReadWriteStream;
+
+	/**
+	 * This is required as per:
+	 * https://github.com/microsoft/TypeScript/issues/5073
+	 */
+	namespace f {}
+
+	export = f;
+}

lib/vscode/build/lib/typings/gulp-cssnano.d.ts

@@ -0,0 +1,12 @@
+
+declare module "gulp-cssnano" {
+	function f(opts:{reduceIdents:boolean;}): NodeJS.ReadWriteStream;
+
+	/**
+	 * This is required as per:
+	 * https://github.com/microsoft/TypeScript/issues/5073
+	 */
+	namespace f {}
+
+	export = f;
+}

lib/vscode/build/lib/typings/gulp-flatmap.d.ts

@@ -0,0 +1,12 @@
+declare module 'gulp-flatmap' {
+	import File = require('vinyl');
+	function f(fn:(stream:NodeJS.ReadWriteStream, file:File)=>NodeJS.ReadWriteStream): NodeJS.ReadWriteStream;
+
+	/**
+	 * This is required as per:
+	 * https://github.com/microsoft/TypeScript/issues/5073
+	 */
+	namespace f {}
+
+	export = f;
+}

lib/vscode/build/lib/typings/gulp-remote-src.d.ts

@@ -0,0 +1,23 @@
+declare module 'gulp-remote-retry-src' {
+
+	import stream = require("stream");
+
+	function remote(url: string, options: remote.IOptions): stream.Stream;
+
+	module remote {
+		export interface IRequestOptions {
+			body?: any;
+			json?: boolean;
+			method?: string;
+			headers?: any;
+		}
+
+		export interface IOptions {
+			base?: string;
+			buffer?: boolean;
+			requestOptions?: IRequestOptions;
+		}
+	}
+
+	export = remote;
+}

lib/vscode/build/lib/typings/gulp-tsb.d.ts

@@ -0,0 +1,18 @@
+
+
+declare module "gulp-tsb" {
+
+	export interface ICancellationToken {
+		isCancellationRequested(): boolean;
+	}
+
+	export interface IncrementalCompiler {
+		(token?: ICancellationToken): NodeJS.ReadWriteStream;
+		src(opts?: {
+			cwd?: string;
+			base?: string;
+		}): NodeJS.ReadStream;
+	}
+	export function create(projectPath: string, existingOptions: any, verbose?: boolean, onError?: (message: any) => void): IncrementalCompiler;
+
+}

lib/vscode/build/lib/typings/is.d.ts

@@ -0,0 +1,11 @@
+declare module 'is' {
+	function a(value: any, type: string): boolean;
+	function defined(value: any): boolean;
+	function undef(value: any): boolean;
+	function object(value: any): boolean;
+	function string(value: any): value is string;
+	function boolean(value: any): boolean;
+	function array(value: any): boolean;
+	function empty<T>(value: Object | Array<T>): boolean;
+	function equal<T extends Object | Array<any> | Function | Date>(value: T, other: T): boolean;
+}

lib/vscode/build/lib/typings/lazy.js.d.ts

@@ -0,0 +1,276 @@
+// Type definitions for Lazy.js 0.3.2
+// Project: https://github.com/dtao/lazy.js/
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare function Lazy(value: string): Lazy.StringLikeSequence;
+declare function Lazy<T>(value: T[]): Lazy.ArrayLikeSequence<T>;
+declare function Lazy(value: any[]): Lazy.ArrayLikeSequence<any>;
+declare function Lazy<T>(value: Object): Lazy.ObjectLikeSequence<T>;
+declare function Lazy(value: Object): Lazy.ObjectLikeSequence<any>;
+
+declare module Lazy {
+	function strict(): StrictLazy;
+	function generate<T>(generatorFn: GeneratorCallback<T>, length?: number): GeneratedSequence<T>;
+	function range(to: number): GeneratedSequence<number>;
+	function range(from: number, to: number, step?: number): GeneratedSequence<number>;
+	function repeat<T>(value: T, count?: number): GeneratedSequence<T>;
+	function on<T>(eventType: string): Sequence<T>;
+	function readFile(path: string): StringLikeSequence;
+	function makeHttpRequest(path: string): StringLikeSequence;
+
+	interface StrictLazy {
+		(value: string): StringLikeSequence;
+		<T>(value: T[]): ArrayLikeSequence<T>;
+		(value: any[]): ArrayLikeSequence<any>;
+		<T>(value: Object): ObjectLikeSequence<T>;
+		(value: Object): ObjectLikeSequence<any>;
+		strict(): StrictLazy;
+		generate<T>(generatorFn: GeneratorCallback<T>, length?: number): GeneratedSequence<T>;
+		range(to: number): GeneratedSequence<number>;
+		range(from: number, to: number, step?: number): GeneratedSequence<number>;
+		repeat<T>(value: T, count?: number): GeneratedSequence<T>;
+		on<T>(eventType: string): Sequence<T>;
+		readFile(path: string): StringLikeSequence;
+		makeHttpRequest(path: string): StringLikeSequence;
+	}
+
+	interface ArrayLike<T> {
+		length: number;
+		[index: number]: T;
+	}
+
+	interface Callback {
+		(): void;
+	}
+
+	interface ErrorCallback {
+		(error: any): void;
+	}
+
+	interface ValueCallback<T> {
+		(value: T): void;
+	}
+
+	interface GetKeyCallback<T> {
+		(value: T): string;
+	}
+
+	interface TestCallback<T> {
+		(value: T): boolean;
+	}
+
+	interface MapCallback<T, U> {
+		(value: T): U;
+	}
+
+	interface MapStringCallback {
+		(value: string): string;
+	}
+
+	interface NumberCallback<T> {
+		(value: T): number;
+	}
+
+	interface MemoCallback<T, U> {
+		(memo: U, value: T): U;
+	}
+
+	interface GeneratorCallback<T> {
+		(index: number): T;
+	}
+
+	interface CompareCallback {
+		(x: any, y: any): number;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	interface Iterator<T> {
+		new(sequence: Sequence<T>): Iterator<T>;
+		current(): T;
+		moveNext(): boolean;
+	}
+
+	interface GeneratedSequence<T> extends Sequence<T> {
+		new(generatorFn: GeneratorCallback<T>, length: number): GeneratedSequence<T>;
+		length(): number;
+	}
+
+	interface AsyncSequence<T> extends SequenceBase<T> {
+		each(callback: ValueCallback<T>): AsyncHandle<T>;
+	}
+
+	interface AsyncHandle<T> {
+		cancel(): void;
+		onComplete(callback: Callback): void;
+		onError(callback: ErrorCallback): void;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	module Sequence {
+		function define(methodName: string[], overrides: Object): Function;
+	}
+
+	interface Sequence<T> extends SequenceBase<T> {
+		each(eachFn: ValueCallback<T>): Sequence<T>;
+	}
+
+	interface ArraySequence<T> extends SequenceBase<T[]> {
+		flatten(): Sequence<T>;
+	}
+
+	interface SequenceBase<T> extends SequenceBaser<T> {
+		first(): any;
+		first(count: number): Sequence<T>;
+		indexOf(value: any, startIndex?: number): Sequence<T>;
+
+		last(): any;
+		last(count: number): Sequence<T>;
+		lastIndexOf(value: any): Sequence<T>;
+
+		reverse(): Sequence<T>;
+	}
+
+	interface SequenceBaser<T> {
+		// TODO improve define() (needs ugly overload)
+		async(interval: number): AsyncSequence<T>;
+		chunk(size: number): Sequence<T>;
+		compact(): Sequence<T>;
+		concat(var_args: T[]): Sequence<T>;
+		concat(sequence: Sequence<T>): Sequence<T>;
+		consecutive(length: number): Sequence<T>;
+		contains(value: T): boolean;
+		countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+		countBy(propertyName: string): ObjectLikeSequence<T>;
+		dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
+		every(predicateFn: TestCallback<T>): boolean;
+		filter(predicateFn: TestCallback<T>): Sequence<T>;
+		find(predicateFn: TestCallback<T>): Sequence<T>;
+		findWhere(properties: Object): Sequence<T>;
+
+		groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+		initial(count?: number): Sequence<T>;
+		intersection(var_args: T[]): Sequence<T>;
+		invoke(methodName: string): Sequence<T>;
+		isEmpty(): boolean;
+		join(delimiter?: string): string;
+		map<U>(mapFn: MapCallback<T, U[]>): ArraySequence<U>;
+		map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
+
+		// TODO: vscode addition to workaround strict null errors
+		flatten(): Sequence<any>;
+
+		max(valueFn?: NumberCallback<T>): T;
+		min(valueFn?: NumberCallback<T>): T;
+		none(valueFn?: TestCallback<T>): boolean;
+		pluck(propertyName: string): Sequence<T>;
+		reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
+		reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
+		reject(predicateFn: TestCallback<T>): Sequence<T>;
+		rest(count?: number): Sequence<T>;
+		shuffle(): Sequence<T>;
+		some(predicateFn?: TestCallback<T>): boolean;
+		sort(sortFn?: CompareCallback, descending?: boolean): Sequence<T>;
+		sortBy(sortFn: string, descending?: boolean): Sequence<T>;
+		sortBy(sortFn: NumberCallback<T>, descending?: boolean): Sequence<T>;
+		sortedIndex(value: T): Sequence<T>;
+		size(): number;
+		sum(valueFn?: NumberCallback<T>): Sequence<T>;
+		takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
+		union(var_args: T[]): Sequence<T>;
+		uniq(): Sequence<T>;
+		where(properties: Object): Sequence<T>;
+		without(...var_args: T[]): Sequence<T>;
+		without(var_args: T[]): Sequence<T>;
+		zip(var_args: T[]): ArraySequence<T>;
+
+		toArray(): T[];
+		toObject(): Object;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	module ArrayLikeSequence {
+		function define(methodName: string[], overrides: Object): Function;
+	}
+
+	interface ArrayLikeSequence<T> extends Sequence<T> {
+		// define()X;
+		concat(var_args: T[]): ArrayLikeSequence<T>;
+		concat(sequence: Sequence<T>): Sequence<T>;
+		first(count?: number): ArrayLikeSequence<T>;
+		get(index: number): T;
+		length(): number;
+		map<U>(mapFn: MapCallback<T, U[]>): ArraySequence<U>;
+		map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
+		pop(): ArrayLikeSequence<T>;
+		rest(count?: number): ArrayLikeSequence<T>;
+		reverse(): ArrayLikeSequence<T>;
+		shift(): ArrayLikeSequence<T>;
+		slice(begin: number, end?: number): ArrayLikeSequence<T>;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	module ObjectLikeSequence {
+		function define(methodName: string[], overrides: Object): Function;
+	}
+
+	interface ObjectLikeSequence<T> extends Sequence<T> {
+		assign(other: Object): ObjectLikeSequence<T>;
+		// throws error
+		//async(): X;
+		defaults(defaults: Object): ObjectLikeSequence<T>;
+		functions(): Sequence<T>;
+		get(property: string): ObjectLikeSequence<T>;
+		invert(): ObjectLikeSequence<T>;
+		keys(): Sequence<string>;
+		omit(properties: string[]): ObjectLikeSequence<T>;
+		pairs(): Sequence<T>;
+		pick(properties: string[]): ObjectLikeSequence<T>;
+		toArray(): T[];
+		toObject(): Object;
+		values(): Sequence<T>;
+	}
+
+	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+	module StringLikeSequence {
+		function define(methodName: string[], overrides: Object): Function;
+	}
+
+	interface StringLikeSequence extends SequenceBaser<string> {
+		charAt(index: number): string;
+		charCodeAt(index: number): number;
+		contains(value: string): boolean;
+		endsWith(suffix: string): boolean;
+
+		first(): string;
+		first(count: number): StringLikeSequence;
+
+		indexOf(substring: string, startIndex?: number): number;
+
+		last(): string;
+		last(count: number): StringLikeSequence;
+
+		lastIndexOf(substring: string, startIndex?: number): number;
+		mapString(mapFn: MapStringCallback): StringLikeSequence;
+		match(pattern: RegExp): StringLikeSequence;
+		reverse(): StringLikeSequence;
+
+		split(delimiter: string): StringLikeSequence;
+		split(delimiter: RegExp): StringLikeSequence;
+
+		startsWith(prefix: string): boolean;
+		substring(start: number, stop?: number): StringLikeSequence;
+		toLowerCase(): StringLikeSequence;
+		toUpperCase(): StringLikeSequence;
+	}
+}
+
+declare module 'lazy.js' {
+	export = Lazy;
+}
+

lib/vscode/build/lib/typings/vinyl.d.ts

@@ -0,0 +1,112 @@
+// Type definitions for vinyl 0.4.3
+// Project: https://github.com/wearefractal/vinyl
+// Definitions by: vvakame <https://github.com/vvakame/>, jedmao <https://github.com/jedmao>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module "vinyl" {
+
+	import fs = require("fs");
+
+	/**
+	 * A virtual file format.
+	 */
+	class File {
+		constructor(options?: {
+			/**
+			* Default: process.cwd()
+			*/
+			cwd?: string;
+			/**
+			 * Used for relative pathing. Typically where a glob starts.
+			 */
+			base?: string;
+			/**
+			 * Full path to the file.
+			 */
+			path?: string;
+			/**
+			 * Path history. Has no effect if options.path is passed.
+			 */
+			history?: string[];
+			/**
+			 * The result of an fs.stat call. See fs.Stats for more information.
+			 */
+			stat?: fs.Stats;
+			/**
+			 * File contents.
+			 * Type: Buffer, Stream, or null
+			 */
+			contents?: Buffer | NodeJS.ReadWriteStream;
+		});
+
+		/**
+		 * Default: process.cwd()
+		 */
+		public cwd: string;
+		/**
+		 * Used for relative pathing. Typically where a glob starts.
+		 */
+		public base: string;
+		/**
+		 * Full path to the file.
+		 */
+		public path: string;
+		public stat: fs.Stats;
+		/**
+		 * Type: Buffer|Stream|null (Default: null)
+		 */
+		public contents: Buffer | NodeJS.ReadableStream;
+		/**
+		 * Returns path.relative for the file base and file path.
+		 * Example:
+		 *  var file = new File({
+		 *    cwd: "/",
+		 *    base: "/test/",
+		 *    path: "/test/file.js"
+		 *  });
+		 *  console.log(file.relative); // file.js
+		 */
+		public relative: string;
+
+		public isBuffer(): boolean;
+
+		public isStream(): boolean;
+
+		public isNull(): boolean;
+
+		public isDirectory(): boolean;
+
+		/**
+		 * Returns a new File object with all attributes cloned. Custom attributes are deep-cloned.
+		 */
+		public clone(opts?: { contents?: boolean }): File;
+
+		/**
+		 * If file.contents is a Buffer, it will write it to the stream.
+		 * If file.contents is a Stream, it will pipe it to the stream.
+		 * If file.contents is null, it will do nothing.
+		 */
+		public pipe<T extends NodeJS.ReadWriteStream>(
+			stream: T,
+			opts?: {
+				/**
+				 * If false, the destination stream will not be ended (same as node core).
+				 */
+				end?: boolean;
+			}): T;
+
+		/**
+		 * Returns a pretty String interpretation of the File. Useful for console.log.
+		 */
+		public inspect(): string;
+	}
+
+	/**
+	 * This is required as per:
+	 * https://github.com/microsoft/TypeScript/issues/5073
+	 */
+	namespace File {}
+
+	export = File;
+
+}

lib/vscode/build/lib/util.ts

@@ -0,0 +1,342 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 debounce = require('debounce');
+import * as _filter from 'gulp-filter';
+import * as rename from 'gulp-rename';
+import * as _ from 'underscore';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as _rimraf from 'rimraf';
+import * as git from './git';
+import * as VinylFile from 'vinyl';
+import { ThroughStream } from 'through';
+import * as sm from 'source-map';
+
+const root = path.dirname(path.dirname(__dirname));
+
+export interface ICancellationToken {
+	isCancellationRequested(): boolean;
+}
+
+const NoCancellationToken: ICancellationToken = { isCancellationRequested: () => false };
+
+export interface IStreamProvider {
+	(cancellationToken?: ICancellationToken): NodeJS.ReadWriteStream;
+}
+
+export function incremental(streamProvider: IStreamProvider, initial: NodeJS.ReadWriteStream, supportsCancellation?: boolean): NodeJS.ReadWriteStream {
+	const input = es.through();
+	const output = es.through();
+	let state = 'idle';
+	let buffer = Object.create(null);
+
+	const token: ICancellationToken | undefined = !supportsCancellation ? undefined : { isCancellationRequested: () => Object.keys(buffer).length > 0 };
+
+	const run = (input: NodeJS.ReadWriteStream, isCancellable: boolean) => {
+		state = 'running';
+
+		const stream = !supportsCancellation ? streamProvider() : streamProvider(isCancellable ? token : NoCancellationToken);
+
+		input
+			.pipe(stream)
+			.pipe(es.through(undefined, () => {
+				state = 'idle';
+				eventuallyRun();
+			}))
+			.pipe(output);
+	};
+
+	if (initial) {
+		run(initial, false);
+	}
+
+	const eventuallyRun = debounce(() => {
+		const paths = Object.keys(buffer);
+
+		if (paths.length === 0) {
+			return;
+		}
+
+		const data = paths.map(path => buffer[path]);
+		buffer = Object.create(null);
+		run(es.readArray(data), true);
+	}, 500);
+
+	input.on('data', (f: any) => {
+		buffer[f.path] = f;
+
+		if (state === 'idle') {
+			eventuallyRun();
+		}
+	});
+
+	return es.duplex(input, output);
+}
+
+export function fixWin32DirectoryPermissions(): NodeJS.ReadWriteStream {
+	if (!/win32/.test(process.platform)) {
+		return es.through();
+	}
+
+	return es.mapSync<VinylFile, VinylFile>(f => {
+		if (f.stat && f.stat.isDirectory && f.stat.isDirectory()) {
+			f.stat.mode = 16877;
+		}
+
+		return f;
+	});
+}
+
+export function setExecutableBit(pattern?: string | string[]): NodeJS.ReadWriteStream {
+	const setBit = es.mapSync<VinylFile, VinylFile>(f => {
+		if (!f.stat) {
+			f.stat = { isFile() { return true; } } as any;
+		}
+		f.stat.mode = /* 100755 */ 33261;
+		return f;
+	});
+
+	if (!pattern) {
+		return setBit;
+	}
+
+	const input = es.through();
+	const filter = _filter(pattern, { restore: true });
+	const output = input
+		.pipe(filter)
+		.pipe(setBit)
+		.pipe(filter.restore);
+
+	return es.duplex(input, output);
+}
+
+export function toFileUri(filePath: string): string {
+	const match = filePath.match(/^([a-z])\:(.*)$/i);
+
+	if (match) {
+		filePath = '/' + match[1].toUpperCase() + ':' + match[2];
+	}
+
+	return 'file://' + filePath.replace(/\\/g, '/');
+}
+
+export function skipDirectories(): NodeJS.ReadWriteStream {
+	return es.mapSync<VinylFile, VinylFile | undefined>(f => {
+		if (!f.isDirectory()) {
+			return f;
+		}
+	});
+}
+
+export function cleanNodeModules(rulePath: string): NodeJS.ReadWriteStream {
+	const rules = fs.readFileSync(rulePath, 'utf8')
+		.split(/\r?\n/g)
+		.map(line => line.trim())
+		.filter(line => line && !/^#/.test(line));
+
+	const excludes = rules.filter(line => !/^!/.test(line)).map(line => `!**/node_modules/${line}`);
+	const includes = rules.filter(line => /^!/.test(line)).map(line => `**/node_modules/${line.substr(1)}`);
+
+	const input = es.through();
+	const output = es.merge(
+		input.pipe(_filter(['**', ...excludes])),
+		input.pipe(_filter(includes))
+	);
+
+	return es.duplex(input, output);
+}
+
+declare class FileSourceMap extends VinylFile {
+	public sourceMap: sm.RawSourceMap;
+}
+
+export function loadSourcemaps(): NodeJS.ReadWriteStream {
+	const input = es.through();
+
+	const output = input
+		.pipe(es.map<FileSourceMap, FileSourceMap | undefined>((f, cb): FileSourceMap | undefined => {
+			if (f.sourceMap) {
+				cb(undefined, f);
+				return;
+			}
+
+			if (!f.contents) {
+				cb(undefined, f);
+				return;
+			}
+
+			const contents = (<Buffer>f.contents).toString('utf8');
+
+			const reg = /\/\/# sourceMappingURL=(.*)$/g;
+			let lastMatch: RegExpMatchArray | null = null;
+			let match: RegExpMatchArray | null = null;
+
+			while (match = reg.exec(contents)) {
+				lastMatch = match;
+			}
+
+			if (!lastMatch) {
+				f.sourceMap = {
+					version: '3',
+					names: [],
+					mappings: '',
+					sources: [f.relative],
+					sourcesContent: [contents]
+				};
+
+				cb(undefined, f);
+				return;
+			}
+
+			f.contents = Buffer.from(contents.replace(/\/\/# sourceMappingURL=(.*)$/g, ''), 'utf8');
+
+			fs.readFile(path.join(path.dirname(f.path), lastMatch[1]), 'utf8', (err, contents) => {
+				if (err) { return cb(err); }
+
+				f.sourceMap = JSON.parse(contents);
+				cb(undefined, f);
+			});
+		}));
+
+	return es.duplex(input, output);
+}
+
+export function stripSourceMappingURL(): NodeJS.ReadWriteStream {
+	const input = es.through();
+
+	const output = input
+		.pipe(es.mapSync<VinylFile, VinylFile>(f => {
+			const contents = (<Buffer>f.contents).toString('utf8');
+			f.contents = Buffer.from(contents.replace(/\n\/\/# sourceMappingURL=(.*)$/gm, ''), 'utf8');
+			return f;
+		}));
+
+	return es.duplex(input, output);
+}
+
+export function rewriteSourceMappingURL(sourceMappingURLBase: string): NodeJS.ReadWriteStream {
+	const input = es.through();
+
+	const output = input
+		.pipe(es.mapSync<VinylFile, VinylFile>(f => {
+			const contents = (<Buffer>f.contents).toString('utf8');
+			const str = `//# sourceMappingURL=${sourceMappingURLBase}/${path.dirname(f.relative).replace(/\\/g, '/')}/$1`;
+			f.contents = Buffer.from(contents.replace(/\n\/\/# sourceMappingURL=(.*)$/gm, str));
+			return f;
+		}));
+
+	return es.duplex(input, output);
+}
+
+export function rimraf(dir: string): () => Promise<void> {
+	const result = () => new Promise<void>((c, e) => {
+		let retries = 0;
+
+		const retry = () => {
+			_rimraf(dir, { maxBusyTries: 1 }, (err: any) => {
+				if (!err) {
+					return c();
+				}
+
+				if (err.code === 'ENOTEMPTY' && ++retries < 5) {
+					return setTimeout(() => retry(), 10);
+				}
+
+				return e(err);
+			});
+		};
+
+		retry();
+	});
+
+	result.taskName = `clean-${path.basename(dir).toLowerCase()}`;
+	return result;
+}
+
+function _rreaddir(dirPath: string, prepend: string, result: string[]): void {
+	const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			_rreaddir(path.join(dirPath, entry.name), `${prepend}/${entry.name}`, result);
+		} else {
+			result.push(`${prepend}/${entry.name}`);
+		}
+	}
+}
+
+export function rreddir(dirPath: string): string[] {
+	let result: string[] = [];
+	_rreaddir(dirPath, '', result);
+	return result;
+}
+
+export function ensureDir(dirPath: string): void {
+	if (fs.existsSync(dirPath)) {
+		return;
+	}
+	ensureDir(path.dirname(dirPath));
+	fs.mkdirSync(dirPath);
+}
+
+export function getVersion(root: string): string | undefined {
+	let version = process.env['BUILD_SOURCEVERSION'];
+
+	if (!version || !/^[0-9a-f]{40}$/i.test(version)) {
+		version = git.getVersion(root);
+	}
+
+	return version;
+}
+
+export function rebase(count: number): NodeJS.ReadWriteStream {
+	return rename(f => {
+		const parts = f.dirname ? f.dirname.split(/[\/\\]/) : [];
+		f.dirname = parts.slice(count).join(path.sep);
+	});
+}
+
+export interface FilterStream extends NodeJS.ReadWriteStream {
+	restore: ThroughStream;
+}
+
+export function filter(fn: (data: any) => boolean): FilterStream {
+	const result = <FilterStream><any>es.through(function (data) {
+		if (fn(data)) {
+			this.emit('data', data);
+		} else {
+			result.restore.push(data);
+		}
+	});
+
+	result.restore = es.through();
+	return result;
+}
+
+export function versionStringToNumber(versionStr: string) {
+	const semverRegex = /(\d+)\.(\d+)\.(\d+)/;
+	const match = versionStr.match(semverRegex);
+	if (!match) {
+		throw new Error('Version string is not properly formatted: ' + versionStr);
+	}
+
+	return parseInt(match[1], 10) * 1e4 + parseInt(match[2], 10) * 1e2 + parseInt(match[3], 10);
+}
+
+export function streamToPromise(stream: NodeJS.ReadWriteStream): Promise<void> {
+	return new Promise((c, e) => {
+		stream.on('error', err => e(err));
+		stream.on('end', () => c());
+	});
+}
+
+export function getElectronVersion(): string {
+	const yarnrc = fs.readFileSync(path.join(root, '.yarnrc'), 'utf8');
+	const target = /^target "(.*)"$/m.exec(yarnrc)![1];
+	return target;
+}

lib/vscode/build/lib/watch/.gitignore

@@ -0,0 +1 @@
+.yarnrc

lib/vscode/build/lib/watch/index.ts

@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+const watch = process.platform === 'win32' ? require('./watch-win32') : require('vscode-gulp-watch');
+
+module.exports = function () {
+	return watch.apply(null, arguments);
+};

lib/vscode/build/lib/watch/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "watch",
+  "version": "1.0.0",
+  "description": "",
+  "author": "Microsoft ",
+  "private": true,
+  "license": "MIT",
+  "devDependencies": {},
+  "dependencies": {
+    "vscode-gulp-watch": "^5.0.2"
+  }
+}

lib/vscode/build/lib/watch/watch-win32.ts

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as path from 'path';
+import * as cp from 'child_process';
+import * as fs from 'fs';
+import * as File from 'vinyl';
+import * as es from 'event-stream';
+import * as filter from 'gulp-filter';
+import { Stream } from 'stream';
+
+const watcherPath = path.join(__dirname, 'watcher.exe');
+
+function toChangeType(type: '0' | '1' | '2'): 'change' | 'add' | 'unlink' {
+	switch (type) {
+		case '0': return 'change';
+		case '1': return 'add';
+		default: return 'unlink';
+	}
+}
+
+function watch(root: string): Stream {
+	const result = es.through();
+	let child: cp.ChildProcess | null = cp.spawn(watcherPath, [root]);
+
+	child.stdout.on('data', function (data) {
+		const lines: string[] = data.toString('utf8').split('\n');
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i].trim();
+			if (line.length === 0) {
+				continue;
+			}
+
+			const changeType = <'0' | '1' | '2'>line[0];
+			const changePath = line.substr(2);
+
+			// filter as early as possible
+			if (/^\.git/.test(changePath) || /(^|\\)out($|\\)/.test(changePath)) {
+				continue;
+			}
+
+			const changePathFull = path.join(root, changePath);
+
+			const file = new File({
+				path: changePathFull,
+				base: root
+			});
+			(<any>file).event = toChangeType(changeType);
+			result.emit('data', file);
+		}
+	});
+
+	child.stderr.on('data', function (data) {
+		result.emit('error', data);
+	});
+
+	child.on('exit', function (code) {
+		result.emit('error', 'Watcher died with code ' + code);
+		child = null;
+	});
+
+	process.once('SIGTERM', function () { process.exit(0); });
+	process.once('SIGTERM', function () { process.exit(0); });
+	process.once('exit', function () { if (child) { child.kill(); } });
+
+	return result;
+}
+
+const cache: { [cwd: string]: Stream; } = Object.create(null);
+
+module.exports = function (pattern: string | string[] | filter.FileFunction, options?: { cwd?: string; base?: string; }) {
+	options = options || {};
+
+	const cwd = path.normalize(options.cwd || process.cwd());
+	let watcher = cache[cwd];
+
+	if (!watcher) {
+		watcher = cache[cwd] = watch(cwd);
+	}
+
+	const rebase = !options.base ? es.through() : es.mapSync(function (f: File) {
+		f.base = options!.base!;
+		return f;
+	});
+
+	return watcher
+		.pipe(filter(['**', '!.git{,/**}'])) // ignore all things git
+		.pipe(filter(pattern))
+		.pipe(es.map(function (file: File, cb) {
+			fs.stat(file.path, function (err, stat) {
+				if (err && err.code === 'ENOENT') { return cb(undefined, file); }
+				if (err) { return cb(); }
+				if (!stat.isFile()) { return cb(); }
+
+				fs.readFile(file.path, function (err, contents) {
+					if (err && err.code === 'ENOENT') { return cb(undefined, file); }
+					if (err) { return cb(); }
+
+					file.contents = contents;
+					file.stat = stat;
+					cb(undefined, file);
+				});
+			});
+		}))
+		.pipe(rebase);
+};

lib/vscode/build/lib/watch/yarn.lock

@@ -0,0 +1,677 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+ansi-colors@1.1.0, ansi-colors@^1.0.1:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-1.1.0.tgz#6374b4dd5d4718ff3ce27a671a3b1cad077132a9"
+  integrity sha512-SFKX67auSNoVR38N3L+nvsPjOE0bybKTYbkf5tRvushrAPQ9V75huw0ZxBkKVeRU9kqH3d6HA4xTckbwZ4ixmA==
+  dependencies:
+    ansi-wrap "^0.1.0"
+
+ansi-gray@^0.1.1:
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/ansi-gray/-/ansi-gray-0.1.1.tgz#2962cf54ec9792c48510a3deb524436861ef7251"
+  integrity sha1-KWLPVOyXksSFEKPetSRDaGHvclE=
+  dependencies:
+    ansi-wrap "0.1.0"
+
+ansi-wrap@0.1.0, ansi-wrap@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/ansi-wrap/-/ansi-wrap-0.1.0.tgz#a82250ddb0015e9a27ca82e82ea603bbfa45efaf"
+  integrity sha1-qCJQ3bABXponyoLoLqYDu/pF768=
+
+anymatch@^1.3.0:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-1.3.2.tgz#553dcb8f91e3c889845dfdba34c77721b90b9d7a"
+  integrity sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==
+  dependencies:
+    micromatch "^2.1.5"
+    normalize-path "^2.0.0"
+
+anymatch@~3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.1.tgz#c55ecf02185e2469259399310c173ce31233b142"
+  integrity sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==
+  dependencies:
+    normalize-path "^3.0.0"
+    picomatch "^2.0.4"
+
+arr-diff@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf"
+  integrity sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=
+  dependencies:
+    arr-flatten "^1.0.1"
+
+arr-diff@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
+  integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=
+
+arr-flatten@^1.0.1:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.1.0.tgz#36048bbff4e7b47e136644316c99669ea5ae91f1"
+  integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==
+
+arr-union@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4"
+  integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ=
+
+array-unique@^0.2.1:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53"
+  integrity sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=
+
+assign-symbols@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367"
+  integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c=
+
+binary-extensions@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.0.0.tgz#23c0df14f6a88077f5f986c0d167ec03c3d5537c"
+  integrity sha512-Phlt0plgpIIBOGTT/ehfFnbNlfsDEiqmzE2KRXoX1bLIlir4X/MR+zSyBEkL05ffWgnRSf/DXv+WrUAVr93/ow==
+
+braces@^1.8.2:
+  version "1.8.5"
+  resolved "https://registry.yarnpkg.com/braces/-/braces-1.8.5.tgz#ba77962e12dff969d6b76711e914b737857bf6a7"
+  integrity sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=
+  dependencies:
+    expand-range "^1.8.1"
+    preserve "^0.2.0"
+    repeat-element "^1.1.2"
+
+braces@~3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.2.tgz#3454e1a462ee8d599e236df336cd9ea4f8afe107"
+  integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==
+  dependencies:
+    fill-range "^7.0.1"
+
+chokidar@3.3.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.3.0.tgz#12c0714668c55800f659e262d4962a97faf554a6"
+  integrity sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==
+  dependencies:
+    anymatch "~3.1.1"
+    braces "~3.0.2"
+    glob-parent "~5.1.0"
+    is-binary-path "~2.1.0"
+    is-glob "~4.0.1"
+    normalize-path "~3.0.0"
+    readdirp "~3.2.0"
+  optionalDependencies:
+    fsevents "~2.1.1"
+
+clone-buffer@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/clone-buffer/-/clone-buffer-1.0.0.tgz#e3e25b207ac4e701af721e2cb5a16792cac3dc58"
+  integrity sha1-4+JbIHrE5wGvch4staFnksrD3Fg=
+
+clone-stats@^0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/clone-stats/-/clone-stats-0.0.1.tgz#b88f94a82cf38b8791d58046ea4029ad88ca99d1"
+  integrity sha1-uI+UqCzzi4eR1YBG6kAprYjKmdE=
+
+clone-stats@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/clone-stats/-/clone-stats-1.0.0.tgz#b3782dff8bb5474e18b9b6bf0fdfe782f8777680"
+  integrity sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=
+
+clone@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/clone/-/clone-1.0.4.tgz#da309cc263df15994c688ca902179ca3c7cd7c7e"
+  integrity sha1-2jCcwmPfFZlMaIypAheco8fNfH4=
+
+clone@^2.1.1:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/clone/-/clone-2.1.2.tgz#1b7f4b9f591f1e8f83670401600345a02887435f"
+  integrity sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=
+
+cloneable-readable@^1.0.0:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/cloneable-readable/-/cloneable-readable-1.1.3.tgz#120a00cb053bfb63a222e709f9683ea2e11d8cec"
+  integrity sha512-2EF8zTQOxYq70Y4XKtorQupqF0m49MBz2/yf5Bj+MHjvpG3Hy7sImifnqD6UA+TKYxeSV+u6qqQPawN5UvnpKQ==
+  dependencies:
+    inherits "^2.0.1"
+    process-nextick-args "^2.0.0"
+    readable-stream "^2.3.5"
+
+color-support@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/color-support/-/color-support-1.1.3.tgz#93834379a1cc9a0c61f82f52f0d04322251bd5a2"
+  integrity sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==
+
+core-util-is@~1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7"
+  integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=
+
+expand-brackets@^0.1.4:
+  version "0.1.5"
+  resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-0.1.5.tgz#df07284e342a807cd733ac5af72411e581d1177b"
+  integrity sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=
+  dependencies:
+    is-posix-bracket "^0.1.0"
+
+expand-range@^1.8.1:
+  version "1.8.2"
+  resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-1.8.2.tgz#a299effd335fe2721ebae8e257ec79644fc85337"
+  integrity sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=
+  dependencies:
+    fill-range "^2.1.0"
+
+extend-shallow@^3.0.2:
+  version "3.0.2"
+  resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8"
+  integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=
+  dependencies:
+    assign-symbols "^1.0.0"
+    is-extendable "^1.0.1"
+
+extglob@^0.3.1:
+  version "0.3.2"
+  resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1"
+  integrity sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=
+  dependencies:
+    is-extglob "^1.0.0"
+
+fancy-log@1.3.2:
+  version "1.3.2"
+  resolved "https://registry.yarnpkg.com/fancy-log/-/fancy-log-1.3.2.tgz#f41125e3d84f2e7d89a43d06d958c8f78be16be1"
+  integrity sha1-9BEl49hPLn2JpD0G2VjI94vha+E=
+  dependencies:
+    ansi-gray "^0.1.1"
+    color-support "^1.1.3"
+    time-stamp "^1.0.0"
+
+filename-regex@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.1.tgz#c1c4b9bee3e09725ddb106b75c1e301fe2f18b26"
+  integrity sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=
+
+fill-range@^2.1.0:
+  version "2.2.4"
+  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-2.2.4.tgz#eb1e773abb056dcd8df2bfdf6af59b8b3a936565"
+  integrity sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==
+  dependencies:
+    is-number "^2.1.0"
+    isobject "^2.0.0"
+    randomatic "^3.0.0"
+    repeat-element "^1.1.2"
+    repeat-string "^1.5.2"
+
+fill-range@^7.0.1:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.0.1.tgz#1919a6a7c75fe38b2c7c77e5198535da9acdda40"
+  integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==
+  dependencies:
+    to-regex-range "^5.0.1"
+
+first-chunk-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/first-chunk-stream/-/first-chunk-stream-2.0.0.tgz#1bdecdb8e083c0664b91945581577a43a9f31d70"
+  integrity sha1-G97NuOCDwGZLkZRVgVd6Q6nzHXA=
+  dependencies:
+    readable-stream "^2.0.2"
+
+for-in@^1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80"
+  integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=
+
+for-own@^0.1.4:
+  version "0.1.5"
+  resolved "https://registry.yarnpkg.com/for-own/-/for-own-0.1.5.tgz#5265c681a4f294dabbf17c9509b6763aa84510ce"
+  integrity sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=
+  dependencies:
+    for-in "^1.0.1"
+
+fsevents@~2.1.1:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.1.2.tgz#4c0a1fb34bc68e543b4b82a9ec392bfbda840805"
+  integrity sha512-R4wDiBwZ0KzpgOWetKDug1FZcYhqYnUYKtfZYt4mD5SBz76q0KR4Q9o7GIPamsVPGmW3EYPPJ0dOOjvx32ldZA==
+
+glob-base@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/glob-base/-/glob-base-0.3.0.tgz#dbb164f6221b1c0b1ccf82aea328b497df0ea3c4"
+  integrity sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=
+  dependencies:
+    glob-parent "^2.0.0"
+    is-glob "^2.0.0"
+
+glob-parent@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-2.0.0.tgz#81383d72db054fcccf5336daa902f182f6edbb28"
+  integrity sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=
+  dependencies:
+    is-glob "^2.0.0"
+
+glob-parent@^3.0.1:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-3.1.0.tgz#9e6af6299d8d3bd2bd40430832bd113df906c5ae"
+  integrity sha1-nmr2KZ2NO9K9QEMIMr0RPfkGxa4=
+  dependencies:
+    is-glob "^3.1.0"
+    path-dirname "^1.0.0"
+
+glob-parent@~5.1.0:
+  version "5.1.1"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.1.tgz#b6c1ef417c4e5663ea498f1c45afac6916bbc229"
+  integrity sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==
+  dependencies:
+    is-glob "^4.0.1"
+
+graceful-fs@^4.1.2:
+  version "4.2.3"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.3.tgz#4a12ff1b60376ef09862c2093edd908328be8423"
+  integrity sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==
+
+inherits@^2.0.1, inherits@~2.0.3:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
+
+is-binary-path@~2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09"
+  integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==
+  dependencies:
+    binary-extensions "^2.0.0"
+
+is-buffer@^1.1.5:
+  version "1.1.6"
+  resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
+  integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
+
+is-dotfile@^1.0.0:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/is-dotfile/-/is-dotfile-1.0.3.tgz#a6a2f32ffd2dfb04f5ca25ecd0f6b83cf798a1e1"
+  integrity sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=
+
+is-equal-shallow@^0.1.3:
+  version "0.1.3"
+  resolved "https://registry.yarnpkg.com/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz#2238098fc221de0bcfa5d9eac4c45d638aa1c534"
+  integrity sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=
+  dependencies:
+    is-primitive "^2.0.0"
+
+is-extendable@^0.1.1:
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89"
+  integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=
+
+is-extendable@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-1.0.1.tgz#a7470f9e426733d81bd81e1155264e3a3507cab4"
+  integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==
+  dependencies:
+    is-plain-object "^2.0.4"
+
+is-extglob@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0"
+  integrity sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=
+
+is-extglob@^2.1.0, is-extglob@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2"
+  integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=
+
+is-glob@^2.0.0, is-glob@^2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863"
+  integrity sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=
+  dependencies:
+    is-extglob "^1.0.0"
+
+is-glob@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-3.1.0.tgz#7ba5ae24217804ac70707b96922567486cc3e84a"
+  integrity sha1-e6WuJCF4BKxwcHuWkiVnSGzD6Eo=
+  dependencies:
+    is-extglob "^2.1.0"
+
+is-glob@^4.0.1, is-glob@~4.0.1:
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc"
+  integrity sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==
+  dependencies:
+    is-extglob "^2.1.1"
+
+is-number@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/is-number/-/is-number-2.1.0.tgz#01fcbbb393463a548f2f466cce16dece49db908f"
+  integrity sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=
+  dependencies:
+    kind-of "^3.0.2"
+
+is-number@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/is-number/-/is-number-4.0.0.tgz#0026e37f5454d73e356dfe6564699867c6a7f0ff"
+  integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ==
+
+is-number@^7.0.0:
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b"
+  integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==
+
+is-plain-object@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
+  integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
+  dependencies:
+    isobject "^3.0.1"
+
+is-posix-bracket@^0.1.0:
+  version "0.1.1"
+  resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4"
+  integrity sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=
+
+is-primitive@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575"
+  integrity sha1-IHurkWOEmcB7Kt8kCkGochADRXU=
+
+is-utf8@^0.2.0:
+  version "0.2.1"
+  resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72"
+  integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=
+
+isarray@1.0.0, isarray@~1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11"
+  integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=
+
+isobject@^2.0.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89"
+  integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=
+  dependencies:
+    isarray "1.0.0"
+
+isobject@^3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
+  integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
+
+kind-of@^3.0.2:
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64"
+  integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=
+  dependencies:
+    is-buffer "^1.1.5"
+
+kind-of@^6.0.0:
+  version "6.0.3"
+  resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
+  integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
+
+math-random@^1.0.1:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/math-random/-/math-random-1.0.4.tgz#5dd6943c938548267016d4e34f057583080c514c"
+  integrity sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A==
+
+micromatch@^2.1.5:
+  version "2.3.11"
+  resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565"
+  integrity sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=
+  dependencies:
+    arr-diff "^2.0.0"
+    array-unique "^0.2.1"
+    braces "^1.8.2"
+    expand-brackets "^0.1.4"
+    extglob "^0.3.1"
+    filename-regex "^2.0.0"
+    is-extglob "^1.0.0"
+    is-glob "^2.0.1"
+    kind-of "^3.0.2"
+    normalize-path "^2.0.1"
+    object.omit "^2.0.0"
+    parse-glob "^3.0.4"
+    regex-cache "^0.4.2"
+
+normalize-path@^2.0.0, normalize-path@^2.0.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9"
+  integrity sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=
+  dependencies:
+    remove-trailing-separator "^1.0.1"
+
+normalize-path@^3.0.0, normalize-path@~3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65"
+  integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==
+
+object-assign@^4.1.0:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
+  integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=
+
+object.omit@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa"
+  integrity sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=
+  dependencies:
+    for-own "^0.1.4"
+    is-extendable "^0.1.1"
+
+parse-glob@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c"
+  integrity sha1-ssN2z7EfNVE7rdFz7wu246OIORw=
+  dependencies:
+    glob-base "^0.3.0"
+    is-dotfile "^1.0.0"
+    is-extglob "^1.0.0"
+    is-glob "^2.0.0"
+
+path-dirname@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/path-dirname/-/path-dirname-1.0.2.tgz#cc33d24d525e099a5388c0336c6e32b9160609e0"
+  integrity sha1-zDPSTVJeCZpTiMAzbG4yuRYGCeA=
+
+path-is-absolute@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
+  integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
+
+picomatch@^2.0.4:
+  version "2.2.2"
+  resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.2.2.tgz#21f333e9b6b8eaff02468f5146ea406d345f4dad"
+  integrity sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==
+
+pify@^2.3.0:
+  version "2.3.0"
+  resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c"
+  integrity sha1-7RQaasBDqEnqWISY59yosVMw6Qw=
+
+pinkie-promise@^2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa"
+  integrity sha1-ITXW36ejWMBprJsXh3YogihFD/o=
+  dependencies:
+    pinkie "^2.0.0"
+
+pinkie@^2.0.0:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870"
+  integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA=
+
+plugin-error@1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/plugin-error/-/plugin-error-1.0.1.tgz#77016bd8919d0ac377fdcdd0322328953ca5781c"
+  integrity sha512-L1zP0dk7vGweZME2i+EeakvUNqSrdiI3F91TwEoYiGrAfUXmVv6fJIq4g82PAXxNsWOp0J7ZqQy/3Szz0ajTxA==
+  dependencies:
+    ansi-colors "^1.0.1"
+    arr-diff "^4.0.0"
+    arr-union "^3.1.0"
+    extend-shallow "^3.0.2"
+
+preserve@^0.2.0:
+  version "0.2.0"
+  resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b"
+  integrity sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=
+
+process-nextick-args@^2.0.0, process-nextick-args@~2.0.0:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2"
+  integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==
+
+randomatic@^3.0.0:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-3.1.1.tgz#b776efc59375984e36c537b2f51a1f0aff0da1ed"
+  integrity sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw==
+  dependencies:
+    is-number "^4.0.0"
+    kind-of "^6.0.0"
+    math-random "^1.0.1"
+
+readable-stream@^2.0.2, readable-stream@^2.2.2, readable-stream@^2.3.5:
+  version "2.3.7"
+  resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57"
+  integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==
+  dependencies:
+    core-util-is "~1.0.0"
+    inherits "~2.0.3"
+    isarray "~1.0.0"
+    process-nextick-args "~2.0.0"
+    safe-buffer "~5.1.1"
+    string_decoder "~1.1.1"
+    util-deprecate "~1.0.1"
+
+readdirp@~3.2.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.2.0.tgz#c30c33352b12c96dfb4b895421a49fd5a9593839"
+  integrity sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==
+  dependencies:
+    picomatch "^2.0.4"
+
+regex-cache@^0.4.2:
+  version "0.4.4"
+  resolved "https://registry.yarnpkg.com/regex-cache/-/regex-cache-0.4.4.tgz#75bdc58a2a1496cec48a12835bc54c8d562336dd"
+  integrity sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==
+  dependencies:
+    is-equal-shallow "^0.1.3"
+
+remove-trailing-separator@^1.0.1:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef"
+  integrity sha1-wkvOKig62tW8P1jg1IJJuSN52O8=
+
+repeat-element@^1.1.2:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.3.tgz#782e0d825c0c5a3bb39731f84efee6b742e6b1ce"
+  integrity sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g==
+
+repeat-string@^1.5.2:
+  version "1.6.1"
+  resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637"
+  integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc=
+
+replace-ext@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/replace-ext/-/replace-ext-0.0.1.tgz#29bbd92078a739f0bcce2b4ee41e837953522924"
+  integrity sha1-KbvZIHinOfC8zitO5B6DeVNSKSQ=
+
+replace-ext@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/replace-ext/-/replace-ext-1.0.0.tgz#de63128373fcbf7c3ccfa4de5a480c45a67958eb"
+  integrity sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=
+
+safe-buffer@~5.1.0, safe-buffer@~5.1.1:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
+  integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
+
+string_decoder@~1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8"
+  integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==
+  dependencies:
+    safe-buffer "~5.1.0"
+
+strip-bom-stream@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/strip-bom-stream/-/strip-bom-stream-2.0.0.tgz#f87db5ef2613f6968aa545abfe1ec728b6a829ca"
+  integrity sha1-+H217yYT9paKpUWr/h7HKLaoKco=
+  dependencies:
+    first-chunk-stream "^2.0.0"
+    strip-bom "^2.0.0"
+
+strip-bom@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e"
+  integrity sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=
+  dependencies:
+    is-utf8 "^0.2.0"
+
+time-stamp@^1.0.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/time-stamp/-/time-stamp-1.1.0.tgz#764a5a11af50561921b133f3b44e618687e0f5c3"
+  integrity sha1-dkpaEa9QVhkhsTPztE5hhofg9cM=
+
+to-regex-range@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4"
+  integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==
+  dependencies:
+    is-number "^7.0.0"
+
+util-deprecate@~1.0.1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
+  integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
+
+vinyl-file@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/vinyl-file/-/vinyl-file-2.0.0.tgz#a7ebf5ffbefda1b7d18d140fcb07b223efb6751a"
+  integrity sha1-p+v1/779obfRjRQPyweyI++2dRo=
+  dependencies:
+    graceful-fs "^4.1.2"
+    pify "^2.3.0"
+    pinkie-promise "^2.0.0"
+    strip-bom "^2.0.0"
+    strip-bom-stream "^2.0.0"
+    vinyl "^1.1.0"
+
+vinyl@^1.1.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-1.2.0.tgz#5c88036cf565e5df05558bfc911f8656df218884"
+  integrity sha1-XIgDbPVl5d8FVYv8kR+GVt8hiIQ=
+  dependencies:
+    clone "^1.0.0"
+    clone-stats "^0.0.1"
+    replace-ext "0.0.1"
+
+vinyl@^2.1.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-2.2.0.tgz#d85b07da96e458d25b2ffe19fece9f2caa13ed86"
+  integrity sha512-MBH+yP0kC/GQ5GwBqrTPTzEfiiLjta7hTtvQtbxBgTeSXsmKQRQecjibMbxIXzVT3Y9KJK+drOz1/k+vsu8Nkg==
+  dependencies:
+    clone "^2.1.1"
+    clone-buffer "^1.0.0"
+    clone-stats "^1.0.0"
+    cloneable-readable "^1.0.0"
+    remove-trailing-separator "^1.0.1"
+    replace-ext "^1.0.0"
+
+vscode-gulp-watch@^5.0.2:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/vscode-gulp-watch/-/vscode-gulp-watch-5.0.2.tgz#0060ba8d091284a6fbd7e608aa318a9c1d73b840"
+  integrity sha512-l2v+W3iQvxpX2ny2C7eJTd+83rQXiZ85KGY0mub/QRqUxgDc+KH/EYiw4mttzIhPzVBmxrUO4RcLNbPdccg0mQ==
+  dependencies:
+    ansi-colors "1.1.0"
+    anymatch "^1.3.0"
+    chokidar "3.3.0"
+    fancy-log "1.3.2"
+    glob-parent "^3.0.1"
+    normalize-path "^3.0.0"
+    object-assign "^4.1.0"
+    path-is-absolute "^1.0.1"
+    plugin-error "1.0.1"
+    readable-stream "^2.2.2"
+    vinyl "^2.1.0"
+    vinyl-file "^2.0.0"