Adopt esbuild for monaco-languages

build/utils.js

@@ -189,6 +189,7 @@ function buildESM(options) {
 			AMD: 'false'
 		},
 		external: options.external,
+		outbase: 'src',
 		outdir: 'release/esm/',
 		plugins: [
 			alias({
@@ -223,6 +224,7 @@ function buildOneAMD(type, options) {
 		footer: {
 			js: 'return moduleExports;\n});'
 		},
+		outbase: 'src',
 		outdir: `release/${type}/`,
 		plugins: [
 			alias({

monaco-languages/build.js

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//@ts-check
+
+const glob = require('glob');
+const { removeDir, tsc, buildESM, buildAMD } = require('../build/utils');
+
+removeDir(`monaco-languages/release`);
+removeDir(`monaco-languages/out`);
+
+tsc(`monaco-languages/src/tsconfig.json`);
+
+glob('src/*/*.contribution.ts', { cwd: __dirname }, function (err, files) {
+	if (err) {
+		console.error(err);
+		return;
+	}
+
+	const languages = files.map((file) => file.split('/')[1]);
+
+	// ESM
+	{
+		/** @type {string[]} */
+		const entryPoints = ['src/monaco.contribution.ts', 'src/_.contribution.ts'];
+		const external = ['monaco-editor-core', '*/_.contribution'];
+		for (const language of languages) {
+			entryPoints.push(`src/${language}/${language}.contribution.ts`);
+			entryPoints.push(`src/${language}/${language}.ts`);
+			external.push(`*/${language}.contribution`);
+			external.push(`*/${language}`);
+		}
+		buildESM({
+			entryPoints,
+			external
+		});
+	}
+
+	// AMD
+	{
+		buildAMD({
+			entryPoint: 'src/monaco.contribution.ts',
+			banner: 'define("vs/basic-languages/monaco.contribution",["vs/editor/editor.api"],()=>{'
+		});
+		for (const language of languages) {
+			buildAMD({
+				entryPoint: `src/${language}/${language}.ts`,
+				banner: `define("vs/basic-languages/${language}/${language}",[],()=>{`
+			})
+		}
+	}
+});

monaco-languages/package.json

@@ -1,9 +1,7 @@
 {
 	"scripts": {
-		"compile": "../node_modules/.bin/mrmdir ./out && ../node_modules/.bin/tsc -p ./src/tsconfig.json && ../node_modules/.bin/tsc -p ./src/tsconfig.esm.json",
 		"watch": "../node_modules/.bin/tsc -p ./src --watch",
-		"watch-esm": "../node_modules/.bin/tsc -p ./src/tsconfig.esm.json --watch",
 		"test": "node ./test/all.js",
-		"prepublishOnly": "../node_modules/.bin/mrmdir ./release && npm run compile && node ./scripts/release.js && node ./scripts/bundle"
+		"prepublishOnly": "node ./build"
 	}
 }

monaco-languages/src/abap/abap.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'abap',
 	extensions: ['.abap'],
 	aliases: ['abap', 'ABAP'],
-	loader: () => import('./abap')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/abap/abap'], resolve, reject);
+			});
+		} else {
+			return import('./abap');
+		}
+	}
 });

monaco-languages/src/apex/apex.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'apex',
 	extensions: ['.cls'],
 	aliases: ['Apex', 'apex'],
 	mimetypes: ['text/x-apex-source', 'text/x-apex'],
-	loader: () => import('./apex')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/apex/apex'], resolve, reject);
+			});
+		} else {
+			return import('./apex');
+		}
+	}
 });

monaco-languages/src/azcli/azcli.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'azcli',
 	extensions: ['.azcli'],
 	aliases: ['Azure CLI', 'azcli'],
-	loader: () => import('./azcli')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/azcli/azcli'], resolve, reject);
+			});
+		} else {
+			return import('./azcli');
+		}
+	}
 });

monaco-languages/src/bat/bat.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'bat',
 	extensions: ['.bat', '.cmd'],
 	aliases: ['Batch', 'bat'],
