Hello Code

.gitignore

+.DS_Store
+npm-debug.log
+Thumbs.db
+node_modules/
+out/
+out-build/
+out-editor/
+out-editor-min/
+out-editor-ossfree/
+out-editor-ossfree-min/
+out-vscode/
+out-vscode-min/
+build/node_modules
\ No newline at end of file

.vscode/launch.json

+{
+	"version": "0.1.0",
+	"configurations": [
+		{
+			"name": "Unit Tests",
+			"type": "node",
+			"request": "launch",
+			"program": "node_modules/mocha/bin/_mocha",
+			"stopOnEntry": false,
+			"args": [
+				"--timeout",
+				"999999",
+				"--colors"
+			],
+			"cwd": ".",
+			"runtimeExecutable": null,
+			"runtimeArgs": [],
+			"env": {},
+			"sourceMaps": true,
+			"outDir": "out"
+		},
+		{
+			"name": "Attach to Extension Host",
+			"type": "node",
+			"request": "attach",
+			"port": 5870,
+			"sourceMaps": true,
+			"outDir": "out"
+		},
+		{
+			"name": "VSCode API Tests",
+			"type": "extensionHost",
+			"request": "launch",
+			"runtimeExecutable": "${execPath}",
+			"args": [
+				"${workspaceRoot}/extensions/vscode-api-tests/testWorkspace",
+				"--extensionDevelopmentPath=${workspaceRoot}/extensions/vscode-api-tests",
+				"--extensionTestsPath=${workspaceRoot}/extensions/vscode-api-tests/out"
+			],
+			"stopOnEntry": false,
+			"sourceMaps": true,
+			"outDir": "out"
+		}
+	]
+}
\ No newline at end of file

.vscode/settings.json

+{
+	"editor.insertSpaces": false,
+	"files.trimTrailingWhitespace": true,
+	"files.exclude": {
+		".git": true,
+		"**/.DS_Store": true,
+		"**/coverage": true
+	},
+	"search.exclude": {
+		"**/node_modules/**": true,
+		"**/bower_components": true,
+		"out*/**": true,
+		"extensions/**/out/**": true
+	}
+}
\ No newline at end of file

.vscode/tasks.json

+{
+	"version": "0.1.0",
+	"command": "gulp",
+	"isShellCommand": true,
+	"tasks": [
+		{
+			"taskName": "watch",
+			"args": [
+				"--no-color"
+			],
+			"isBuildCommand": true,
+			"isWatching": true,
+			"problemMatcher": {
+				"owner": "typescript",
+				"fileLocation": ["absolute"],
+				"pattern": {
+					"regexp": "^\\*\\*\\* Error: ([^(]+)\\((\\d+|\\d+,\\d+|\\d+,\\d+,\\d+,\\d+)\\): (.*)$",
+					"file": 1,
+					"location": 2,
+					"message": 3
+				},
+				"watching": {
+					"beginsPattern": "^\\*\\*\\* Starting\\.\\.\\.$",
+					"endsPattern": "^\\*\\*\\* Finished"
+				}
+			}
+		},
+		{
+			"taskName": "test",
+			"args": [
+				"--no-color"
+			],
+			"showOutput": "always",
+			"isTestCommand": true
+		}
+	]
+}
\ No newline at end of file

LICENSE.txt

+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
+OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file

OSSREADME.json

