Reduce the number of folders where we use TS

build/lib/monaco-api.ts

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