-	loader: () => import('./bat')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/bat/bat'], resolve, reject);
+			});
+		} else {
+			return import('./bat');
+		}
+	}
 });

monaco-languages/src/bicep/bicep.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'bicep',
 	extensions: ['.bicep'],
 	aliases: ['Bicep'],
-	loader: () => import('./bicep')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/bicep/bicep'], resolve, reject);
+			});
+		} else {
+			return import('./bicep');
+		}
+	}
 });

monaco-languages/src/cameligo/cameligo.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'cameligo',
 	extensions: ['.mligo'],
 	aliases: ['Cameligo'],
-	loader: () => import('./cameligo')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/cameligo/cameligo'], resolve, reject);
+			});
+		} else {
+			return import('./cameligo');
+		}
+	}
 });

monaco-languages/src/clojure/clojure.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'clojure',
 	extensions: ['.clj', '.cljs', '.cljc', '.edn'],
 	aliases: ['clojure', 'Clojure'],
-	loader: () => import('./clojure')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/clojure/clojure'], resolve, reject);
+			});
+		} else {
+			return import('./clojure');
+		}
+	}
 });

monaco-languages/src/coffee/coffee.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'coffeescript',
 	extensions: ['.coffee'],
 	aliases: ['CoffeeScript', 'coffeescript', 'coffee'],
 	mimetypes: ['text/x-coffeescript', 'text/coffeescript'],
-	loader: () => import('./coffee')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/coffee/coffee'], resolve, reject);
+			});
+		} else {
+			return import('./coffee');
+		}
+	}
 });

monaco-languages/src/cpp/cpp.contribution.ts

@@ -5,15 +5,34 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'c',
 	extensions: ['.c', '.h'],
 	aliases: ['C', 'c'],
-	loader: () => import('./cpp')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/cpp/cpp'], resolve, reject);
+			});
+		} else {
+			return import('./cpp');
+		}
+	}
 });
 registerLanguage({
 	id: 'cpp',
 	extensions: ['.cpp', '.cc', '.cxx', '.hpp', '.hh', '.hxx'],
 	aliases: ['C++', 'Cpp', 'cpp'],
-	loader: () => import('./cpp')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/cpp/cpp'], resolve, reject);
+			});
+		} else {
+			return import('./cpp');
+		}
+	}
 });

monaco-languages/src/csharp/csharp.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'csharp',
 	extensions: ['.cs', '.csx', '.cake'],
 	aliases: ['C#', 'csharp'],
-	loader: () => import('./csharp')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/csharp/csharp'], resolve, reject);
+			});
+		} else {
+			return import('./csharp');
+		}
+	}
 });

monaco-languages/src/csp/csp.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'csp',
 	extensions: [],
 	aliases: ['CSP', 'csp'],
-	loader: () => import('./csp')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/csp/csp'], resolve, reject);
+			});
+		} else {
+			return import('./csp');
+		}
+	}
 });

monaco-languages/src/css/css.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'css',
 	extensions: ['.css'],
 	aliases: ['CSS', 'css'],
 	mimetypes: ['text/css'],
-	loader: () => import('./css')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/css/css'], resolve, reject);
+			});
+		} else {
+			return import('./css');
+		}
+	}
 });

monaco-languages/src/dart/dart.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'dart',
 	extensions: ['.dart'],
 	aliases: ['Dart', 'dart'],
 	mimetypes: ['text/x-dart-source', 'text/x-dart'],
-	loader: () => import('./dart')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/dart/dart'], resolve, reject);
+			});
+		} else {
+			return import('./dart');
+		}
+	}
 });

monaco-languages/src/dockerfile/dockerfile.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'dockerfile',
 	extensions: ['.dockerfile'],
 	filenames: ['Dockerfile'],
 	aliases: ['Dockerfile'],
-	loader: () => import('./dockerfile')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/dockerfile/dockerfile'], resolve, reject);
+			});
+		} else {
+			return import('./dockerfile');
+		}
+	}
 });