+// Listing in here platform dependencies that come in at build time
+
+[{
+	"name": "atom-brightray",
+	"repositoryURL": "https://github.com/atom/brightray",
+	"license": "MIT",
+	"isProd": true
+},
+{
+	"name": "chromium",
+	"version": "45.0.2454.85",
+	"repositoryURL": "http://www.chromium.org/Home",
+	"licenseDetail": [
+		"BSD License",
+		"",
+		"Copyright 2014 The Chromium Authors. All rights reserved.",
+		"",
+		"Redistribution and use in source and binary forms, with or without modification,",
+		"are permitted provided that the following conditions are met:",
+		"",
+		" * Redistributions of source code must retain the above copyright notice, this",
+		"   list of conditions and the following disclaimer.",
+		"",
+		" * Redistributions in binary form must reproduce the above copyright notice,",
+		"   this list of conditions and the following disclaimer in the documentation",
+		"   and/or other materials provided with the distribution.",
+		"",
+		" * Neither the name Google Inc. nor the names of its contributors may be used to",
+		"   endorse or promote products derived from this software without specific",
+		"   prior written permission.",
+		"",
+		"THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND",
+		"ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED",
+		"WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE",
+		"DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR",
+		"ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES",
+		"(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;",
+		"LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON",
+		"ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT",
+		"(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS",
+		"SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+	],
+	"isProd": true
+},
+{
+	"name": "libchromiumcontent",
+	"version": "45.0.2454.85 ",
+	"license": "MIT",
+	"repositoryURL": "https://github.com/atom/libchromiumcontent",
+	"isProd": true
+},
+{
+	"name": "nodejs",
+	"version": "4.1.1",
+	"repositoryURL": "https://github.com/nodejs/node",
+	"isProd": true
+},
+{
+	"name": "electron",
+	"version": "0.34.1",
+	"license": "MIT",
+	"repositoryURL": "https://github.com/atom/electron",
+	"isProd": true
+},
+{
+	"name": "inno setup",
+	"version": "5.5.6",
+	"repositoryURL": "https://github.com/jrsoftware/issrc",
+	"isProd": true
+},
+
+
+// ----------------------------------------------------------
+// The following definitions are here for the sole purpose of
+// defining licenses for dependencies where licensing cannot
+// be inferred by tooling:
+
+{
+	// Reason: LICENSE file missing in repo
+	// SOURCE: https://github.com/isaacs/core-util-is/blob/master/lib/util.js
+	"name":"core-util-is",
+	"isLicense": true,
+	"licenseDetail": [
+		"Copyright Joyent, Inc. and other Node contributors.",
+		"",
+		"Permission is hereby granted, free of charge, to any person obtaining a",
+		"copy of this software and associated documentation files (the",
+		"\"Software\"), to deal in the Software without restriction, including",
+		"without limitation the rights to use, copy, modify, merge, publish,",
+		"distribute, sublicense, and/or sell copies of the Software, and to permit",
+		"persons to whom the Software is furnished to do so, subject to the",
+		"following conditions:",
+		"",
+		"The above copyright notice and this permission notice shall be included",
+		"in all copies or substantial portions of the Software.",
+		"",
+		"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS",
+		"OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF",
+		"MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN",
+		"NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,",
+		"DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR",
+		"OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE",
+		"USE OR OTHER DEALINGS IN THE SOFTWARE."
+	]
+},
+{
+	// Reason: vscode-textmate is not public yet
+	// TODO: Remove once vscode-textmate visibility is made public
+	"name": "vscode-textmate",
+	"isLicense": true,
+	"licenseDetail": [
+		"The MIT License (MIT)",
+		"",
+		"Copyright (c) Microsoft Corporation",
+		"",
+		"Permission is hereby granted, free of charge, to any person obtaining a copy",
+		"of this software and associated documentation files (the \"Software\"), to deal",
+		"in the Software without restriction, including without limitation the rights",
+		"to use, copy, modify, merge, publish, distribute, sublicense, and/or sell",
+		"copies of the Software, and to permit persons to whom the Software is",
+		"furnished to do so, subject to the following conditions:",
+		"",
+		"The above copyright notice and this permission notice shall be included in all",
+		"copies or substantial portions of the Software.",
+		"",
+		"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR",
+		"IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,",
+		"FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE",
+		"AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER",
+		"LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,",
+		"OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE",
+		"SOFTWARE."
+	]
+},
+{
+	// Reason: LICENSE file missing in repo
+	"name": "winreg",
+	"isLicense": true,
+	"licenseDetail": [
+		"Copyright (c) Paul Bottin",
+		"",
+		"The BSD License",
+		"",
+		"Redistribution and use in source and binary forms, with or without",
+		"modification, are permitted provided that the following conditions",
+		"are met:",
+		"",
+		"1. Redistributions of source code must retain the above copyright",
+		"   notice, this list of conditions and the following disclaimer.",
+		"",
+		"2. Redistributions in binary form must reproduce the above copyright",
+		"   notice, this list of conditions and the following disclaimer in the",
+		"   documentation and/or other materials provided with the distribution.",
+		"",
+		"THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND",
+		"ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE",
+		"IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR",
+		"PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS",
+		"BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR",
+		"CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF",
+		"SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR",
+		"BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,",
+		"WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE",
+		"OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN",
+		"IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+	]
+},
+{
+	// Reason: LICENSE file doesn't have Copyright statement
+	"name": "readdirp",
+	"isLicense": true,
+	"licenseDetail": [
+		"This software is released under the MIT license:",
+		"",
+		"Copyright (c) Thorsten Lorenz",
+		"",
+		"Permission is hereby granted, free of charge, to any person obtaining a copy of",
+		"this software and associated documentation files (the \"Software\"), to deal in",
+		"the Software without restriction, including without limitation the rights to",
+		"use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of",
+		"the Software, and to permit persons to whom the Software is furnished to do so,",
+		"subject to the following conditions:",
+		"",
+		"The above copyright notice and this permission notice shall be included in all",
+		"copies or substantial portions of the Software.",
+		"",
+		"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR",
+		"IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS",
+		"FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR",
+		"COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER",
+		"IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN",
+		"CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE."
+	]
+}
+
+]

build/gulpfile.js

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+var gulp = require('gulp');
+var tsb = require('gulp-tsb');
+var util = require('./lib/util');
+var watcher = require('./lib/watch');
+var assign = require('object-assign');
+
+var compilation = tsb.create(assign({ verbose: true }, require('./tsconfig.json').compilerOptions));
+
+gulp.task('compile', function() {
+	return gulp.src('**/*.ts', { base: '.' })
+		.pipe(compilation())
+		.pipe(gulp.dest(''));
+});
+
+gulp.task('watch', function() {
+	var src = gulp.src('**/*.ts', { base: '.' });
+
+	return watcher('**/*.ts', { base: '.' })
+		.pipe(util.incremental(compilation, src))
+		.pipe(gulp.dest(''));
+});
+
+gulp.task('default', ['compile']);

build/lib/buildResponseHelper.js

+
+var fs = require('fs'),
+	path = require('path'),
+	glob = require('glob');
+
+var StartState = 0;
+var BundleRead = 1;
+var ReadingFiles = 2;
+
+exports.parse = function (content) {
+
+	var state = StartState,
+		lines = content.split(/\r\n|\n/),
+		bundledModules = {},
+		cssModules = {},
+		toDelete = {};
+
+	lines.forEach(function (line) {
+		line = line.trim();
+		switch (state) {
+			case StartState:
+				if (line.length > 0) {
+					if (/.*\.js$/.test(line)) {
+						bundledModules[line] = true;
+						cssModules[(line.substring(0, line.length - 2) + 'css').toLowerCase()] = true;
+					}
+					state = BundleRead;
+				}
+				break;
+			case BundleRead:
+				if ('----------------' === line) {
+					state = ReadingFiles;
+				}
+				break;
+			case ReadingFiles:
+				if (line.length === 0) {
+					state = StartState;
+				} else {
+					if (!bundledModules[line]) {
+						toDelete[line] = true;
+					}
+				}
+				break;
+		}
+	});
+
+	return {
+		bundledModules: bundledModules,
+		cssModules: cssModules,
+		toDelete: toDelete
+	};
+};
+
+//exports.cleanEmptyFolders = function (location) {
+//	glob.sync('**/*', {
+//		cwd: location
+//	}).sort(function (a, b) {
+//		if (a === b) {
+//			return 0;
+//		}
+//		if (a > b) {
+//			return -1;
+//		}
+//		return 1;
+//	}).forEach(function (file) {
+//		
+//	});
+//	
+//	console.log(all);
+//	
+//}
\ No newline at end of file

build/lib/bundle.js

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var fs = require('fs');
+var path = require('path');
+var vm = require('vm');
+/**
+ * Bundle `entryPoints` given config `config`.
+ */
+function bundle(entryPoints, config, callback) {
+    var entryPointsMap = {};
+    entryPoints.forEach(function (module) {
+        entryPointsMap[module.name] = module;
+    });
+    var code = require('fs').readFileSync(path.join(__dirname, '../../src/vs/loader.js'));
+    var r = vm.runInThisContext('(function(require, module, exports) { ' + code + '\n});');
+    var loaderModule = { exports: {} };
+    r.call({}, require, loaderModule, loaderModule.exports);
+    var loader = loaderModule.exports;
+    config.isBuild = true;
+    loader.config(config);
+    loader(Object.keys(entryPointsMap), function () {
+        var modules = loader.getBuildInfo();
+        callback(null, emitEntryPoints(modules, entryPointsMap));
+    }, function (err) { return callback(err, null); });
+}
+exports.bundle = bundle;
+function emitEntryPoints(modules, entryPoints) {
+    var modulesMap = {};
+    modules.forEach(function (m) {
+        modulesMap[m.id] = m;
+    });
+    var modulesGraph = {};
+    modules.forEach(function (m) {
+        modulesGraph[m.id] = m.dependencies;
+    });
+    var sortedModules = topologicalSort(modulesGraph);
+    var result = [];
+    var usedPlugins = {};
+    Object.keys(entryPoints).forEach(function (moduleToBundle) {
+        var info = entryPoints[moduleToBundle];
+        var rootNodes = [moduleToBundle].concat(info.include || []);
+        var allDependencies = visit(rootNodes, modulesGraph);
+        var excludes = ['require', 'exports', 'module'].concat(info.exclude || []);
+        excludes.forEach(function (excludeRoot) {
+            var allExcludes = visit([excludeRoot], modulesGraph);
+            Object.keys(allExcludes).forEach(function (exclude) {
+                delete allDependencies[exclude];
+            });
+        });
+        var includedModules = sortedModules.filter(function (module) {
+            return allDependencies[module];
+        });
+        var res = emitEntryPoint(modulesMap, modulesGraph, moduleToBundle, includedModules);
+        result = result.concat(res.files);
+        for (var pluginName in res.usedPlugins) {
+            usedPlugins[pluginName] = usedPlugins[pluginName] || res.usedPlugins[pluginName];
+        }
+    });
+    Object.keys(usedPlugins).forEach(function (pluginName) {
+        var plugin = usedPlugins[pluginName];
+        if (typeof plugin.finishBuild === 'function') {
+            var write = function (filename, contents) {
+                result.push({
+                    dest: filename,
+                    sources: [{
+                            path: null,
+                            contents: contents
+                        }]
+                });
+            };
+            plugin.finishBuild(write);
+        }
+    });
+    return result;
+}
+function emitEntryPoint(modulesMap, deps, entryPoint, includedModules) {
+    var mainResult = {
+        sources: [],
+        dest: entryPoint + '.js'
+    }, results = [mainResult];
+    var usedPlugins = {};
+    var getLoaderPlugin = function (pluginName) {
+        if (!usedPlugins[pluginName]) {
+            usedPlugins[pluginName] = modulesMap[pluginName].exports;
+        }
+        return usedPlugins[pluginName];
+    };
+    includedModules.forEach(function (c) {
+        var bangIndex = c.indexOf('!');
+        if (bangIndex >= 0) {
+            var pluginName = c.substr(0, bangIndex);
+            var plugin = getLoaderPlugin(pluginName);
+            mainResult.sources.push(emitPlugin(entryPoint, plugin, pluginName, c.substr(bangIndex + 1)));
+            return;
+        }
+        var module = modulesMap[c];
+        if (module.path === 'empty:') {
+            return;
+        }
+        var 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, deps[c], module.defineLocation, module.path, contents));
+        }
+    });
+    Object.keys(usedPlugins).forEach(function (pluginName) {
+        var plugin = usedPlugins[pluginName];
+        if (typeof plugin.writeFile === 'function') {
+            var req = (function () {
+                throw new Error('no-no!');
+            });
+            req.toUrl = function (something) { return something; };
+            var write = function (filename, contents) {
+                results.push({
+                    dest: filename,
+                    sources: [{
+                            path: null,
+                            contents: contents
+                        }]
+                });
+            };
+            plugin.writeFile(pluginName, entryPoint, req, write, {});
+        }
+    });
+    return {
+        files: results,
+        usedPlugins: usedPlugins
+    };
+}
+function readFileAndRemoveBOM(path) {
+    var BOM_CHAR_CODE = 65279;
+    var contents = fs.readFileSync(path, 'utf8');
+    // Remove BOM
+    if (contents.charCodeAt(0) === BOM_CHAR_CODE) {
+        contents = contents.substring(1);
+    }
+    return contents;
+}
+function emitPlugin(entryPoint, plugin, pluginName, moduleName) {
+    var result = '';
+    if (typeof plugin.write === 'function') {
+        var write = (function (what) {
+            result += what;
+        });
+        write.getEntryPoint = function () {
+            return entryPoint;
+        };
+        write.asModule = function (moduleId, code) {
+            code = code.replace(/^define\(/, 'define("' + moduleId + '",');
+            result += code;
+        };
+        plugin.write(pluginName, moduleName, write);
+    }
+    return {
+        path: null,
+        contents: result
+    };
+}
+function emitNamedModule(moduleId, myDeps, defineCallPosition, path, contents) {
+    // `defineCallPosition` is the position in code: |define()
+    var defineCallOffset = positionToOffset(contents, defineCallPosition.line, defineCallPosition.col);
+    // `parensOffset` is the position in code: define|()
+    var parensOffset = contents.indexOf('(', defineCallOffset);
+    var insertStr = '"' + moduleId + '", ';
+    return {
+        path: path,
+        contents: contents.substr(0, parensOffset + 1) + insertStr + contents.substr(parensOffset + 1)
+    };
+}
+function emitShimmedModule(moduleId, myDeps, factory, path, contents) {
+    var strDeps = (myDeps.length > 0 ? '"' + myDeps.join('", "') + '"' : '');
+    var 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, desiredLine, desiredCol) {
+    if (desiredLine === 1) {
+        return desiredCol - 1;
+    }
+    var line = 1, 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, graph) {
+    var result = {}, queue = rootNodes;
+    rootNodes.forEach(function (node) {
+        result[node] = true;
+    });
+    while (queue.length > 0) {
+        var el = queue.shift();
+        var myEdges = graph[el] || [];
+        myEdges.forEach(function (toNode) {
+            if (!result[toNode]) {
+                result[toNode] = true;
+                queue.push(toNode);
+            }
+        });
+    }
+    return result;
+}
+/**
+ * Perform a topological sort on `graph`
+ */
+function topologicalSort(graph) {
+    var allNodes = {}, outgoingEdgeCount = {}, inverseEdges = {};
+    Object.keys(graph).forEach(function (fromNode) {
+        allNodes[fromNode] = true;
+        outgoingEdgeCount[fromNode] = graph[fromNode].length;
+        graph[fromNode].forEach(function (toNode) {
+            allNodes[toNode] = true;
+            outgoingEdgeCount[toNode] = outgoingEdgeCount[toNode] || 0;
+            inverseEdges[toNode] = inverseEdges[toNode] || [];
+            inverseEdges[toNode].push(fromNode);
+        });
+    });
+    // https://en.wikipedia.org/wiki/Topological_sorting
+    var S = [], L = [];
+    Object.keys(allNodes).forEach(function (node) {
+        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();
+        var n = S.shift();
+        L.push(n);
+        var myInverseEdges = inverseEdges[n] || [];
+        myInverseEdges.forEach(function (m) {
+            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;
+}

build/lib/bundle.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import fs = require('fs');
+import path = require('path');
+import vm = require('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[];
+}
+
+interface IEntryPointMap {
+	[moduleId:string]: IEntryPoint;
+}
+
+interface IGraph {
+	[node:string]: string[];
+}
+
+interface INodeSet {
+	[node:string]: boolean;
+}
+
+export interface IFile {
+	path: string;
+	contents: string;
+}
+
+export interface IConcatFile {
+	dest: string;
+	sources: IFile[];
+}
+
+export interface ILoaderConfig {
+	isBuild?: boolean;
+}
+
+/**
+ * Bundle `entryPoints` given config `config`.
+ */
+export function bundle(entryPoints:IEntryPoint[], config:ILoaderConfig, callback:(err:any, result:IConcatFile[]) => void): void {
+	let entryPointsMap:IEntryPointMap = {};
+	entryPoints.forEach((module:IEntryPoint) => {
+		entryPointsMap[module.name] = module;
+	});
+
+
+	var code = require('fs').readFileSync(path.join(__dirname, '../../src/vs/loader.js'));
+	var r: Function = <any> vm.runInThisContext('(function(require, module, exports) { ' + code + '\n});');
+	var loaderModule = { exports: {} };
+	r.call({}, require, loaderModule, loaderModule.exports);
+
+	var loader:any = loaderModule.exports;
+	config.isBuild = true;
+	loader.config(config);
+
+	loader(Object.keys(entryPointsMap), () => {
+		let modules = <IBuildModuleInfo[]>loader.getBuildInfo();
+		callback(null, emitEntryPoints(modules, entryPointsMap));
+	}, (err) => callback(err, null))
+}
+
+function emitEntryPoints(modules:IBuildModuleInfo[], entryPoints:IEntryPointMap): IConcatFile[] {
+	let modulesMap: IBuildModuleInfoMap = {};
+	modules.forEach((m:IBuildModuleInfo) => {
+		modulesMap[m.id] = m;
+	});
+
+	let modulesGraph:IGraph = {};
+	modules.forEach((m:IBuildModuleInfo) => {
+		modulesGraph[m.id] = m.dependencies;
+	});
+
+	let sortedModules = topologicalSort(modulesGraph);
+
+	let result: IConcatFile[] = [];
+	let usedPlugins: IPluginMap = {};
+
+	Object.keys(entryPoints).forEach((moduleToBundle:string) => {
+		let info = entryPoints[moduleToBundle];
+		let rootNodes = [moduleToBundle].concat(info.include || []);
+		let allDependencies = visit(rootNodes, modulesGraph);
+		let excludes:string[] = ['require', 'exports', 'module'].concat(info.exclude || []);
+
+		excludes.forEach((excludeRoot:string) => {
+			let allExcludes = visit([excludeRoot], modulesGraph);
+			Object.keys(allExcludes).forEach((exclude:string) => {
+				delete allDependencies[exclude];
+			});
+		});
+
+		let includedModules = sortedModules.filter((module:string) => {
+			return allDependencies[module];
+		});
+
+		let res = emitEntryPoint(modulesMap, modulesGraph, moduleToBundle, includedModules);
+
+		result = result.concat(res.files);
+		for (let pluginName in res.usedPlugins) {
+			usedPlugins[pluginName] = usedPlugins[pluginName] || res.usedPlugins[pluginName];
+		}
+	});
+
+	Object.keys(usedPlugins).forEach((pluginName:string) => {
+		let plugin = usedPlugins[pluginName];
+		if (typeof plugin.finishBuild === 'function') {
+			let write = (filename:string, contents:string) => {
+				result.push({
+					dest: filename,
+					sources: [{
+						path: null,
+						contents: contents
+					}]
+				});
+			};
+			plugin.finishBuild(write);
+		}
+	});
+
+	return result;
+}
+
+interface IPluginMap {
+	[moduleId:string]:ILoaderPlugin;
+}
+
+interface IEmitEntryPointResult {
+	files: IConcatFile[];
+	usedPlugins: IPluginMap;
+}
+
+function emitEntryPoint(modulesMap:IBuildModuleInfoMap, deps:IGraph, entryPoint:string, includedModules:string[]): IEmitEntryPointResult {
+	let mainResult: IConcatFile = {
+			sources: [],
+			dest: entryPoint + '.js'
+		},
+		results: IConcatFile[] = [mainResult];
+
+	let usedPlugins: IPluginMap = {};
+	let getLoaderPlugin = (pluginName:string):ILoaderPlugin => {
+		if (!usedPlugins[pluginName]) {
+			usedPlugins[pluginName] = modulesMap[pluginName].exports;
+		}
+		return usedPlugins[pluginName];
+	}
+
+	includedModules.forEach((c:string) => {
+		let bangIndex = c.indexOf('!');
+
+		if (bangIndex >= 0) {
+			let pluginName = c.substr(0, bangIndex);
+			let plugin = getLoaderPlugin(pluginName);
+			mainResult.sources.push(emitPlugin(entryPoint, plugin, pluginName, c.substr(bangIndex + 1)));
+			return;
+		}
+
+		let module = modulesMap[c];
+
+		if (module.path === 'empty:') {
+			return;
+		}
+
+		let 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, deps[c], module.defineLocation, module.path, contents));
+		}
+	});
+
+	Object.keys(usedPlugins).forEach((pluginName:string) => {
+		let plugin = usedPlugins[pluginName];
+		if (typeof plugin.writeFile === 'function') {
+			let req:ILoaderPluginReqFunc = <any>(() => {
+				throw new Error('no-no!');
+			});
+			req.toUrl = something => something;
+
+			let write = (filename:string, contents:string) => {
+				results.push({
+					dest: filename,
+					sources: [{
+						path: null,
+						contents: contents
+					}]
+				});
+			};
+			plugin.writeFile(pluginName, entryPoint, req, write, {});
+		}
+	});
+
+	return {
+		files: results,
+		usedPlugins: usedPlugins
+	};
+}
+
+function readFileAndRemoveBOM(path:string): string {
+	var BOM_CHAR_CODE = 65279;
+	var 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') {
+		let write: ILoaderPluginWriteFunc = <any>((what) => {
+			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, myDeps:string[], defineCallPosition:IPosition, path:string, contents:string): IFile {
+
+	// `defineCallPosition` is the position in code: |define()
+	let defineCallOffset = positionToOffset(contents, defineCallPosition.line, defineCallPosition.col);
+
+	// `parensOffset` is the position in code: define|()
+	let parensOffset = contents.indexOf('(', defineCallOffset);
+
+	let 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 {
+	let strDeps = (myDeps.length > 0 ? '"' + myDeps.join('", "') + '"' : '');
+	let 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,
+		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 {
+	let result:INodeSet = {},
+		queue = rootNodes;
+
+	rootNodes.forEach((node) => {
+		result[node] = true;
+	});
+
+	while (queue.length > 0) {
+		let el = queue.shift();
+		let 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[] {
+
+	let 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
+	let 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();
+
+		let n:string = S.shift();
+		L.push(n);
+
+		let 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;
+}

build/lib/copyrights.js

+var es = require('event-stream');
+var fs = require('fs');
+var path = require('path');
+
+var copyright = [
+	'/*---------------------------------------------------------------------------------------------',
+	' *  Copyright (c) Microsoft Corporation. All rights reserved.',
+	' *  Licensed under the MIT License. See License.txt in the project root for license information.',
+	' *--------------------------------------------------------------------------------------------*/'
+].join('\n');
+
+var ignoreList = [
+	'/src/vs/languages/typescript/common/lib/lib.d.ts',
+	'/src/vs/languages/typescript/common/lib/lib.es6.d.ts',
+	'/src/vs/languages/typescript/common/lib/typescriptServices.d.ts',
+	'/src/vs/workbench/parts/emmet/node/emmet.d.ts',
+	'/src/vs/editor/standalone-languages/swift.ts',
+	'/src/vs/workbench/browser/media/octicons/octicons.css',
+	'/src/vs/base/test/node/encoding/fixtures/some_utf16be.css',
+	'/src/vs/base/test/node/encoding/fixtures/some_utf16le.css',
+	'/src/vs/workbench/services/search/test/node/fixtures/site.css',
+	'/src/vs/workbench/services/search/test/node/fixtures/some_utf16be.css',
+	'/src/vs/workbench/services/search/test/node/fixtures/some_utf16le.css',
+	'/src/vs/workbench/services/files/test/node/fixtures/service/some_utf16le.css',
+	'/extensions/lib.core.d.ts',
+	'/extensions/node.d.ts',
+	'/extensions/csharp-o/src/typings/applicationinsights.d.ts',
+	'/extensions/typescript/out/lib/lib.core.d.ts',
+	'/extensions/typescript/out/lib/lib.core.es6.d.ts',
+	'/extensions/typescript/out/lib/lib.d.ts',
+	'/extensions/typescript/out/lib/lib.dom.d.ts',
+	'/extensions/typescript/out/lib/lib.es6.d.ts',
+	'/extensions/typescript/out/lib/lib.scriptHost.d.ts',
+	'/extensions/typescript/out/lib/lib.webworker.d.ts',
+	'/extensions/typescript/src/lib/lib.core.d.ts',
+	'/extensions/typescript/src/lib/lib.core.es6.d.ts',
+	'/extensions/typescript/src/lib/lib.d.ts',
+	'/extensions/typescript/src/lib/lib.dom.d.ts',
+	'/extensions/typescript/src/lib/lib.es6.d.ts',
+	'/extensions/typescript/src/lib/lib.scriptHost.d.ts',
+	'/extensions/typescript/src/lib/lib.webworker.d.ts',
+	'/extensions/csharp-o/src/typings/semver/semver.d.ts'
+];
+
+function ignore(filePath) {
+	filePath = path.posix.normalize(filePath);
+
+	return ignoreList.some(function(p) {
+		return filePath.indexOf(p) !== -1;
+	});
+}
+
+exports.copyrights = function () {
+	return es.mapSync(function (file) {
+		if (file.contents) {
+			var contents = file.contents.toString('utf8');
+
+			if (contents.indexOf(copyright) !== 0 && !ignore(file.path)) {
+				throw new Error('File ' + file.path + ' does not contain copyright statement.');
+			}
+		}
+	});
+};
+
+exports.insertCopyrights = function() {
+	return es.mapSync(function (file) {
+		if (file.contents) {
+			var contents = file.contents.toString('utf8');
+
+			if (contents.indexOf(copyright) !== 0 && !ignore(file.path)) {
+				contents = copyright + '\n\n' + contents;
+				fs.writeFileSync(file.path, contents, 'utf8');
+			}
+		}
+	});
+}

build/lib/git.js

+var path = require('path');
+var fs = require('fs');
+
+exports.getVersion = function (repo) {
+	var git = path.join(repo, '.git');
+	var headPath = path.join(git, 'HEAD');
+	var head;
+
+	try {
+		head = fs.readFileSync(headPath, 'utf8').trim();
+	} catch (e) {
+		return void 0;
+	}
+
+	if (/^[0-9a-f]{40}$/i.test(head)) {
+		return head;
+	}
+
+	var refMatch = /^ref: (.*)$/.exec(head);
+
+	if (!refMatch) {
+		return void 0;
+	}
+
+	var ref = refMatch[1];
+	var refPath = path.join(git, ref);
+
+	try {
+		return fs.readFileSync(refPath, 'utf8').trim();
+	} catch (e) {
+		// noop
+	}
+
+	var packedRefsPath = path.join(git, 'packed-refs');
+	var refsRaw;
+
+	try {
+		refsRaw = fs.readFileSync(packedRefsPath, 'utf8').trim();
+	} catch (e) {
+		return void 0;
+	}
+
+	var refsRegex = /^([0-9a-f]{40})\s+(.+)$/gm;
+	var refsMatch;
+	var refs = {};
+
+	while (refsMatch = refsRegex.exec(refsRaw)) {
+		refs[refsMatch[2]] = refsMatch[1];
+	}
+
+	return refs[ref];
+};
\ No newline at end of file

build/lib/nls.js

+var ts = require('./typescript/typescriptServices');
+var lazy = require('lazy.js');
+var event_stream_1 = require('event-stream');
+var File = require('vinyl');
+var sm = require('source-map');
+var assign = require('object-assign');
+var clone = require('clone');
+var path = require('path');
+var CollectStepResult;
+(function (CollectStepResult) {
+    CollectStepResult[CollectStepResult["Yes"] = 0] = "Yes";
+    CollectStepResult[CollectStepResult["YesAndRecurse"] = 1] = "YesAndRecurse";
+    CollectStepResult[CollectStepResult["No"] = 2] = "No";
+    CollectStepResult[CollectStepResult["NoAndRecurse"] = 3] = "NoAndRecurse";
+})(CollectStepResult || (CollectStepResult = {}));
+function collect(node, fn) {
+    var result = [];
+    function loop(node) {
+        var 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 zip(stream, zipper) {
+    if (zipper === void 0) { zipper = function (a, b) { return [a, b]; }; }
+    var pass = event_stream_1.through();
+    var oneBuffer = [];
+    var otherBuffer = [];
+    var result = pass.pipe(event_stream_1.through(function (f) {
+        oneBuffer.push(f);
+        flush();
+    }), function () {
+        flush();
+        result.emit('end');
+    });
+    function flush() {
+        while (oneBuffer.length > 0 && otherBuffer.length > 0) {
+            result.emit('data', zipper(oneBuffer.shift(), otherBuffer.shift()));
+        }
+    }
+    stream.pipe(event_stream_1.through(function (f) { return otherBuffer.push(f); }));
+    return event_stream_1.duplex(pass, result);
+}
+function template(lines) {
+    var indent = '', wrap = '';
+    if (lines.length > 1) {
+        indent = '\t';
+        wrap = '\n';
+    }
+    return "/*---------------------------------------------------------\n * Copyright (C) Microsoft Corporation. All rights reserved.\n *--------------------------------------------------------*/\ndefine([], [" + (wrap + lines.map(function (l) { return indent + l; }).join(',\n') + wrap) + "]);";
+}
+/**
+ * Returns a stream containing the patched JavaScript and source maps.
+ */
+function nls() {
+    var input = event_stream_1.through();
+    var output = input.pipe(event_stream_1.through(function (f) {
+        var _this = this;
+        if (!f.sourceMap) {
+            return this.emit('error', new Error("File " + f.relative + " does not have sourcemaps."));
+        }
+        var 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."));
+        }
+        var root = f.sourceMap.sourceRoot;
+        if (root) {
+            source = path.join(root, source);
+        }
+        var 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(function (f) { return _this.emit('data', f); });
+    }));
+    return event_stream_1.duplex(input, output);
+}
+function isImportNode(node) {
+    return node.kind === 212 /* ImportDeclaration */ || node.kind === 211 /* ImportEqualsDeclaration */;
+}
+var nls;
+(function (nls_1) {
+    function fileFrom(file, contents, path) {
+        if (path === void 0) { path = file.path; }
+        return new File({
+            contents: new Buffer(contents),
+            base: file.base,
+            cwd: file.cwd,
+            path: path
+        });
+    }
+    nls_1.fileFrom = fileFrom;
+    function mappedPositionFrom(source, lc) {
+        return { source: source, line: lc.line + 1, column: lc.character };
+    }
+    nls_1.mappedPositionFrom = mappedPositionFrom;
+    function lcFrom(position) {
+        return { line: position.line - 1, character: position.column };
+    }
+    nls_1.lcFrom = lcFrom;
+    var SingleFileServiceHost = (function () {
+        function SingleFileServiceHost(options, filename, contents) {
+            var _this = this;
+            this.options = options;
+            this.filename = filename;
+            this.getCompilationSettings = function () { return _this.options; };
+            this.getScriptFileNames = function () { return [_this.filename]; };
+            this.getScriptVersion = function () { return '1'; };
+            this.getScriptSnapshot = function (name) { return name === _this.filename ? _this.file : _this.lib; };
+            this.getCurrentDirectory = function () { return ''; };
+            this.getDefaultLibFileName = function () { return 'lib.d.ts'; };
+            this.file = ts.ScriptSnapshot.fromString(contents);
+            this.lib = ts.ScriptSnapshot.fromString('');
+        }
+        return SingleFileServiceHost;
+    })();
+    nls_1.SingleFileServiceHost = SingleFileServiceHost;
+    function isCallExpressionWithinTextSpanCollectStep(textSpan, node) {
+        if (!ts.textSpanContainsTextSpan({ start: node.pos, length: node.end - node.pos }, textSpan)) {
+            return CollectStepResult.No;
+        }
+        return node.kind === 160 /* CallExpression */ ? CollectStepResult.YesAndRecurse : CollectStepResult.NoAndRecurse;
+    }
+    function analyze(contents, options) {
+        if (options === void 0) { options = {}; }
+        var filename = 'file.ts';
+        var serviceHost = new SingleFileServiceHost(assign(clone(options), { noResolve: true }), filename, contents);
+        var service = ts.createLanguageService(serviceHost);
+        var sourceFile = service.getSourceFile(filename);
+        // all imports
+        var imports = lazy(collect(sourceFile, function (n) { return isImportNode(n) ? CollectStepResult.YesAndRecurse : CollectStepResult.NoAndRecurse; }));
+        // import nls = require('vs/nls');
+        var importEqualsDeclarations = imports
+            .filter(function (n) { return n.kind === 211 /* ImportEqualsDeclaration */; })
+            .map(function (n) { return n; })
+            .filter(function (d) { return d.moduleReference.kind === 222 /* ExternalModuleReference */; })
+            .filter(function (d) { return d.moduleReference.expression.getText() === "'vs/nls'"; });
+        // import ... from 'vs/nls';
+        var importDeclarations = imports
+            .filter(function (n) { return n.kind === 212 /* ImportDeclaration */; })
+            .map(function (n) { return n; })
+            .filter(function (d) { return d.moduleSpecifier.kind === 8 /* StringLiteral */; })
+            .filter(function (d) { return d.moduleSpecifier.getText() === "'vs/nls'"; })
+            .filter(function (d) { return !!d.importClause && !!d.importClause.namedBindings; });
+        var nlsExpressions = importEqualsDeclarations
+            .map(function (d) { return d.moduleReference.expression; })
+            .concat(importDeclarations.map(function (d) { return d.moduleSpecifier; }))
+            .map(function (d) { return ({
+            start: ts.getLineAndCharacterOfPosition(sourceFile, d.getStart()),
+            end: ts.getLineAndCharacterOfPosition(sourceFile, d.getEnd())
+        }); });
+        // `nls.localize(...)` calls
+        var nlsLocalizeCallExpressions = importDeclarations
+            .filter(function (d) { return d.importClause.namedBindings.kind === 214 /* NamespaceImport */; })
+            .map(function (d) { return d.importClause.namedBindings.name; })
+            .concat(importEqualsDeclarations.map(function (d) { return d.name; }))
+            .map(function (n) { return service.getReferencesAtPosition(filename, n.pos + 1); })
+            .flatten()
+            .filter(function (r) { return !r.isWriteAccess; })
+            .map(function (r) { return collect(sourceFile, function (n) { return isCallExpressionWithinTextSpanCollectStep(r.textSpan, n); }); })
+            .map(function (a) { return lazy(a).last(); })
+            .filter(function (n) { return !!n; })
+            .map(function (n) { return n; })
+            .filter(function (n) { return n.expression.kind === 158 /* PropertyAccessExpression */ && n.expression.name.getText() === 'localize'; });
+        // `localize` named imports
+        var allLocalizeImportDeclarations = importDeclarations
+            .filter(function (d) { return d.importClause.namedBindings.kind === 215 /* NamedImports */; })
+            .map(function (d) { return d.importClause.namedBindings.elements; })
+            .flatten();
+        // `localize` read-only references
+        var localizeReferences = allLocalizeImportDeclarations
+            .filter(function (d) { return d.name.getText() === 'localize'; })
+            .map(function (n) { return service.getReferencesAtPosition(filename, n.pos + 1); })
+            .flatten()
+            .filter(function (r) { return !r.isWriteAccess; });
+        // custom named `localize` read-only references
+        var namedLocalizeReferences = allLocalizeImportDeclarations
+            .filter(function (d) { return d.propertyName && d.propertyName.getText() === 'localize'; })
+            .map(function (n) { return service.getReferencesAtPosition(filename, n.name.pos + 1); })
+            .flatten()
+            .filter(function (r) { return !r.isWriteAccess; });
+        // find the deepest call expressions AST nodes that contain those references
+        var localizeCallExpressions = localizeReferences
+            .concat(namedLocalizeReferences)
+            .map(function (r) { return collect(sourceFile, function (n) { return isCallExpressionWithinTextSpanCollectStep(r.textSpan, n); }); })
+            .map(function (a) { return lazy(a).last(); })
+            .filter(function (n) { return !!n; })
+            .map(function (n) { return n; });
+        // collect everything
+        var localizeCalls = nlsLocalizeCallExpressions
+            .concat(localizeCallExpressions)
+            .map(function (e) { return e.arguments; })
+            .filter(function (a) { return a.length > 1; })
+            .sort(function (a, b) { return a[0].getStart() - b[0].getStart(); })
+            .map(function (a) { return ({
+            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()
+        };
+    }
+    nls_1.analyze = analyze;
+    var TextModel = (function () {
+        function TextModel(contents) {
+            var regex = /\r\n|\r|\n/g;
+            var index = 0;
+            var match;
+            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('');
+            }
+        }
+        TextModel.prototype.get = function (index) {
+            return this.lines[index];
+        };
+        TextModel.prototype.set = function (index, line) {
+            this.lines[index] = line;
+        };
+        Object.defineProperty(TextModel.prototype, "lineCount", {
+            get: function () {
+                return this.lines.length;
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * Applies patch(es) to the model.
+         * Multiple patches must be ordered.
+         * Does not support patches spanning multiple lines.
+         */
+        TextModel.prototype.apply = function (patch) {
+            var startLineNumber = patch.span.start.line;
+            var endLineNumber = patch.span.end.line;
+            var startLine = this.lines[startLineNumber] || '';
+            var endLine = this.lines[endLineNumber] || '';
+            this.lines[startLineNumber] = [
+                startLine.substring(0, patch.span.start.character),
+                patch.content,
+                endLine.substring(patch.span.end.character)
+            ].join('');
+            for (var i = startLineNumber + 1; i <= endLineNumber; i++) {
+                this.lines[i] = '';
+            }
+        };
+        TextModel.prototype.toString = function () {
+            return lazy(this.lines).zip(this.lineEndings)
+                .flatten().toArray().join('');
+        };
+        return TextModel;
+    })();
+    nls_1.TextModel = TextModel;
+    function patchJavascript(patches, contents, moduleId) {
+        var model = new nls.TextModel(contents);
+        // patch the localize calls
+        lazy(patches).reverse().each(function (p) { return model.apply(p); });
+        // patch the 'vs/nls' imports
+        var firstLine = model.get(0);
+        var patchedFirstLine = firstLine.replace(/(['"])vs\/nls\1/g, "$1vs/nls!" + moduleId + "$1");
+        model.set(0, patchedFirstLine);
+        return model.toString();
+    }
+    nls_1.patchJavascript = patchJavascript;
+    function patchSourcemap(patches, rsm, smc) {
+        var smg = new sm.SourceMapGenerator({
+            file: rsm.file,
+            sourceRoot: rsm.sourceRoot
+        });
+        patches = patches.reverse();
+        var currentLine = -1;
+        var currentLineDiff = 0;
+        var source = null;
+        smc.eachMapping(function (m) {
+            var patch = patches[patches.length - 1];
+            var original = { line: m.originalLine, column: m.originalColumn };
+            var 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) {
+                var originalLength = patch.span.end.character - patch.span.start.character;
+                var modifiedLength = patch.content.length;
+                var 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: source, name: m.name, original: original, generated: generated });
+        }, null, sm.SourceMapConsumer.GENERATED_ORDER);
+        if (source) {
+            smg.setSourceContent(source, smc.sourceContentFor(source));
+        }
+        return JSON.parse(smg.toString());
+    }
+    nls_1.patchSourcemap = patchSourcemap;
+    function patch(moduleId, typescript, javascript, sourcemap) {
+        var _a = analyze(typescript), localizeCalls = _a.localizeCalls, nlsExpressions = _a.nlsExpressions;
+        if (localizeCalls.length === 0) {
+            return { javascript: javascript, sourcemap: sourcemap };
+        }
+        var nlsKeys = template(localizeCalls.map(function (lc) { return lc.key; }));
+        var nls = template(localizeCalls.map(function (lc) { return lc.value; }));
+        var smc = new sm.SourceMapConsumer(sourcemap);
+        var positionFrom = mappedPositionFrom.bind(null, sourcemap.sources[0]);
+        var i = 0;
+        // build patches
+        var patches = lazy(localizeCalls)
+            .map(function (lc) { return ([
+            { range: lc.keySpan, content: '' + (i++) },
+            { range: lc.valueSpan, content: 'null' }
+        ]); })
+            .flatten()
+            .map(function (c) {
+            var start = lcFrom(smc.generatedPositionFor(positionFrom(c.range.start)));
+            var end = lcFrom(smc.generatedPositionFor(positionFrom(c.range.end)));
+            return { span: { start: start, end: 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, function (line) {
+                return line.replace(/(['"])vs\/nls\1/g, "$1vs/nls!" + moduleId + "$1");
+            });
+        }
+        sourcemap = patchSourcemap(patches, sourcemap, smc);
+        return { javascript: javascript, sourcemap: sourcemap, nlsKeys: nlsKeys, nls: nls };
+    }
+    nls_1.patch = patch;
+    function patchFiles(javascriptFile, typescript) {
+        // hack?
+        var moduleId = javascriptFile.relative
+            .replace(/\.js$/, '')
+            .replace(/\\/g, '/');
+        var _a = patch(moduleId, typescript, javascriptFile.contents.toString(), javascriptFile.sourceMap), javascript = _a.javascript, sourcemap = _a.sourcemap, nlsKeys = _a.nlsKeys, nls = _a.nls;
+        var result = [fileFrom(javascriptFile, javascript)];
+        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;
+    }
+    nls_1.patchFiles = patchFiles;
+})(nls || (nls = {}));
+module.exports = nls;

build/lib/nls.ts

+import * as ts from './typescript/typescriptServices';
+import * as lazy from 'lazy.js';
+import { duplex, through, mapSync, readArray, merge } from 'event-stream';
+import { Stream } from 'stream';
+import { ThroughStream } from 'through';
+import File = require('vinyl');
+import * as sm from 'source-map';
+import assign = require('object-assign');
+import clone = require('clone');
+import filter = require('gulp-filter');
+import path = require('path');
+import fs = require('fs');
+
+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) {
+		var 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 zip<A,B,R>(stream: Stream, zipper: (a: A, b: B) => R = (a,b) => <any> [a, b]): ThroughStream {
+	const pass = through();
+	const oneBuffer: any[] = [];
+	const otherBuffer: any[] = [];
+
+	const result = pass.pipe(through(f => {
+		oneBuffer.push(f);
+		flush();
+	}), () => {
+		flush();
+		result.emit('end');
+	});
+
+	function flush() {
+		while (oneBuffer.length > 0 && otherBuffer.length > 0) {
+			result.emit('data', zipper(oneBuffer.shift(), otherBuffer.shift()));
+		}
+	}
+
+	stream.pipe(through(f => otherBuffer.push(f)));
+
+	return duplex(pass, 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(): Stream {
+	var input = through();
+	var 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: new Buffer(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(assign(clone(options), { noResolve: true }), filename, contents);
+		const service = ts.createLanguageService(serviceHost);
+		const sourceFile = service.getSourceFile(filename);
+
+		// 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.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.namedBindings.kind === ts.SyntaxKind.NamedImports)
+			.map(d => (<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;
+
+			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 = 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;

build/lib/reporter.js

+var es = require('event-stream');
+var _ = require('underscore');
+
+var allErrors = [];
+var count = 0;
+
+function onStart() {
+	if (count++ > 0) {
+		return;
+	}
+
+	console.log('*** Starting...');
+}
+
+function onEnd() {
+	if (--count > 0) {
+		return ;
+	}
+
+	var errors = _.flatten(allErrors);
+	errors.map(function (err) { console.log('*** Error:', err); });
+	console.log('*** Finished with', errors.length, 'errors.');
+}
+
+module.exports = function () {
+	var errors = [];
+	allErrors.push(errors);
+
+	return function (err) {
+		if (err) {
+			errors.push(err);
+			return;
+		}
+
+		errors.length = 0;
+		onStart();
+		return es.through(null, function () {
+			onEnd();
+			this.emit('end');
+		});
+	};
+};
\ No newline at end of file

build/lib/style.js

+var es = require('event-stream');
+var path = require('path');
+
+module.exports = function (opts) {
+	return es.mapSync(function (file) {
+		if (file.stat.isDirectory()) {
+			return file;
+		}
+		var contents = file.contents.toString('utf8');
+
+		if (opts.complain) {
+			if (contents.indexOf('\r\n') >= 0) {
+				console.log(file.path + ' uses \\r\\n');
+			}
+
+			if (opts.whitespace) {
+				var lines = contents.split(/\r\n|\r|\n/);
+				var hadErrorLineNumber = 0;
+				for (var i = 0, len = lines.length; i < len; i++) {
+					var line = lines[i];
+					if (line.length === 0) {
+						// empty lines are OK
+						continue;
+					}
+
+					if (/^[\t]*[^\s]/.test(line)) {
+						// good indent
+						continue;
+					} else if (/^[\t]* \*/.test(line)) {
+						// block comment using an extra space
+						continue;
+					} else if (/^[\t]+$/.test(line)) {
+						// empty line
+						continue;
+					} else {
+						// console.log(file.path + '(' + hadErrorLineNumber + ',1): Mixed whitespace indentation');
+						hadErrorLineNumber = i + 1;
+						break;
+					}
+				}
+
+				if (hadErrorLineNumber) {
+					console.log(file.path + '(' + hadErrorLineNumber + ',1): Mixed whitespace indentation');
+				}
+			}
+		} else {
+			var lines = contents.split(/\r\n|\r|\n/);
+
+			if (opts.whitespace) {
+				for (var i = 0, len = lines.length; i < len; i++) {
+					var line = lines[i];
+					line = line.replace(/^\ {28}/, '\t\t\t\t\t\t\t');
+					line = line.replace(/^\ {24}/, '\t\t\t\t\t\t');
+					line = line.replace(/^\ {20}/, '\t\t\t\t\t');
+					line = line.replace(/^\ {16}/, '\t\t\t\t');
+					line = line.replace(/^\ {12}/, '\t\t\t');
+					line = line.replace(/^\ {8}/, '\t\t');
+					line = line.replace(/^\ {4}/, '\t');
+					lines[i] = line;
+				}
+			}
+
+			file.contents = new Buffer(lines.join('\n'), 'utf8');
+		}
+		return file;
+	});
+};

build/lib/typings/clone.d.ts

+declare module 'clone' {
+	function fn<T>(obj: T): T;
+	export = fn;
+}
\ No newline at end of file

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

+declare module "event-stream" {
+	import { Stream } from 'stream';
+	import { ThroughStream } from 'through';
+
+	function merge(...stream: Stream[]): ThroughStream;
+	function concat(...stream: Stream[]): ThroughStream;
+	function duplex(istream: Stream, ostream: Stream): ThroughStream;
+
+	function through(write?: (data: any) => void, end?: () => 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;
+
+}
\ No newline at end of file

build/lib/typings/gulp-filter.d.ts

+declare module 'gulp-filter' {
+	import { ThroughStream } from 'through';
+
+	function fn(pattern: string): ThroughStream;
+	function fn(patterns: string[]): ThroughStream;
+
+	export = fn;
+}
\ No newline at end of file

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

+// 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>;
+
+		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;
+}
+

build/lib/typings/object-assign.d.ts

+declare module 'object-assign' {
+    function fn(target: any, ...sources: any[]): any;
+	export = fn;
+}
\ No newline at end of file

build/lib/typings/source-map.d.ts

+// Type definitions for source-map v0.1.38
+// Project: https://github.com/mozilla/source-map
+// Definitions by: Morten Houston Ludvigsen <https://github.com/MortenHoustonLudvigsen>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module SourceMap {
+    interface StartOfSourceMap {
+        file?: string;
+        sourceRoot?: string;
+    }
+
+    interface RawSourceMap extends StartOfSourceMap {
+        version: string;
+        sources: Array<string>;
+        names: Array<string>;
+        sourcesContent?: string;
+        mappings: string;
+    }
+
+    interface Position {
+        line: number;
+        column: number;
+    }
+
+    interface MappedPosition extends Position {
+        source: string;
+        name?: string;
+    }
+
+    interface MappingItem {
+        source: string;
+        generatedLine: number;
+        generatedColumn: number;
+        originalLine: number;
+        originalColumn: number;
+        name: string;
+    }
+
+    interface Mapping {
+        generated: Position;
+        original: Position;
+        source: string;
+        name?: string;
+    }
+
+    interface CodeWithSourceMap {
+        code: string;
+        map: SourceMapGenerator;
+    }
+
+    class SourceMapConsumer {
+        public static GENERATED_ORDER: number;
+        public static ORIGINAL_ORDER: number;
+
+        constructor(rawSourceMap: RawSourceMap);
+        public originalPositionFor(generatedPosition: Position): MappedPosition;
+        public generatedPositionFor(originalPosition: MappedPosition): Position;
+        public sourceContentFor(source: string): string;
+        public eachMapping(callback: (mapping: MappingItem) => void, context?: any, order?: number): void;
+    }
+
+    class SourceMapGenerator {
+        constructor(startOfSourceMap?: StartOfSourceMap);
+        public static fromSourceMap(sourceMapConsumer: SourceMapConsumer): SourceMapGenerator;
+        public addMapping(mapping: Mapping): void;
+        public setSourceContent(sourceFile: string, sourceContent: string): void;
+        public applySourceMap(sourceMapConsumer: SourceMapConsumer, sourceFile?: string, sourceMapPath?: string): void;
+        public toString(): string;
+    }
+
+    class SourceNode {
+        constructor();
+        constructor(line: number, column: number, source: string);
+        constructor(line: number, column: number, source: string, chunk?: string, name?: string);
+        public static fromStringWithSourceMap(code: string, sourceMapConsumer: SourceMapConsumer, relativePath?: string): SourceNode;
+        public add(chunk: string): void;
+        public prepend(chunk: string): void;
+        public setSourceContent(sourceFile: string, sourceContent: string): void;
+        public walk(fn: (chunk: string, mapping: MappedPosition) => void): void;
+        public walkSourceContents(fn: (file: string, content: string) => void): void;
+        public join(sep: string): SourceNode;
+        public replaceRight(pattern: string, replacement: string): SourceNode;
+        public toString(): string;
+        public toStringWithSourceMap(startOfSourceMap?: StartOfSourceMap): CodeWithSourceMap;
+    }
+}
+
+declare module 'source-map' {
+    export = SourceMap;
+}

build/lib/typings/through.d.ts

+// Type definitions for through
+// Project: https://github.com/dominictarr/through
+// Definitions by: Andrew Gaspar <https://github.com/AndrewGaspar/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "through" {
+	import stream = require("stream");
+
+	function through(write?: (data:any) => void,
+		end?: () => void,
+		opts?: {
+			autoDestroy: boolean;
+		}): through.ThroughStream;
+
+	module through {
+		export interface ThroughStream extends stream.Transform {
+			autoDestroy: boolean;
+		}
+	}
+
+	export = through;
+}
\ No newline at end of file

build/lib/typings/vinyl.d.ts

+// 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/borisyankov/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;
+			/**
+			* Type: Buffer|Stream|null (Default: null)
+			*/
+			contents?: any;
+		});
+
+		/**
+		* 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: any;
+		/**
+		* 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;
+	}
+
+	export = File;
+
+}

build/lib/util.js

+var es = require('event-stream');
+var debounce = require('debounce');
+var filter = require('gulp-filter');
+var azure = require('gulp-azure-storage');
+var rename = require('gulp-rename');
+var vzip = require('gulp-vinyl-zip');
+var util = require('gulp-util');
+var remote = require('gulp-remote-src');
+var _ = require('underscore');
+var path = require('path');
+var fs = require('fs');
+var rimraf = require('rimraf');
+
+var NoCancellationToken = {
+	isCancellationRequested: function () {
+		return false;
+	}
+};
+
+exports.incremental = function (streamProvider, initial, supportsCancellation) {
+	var state = 'idle';
+	var input = es.through();
+	var output = es.through();
+	var buffer = Object.create(null);
+
+	var token = !supportsCancellation ? null : {
+		isCancellationRequested: function () {
+			// console.log('isCancellationRequested', Object.keys(buffer).length, new Date());
+			return Object.keys(buffer).length > 0;
+		}
+	};
+
+	var run = function (input, isCancellable) {
+		state = 'running';
+
+		var stream = !supportsCancellation ? streamProvider() : streamProvider(isCancellable ? token : NoCancellationToken);
+
+		input
+			.pipe(stream)
+			.pipe(es.through(null, function () {
+				state = 'idle';
+				eventuallyRun();
+			}))
+			.pipe(output);
+	};
+
+	if (initial) {
+		run(initial, false);
+	}
+
+	var eventuallyRun = debounce(function () {
+		var paths = Object.keys(buffer);
+
+		if (paths.length === 0) {
+			return;
+		}
+
+		var data = paths.map(function (path) {
+			return buffer[path];
+		});
+
+		buffer = Object.create(null);
+		run(es.readArray(data), true);
+	}, 500);
+
+	input.on('data', function (f) {
+		buffer[f.path] = f;
+
+		if (state === 'idle') {
+			eventuallyRun();
+		}
+	});
+
+	return es.duplex(input, output);
+};
+
+exports.fixWin32DirectoryPermissions = function () {
+	if (!/win32/.test(process.platform)) {
+		return es.through();
+	}
+
+	return es.mapSync(function (f) {
+		if (f.stat && f.stat.isDirectory && f.stat.isDirectory()) {
+			f.stat.mode = 16877;
+		}
+
+		return f;
+	});
+};
+
+exports.setExecutableBit = function (pattern) {
+	var setBit = es.mapSync(function (f) {
+		f.stat.mode = /* 100755 */ 33261;
+		return f;
+	});
+
+	if (!pattern) {
+		return setBit;
+	}
+
+	var input = es.through();
+	var _filter = filter(pattern, { restore: true });
+	var output = input
+		.pipe(_filter)
+		.pipe(setBit)
+		.pipe(_filter.restore);
+
+	return es.duplex(input, output);
+};
+
+exports.handleAzureJson = function (env) {
+	var input = es.through();
+	var azureJsonFilter = filter('**/*.azure.json', { restore: true });
+
+	var allOpts = [];
+	var result = es.through();
+
+	var output = input
+		.pipe(azureJsonFilter)
+		.pipe(es.through(function (f) {
+			util.log('Downloading binaries from Azure:', util.colors.yellow(f.relative), '...');
+			var opts = JSON.parse(f.contents.toString());
+			opts.prefix = _.template(opts.zip || opts.prefix)(env);
+			opts.output = path.join(path.dirname(f.relative), opts.output);
+			allOpts.push(opts);
+		}, function () {
+			var streams = allOpts.map(function (opts) {
+				var result = azure.download(_.extend(opts, { buffer: true, quiet: true }));
+
+				if (opts.zip) {
+					result = result.pipe(vzip.src());
+				}
+
+				return result.pipe(rename(function (p) {
+					p.dirname = path.join(opts.output, p.dirname);
+				}));
+			});
+
+			es.merge(streams)
+				.pipe(result)
+				.pipe(es.through(null, function() {
+					util.log('Finished downloading from Azure');
+					this.emit('end');
+				}));
+			this.emit('end');
+		}))
+		.pipe(azureJsonFilter.restore);
+
+	return es.duplex(input, es.merge(output, result));
+};
+
+exports.toFileUri = function (filePath) {
+	var match = filePath.match(/^([a-z])\:(.*)$/i);
+
+	if (match) {
+		filePath = '/' + match[1].toUpperCase() + ':' + match[2];
+	}
+
+	return 'file://' + filePath.replace(/\\/g, '/');
+};
+
+exports.rebase = function (base, append) {
+	return es.mapSync(function (f) {
+		if (append) {
+			f.base = path.join(f.base, base);
+		} else {
+			f.base = base;
+		}
+		return f;
+	});
+};
+
+exports.skipDirectories = function () {
+	return es.mapSync(function (f) {
+		if (!f.isDirectory()) {
+			return f;
+		}
+	});
+};
+
+exports.cleanNodeModule = function (name, excludes, isNative) {
+	var glob = function (path) { return '**/node_modules/' + name + (path ? '/' + path : ''); };
+	var negate = function (str) { return '!' + str; };
+
+	var allFilter = filter(glob('**'), { restore: true });
+	var globs = [glob('**')].concat(excludes.map(_.compose(negate, glob)));
+
+	var input = es.through();
+	var nodeModuleInput = input.pipe(allFilter);
+	var output = nodeModuleInput.pipe(filter(globs));
+
+	if (isNative) {
+		output = es.merge(output, nodeModuleInput.pipe(filter(glob('**/*.node'))));
+	}
+
+	output = output.pipe(allFilter.restore);
+	return es.duplex(input, output);
+};
+
+exports.loadSourcemaps = function () {
+	var input = es.through();
+
+	var output = input
+		.pipe(es.map(function (f, cb) {
+			if (f.sourceMap) {
+				return cb(null, f);
+			}
+
+			if (!f.contents) {
+				return cb(new Error('empty file'));
+			}
+
+			var contents = f.contents.toString('utf8');
+
+			var reg = /\/\/# sourceMappingURL=(.*)$/g;
+			var lastMatch = null;
+			var match = null;
+
+			while (match = reg.exec(contents)) {
+				lastMatch = match;
+			}
+
+			if (!lastMatch) {
+				f.sourceMap = {
+					version : 3,
+					names: [],
+					mappings: '',
+					sources: [f.relative.replace(/\//g, '/')],
+					sourcesContent: [contents]
+				};
+
+				return cb(null, f);
+			}
+
+			f.contents = new Buffer(contents.replace(/\/\/# sourceMappingURL=(.*)$/g, ''), 'utf8');
+
+			fs.readFile(path.join(path.dirname(f.path), lastMatch[1]), 'utf8', function (err, contents) {
+				if (err) { return cb(err); }
+
+				f.sourceMap = JSON.parse(contents);
+				cb(null, f);
+			});
+		}));
+
+	return es.duplex(input, output);
+};
+
+exports.rimraf = function(dir) {
+	return function (cb) {
+		rimraf(dir, cb);
+	};
+};
+
+exports.downloadExtensions = function(extensions) {
+	var streams = Object.keys(extensions).map(function (fullName) {
+		var version = extensions[fullName];
+		var match = /^([^.]+)\.([^.]+)$/.exec(fullName);
+
+		if (!match) {
+			throw new Error('Bad extension: ' + fullName);
+		}
+
+		var publisher = match[1];
+		var name = match[2];
+		var url = 'https://' + publisher + '.gallery.vsassets.io/_apis/public/gallery/publisher/'
+			+ publisher + '/extension/' + name + '/' + version
+			+ '/assetbyname/Microsoft.VisualStudio.Services.VSIXPackage';
+
+		return remote(url, { base: '' })
+			.pipe(vzip.src())
+			.pipe(filter('extension/**'))
+			.pipe(rename(function (p) {
+				p.dirname = path.posix.join(fullName, p.dirname.replace(/^extension[/\\]?/, ''));
+			}));
+	});
+
+	return es.merge(streams);
+};
\ No newline at end of file

build/lib/watch/index.js

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+var es = require('event-stream');
+
+function handleDeletions() {
+	return es.mapSync(function (f) {
+		if (!f.contents) {
+			f.contents = new Buffer('');
+			f.stat = { mtime: new Date() };
+		}
+
+		return f;
+	});
+}
+
+var watch = process.platform === 'win32' ? require('./watch-win32') : require('gulp-watch');
+
+module.exports = function () {
+	return watch.apply(null, arguments)
+		.pipe(handleDeletions());
+};

build/lib/watch/package.json

+{
+	"name": "watch",
+	"version": "1.0.0",
+	"description": "",
+	"author": "Microsoft ",
+	"private": true,
+	"devDependencies": {
+		"gulp-watch": "^4.3.5"
+	}
+}

build/lib/watch/watch-win32.js

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+var path = require('path');
+var cp = require('child_process');
+var fs = require('fs');
+var File = require('vinyl');
+var es = require('event-stream');
+var filter = require('gulp-filter');
+
+var watcherPath = path.join(__dirname, 'watcher.exe');
+
+function toChangeType(type) {
+	switch (type) {
+		case '0': return 'change';
+		case '1': return 'add';
+		default: return 'unlink';
+	}
+}
+
+function watch(root) {
+	var result = es.through();
+	var child = cp.spawn(watcherPath, [root]);
+
+	child.stdout.on('data', function(data) {
+		var lines = data.toString('utf8').split('\n');
+		for (var i = 0; i < lines.length; i++) {
+			var line = lines[i].trim();
+			if (line.length === 0) {
+				continue;
+			}
+
+			var changeType = line[0];
+			var changePath = line.substr(2);
+			var changePathFull = path.join(root, changePath);
+
+			var file = new File({
+				path: changePathFull,
+				base: root
+			});
+
+			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 () { child && child.kill(); });
+
+	return result;
+}
+
+var cache = Object.create(null);
+
+module.exports = function(pattern, options) {
+	options = options || {};
+
+	var cwd = path.normalize(options.cwd || process.cwd());
+	var watcher = cache[cwd];
+
+	if (!watcher) {
+		watcher = cache[cwd] = watch(cwd);
+	}
+
+	var rebase = !options.base ? es.through() : es.mapSync(function (f) {
+		f.base = options.base;
+		return f;
+	});
+
+	return watcher
+		.pipe(filter(['**', '!.git{,/**}'])) // ignore all things git
+		.pipe(filter(pattern))
+		.pipe(es.map(function (file, cb) {
+			fs.stat(file.path, function (err, stat) {
+				if (err && err.code === 'ENOENT') { return cb(null, file); }
+				if (err) { return cb(); }
+				if (!stat.isFile()) { return cb(); }
+
+				fs.readFile(file.path, function (err, contents) {
+					if (err && err.code === 'ENOENT') { return cb(null, file); }
+					if (err) { return cb(); }
+
+					file.contents = contents;
+					file.stat = stat;
+					cb(null, file);
+				});
+			});
+		}))
+		.pipe(rebase);
+};
\ No newline at end of file

build/tsconfig.json

+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"noImplicitAny": false,
+		"removeComments": false,
+		"preserveConstEnums": true,
+		"target": "ES5",
+		"sourceMap": false,
+		"experimentalDecorators": true,
+		"noLib": true
+	}
+}
\ No newline at end of file

extensions/bat/OSSREADME.json

+// ATTENTION - THIS DIRECTORY CONTAINS THIRD PARTY OPEN SOURCE MATERIALS:
+[{
+	"name": "sublimehq/Packages",
+	"version": "0.0.0",
+	"license": "TextMate Bundle License",
+	"repositoryURL": "https://github.com/sublimehq/Packages",
+	"licenseDetail": [
+		"Copyright (c) Sublime Packages project authors",
+		"",
+		"If not otherwise specified (see below), files in this folder fall under the following license: ",
+		"",
+		"Permission to copy, use, modify, sell and distribute this",
+		"software is granted. This software is provided \"as is\" without",
+		"express or implied warranty, and with no claim as to its",
+		"suitability for any purpose.",
+		"",
+		"An exception is made for files in readable text which contain their own license information, ",
+		"or files where an accompanying file exists (in the same directory) with a \"-license\" suffix added ",
+		"to the base-name name of the original file, and an extension of txt, html, or similar. For example ",
+		"\"tidy\" is accompanied by \"tidy-license.txt\"."
+	]
+}]

extensions/bat/bat.configuration.json

+{
+	"comments": {
+		"lineComment": "REM"
+	},
+	"brackets": [
+		["{", "}"],
+		["[", "]"],
+		["(", ")"]
+	]
+}
\ No newline at end of file

extensions/bat/package.json

+{
+	"name": "bat",
+	"version": "0.1.0",
+	"publisher": "vscode",
+	"engines": { "vscode": "*" },
+	"contributes": {
+		"languages": [{
+			"id": "bat",
+			"extensions": [ ".bat", ".cmd"],
+			"aliases": [ "Batch", "bat" ],
+			"configuration": "./bat.configuration.json"
+		}],
+		"grammars": [{
+			"language": "bat",
+			"scopeName": "source.dosbatch",
+			"path": "./syntaxes/Batch File.tmLanguage"
+		}]
+	}
+}
\ No newline at end of file

extensions/bat/syntaxes/Batch File.tmLanguage

+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+    <dict>
+        <key>uuid</key>
+        <string>E07EC438-7B75-4437-8AA1-DA94C1E6EACC</string>
+        <key>patterns</key>
+        <array>
+            <dict>
+                <key>name</key>
+                <string>keyword.command.dosbatch</string>
+                <key>match</key>
+                <string>\b(?i)(?:append|assoc|at|attrib|break|cacls|cd|chcp|chdir|chkdsk|chkntfs|cls|cmd|color|comp|compact|convert|copy|date|del|dir|diskcomp|diskcopy|doskey|echo|endlocal|erase|fc|find|findstr|format|ftype|graftabl|help|keyb|label|md|mkdir|mode|more|move|path|pause|popd|print|prompt|pushd|rd|recover|rem|ren|rename|replace|restore|rmdir|set|setlocal|shift|sort|start|subst|time|title|tree|type|ver|verify|vol|xcopy)\b</string>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>keyword.control.statement.dosbatch</string>
+                <key>match</key>
+                <string>\b(?i)(?:goto|call|exit)\b</string>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>keyword.control.conditional.if.dosbatch</string>
+                <key>match</key>
+                <string>\b(?i)if\s+((not)\s+)(exist|defined|errorlevel|cmdextversion)\b</string>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>keyword.control.conditional.dosbatch</string>
+                <key>match</key>
+                <string>\b(?i)(?:if|else)\b</string>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>keyword.control.repeat.dosbatch</string>
+                <key>match</key>
+                <string>\b(?i)for\b</string>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>keyword.operator.dosbatch</string>
+                <key>match</key>
+                <string>\b(?:EQU|NEQ|LSS|LEQ|GTR|GEQ)\b</string>
+            </dict>
+            <dict>
+                <key>captures</key>
+                <dict>
+                    <key>1</key>
+                    <dict>
+                        <key>name</key>
+                        <string>keyword.command.rem.dosbatch</string>
+                    </dict>
+                </dict>
+                <key>name</key>
+                <string>comment.line.rem.dosbatch</string>
+                <key>match</key>
+                <string>(?:^|\s)((?i)rem)(?:$|\s.*$)</string>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>comment.line.colons.dosbatch</string>
+                <key>match</key>
+                <string>\s*:\s*:.*$</string>
+            </dict>
+            <dict>
+                <key>begin</key>
+                <string>"</string>
+                <key>endCaptures</key>
+                <dict>
+                    <key>0</key>
+                    <dict>
+                        <key>name</key>
+                        <string>punctuation.definition.string.end.shell</string>
+                    </dict>
+                </dict>
+                <key>beginCaptures</key>
+                <dict>
+                    <key>0</key>
+                    <dict>
+                        <key>name</key>
+                        <string>punctuation.definition.string.begin.shell</string>
+                    </dict>
+                </dict>
+                <key>name</key>
+                <string>string.quoted.double.dosbatch</string>
+                <key>end</key>
+                <string>"</string>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>keyword.operator.pipe.dosbatch</string>
+                <key>match</key>
+                <string>[|]</string>
+            </dict>
+            <dict>
+                <key>name</key>
+                <string>keyword.operator.redirect.shell</string>
+                <key>match</key>
+                <string>&amp;&gt;|\d*&gt;&amp;\d*|\d*(&gt;&gt;|&gt;|&lt;)|\d*&lt;&amp;|\d*&lt;&gt;</string>
+            </dict>
+        </array>
+        <key>name</key>
+        <string>Batch File</string>
+        <key>scopeName</key>
+        <string>source.dosbatch</string>
+        <key>fileTypes</key>
+        <array>
+            <string>bat</string>
+        </array>
+    </dict>
+</plist>
\ No newline at end of file

extensions/clojure/OSSREADME.json

+// ATTENTION - THIS DIRECTORY CONTAINS THIRD PARTY OPEN SOURCE MATERIALS:
+[{
+	"name": "mmcgrana/textmate-clojure",
+	"version": "0.0.0",
+	"license": "MIT",
+	"repositoryURL": "https://github.com/mmcgrana/textmate-clojure"
+}]

extensions/clojure/clojure.configuration.json

+{
+	"comments": {
+		"lineComment": ";",
+		"blockComment": [ "(comment", ")" ]
+	},
+	"brackets": [
+		["{", "}"],
+		["[", "]"],
+		["(", ")"]
+	]
+}
\ No newline at end of file

extensions/clojure/package.json

+{
+	"name": "clojure",
+	"version": "0.1.0",
+	"publisher": "vscode",
+	"engines": { "vscode": "*" },
+	"contributes": {
+		"languages": [{
+			"id": "clojure",
+			"aliases": ["Clojure", "clojure"],
+			"extensions": [".clj", ".cljs", ".cljx", ".clojure", ".edn"],
+			"configuration": "./clojure.configuration.json"
+		}],
+		"grammars": [{
+			"language": "clojure",
+			"scopeName": "source.clojure",
+			"path": "./syntaxes/Clojure.tmLanguage"
+		}]
+	}
+}
\ No newline at end of file

extensions/coffeescript/OSSREADME.json

+// ATTENTION - THIS DIRECTORY CONTAINS THIRD PARTY OPEN SOURCE MATERIALS:
+[{
+	"name": "textmate/coffee-script.tmbundle",
+	"version": "0.0.0",
+	"license": "MIT",
+	"repositoryURL": "https://github.com/textmate/coffee-script.tmbundle"
+}]

extensions/coffeescript/coffeescript.configuration.json

+{
+	"comments": {
+		"lineComment": "#",
+		"blockComment": [ "###", "###" ]
+	},
+	"brackets": [
+		["{", "}"],
+		["[", "]"],
+		["(", ")"]
+	]
+}
\ No newline at end of file

extensions/coffeescript/package.json

+{
+	"name": "coffeescript",
+	"version": "0.1.0",
+	"publisher": "vscode",
+	"engines": { "vscode": "*" },
+	"contributes": {
+		"languages": [{
+			"id": "coffeescript",
+			"extensions": [ ".coffee" ],
+			"aliases": [ "CoffeeScript", "coffeescript", "coffee" ],
+			"configuration": "./coffeescript.configuration.json"
+		}],
+		"grammars": [{
+			"language": "coffeescript",
+			"scopeName": "source.coffee",
+			"path": "./syntaxes/CoffeeScript.tmLanguage"
+		}],
+		"debuggers": [{
+			"type": "node",
+			"enableBreakpointsFor": { "languageIds": ["coffeescript"] }
+		}]
+	}
+}
\ No newline at end of file

extensions/cpp/OSSREADME.json

+// ATTENTION - THIS DIRECTORY CONTAINS THIRD PARTY OPEN SOURCE MATERIALS:
+[{
+	"name": "textmate/c.tmbundle",
+	"version": "0.0.0",
+	"license": "TextMate Bundle License",
+	"repositoryURL": "https://github.com/textmate/c.tmbundle",
+	"licenseDetail": [
+		"Copyright (c) textmate-c.tmbundle authors",
+		"",
+		"If not otherwise specified (see below), files in this repository fall under the following license:",
+		"",
+		"Permission to copy, use, modify, sell and distribute this",
+		"software is granted. This software is provided \"as is\" without",
+		"express or implied warranty, and with no claim as to its",
+		"suitability for any purpose.",
+		"",
+		"An exception is made for files in readable text which contain their own license information,",
+		"or files where an accompanying file exists (in the same directory) with a \"-license\" suffix added",
+		"to the base-name name of the original file, and an extension of txt, html, or similar. For example",
+		"\"tidy\" is accompanied by \"tidy-license.txt\"."
+	]
+}]

extensions/cpp/cpp.configuration.json

+{
+	"comments": {
+		"lineComment": "//",
+		"blockComment": ["/*", "*/"]
+	},
+	"brackets": [
+		["{", "}"],
+		["[", "]"],
+		["(", ")"]
+	]
+}
\ No newline at end of file

extensions/cpp/package.json

+{
+	"name": "cpp",
+	"version": "0.1.0",
+	"publisher": "vscode",
+	"engines": { "vscode": "*" },
+	"contributes": {
+		"languages": [{
+			"id": "c",
+			"extensions": [ ".c", ".h" ],
+			"aliases": [ "C", "c" ],
+			"configuration": "./cpp.configuration.json"
+		},
+		{
+			"id": "cpp",
+			"extensions": [ ".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx" ],
+			"aliases": [ "C++", "Cpp", "cpp"],
+			"configuration": "./cpp.configuration.json"
+		}],
+		"grammars": [{
+			"language": "c",
+			"scopeName": "source.c",
+			"path": "./syntaxes/c.plist"
+		},
+		{
+			"language": "cpp",
+			"scopeName": "source.c++",
+			"path": "./syntaxes/c++.plist"
+		}]
+	}
+}
\ No newline at end of file

extensions/csharp-o/.gitignore

+bin

extensions/csharp-o/OSSREADME.json

+[
+	{
+		"name": "Omnisharp-roslyn",
+		"repositoryURL": "https://github.com/OmniSharp/omnisharp-roslyn",
+		"version": "1.5.5",
+		"license": "MIT",
+		"isProd": true
+	},
+	{
+		"name": "ScriptCS",
+		"repositoryURL": "https://github.com/scriptcs/scriptcs",
+		"version": "0.16.0",
+		"license": "Apache2",
+		"licenseDetail": [
+			"Copyright 2013 Glenn Block, Justin Rusbatch, Filip Wojcieszyn",
+			"",
+			"Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file ",
+			"except in compliance with the License. You may obtain a copy of the License at",
+			"",
+			"http://www.apache.org/licenses/LICENSE-2.0",
+			"",
+			"Unless required by applicable law or agreed to in writing, software distributed under the ",
+			"License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, ",
+			"either express or implied. See the License for the specific language governing permissions ",
+			"and limitations under the License."
+		],
+		"isProd": true
+	}
+]
\ No newline at end of file

extensions/csharp-o/src/features/abstractProvider.ts

+/*---------------------------------------------------------------------------------------------
+ *  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 {OmnisharpServer} from '../omnisharpServer';
+import {Disposable} from 'vscode';
+
+export default class AbstractProvider {
+
+	protected _server: OmnisharpServer;
+	protected _disposables: Disposable[];
+
+	constructor(server: OmnisharpServer) {
+		this._server = server;
+		this._disposables = [];
+	}
+
+	dispose() {
+		while (this._disposables.length) {
+			this._disposables.pop().dispose();
+		}
+	}
+}

extensions/csharp-o/src/typings/ref.d.ts

+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+/// <reference path='../../../../src/vs/vscode.d.ts'/>
+/// <reference path='../../../../src/typings/mocha.d.ts'/>
+/// <reference path='../../../../extensions/declares.d.ts'/>
+/// <reference path='../../../../extensions/node.d.ts'/>
+/// <reference path='../../../../extensions/lib.core.d.ts'/>
\ No newline at end of file