SQL Operations Studio Public Preview 1 (0.23) release source code

build/monaco/README-npm.md

@@ -0,0 +1,14 @@
+# monaco-editor-core
+
+> This npm module is a building block for the [monaco-editor](https://www.npmjs.com/package/monaco-editor)
+npm module and unless you are doing something special (e.g. authoring a monaco editor language that can be shipped
+and consumed independently), it is best to consume the [monaco-editor](https://www.npmjs.com/package/monaco-editor) module
+that contains this module and adds languages supports.
+
+The Monaco Editor is the code editor that powers [VS Code](https://github.com/Microsoft/vscode),
+a good page describing the code editor's features is [here](https://code.visualstudio.com/docs/editor/editingevolved).
+
+This npm module contains the core editor functionality, as it comes from the [vscode repository](https://github.com/Microsoft/vscode).
+
+## License
+[Source EULA](https://github.com/Microsoft/sqlopsstudio/blob/master/LICENSE.txt)

build/monaco/README.md

@@ -0,0 +1,20 @@
+# Steps to publish a new version of monaco-editor-core
+
+## Generate monaco.d.ts
+
+* The `monaco.d.ts` is now automatically generated when running `gulp watch`
+
+## Bump version
+
+* increase version in `build/monaco/package.json`
+
+## Generate npm contents for monaco-editor-core
+
+* Be sure to have all changes committed **and pushed to the remote**
+* (the generated files contain the HEAD sha and that should be available on the remote)
+* run gulp editor-distro
+
+## Publish
+
+* `cd out-monaco-editor-core`
+* `npm publish`

build/monaco/ThirdPartyNotices.txt

@@ -0,0 +1,85 @@
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+Do Not Translate or Localize
+
+This project incorporates components from the projects listed below. The original copyright notices and the licenses
+under which Microsoft received such components are set forth below. Microsoft reserves all rights not expressly granted
+herein, whether by implication, estoppel or otherwise.
+
+
+
+
+%% winjs version 4.4.0 (https://github.com/winjs/winjs)
+=========================================
+WinJS
+
+Copyright (c) Microsoft Corporation
+
+All rights reserved.
+
+Source EULA
+
+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.
+
+=========================================
+END OF winjs NOTICES AND INFORMATION
+
+
+
+
+%% string_scorer version 0.1.20 (https://github.com/joshaven/string_score)
+=========================================
+This software is released under the Source EULA:
+
+Copyright (c) Joshaven Potter
+
+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.
+=========================================
+END OF string_scorer NOTICES AND INFORMATION
+
+
+
+
+%% chjj-marked NOTICES AND INFORMATION BEGIN HERE
+=========================================
+The Source EULA License
+
+Copyright (c) 2011-2014, Christopher Jeffrey (https://github.com/chjj/)
+
+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.
+=========================================
+END OF chjj-marked NOTICES AND INFORMATION

build/monaco/api.js

@@ -0,0 +1,327 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs = require("fs");
+var ts = require("typescript");
+var path = require("path");
+var tsfmt = require('../../tsfmt.json');
+var util = require('gulp-util');
+function log(message) {
+    var rest = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rest[_i - 1] = arguments[_i];
+    }
+    util.log.apply(util, [util.colors.cyan('[monaco.d.ts]'), message].concat(rest));
+}
+var SRC = path.join(__dirname, '../../src');
+var OUT_ROOT = path.join(__dirname, '../../');
+var RECIPE_PATH = path.join(__dirname, './monaco.d.ts.recipe');
+var DECLARATION_PATH = path.join(__dirname, '../../src/vs/monaco.d.ts');
+var CURRENT_PROCESSING_RULE = '';
+function logErr(message) {
+    var rest = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        rest[_i - 1] = arguments[_i];
+    }
+    util.log(util.colors.red('[monaco.d.ts]'), 'WHILE HANDLING RULE: ', CURRENT_PROCESSING_RULE);
+    util.log.apply(util, [util.colors.red('[monaco.d.ts]'), message].concat(rest));
+}
+function moduleIdToPath(out, moduleId) {
+    if (/\.d\.ts/.test(moduleId)) {
+        return path.join(SRC, moduleId);
+    }
+    return path.join(OUT_ROOT, out, moduleId) + '.d.ts';
+}
+var SOURCE_FILE_MAP = {};
+function getSourceFile(out, inputFiles, moduleId) {
+    if (!SOURCE_FILE_MAP[moduleId]) {
+        var filePath = path.normalize(moduleIdToPath(out, moduleId));
+        if (!inputFiles.hasOwnProperty(filePath)) {
+            logErr('CANNOT FIND FILE ' + filePath + '. YOU MIGHT NEED TO RESTART gulp');
+            return null;
+        }
+        var fileContents = inputFiles[filePath];
+        var sourceFile = ts.createSourceFile(filePath, fileContents, ts.ScriptTarget.ES5);
+        SOURCE_FILE_MAP[moduleId] = sourceFile;
+    }
+    return SOURCE_FILE_MAP[moduleId];
+}
+function isDeclaration(a) {
+    return (a.kind === ts.SyntaxKind.InterfaceDeclaration
+        || a.kind === ts.SyntaxKind.EnumDeclaration
+        || a.kind === ts.SyntaxKind.ClassDeclaration
+        || a.kind === ts.SyntaxKind.TypeAliasDeclaration
+        || a.kind === ts.SyntaxKind.FunctionDeclaration
+        || a.kind === ts.SyntaxKind.ModuleDeclaration);
+}
+function visitTopLevelDeclarations(sourceFile, visitor) {
+    var stop = false;
+    var visit = function (node) {
+        if (stop) {
+            return;
+        }
+        switch (node.kind) {
+            case ts.SyntaxKind.InterfaceDeclaration:
+            case ts.SyntaxKind.EnumDeclaration:
+            case ts.SyntaxKind.ClassDeclaration:
+            case ts.SyntaxKind.VariableStatement:
+            case ts.SyntaxKind.TypeAliasDeclaration:
+            case ts.SyntaxKind.FunctionDeclaration:
+            case ts.SyntaxKind.ModuleDeclaration:
+                stop = visitor(node);
+        }
+        // if (node.kind !== ts.SyntaxKind.SourceFile) {
+        // 	if (getNodeText(sourceFile, node).indexOf('SymbolKind') >= 0) {
+        // 		console.log('FOUND TEXT IN NODE: ' + ts.SyntaxKind[node.kind]);
+        // 		console.log(getNodeText(sourceFile, node));
+        // 	}
+        // }
+        if (stop) {
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+}
+function getAllTopLevelDeclarations(sourceFile) {
+    var all = [];
+    visitTopLevelDeclarations(sourceFile, function (node) {
+        if (node.kind === ts.SyntaxKind.InterfaceDeclaration || node.kind === ts.SyntaxKind.ClassDeclaration || node.kind === ts.SyntaxKind.ModuleDeclaration) {
+            var interfaceDeclaration = node;
+            var triviaStart = interfaceDeclaration.pos;
+            var triviaEnd = interfaceDeclaration.name.pos;
+            var triviaText = getNodeText(sourceFile, { pos: triviaStart, end: triviaEnd });
+            // // let nodeText = getNodeText(sourceFile, node);
+            // if (getNodeText(sourceFile, node).indexOf('SymbolKind') >= 0) {
+            // 	console.log('TRIVIA: ', triviaText);
+            // }
+            if (triviaText.indexOf('@internal') === -1) {
+                all.push(node);
+            }
+        }
+        else {
+            var nodeText = getNodeText(sourceFile, node);
+            if (nodeText.indexOf('@internal') === -1) {
+                all.push(node);
+            }
+        }
+        return false /*continue*/;
+    });
+    return all;
+}
+function getTopLevelDeclaration(sourceFile, typeName) {
+    var result = null;
+    visitTopLevelDeclarations(sourceFile, function (node) {
+        if (isDeclaration(node)) {
+            if (node.name.text === typeName) {
+                result = node;
+                return true /*stop*/;
+            }
+            return false /*continue*/;
+        }
+        // node is ts.VariableStatement
+        if (getNodeText(sourceFile, node).indexOf(typeName) >= 0) {
+            result = node;
+            return true /*stop*/;
+        }
+        return false /*continue*/;
+    });
+    return result;
+}
+function getNodeText(sourceFile, node) {
+    return sourceFile.getFullText().substring(node.pos, node.end);
+}
+function getMassagedTopLevelDeclarationText(sourceFile, declaration) {
+    var result = getNodeText(sourceFile, declaration);
+    // if (result.indexOf('MonacoWorker') >= 0) {
+    // 	console.log('here!');
+    // 	// console.log(ts.SyntaxKind[declaration.kind]);
+    // }
+    if (declaration.kind === ts.SyntaxKind.InterfaceDeclaration || declaration.kind === ts.SyntaxKind.ClassDeclaration) {
+        var interfaceDeclaration = declaration;
+        var members = interfaceDeclaration.members;
+        members.forEach(function (member) {
+            try {
+                var memberText = getNodeText(sourceFile, member);
+                if (memberText.indexOf('@internal') >= 0 || memberText.indexOf('private') >= 0) {
+                    // console.log('BEFORE: ', result);
+                    result = result.replace(memberText, '');
+                    // console.log('AFTER: ', result);
+                }
+            }
+            catch (err) {
+                // life..
+            }
+        });
+    }
+    result = result.replace(/export default/g, 'export');
+    result = result.replace(/export declare/g, 'export');
+    return result;
+}
+function format(text) {
+    // Parse the source text
+    var sourceFile = ts.createSourceFile('file.ts', text, ts.ScriptTarget.Latest, /*setParentPointers*/ true);
+    // Get the formatting edits on the input sources
+    var edits = ts.formatting.formatDocument(sourceFile, getRuleProvider(tsfmt), tsfmt);
+    // Apply the edits on the input code
+    return applyEdits(text, edits);
+    function getRuleProvider(options) {
+        // Share this between multiple formatters using the same options.
+        // This represents the bulk of the space the formatter uses.
+        var ruleProvider = new ts.formatting.RulesProvider();
+        ruleProvider.ensureUpToDate(options);
+        return ruleProvider;
+    }
+    function applyEdits(text, edits) {
+        // Apply edits in reverse on the existing text
+        var result = text;
+        for (var i = edits.length - 1; i >= 0; i--) {
+            var change = edits[i];
+            var head = result.slice(0, change.span.start);
+            var tail = result.slice(change.span.start + change.span.length);
+            result = head + change.newText + tail;
+        }
+        return result;
+    }
+}
+function createReplacer(data) {
+    data = data || '';
+    var rawDirectives = data.split(';');
+    var directives = [];
+    rawDirectives.forEach(function (rawDirective) {
+        if (rawDirective.length === 0) {
+            return;
+        }
+        var pieces = rawDirective.split('=>');
+        var findStr = pieces[0];
+        var replaceStr = pieces[1];
+        findStr = findStr.replace(/[\-\\\{\}\*\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&');
+        findStr = '\\b' + findStr + '\\b';
+        directives.push([new RegExp(findStr, 'g'), replaceStr]);
+    });
+    return function (str) {
+        for (var i = 0; i < directives.length; i++) {
+            str = str.replace(directives[i][0], directives[i][1]);
+        }
+        return str;
+    };
+}
+function generateDeclarationFile(out, inputFiles, recipe) {
+    var lines = recipe.split(/\r\n|\n|\r/);
+    var result = [];
+    lines.forEach(function (line) {
+        var m1 = line.match(/^\s*#include\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+        if (m1) {
+            CURRENT_PROCESSING_RULE = line;
+            var moduleId = m1[1];
+            var sourceFile_1 = getSourceFile(out, inputFiles, moduleId);
+            if (!sourceFile_1) {
+                return;
+            }
+            var replacer_1 = createReplacer(m1[2]);
+            var typeNames = m1[3].split(/,/);
+            typeNames.forEach(function (typeName) {
+                typeName = typeName.trim();
+                if (typeName.length === 0) {
+                    return;
+                }
+                var declaration = getTopLevelDeclaration(sourceFile_1, typeName);
+                if (!declaration) {
+                    logErr('Cannot find type ' + typeName);
+                    return;
+                }
+                result.push(replacer_1(getMassagedTopLevelDeclarationText(sourceFile_1, declaration)));
+            });
+            return;
+        }
+        var m2 = line.match(/^\s*#includeAll\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+        if (m2) {
+            CURRENT_PROCESSING_RULE = line;
+            var moduleId = m2[1];
+            var sourceFile_2 = getSourceFile(out, inputFiles, moduleId);
+            if (!sourceFile_2) {
+                return;
+            }
+            var replacer_2 = createReplacer(m2[2]);
+            var typeNames = m2[3].split(/,/);
+            var typesToExcludeMap_1 = {};
+            var typesToExcludeArr_1 = [];
+            typeNames.forEach(function (typeName) {
+                typeName = typeName.trim();
+                if (typeName.length === 0) {
+                    return;
+                }
+                typesToExcludeMap_1[typeName] = true;
+                typesToExcludeArr_1.push(typeName);
+            });
+            getAllTopLevelDeclarations(sourceFile_2).forEach(function (declaration) {
+                if (isDeclaration(declaration)) {
+                    if (typesToExcludeMap_1[declaration.name.text]) {
+                        return;
+                    }
+                }
+                else {
+                    // node is ts.VariableStatement
+                    var nodeText = getNodeText(sourceFile_2, declaration);
+                    for (var i = 0; i < typesToExcludeArr_1.length; i++) {
+                        if (nodeText.indexOf(typesToExcludeArr_1[i]) >= 0) {
+                            return;
+                        }
+                    }
+                }
+                result.push(replacer_2(getMassagedTopLevelDeclarationText(sourceFile_2, declaration)));
+            });
+            return;
+        }
+        result.push(line);
+    });
+    var resultTxt = result.join('\n');
+    resultTxt = resultTxt.replace(/\bURI\b/g, 'Uri');
+    resultTxt = resultTxt.replace(/\bEvent</g, 'IEvent<');
+    resultTxt = resultTxt.replace(/\bTPromise</g, 'Promise<');
+    resultTxt = format(resultTxt);
+    resultTxt = resultTxt.replace(/\r\n/g, '\n');
+    return resultTxt;
+}
+function getFilesToWatch(out) {
+    var recipe = fs.readFileSync(RECIPE_PATH).toString();
+    var lines = recipe.split(/\r\n|\n|\r/);
+    var result = [];
+    lines.forEach(function (line) {
+        var m1 = line.match(/^\s*#include\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+        if (m1) {
+            var moduleId = m1[1];
+            result.push(moduleIdToPath(out, moduleId));
+            return;
+        }
+        var m2 = line.match(/^\s*#includeAll\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+        if (m2) {
+            var moduleId = m2[1];
+            result.push(moduleIdToPath(out, moduleId));
+            return;
+        }
+    });
+    return result;
+}
+exports.getFilesToWatch = getFilesToWatch;
+function run(out, inputFiles) {
+    log('Starting monaco.d.ts generation');
+    SOURCE_FILE_MAP = {};
+    var recipe = fs.readFileSync(RECIPE_PATH).toString();
+    var result = generateDeclarationFile(out, inputFiles, recipe);
+    var currentContent = fs.readFileSync(DECLARATION_PATH).toString();
+    log('Finished monaco.d.ts generation');
+    return {
+        content: result,
+        filePath: DECLARATION_PATH,
+        isTheSame: currentContent === result
+    };
+}
+exports.run = run;
+function complainErrors() {
+    logErr('Not running monaco.d.ts generation due to compile errors');
+}
+exports.complainErrors = complainErrors;

build/monaco/api.ts

@@ -0,0 +1,382 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import fs = require('fs');
+import ts = require('typescript');
+import path = require('path');
+const tsfmt = require('../../tsfmt.json');
+
+var util = require('gulp-util');
+function log(message: any, ...rest: any[]): void {
+	util.log(util.colors.cyan('[monaco.d.ts]'), message, ...rest);
+}
+
+const SRC = path.join(__dirname, '../../src');
+const OUT_ROOT = path.join(__dirname, '../../');
+const RECIPE_PATH = path.join(__dirname, './monaco.d.ts.recipe');
+const DECLARATION_PATH = path.join(__dirname, '../../src/vs/monaco.d.ts');
+
+var CURRENT_PROCESSING_RULE = '';
+function logErr(message: any, ...rest: any[]): void {
+	util.log(util.colors.red('[monaco.d.ts]'), 'WHILE HANDLING RULE: ', CURRENT_PROCESSING_RULE);
+	util.log(util.colors.red('[monaco.d.ts]'), message, ...rest);
+}
+
+function moduleIdToPath(out:string, moduleId:string): string {
+	if (/\.d\.ts/.test(moduleId)) {
+		return path.join(SRC, moduleId);
+	}
+	return path.join(OUT_ROOT, out, moduleId) + '.d.ts';
+}
+
+let SOURCE_FILE_MAP: {[moduleId:string]:ts.SourceFile;} = {};
+function getSourceFile(out:string, inputFiles: { [file: string]: string; }, moduleId:string): ts.SourceFile {
+	if (!SOURCE_FILE_MAP[moduleId]) {
+		let filePath = path.normalize(moduleIdToPath(out, moduleId));
+
+		if (!inputFiles.hasOwnProperty(filePath)) {
+			logErr('CANNOT FIND FILE ' + filePath + '. YOU MIGHT NEED TO RESTART gulp');
+			return null;
+		}
+
+		let fileContents = inputFiles[filePath];
+		let sourceFile = ts.createSourceFile(filePath, fileContents, ts.ScriptTarget.ES5);
+
+		SOURCE_FILE_MAP[moduleId] = sourceFile;
+	}
+	return SOURCE_FILE_MAP[moduleId];
+}
+
+
+type TSTopLevelDeclaration = ts.InterfaceDeclaration | ts.EnumDeclaration | ts.ClassDeclaration | ts.TypeAliasDeclaration | ts.FunctionDeclaration | ts.ModuleDeclaration;
+type TSTopLevelDeclare = TSTopLevelDeclaration | ts.VariableStatement;
+
+function isDeclaration(a:TSTopLevelDeclare): a is TSTopLevelDeclaration {
+	return (
+		a.kind === ts.SyntaxKind.InterfaceDeclaration
+		|| a.kind === ts.SyntaxKind.EnumDeclaration
+		|| a.kind === ts.SyntaxKind.ClassDeclaration
+		|| a.kind === ts.SyntaxKind.TypeAliasDeclaration
+		|| a.kind === ts.SyntaxKind.FunctionDeclaration
+		|| a.kind === ts.SyntaxKind.ModuleDeclaration
+	);
+}
+
+function visitTopLevelDeclarations(sourceFile:ts.SourceFile, visitor:(node:TSTopLevelDeclare)=>boolean): void {
+	let stop = false;
+
+	let visit = (node: ts.Node): void => {
+		if (stop) {
+			return;
+		}
+
+		switch (node.kind) {
+			case ts.SyntaxKind.InterfaceDeclaration:
+			case ts.SyntaxKind.EnumDeclaration:
+			case ts.SyntaxKind.ClassDeclaration:
+			case ts.SyntaxKind.VariableStatement:
+			case ts.SyntaxKind.TypeAliasDeclaration:
+			case ts.SyntaxKind.FunctionDeclaration:
+			case ts.SyntaxKind.ModuleDeclaration:
+				stop = visitor(<TSTopLevelDeclare>node);
+		}
+
+		// if (node.kind !== ts.SyntaxKind.SourceFile) {
+		// 	if (getNodeText(sourceFile, node).indexOf('SymbolKind') >= 0) {
+		// 		console.log('FOUND TEXT IN NODE: ' + ts.SyntaxKind[node.kind]);
+		// 		console.log(getNodeText(sourceFile, node));
+		// 	}
+		// }
+
+		if (stop) {
+			return;
+		}
+		ts.forEachChild(node, visit);
+	};
+
+	visit(sourceFile);
+}
+
+
+function getAllTopLevelDeclarations(sourceFile:ts.SourceFile): TSTopLevelDeclare[] {
+	let all:TSTopLevelDeclare[] = [];
+	visitTopLevelDeclarations(sourceFile, (node) => {
+		if (node.kind === ts.SyntaxKind.InterfaceDeclaration || node.kind === ts.SyntaxKind.ClassDeclaration || node.kind === ts.SyntaxKind.ModuleDeclaration) {
+			let interfaceDeclaration = <ts.InterfaceDeclaration>node;
+			let triviaStart = interfaceDeclaration.pos;
+			let triviaEnd = interfaceDeclaration.name.pos;
+			let triviaText = getNodeText(sourceFile, { pos: triviaStart, end: triviaEnd });
+
+			// // let nodeText = getNodeText(sourceFile, node);
+			// if (getNodeText(sourceFile, node).indexOf('SymbolKind') >= 0) {
+			// 	console.log('TRIVIA: ', triviaText);
+			// }
+			if (triviaText.indexOf('@internal') === -1) {
+				all.push(node);
+			}
+		} else {
+			let nodeText = getNodeText(sourceFile, node);
+			if (nodeText.indexOf('@internal') === -1) {
+				all.push(node);
+			}
+		}
+		return false /*continue*/;
+	});
+	return all;
+}
+
+
+function getTopLevelDeclaration(sourceFile:ts.SourceFile, typeName:string): TSTopLevelDeclare {
+	let result:TSTopLevelDeclare = null;
+	visitTopLevelDeclarations(sourceFile, (node) => {
+		if (isDeclaration(node)) {
+			if (node.name.text === typeName) {
+				result = node;
+				return true /*stop*/;
+			}
+			return false /*continue*/;
+		}
+		// node is ts.VariableStatement
+		if (getNodeText(sourceFile, node).indexOf(typeName) >= 0) {
+			result = node;
+			return true /*stop*/;
+		}
+		return false /*continue*/;
+	});
+	return result;
+}
+
+
+function getNodeText(sourceFile:ts.SourceFile, node:{pos:number; end:number;}): string {
+	return sourceFile.getFullText().substring(node.pos, node.end);
+}
+
+
+function getMassagedTopLevelDeclarationText(sourceFile:ts.SourceFile, declaration: TSTopLevelDeclare): string {
+	let result = getNodeText(sourceFile, declaration);
+	// if (result.indexOf('MonacoWorker') >= 0) {
+	// 	console.log('here!');
+	// 	// console.log(ts.SyntaxKind[declaration.kind]);
+	// }
+	if (declaration.kind === ts.SyntaxKind.InterfaceDeclaration || declaration.kind === ts.SyntaxKind.ClassDeclaration) {
+		let interfaceDeclaration = <ts.InterfaceDeclaration | ts.ClassDeclaration>declaration;
+
+		let members:ts.NodeArray<ts.Node> = interfaceDeclaration.members;
+		members.forEach((member) => {
+			try {
+				let memberText = getNodeText(sourceFile, member);
+				if (memberText.indexOf('@internal') >= 0 || memberText.indexOf('private') >= 0) {
+					// console.log('BEFORE: ', result);
+					result = result.replace(memberText, '');
+					// console.log('AFTER: ', result);
+				}
+			} catch (err) {
+				// life..
+			}
+		});
+	}
+	result = result.replace(/export default/g, 'export');
+	result = result.replace(/export declare/g, 'export');
+	return result;
+}
+
+function format(text:string): string {
+
+	// Parse the source text
+	let sourceFile = ts.createSourceFile('file.ts', text, ts.ScriptTarget.Latest, /*setParentPointers*/ true);
+
+	// Get the formatting edits on the input sources
+	let edits = (<any>ts).formatting.formatDocument(sourceFile, getRuleProvider(tsfmt), tsfmt);
+
+	// Apply the edits on the input code
+	return applyEdits(text, edits);
+
+	function getRuleProvider(options: ts.FormatCodeSettings) {
+		// Share this between multiple formatters using the same options.
+		// This represents the bulk of the space the formatter uses.
+		let ruleProvider = new (<any>ts).formatting.RulesProvider();
+		ruleProvider.ensureUpToDate(options);
+		return ruleProvider;
+	}
+
+	function applyEdits(text: string, edits: ts.TextChange[]): string {
+		// Apply edits in reverse on the existing text
+		let result = text;
+		for (let i = edits.length - 1; i >= 0; i--) {
+			let change = edits[i];
+			let head = result.slice(0, change.span.start);
+			let tail = result.slice(change.span.start + change.span.length);
+			result = head + change.newText + tail;
+		}
+		return result;
+	}
+}
+
+function createReplacer(data:string): (str:string)=>string {
+	data = data || '';
+	let rawDirectives = data.split(';');
+	let directives: [RegExp,string][] = [];
+	rawDirectives.forEach((rawDirective) => {
+		if (rawDirective.length === 0) {
+			return;
+		}
+		let pieces = rawDirective.split('=>');
+		let findStr = pieces[0];
+		let replaceStr = pieces[1];
+
+		findStr = findStr.replace(/[\-\\\{\}\*\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&');
+		findStr = '\\b' + findStr + '\\b';
+		directives.push([new RegExp(findStr, 'g'), replaceStr]);
+	});
+
+	return (str:string)=> {
+		for (let i = 0; i < directives.length; i++) {
+			str = str.replace(directives[i][0], directives[i][1]);
+		}
+		return str;
+	};
+}
+
+function generateDeclarationFile(out: string, inputFiles: { [file: string]: string; }, recipe:string): string {
+	let lines = recipe.split(/\r\n|\n|\r/);
+	let result = [];
+
+
+	lines.forEach(line => {
+
+		let m1 = line.match(/^\s*#include\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+		if (m1) {
+			CURRENT_PROCESSING_RULE = line;
+			let moduleId = m1[1];
+			let sourceFile = getSourceFile(out, inputFiles, moduleId);
+			if (!sourceFile) {
+				return;
+			}
+
+			let replacer = createReplacer(m1[2]);
+
+			let typeNames = m1[3].split(/,/);
+			typeNames.forEach((typeName) => {
+				typeName = typeName.trim();
+				if (typeName.length === 0) {
+					return;
+				}
+				let declaration = getTopLevelDeclaration(sourceFile, typeName);
+				if (!declaration) {
+					logErr('Cannot find type ' + typeName);
+					return;
+				}
+				result.push(replacer(getMassagedTopLevelDeclarationText(sourceFile, declaration)));
+			});
+			return;
+		}
+
+		let m2 = line.match(/^\s*#includeAll\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+		if (m2) {
+			CURRENT_PROCESSING_RULE = line;
+			let moduleId = m2[1];
+			let sourceFile = getSourceFile(out, inputFiles, moduleId);
+			if (!sourceFile) {
+				return;
+			}
+
+			let replacer = createReplacer(m2[2]);
+
+			let typeNames = m2[3].split(/,/);
+			let typesToExcludeMap: {[typeName:string]:boolean;} = {};
+			let typesToExcludeArr: string[] = [];
+			typeNames.forEach((typeName) => {
+				typeName = typeName.trim();
+				if (typeName.length === 0) {
+					return;
+				}
+				typesToExcludeMap[typeName] = true;
+				typesToExcludeArr.push(typeName);
+			});
+
+			getAllTopLevelDeclarations(sourceFile).forEach((declaration) => {
+				if (isDeclaration(declaration)) {
+					if (typesToExcludeMap[declaration.name.text]) {
+						return;
+					}
+				} else {
+					// node is ts.VariableStatement
+					let nodeText = getNodeText(sourceFile, declaration);
+					for (let i = 0; i < typesToExcludeArr.length; i++) {
+						if (nodeText.indexOf(typesToExcludeArr[i]) >= 0) {
+							return;
+						}
+					}
+				}
+				result.push(replacer(getMassagedTopLevelDeclarationText(sourceFile, declaration)));
+			});
+			return;
+		}
+
+		result.push(line);
+	});
+
+	let resultTxt = result.join('\n');
+	resultTxt = resultTxt.replace(/\bURI\b/g, 'Uri');
+	resultTxt = resultTxt.replace(/\bEvent</g, 'IEvent<');
+	resultTxt = resultTxt.replace(/\bTPromise</g, 'Promise<');
+
+	resultTxt = format(resultTxt);
+
+	resultTxt = resultTxt.replace(/\r\n/g, '\n');
+	return resultTxt;
+}
+
+export function getFilesToWatch(out:string): string[] {
+	let recipe = fs.readFileSync(RECIPE_PATH).toString();
+	let lines = recipe.split(/\r\n|\n|\r/);
+	let result = [];
+
+	lines.forEach(line => {
+
+		let m1 = line.match(/^\s*#include\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+		if (m1) {
+			let moduleId = m1[1];
+			result.push(moduleIdToPath(out, moduleId));
+			return;
+		}
+
+		let m2 = line.match(/^\s*#includeAll\(([^;)]*)(;[^)]*)?\)\:(.*)$/);
+		if (m2) {
+			let moduleId = m2[1];
+			result.push(moduleIdToPath(out, moduleId));
+			return;
+		}
+	});
+
+	return result;
+}
+
+export interface IMonacoDeclarationResult {
+	content: string;
+	filePath: string;
+	isTheSame: boolean;
+}
+
+export function run(out: string, inputFiles: { [file: string]: string; }): IMonacoDeclarationResult {
+	log('Starting monaco.d.ts generation');
+	SOURCE_FILE_MAP = {};
+
+	let recipe = fs.readFileSync(RECIPE_PATH).toString();
+	let result = generateDeclarationFile(out, inputFiles, recipe);
+
+	let currentContent = fs.readFileSync(DECLARATION_PATH).toString();
+	log('Finished monaco.d.ts generation');
+
+	return {
+		content: result,
+		filePath: DECLARATION_PATH,
+		isTheSame: currentContent === result
+	};
+}
+
+export function complainErrors() {
+	logErr('Not running monaco.d.ts generation due to compile errors');
+}

build/monaco/monaco.d.ts.recipe

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+declare module monaco {
+
+	type Thenable<T> = PromiseLike<T>;
+
+	export interface IDisposable {
+		dispose(): void;
+	}
+
+	export interface IEvent<T> {
+		(listener: (e: T) => any, thisArg?: any): IDisposable;
+	}
+
+	/**
+	 * A helper that allows to emit and listen to typed events
+	 */
+	export class Emitter<T> {
+		constructor();
+		readonly event: Event<T>;
+		fire(event?: T): void;
+		dispose(): void;
+	}
+
+	export enum Severity {
+		Ignore = 0,
+		Info = 1,
+		Warning = 2,
+		Error = 3,
+	}
+
+#include(vs/base/common/winjs.base.d.ts): TValueCallback, ProgressCallback, Promise
+#include(vs/base/common/cancellation): CancellationTokenSource, CancellationToken
+#include(vs/base/common/uri): URI
+#include(vs/editor/common/standalone/standaloneBase): KeyCode, KeyMod
+#include(vs/base/common/htmlContent): IMarkdownString
+#include(vs/base/browser/keyboardEvent): IKeyboardEvent
+#include(vs/base/browser/mouseEvent): IMouseEvent
+#include(vs/editor/common/editorCommon): IScrollEvent
+#include(vs/editor/common/core/position): IPosition, Position
+#include(vs/editor/common/core/range): IRange, Range
+#include(vs/editor/common/core/selection): ISelection, Selection, SelectionDirection
+#include(vs/editor/common/core/token): Token
+}
+
+declare module monaco.editor {
+
+#includeAll(vs/editor/standalone/browser/standaloneEditor;modes.=>languages.;editorCommon.=>):
+#include(vs/editor/standalone/common/standaloneThemeService): BuiltinTheme, IStandaloneThemeData, IColors
+#include(vs/editor/common/modes/supports/tokenization): ITokenThemeRule
+#include(vs/editor/common/services/webWorker): MonacoWebWorker, IWebWorkerOptions
+#include(vs/editor/standalone/browser/standaloneCodeEditor): IEditorConstructionOptions, IDiffEditorConstructionOptions, IStandaloneCodeEditor, IStandaloneDiffEditor
+export interface ICommandHandler {
+	(...args:any[]): void;
+}
+#include(vs/platform/contextkey/common/contextkey): IContextKey
+#include(vs/editor/standalone/browser/standaloneServices): IEditorOverrideServices
+#include(vs/platform/markers/common/markers): IMarker, IMarkerData
+#include(vs/editor/standalone/browser/colorizer): IColorizerOptions, IColorizerElementOptions
+#include(vs/base/common/scrollable): ScrollbarVisibility
+#include(vs/platform/theme/common/themeService): ThemeColor
+#includeAll(vs/editor/common/editorCommon;IMode=>languages.IMode;LanguageIdentifier=>languages.LanguageIdentifier;editorOptions.=>): ISelection, IScrollEvent
+#includeAll(vs/editor/common/model/textModelEvents):
+#includeAll(vs/editor/common/controller/cursorEvents):
+#includeAll(vs/editor/common/config/editorOptions):
+#includeAll(vs/editor/browser/editorBrowser;editorCommon.=>;editorOptions.=>):
+#include(vs/editor/common/config/fontInfo): FontInfo, BareFontInfo
+}
+
+declare module monaco.languages {
+
+#includeAll(vs/editor/standalone/browser/standaloneLanguages;modes.=>;editorCommon.=>editor.;IMarkerData=>editor.IMarkerData):
+#includeAll(vs/editor/common/modes/languageConfiguration):
+#includeAll(vs/editor/common/modes;editorCommon.IRange=>IRange;editorCommon.IPosition=>IPosition;editorCommon.=>editor.):
+#include(vs/editor/common/services/modeService): ILanguageExtensionPoint
+#includeAll(vs/editor/standalone/common/monarch/monarchTypes):
+
+}
+
+declare module monaco.worker {
+
+#includeAll(vs/editor/common/services/editorSimpleWorker;):
+
+}

build/monaco/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "monaco-editor-core",
+  "private": true,
+  "version": "0.9.0",
+  "description": "A browser based code editor",
+  "author": "Microsoft Corporation",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Microsoft/vscode"
+  },
+   "bugs": {
+    "url": "https://github.com/Microsoft/vscode/issues"
+  },
+  "devDependencies": {
+    "@types/minimist": "^1.2.0",
+    "@types/mocha": "^2.2.39",
+    "@types/semver": "^5.3.30",
+    "@types/sinon": "^1.16.34",
+    "debounce": "^1.0.0",
+    "eslint": "^3.4.0",
+    "event-stream": "^3.1.7",
+    "ghooks": "1.0.3",
+    "glob": "^5.0.13",
+    "gulp": "^3.8.9",
+    "gulp-bom": "^1.0.0",
+    "gulp-concat": "^2.6.0",
+    "gulp-cssnano": "^2.1.0",
+    "gulp-filter": "^3.0.0",
+    "gulp-flatmap": "^1.0.0",
+    "gulp-rename": "^1.2.0",
+    "gulp-sourcemaps": "^1.11.0",
+    "gulp-tsb": "^2.0.3",
+    "gulp-tslint": "^7.0.1",
+    "gulp-uglify": "^2.0.0",
+    "gulp-util": "^3.0.6",
+    "gulp-watch": "^4.3.9",
+    "is": "^3.1.0",
+    "istanbul": "^0.3.17",
+    "jsdom-no-contextify": "^3.1.0",
+    "lazy.js": "^0.4.2",
+    "minimatch": "^2.0.10",
+    "mocha": "^2.2.5",
+    "object-assign": "^4.0.1",
+    "pump": "^1.0.1",
+    "remap-istanbul": "^0.6.4",
+    "rimraf": "^2.2.8",
+    "sinon": "^1.17.2",
+    "source-map": "^0.4.4",
+    "tslint": "^4.3.1",
+    "typescript": "2.4.1",
+    "typescript-formatter": "4.0.1",
+    "underscore": "^1.8.2",
+    "vinyl": "^0.4.5",
+    "vscode-nls-dev": "^2.0.1"
+  }
+}