monaco-languages/src/ecl/ecl.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'ecl',
 	extensions: ['.ecl'],
 	aliases: ['ECL', 'Ecl', 'ecl'],
-	loader: () => import('./ecl')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/ecl/ecl'], resolve, reject);
+			});
+		} else {
+			return import('./ecl');
+		}
+	}
 });

monaco-languages/src/elixir/elixir.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'elixir',
 	extensions: ['.ex', '.exs'],
 	aliases: ['Elixir', 'elixir', 'ex'],
-	loader: () => import('./elixir')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/elixir/elixir'], resolve, reject);
+			});
+		} else {
+			return import('./elixir');
+		}
+	}
 });

monaco-languages/src/fillers/monaco-editor-core-amd.ts

@@ -1,12 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-// Resolves with the global monaco API
-
-declare const define: any;
-
-define([], function () {
-	return (<any>self).monaco;
-});

monaco-languages/src/flow9/flow9.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'flow9',
 	extensions: ['.flow'],
 	aliases: ['Flow9', 'Flow', 'flow9', 'flow'],
-	loader: () => import('./flow9')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/flow9/flow9'], resolve, reject);
+			});
+		} else {
+			return import('./flow9');
+		}
+	}
 });

monaco-languages/src/fsharp/fsharp.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'fsharp',
 	extensions: ['.fs', '.fsi', '.ml', '.mli', '.fsx', '.fsscript'],
 	aliases: ['F#', 'FSharp', 'fsharp'],
-	loader: () => import('./fsharp')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/fsharp/fsharp'], resolve, reject);
+			});
+		} else {
+			return import('./fsharp');
+		}
+	}
 });

monaco-languages/src/go/go.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'go',
 	extensions: ['.go'],
 	aliases: ['Go'],
-	loader: () => import('./go')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/go/go'], resolve, reject);
+			});
+		} else {
+			return import('./go');
+		}
+	}
 });

monaco-languages/src/graphql/graphql.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'graphql',
 	extensions: ['.graphql', '.gql'],
 	aliases: ['GraphQL', 'graphql', 'gql'],
 	mimetypes: ['application/graphql'],
-	loader: () => import('./graphql')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/graphql/graphql'], resolve, reject);
+			});
+		} else {
+			return import('./graphql');
+		}
+	}
 });

monaco-languages/src/handlebars/handlebars.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'handlebars',
 	extensions: ['.handlebars', '.hbs'],
 	aliases: ['Handlebars', 'handlebars', 'hbs'],
 	mimetypes: ['text/x-handlebars-template'],
-	loader: () => import('./handlebars')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/handlebars/handlebars'], resolve, reject);
+			});
+		} else {
+			return import('./handlebars');
+		}
+	}
 });

monaco-languages/src/hcl/hcl.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'hcl',
 	extensions: ['.tf', '.tfvars', '.hcl'],
 	aliases: ['Terraform', 'tf', 'HCL', 'hcl'],
-	loader: () => import('./hcl')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/hcl/hcl'], resolve, reject);
+			});
+		} else {
+			return import('./hcl');
+		}
+	}
 });

monaco-languages/src/html/html.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'html',
 	extensions: ['.html', '.htm', '.shtml', '.xhtml', '.mdoc', '.jsp', '.asp', '.aspx', '.jshtm'],
 	aliases: ['HTML', 'htm', 'html', 'xhtml'],
 	mimetypes: ['text/html', 'text/x-jshtm', 'text/template', 'text/ng-template'],
-	loader: () => import('./html')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/html/html'], resolve, reject);
+			});
+		} else {
+			return import('./html');
+		}
+	}
 });

monaco-languages/src/ini/ini.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'ini',
 	extensions: ['.ini', '.properties', '.gitconfig'],
 	filenames: ['config', '.gitattributes', '.gitconfig', '.editorconfig'],
 	aliases: ['Ini', 'ini'],
-	loader: () => import('./ini')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/ini/ini'], resolve, reject);
+			});
+		} else {
+			return import('./ini');
+		}
+	}
 });

monaco-languages/src/java/java.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'java',
 	extensions: ['.java', '.jav'],
 	aliases: ['Java', 'java'],
 	mimetypes: ['text/x-java-source', 'text/x-java'],
-	loader: () => import('./java')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/java/java'], resolve, reject);
+			});
+		} else {
+			return import('./java');
+		}
+	}
 });

monaco-languages/src/javascript/javascript.contribution.ts

@@ -5,6 +5,9 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'javascript',
 	extensions: ['.js', '.es6', '.jsx', '.mjs'],
@@ -12,5 +15,13 @@ registerLanguage({
 	filenames: ['jakefile'],
 	aliases: ['JavaScript', 'javascript', 'js'],
 	mimetypes: ['text/javascript'],
-	loader: () => import('./javascript')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/javascript/javascript'], resolve, reject);
+			});
+		} else {
+			return import('./javascript');
+		}
+	}
 });

monaco-languages/src/julia/julia.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'julia',
 	extensions: ['.jl'],
 	aliases: ['julia', 'Julia'],
-	loader: () => import('./julia')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/julia/julia'], resolve, reject);
+			});
+		} else {
+			return import('./julia');
+		}
+	}
 });

monaco-languages/src/kotlin/kotlin.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'kotlin',
 	extensions: ['.kt'],
 	aliases: ['Kotlin', 'kotlin'],
 	mimetypes: ['text/x-kotlin-source', 'text/x-kotlin'],
-	loader: () => import('./kotlin')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/kotlin/kotlin'], resolve, reject);
+			});
+		} else {
+			return import('./kotlin');
+		}
+	}
 });

monaco-languages/src/less/less.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'less',
 	extensions: ['.less'],
 	aliases: ['Less', 'less'],
 	mimetypes: ['text/x-less', 'text/less'],
-	loader: () => import('./less')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/less/less'], resolve, reject);
+			});
+		} else {
+			return import('./less');
+		}
+	}
 });

monaco-languages/src/lexon/lexon.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'lexon',
 	extensions: ['.lex'],
 	aliases: ['Lexon'],
-	loader: () => import('./lexon')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/lexon/lexon'], resolve, reject);
+			});
+		} else {
+			return import('./lexon');
+		}
+	}
 });

monaco-languages/src/liquid/liquid.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'liquid',
 	extensions: ['.liquid', '.html.liquid'],
 	aliases: ['Liquid', 'liquid'],
 	mimetypes: ['application/liquid'],
-	loader: () => import('./liquid')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/liquid/liquid'], resolve, reject);
+			});
+		} else {
+			return import('./liquid');
+		}
+	}
 });

monaco-languages/src/lua/lua.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'lua',
 	extensions: ['.lua'],
 	aliases: ['Lua', 'lua'],
-	loader: () => import('./lua')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/lua/lua'], resolve, reject);
+			});
+		} else {
+			return import('./lua');
+		}
+	}
 });

monaco-languages/src/m3/m3.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'm3',
 	extensions: ['.m3', '.i3', '.mg', '.ig'],
 	aliases: ['Modula-3', 'Modula3', 'modula3', 'm3'],
-	loader: () => import('./m3')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/m3/m3'], resolve, reject);
+			});
+		} else {
+			return import('./m3');
+		}
+	}
 });

monaco-languages/src/markdown/markdown.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'markdown',
 	extensions: ['.md', '.markdown', '.mdown', '.mkdn', '.mkd', '.mdwn', '.mdtxt', '.mdtext'],
 	aliases: ['Markdown', 'markdown'],
-	loader: () => import('./markdown')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/markdown/markdown'], resolve, reject);
+			});
+		} else {
+			return import('./markdown');
+		}
+	}
 });

monaco-languages/src/mips/mips.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'mips',
 	extensions: ['.s'],
 	aliases: ['MIPS', 'MIPS-V'],
 	mimetypes: ['text/x-mips', 'text/mips', 'text/plaintext'],
-	loader: () => import('./mips')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/mips/mips'], resolve, reject);
+			});
+		} else {
+			return import('./mips');
+		}
+	}
 });

monaco-languages/src/msdax/msdax.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'msdax',
 	extensions: ['.dax', '.msdax'],
 	aliases: ['DAX', 'MSDAX'],
-	loader: () => import('./msdax')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/msdax/msdax'], resolve, reject);
+			});
+		} else {
+			return import('./msdax');
+		}
+	}
 });

monaco-languages/src/mysql/mysql.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'mysql',
 	extensions: [],
 	aliases: ['MySQL', 'mysql'],
-	loader: () => import('./mysql')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/mysql/mysql'], resolve, reject);
+			});
+		} else {
+			return import('./mysql');
+		}
+	}
 });

monaco-languages/src/objective-c/objective-c.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'objective-c',
 	extensions: ['.m'],
 	aliases: ['Objective-C'],
-	loader: () => import('./objective-c')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/objective-c/objective-c'], resolve, reject);
+			});
+		} else {
+			return import('./objective-c');
+		}
+	}
 });

monaco-languages/src/pascal/pascal.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'pascal',
 	extensions: ['.pas', '.p', '.pp'],
 	aliases: ['Pascal', 'pas'],
 	mimetypes: ['text/x-pascal-source', 'text/x-pascal'],
-	loader: () => import('./pascal')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/pascal/pascal'], resolve, reject);
+			});
+		} else {
+			return import('./pascal');
+		}
+	}
 });

monaco-languages/src/pascaligo/pascaligo.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'pascaligo',
 	extensions: ['.ligo'],
 	aliases: ['Pascaligo', 'ligo'],
-	loader: () => import('./pascaligo')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/pascaligo/pascaligo'], resolve, reject);
+			});
+		} else {
+			return import('./pascaligo');
+		}
+	}
 });

monaco-languages/src/perl/perl.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'perl',
 	extensions: ['.pl'],
 	aliases: ['Perl', 'pl'],
-	loader: () => import('./perl')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/perl/perl'], resolve, reject);
+			});
+		} else {
+			return import('./perl');
+		}
+	}
 });

monaco-languages/src/pgsql/pgsql.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'pgsql',
 	extensions: [],
 	aliases: ['PostgreSQL', 'postgres', 'pg', 'postgre'],
-	loader: () => import('./pgsql')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/pgsql/pgsql'], resolve, reject);
+			});
+		} else {
+			return import('./pgsql');
+		}
+	}
 });

monaco-languages/src/php/php.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'php',
 	extensions: ['.php', '.php4', '.php5', '.phtml', '.ctp'],
 	aliases: ['PHP', 'php'],
 	mimetypes: ['application/x-php'],
-	loader: () => import('./php')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/php/php'], resolve, reject);
+			});
+		} else {
+			return import('./php');
+		}
+	}
 });

monaco-languages/src/pla/pla.contribution.ts

@@ -5,8 +5,19 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'pla',
 	extensions: ['.pla'],
-	loader: () => import('./pla')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/pla/pla'], resolve, reject);
+			});
+		} else {
+			return import('./pla');
+		}
+	}
 });

monaco-languages/src/postiats/postiats.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'postiats',
 	extensions: ['.dats', '.sats', '.hats'],
 	aliases: ['ATS', 'ATS/Postiats'],
-	loader: () => import('./postiats')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/postiats/postiats'], resolve, reject);
+			});
+		} else {
+			return import('./postiats');
+		}
+	}
 });

monaco-languages/src/powerquery/powerquery.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'powerquery',
 	extensions: ['.pq', '.pqm'],
 	aliases: ['PQ', 'M', 'Power Query', 'Power Query M'],
-	loader: () => import('./powerquery')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/powerquery/powerquery'], resolve, reject);
+			});
+		} else {
+			return import('./powerquery');
+		}
+	}
 });

monaco-languages/src/powershell/powershell.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'powershell',
 	extensions: ['.ps1', '.psm1', '.psd1'],
 	aliases: ['PowerShell', 'powershell', 'ps', 'ps1'],
-	loader: () => import('./powershell')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/powershell/powershell'], resolve, reject);
+			});
+		} else {
+			return import('./powershell');
+		}
+	}
 });

monaco-languages/src/protobuf/protobuf.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'proto',
 	extensions: ['.proto'],
 	aliases: ['protobuf', 'Protocol Buffers'],
-	loader: () => import('./protobuf')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/protobuf/protobuf'], resolve, reject);
+			});
+		} else {
+			return import('./protobuf');
+		}
+	}
 });

monaco-languages/src/pug/pug.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'pug',
 	extensions: ['.jade', '.pug'],
 	aliases: ['Pug', 'Jade', 'jade'],
-	loader: () => import('./pug')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/pug/pug'], resolve, reject);
+			});
+		} else {
+			return import('./pug');
+		}
+	}
 });

monaco-languages/src/python/python.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'python',
 	extensions: ['.py', '.rpy', '.pyw', '.cpy', '.gyp', '.gypi'],
 	aliases: ['Python', 'py'],
 	firstLine: '^#!/.*\\bpython[0-9.-]*\\b',
-	loader: () => import('./python')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/python/python'], resolve, reject);
+			});
+		} else {
+			return import('./python');
+		}
+	}
 });

monaco-languages/src/qsharp/qsharp.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'qsharp',
 	extensions: ['.qs'],
 	aliases: ['Q#', 'qsharp'],
-	loader: () => import('./qsharp')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/qsharp/qsharp'], resolve, reject);
+			});
+		} else {
+			return import('./qsharp');
+		}
+	}
 });

monaco-languages/src/r/r.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'r',
 	extensions: ['.r', '.rhistory', '.rmd', '.rprofile', '.rt'],
 	aliases: ['R', 'r'],
-	loader: () => import('./r')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/r/r'], resolve, reject);
+			});
+		} else {
+			return import('./r');
+		}
+	}
 });

monaco-languages/src/razor/razor.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'razor',
 	extensions: ['.cshtml'],
 	aliases: ['Razor', 'razor'],
 	mimetypes: ['text/x-cshtml'],
-	loader: () => import('./razor')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/razor/razor'], resolve, reject);
+			});
+		} else {
+			return import('./razor');
+		}
+	}
 });

monaco-languages/src/redis/redis.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'redis',
 	extensions: ['.redis'],
 	aliases: ['redis'],
-	loader: () => import('./redis')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/redis/redis'], resolve, reject);
+			});
+		} else {
+			return import('./redis');
+		}
+	}
 });

monaco-languages/src/redshift/redshift.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'redshift',
 	extensions: [],
 	aliases: ['Redshift', 'redshift'],
-	loader: () => import('./redshift')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/redshift/redshift'], resolve, reject);
+			});
+		} else {
+			return import('./redshift');
+		}
+	}
 });

monaco-languages/src/restructuredtext/restructuredtext.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'restructuredtext',
 	extensions: ['.rst'],
 	aliases: ['reStructuredText', 'restructuredtext'],
-	loader: () => import('./restructuredtext')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/restructuredtext/restructuredtext'], resolve, reject);
+			});
+		} else {
+			return import('./restructuredtext');
+		}
+	}
 });

monaco-languages/src/ruby/ruby.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'ruby',
 	extensions: ['.rb', '.rbx', '.rjs', '.gemspec', '.pp'],
 	filenames: ['rakefile', 'Gemfile'],
 	aliases: ['Ruby', 'rb'],
-	loader: () => import('./ruby')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/ruby/ruby'], resolve, reject);
+			});
+		} else {
+			return import('./ruby');
+		}
+	}
 });

monaco-languages/src/rust/rust.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'rust',
 	extensions: ['.rs', '.rlib'],
 	aliases: ['Rust', 'rust'],
-	loader: () => import('./rust')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/rust/rust'], resolve, reject);
+			});
+		} else {
+			return import('./rust');
+		}
+	}
 });

monaco-languages/src/sb/sb.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'sb',
 	extensions: ['.sb'],
 	aliases: ['Small Basic', 'sb'],
-	loader: () => import('./sb')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/sb/sb'], resolve, reject);
+			});
+		} else {
+			return import('./sb');
+		}
+	}
 });

monaco-languages/src/scala/scala.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'scala',
 	extensions: ['.scala', '.sc', '.sbt'],
 	aliases: ['Scala', 'scala', 'SBT', 'Sbt', 'sbt', 'Dotty', 'dotty'],
 	mimetypes: ['text/x-scala-source', 'text/x-scala', 'text/x-sbt', 'text/x-dotty'],
-	loader: () => import('./scala')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/scala/scala'], resolve, reject);
+			});
+		} else {
+			return import('./scala');
+		}
+	}
 });

monaco-languages/src/scheme/scheme.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'scheme',
 	extensions: ['.scm', '.ss', '.sch', '.rkt'],
 	aliases: ['scheme', 'Scheme'],
-	loader: () => import('./scheme')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/scheme/scheme'], resolve, reject);
+			});
+		} else {
+			return import('./scheme');
+		}
+	}
 });

monaco-languages/src/scss/scss.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'scss',
 	extensions: ['.scss'],
 	aliases: ['Sass', 'sass', 'scss'],
 	mimetypes: ['text/x-scss', 'text/scss'],
-	loader: () => import('./scss')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/scss/scss'], resolve, reject);
+			});
+		} else {
+			return import('./scss');
+		}
+	}
 });

monaco-languages/src/shell/shell.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'shell',
 	extensions: ['.sh', '.bash'],
 	aliases: ['Shell', 'sh'],
-	loader: () => import('./shell')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/shell/shell'], resolve, reject);
+			});
+		} else {
+			return import('./shell');
+		}
+	}
 });

monaco-languages/src/solidity/solidity.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'sol',
 	extensions: ['.sol'],
 	aliases: ['sol', 'solidity', 'Solidity'],
-	loader: () => import('./solidity')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/solidity/solidity'], resolve, reject);
+			});
+		} else {
+			return import('./solidity');
+		}
+	}
 });

monaco-languages/src/sophia/sophia.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'aes',
 	extensions: ['.aes'],
 	aliases: ['aes', 'sophia', 'Sophia'],
-	loader: () => import('./sophia')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/sophia/sophia'], resolve, reject);
+			});
+		} else {
+			return import('./sophia');
+		}
+	}
 });

monaco-languages/src/sparql/sparql.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'sparql',
 	extensions: ['.rq'],
 	aliases: ['sparql', 'SPARQL'],
-	loader: () => import('./sparql')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/sparql/sparql'], resolve, reject);
+			});
+		} else {
+			return import('./sparql');
+		}
+	}
 });

monaco-languages/src/sql/sql.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'sql',
 	extensions: ['.sql'],
 	aliases: ['SQL'],
-	loader: () => import('./sql')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/sql/sql'], resolve, reject);
+			});
+		} else {
+			return import('./sql');
+		}
+	}
 });

monaco-languages/src/st/st.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'st',
 	extensions: ['.st', '.iecst', '.iecplc', '.lc3lib'],
 	aliases: ['StructuredText', 'scl', 'stl'],
-	loader: () => import('./st')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/st/st'], resolve, reject);
+			});
+		} else {
+			return import('./st');
+		}
+	}
 });

monaco-languages/src/swift/swift.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'swift',
 	aliases: ['Swift', 'swift'],
 	extensions: ['.swift'],
 	mimetypes: ['text/swift'],
-	loader: () => import('./swift')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/swift/swift'], resolve, reject);
+			});
+		} else {
+			return import('./swift');
+		}
+	}
 });

monaco-languages/src/systemverilog/systemverilog.contribution.ts

@@ -5,16 +5,35 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'systemverilog',
 	extensions: ['.sv', '.svh'],
 	aliases: ['SV', 'sv', 'SystemVerilog', 'systemverilog'],
-	loader: () => import('./systemverilog')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/systemverilog/systemverilog'], resolve, reject);
+			});
+		} else {
+			return import('./systemverilog');
+		}
+	}
 });
 
 registerLanguage({
 	id: 'verilog',
 	extensions: ['.v', '.vh'],
 	aliases: ['V', 'v', 'Verilog', 'verilog'],
-	loader: () => import('./systemverilog')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/systemverilog/systemverilog'], resolve, reject);
+			});
+		} else {
+			return import('./systemverilog');
+		}
+	}
 });

monaco-languages/src/tcl/tcl.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'tcl',
 	extensions: ['.tcl'],
 	aliases: ['tcl', 'Tcl', 'tcltk', 'TclTk', 'tcl/tk', 'Tcl/Tk'],
-	loader: () => import('./tcl')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/tcl/tcl'], resolve, reject);
+			});
+		} else {
+			return import('./tcl');
+		}
+	}
 });

monaco-languages/src/tsconfig.esm.json

@@ -1,9 +0,0 @@
-{
-	"compilerOptions": {
-		"module": "esnext",
-		"moduleResolution": "node",
-		"outDir": "../out/esm",
-		"target": "es5",
-		"lib": ["dom", "es5", "es2015.collection", "es2015.iterable", "es2015.promise"]
-	}
-}

monaco-languages/src/twig/twig.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'twig',
 	extensions: ['.twig'],
 	aliases: ['Twig', 'twig'],
 	mimetypes: ['text/x-twig'],
-	loader: () => import('./twig')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/twig/twig'], resolve, reject);
+			});
+		} else {
+			return import('./twig');
+		}
+	}
 });

monaco-languages/src/typescript/typescript.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'typescript',
 	extensions: ['.ts', '.tsx'],
 	aliases: ['TypeScript', 'ts', 'typescript'],
 	mimetypes: ['text/typescript'],
-	loader: () => <Promise<any>>import('./typescript')
+	loader: (): Promise<any> => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/typescript/typescript'], resolve, reject);
+			});
+		} else {
+			return import('./typescript');
+		}
+	}
 });

monaco-languages/src/vb/vb.contribution.ts

@@ -5,9 +5,20 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'vb',
 	extensions: ['.vb'],
 	aliases: ['Visual Basic', 'vb'],
-	loader: () => import('./vb')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/vb/vb'], resolve, reject);
+			});
+		} else {
+			return import('./vb');
+		}
+	}
 });

monaco-languages/src/xml/xml.contribution.ts

@@ -5,6 +5,9 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'xml',
 	extensions: [
@@ -25,5 +28,13 @@ registerLanguage({
 	firstLine: '(\\<\\?xml.*)|(\\<svg)|(\\<\\!doctype\\s+svg)',
 	aliases: ['XML', 'xml'],
 	mimetypes: ['text/xml', 'application/xml', 'application/xaml+xml', 'application/xml-dtd'],
-	loader: () => import('./xml')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/xml/xml'], resolve, reject);
+			});
+		} else {
+			return import('./xml');
+		}
+	}
 });

monaco-languages/src/yaml/yaml.contribution.ts

@@ -5,10 +5,21 @@
 
 import { registerLanguage } from '../_.contribution';
 
+declare var AMD: any;
+declare var require: any;
+
 registerLanguage({
 	id: 'yaml',
 	extensions: ['.yaml', '.yml'],
 	aliases: ['YAML', 'yaml', 'YML', 'yml'],
 	mimetypes: ['application/x-yaml', 'text/x-yaml'],
-	loader: () => import('./yaml')
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/yaml/yaml'], resolve, reject);
+			});
+		} else {
+			return import('./yaml');
+		}
+	}
 });