Inlines AMD = false (#5031)

build/amd/vite.config.js

@@ -21,9 +21,6 @@ export default defineConfig(async (args) => {
 	/** @type {import('vite').UserConfig} */
 	return {
 		base: './',
-		define: {
-			AMD: false
-		},
 		build: {
 			lib: {
 				cssFileName: 'editor/editor.main',

build/build-monaco-editor.ts

@@ -80,9 +80,6 @@ function ESM_release() {
 		target: 'esnext',
 		format: 'esm',
 		drop: ['debugger'],
-		define: {
-			AMD: 'false'
-		},
 		banner: {
 			js: bundledFileHeader
 		},

build/utils.ts

@@ -105,9 +105,6 @@ export function buildESM(options: { base: string; entryPoints: string[]; externa
 		target: 'esnext',
 		format: 'esm',
 		drop: ['debugger'],
-		define: {
-			AMD: 'false'
-		},
 		banner: {
 			js: bundledFileHeader
 		},

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./apex')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/apex/apex'], resolve, reject);
-			});
-		} else {
-			return import('./apex');
-		}
-	}
 });

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

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

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

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

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

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

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

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

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./coffee')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/coffee/coffee'], resolve, reject);
-			});
-		} else {
-			return import('./coffee');
-		}
-	}
 });

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

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

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

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

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

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

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

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

src/basic-languages/cypher/cypher.contribution.ts

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./dart')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/dart/dart'], resolve, reject);
-			});
-		} else {
-			return import('./dart');
-		}
-	}
 });

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

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

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

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

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

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

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

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

src/basic-languages/freemarker2/freemarker2.contribution.ts

@@ -5,9 +5,6 @@
 
 import { registerLanguage } from '../_.contribution';
 
-declare var AMD: any;
-declare var require: any;
-
 // freemarker.tag-square.interpolation-dollar is the default
 // According the docs tag-auto will be the default for version 2.4+, but that
 // hasn't event been released yet.
@@ -16,96 +13,54 @@ registerLanguage({
 	extensions: ['.ftl', '.ftlh', '.ftlx'],
 	aliases: ['FreeMarker2', 'Apache FreeMarker2'],
 	loader: () => {
-		if (AMD) {
-			return new Promise<typeof import('./freemarker2')>((resolve, reject) => {
-				require(['vs/basic-languages/freemarker2/freemarker2'], resolve, reject);
-			}).then((m) => m.TagAngleInterpolationDollar);
-		} else {
 		return import('./freemarker2').then((m) => m.TagAutoInterpolationDollar);
 	}
-	}
 });
 
 registerLanguage({
 	id: 'freemarker2.tag-angle.interpolation-dollar',
 	aliases: ['FreeMarker2 (Angle/Dollar)', 'Apache FreeMarker2 (Angle/Dollar)'],
 	loader: () => {
-		if (AMD) {
-			return new Promise<typeof import('./freemarker2')>((resolve, reject) => {
-				require(['vs/basic-languages/freemarker2/freemarker2'], resolve, reject);
-			}).then((m) => m.TagAngleInterpolationDollar);
-		} else {
 		return import('./freemarker2').then((m) => m.TagAngleInterpolationDollar);
 	}
-	}
 });
 
 registerLanguage({
 	id: 'freemarker2.tag-bracket.interpolation-dollar',
 	aliases: ['FreeMarker2 (Bracket/Dollar)', 'Apache FreeMarker2 (Bracket/Dollar)'],
 	loader: () => {
-		if (AMD) {
-			return new Promise<typeof import('./freemarker2')>((resolve, reject) => {
-				require(['vs/basic-languages/freemarker2/freemarker2'], resolve, reject);
-			}).then((m) => m.TagBracketInterpolationDollar);
-		} else {
 		return import('./freemarker2').then((m) => m.TagBracketInterpolationDollar);
 	}
-	}
 });
 
 registerLanguage({
 	id: 'freemarker2.tag-angle.interpolation-bracket',
 	aliases: ['FreeMarker2 (Angle/Bracket)', 'Apache FreeMarker2 (Angle/Bracket)'],
 	loader: () => {
-		if (AMD) {
-			return new Promise<typeof import('./freemarker2')>((resolve, reject) => {
-				require(['vs/basic-languages/freemarker2/freemarker2'], resolve, reject);
-			}).then((m) => m.TagAngleInterpolationBracket);
-		} else {
 		return import('./freemarker2').then((m) => m.TagAngleInterpolationBracket);
 	}
-	}
 });
 
 registerLanguage({
 	id: 'freemarker2.tag-bracket.interpolation-bracket',
 	aliases: ['FreeMarker2 (Bracket/Bracket)', 'Apache FreeMarker2 (Bracket/Bracket)'],
 	loader: () => {
-		if (AMD) {
-			return new Promise<typeof import('./freemarker2')>((resolve, reject) => {
-				require(['vs/basic-languages/freemarker2/freemarker2'], resolve, reject);
-			}).then((m) => m.TagBracketInterpolationBracket);
-		} else {
 		return import('./freemarker2').then((m) => m.TagBracketInterpolationBracket);
 	}
-	}
 });
 
 registerLanguage({
 	id: 'freemarker2.tag-auto.interpolation-dollar',
 	aliases: ['FreeMarker2 (Auto/Dollar)', 'Apache FreeMarker2 (Auto/Dollar)'],
 	loader: () => {
-		if (AMD) {
-			return new Promise<typeof import('./freemarker2')>((resolve, reject) => {
-				require(['vs/basic-languages/freemarker2/freemarker2'], resolve, reject);
-			}).then((m) => m.TagAutoInterpolationDollar);
-		} else {
 		return import('./freemarker2').then((m) => m.TagAutoInterpolationDollar);
 	}
-	}
 });
 
 registerLanguage({
 	id: 'freemarker2.tag-auto.interpolation-bracket',
 	aliases: ['FreeMarker2 (Auto/Bracket)', 'Apache FreeMarker2 (Auto/Bracket)'],
 	loader: () => {
-		if (AMD) {
-			return new Promise<typeof import('./freemarker2')>((resolve, reject) => {
-				require(['vs/basic-languages/freemarker2/freemarker2'], resolve, reject);
-			}).then((m) => m.TagAutoInterpolationBracket);
-		} else {
 		return import('./freemarker2').then((m) => m.TagAutoInterpolationBracket);
 	}
-	}
 });

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

@@ -5,20 +5,9 @@
 
 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: () => {
+	loader: () => import('./fsharp')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/fsharp/fsharp'], resolve, reject);
-			});
-		} else {
-			return import('./fsharp');
-		}
-	}
 });

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./graphql')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/graphql/graphql'], resolve, reject);
-			});
-		} else {
-			return import('./graphql');
-		}
-	}
 });

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./handlebars')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/handlebars/handlebars'], resolve, reject);
-			});
-		} else {
-			return import('./handlebars');
-		}
-	}
 });

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

@@ -5,20 +5,9 @@
 
 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: () => {
+	loader: () => import('./hcl')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/hcl/hcl'], resolve, reject);
-			});
-		} else {
-			return import('./hcl');
-		}
-	}
 });

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./html')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/html/html'], resolve, reject);
-			});
-		} else {
-			return import('./html');
-		}
-	}
 });

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./ini')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/ini/ini'], resolve, reject);
-			});
-		} else {
-			return import('./ini');
-		}
-	}
 });

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./java')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/java/java'], resolve, reject);
-			});
-		} else {
-			return import('./java');
-		}
-	}
 });

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

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

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

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

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./less')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/less/less'], resolve, reject);
-			});
-		} else {
-			return import('./less');
-		}
-	}
 });

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./liquid')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/liquid/liquid'], resolve, reject);
-			});
-		} else {
-			return import('./liquid');
-		}
-	}
 });

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

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

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

@@ -5,20 +5,9 @@
 
 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: () => {
+	loader: () => import('./m3')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/m3/m3'], resolve, reject);
-			});
-		} else {
-			return import('./m3');
-		}
-	}
 });

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

@@ -5,20 +5,9 @@
 
 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: () => {
+	loader: () => import('./markdown')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/markdown/markdown'], resolve, reject);
-			});
-		} else {
-			return import('./markdown');
-		}
-	}
 });

src/basic-languages/mdx/mdx.contribution.ts

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./mips')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/mips/mips'], resolve, reject);
-			});
-		} else {
-			return import('./mips');
-		}
-	}
 });

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

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

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

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

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./pascal')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/pascal/pascal'], resolve, reject);
-			});
-		} else {
-			return import('./pascal');
-		}
-	}
 });

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

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

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

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

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./php')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/php/php'], resolve, reject);
-			});
-		} else {
-			return import('./php');
-		}
-	}
 });

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

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

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

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

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

@@ -5,20 +5,9 @@
 
 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: () => {
+	loader: () => import('./powerquery')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/powerquery/powerquery'], resolve, reject);
-			});
-		} else {
-			return import('./powerquery');
-		}
-	}
 });

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

@@ -5,20 +5,9 @@
 
 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: () => {
+	loader: () => import('./powershell')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/powershell/powershell'], resolve, reject);
-			});
-		} else {
-			return import('./powershell');
-		}
-	}
 });

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

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

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./python')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/python/python'], resolve, reject);
-			});
-		} else {
-			return import('./python');
-		}
-	}
 });

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

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

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

@@ -5,20 +5,9 @@
 
 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: () => {
+	loader: () => import('./r')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/r/r'], resolve, reject);
-			});
-		} else {
-			return import('./r');
-		}
-	}
 });

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./razor')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/razor/razor'], resolve, reject);
-			});
-		} else {
-			return import('./razor');
-		}
-	}
 });

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

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

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

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

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./ruby')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/ruby/ruby'], resolve, reject);
-			});
-		} else {
-			return import('./ruby');
-		}
-	}
 });

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

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

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./scala')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/scala/scala'], resolve, reject);
-			});
-		} else {
-			return import('./scala');
-		}
-	}
 });

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./scss')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/scss/scss'], resolve, reject);
-			});
-		} else {
-			return import('./scss');
-		}
-	}
 });

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -5,20 +5,9 @@
 
 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: () => {
+	loader: () => import('./tcl')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/tcl/tcl'], resolve, reject);
-			});
-		} else {
-			return import('./tcl');
-		}
-	}
 });

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./twig')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/twig/twig'], resolve, reject);
-			});
-		} else {
-			return import('./twig');
-		}
-	}
 });

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

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

src/basic-languages/typespec/typespec.contribution.ts

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

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

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

src/basic-languages/wgsl/wgsl.contribution.ts

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

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

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

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

@@ -5,21 +5,10 @@
 
 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: () => {
+	loader: () => import('./yaml')
-		if (AMD) {
-			return new Promise((resolve, reject) => {
-				require(['vs/basic-languages/yaml/yaml'], resolve, reject);
-			});
-		} else {
-			return import('./yaml');
-		}
-	}
 });

src/language/css/monaco.contribution.ts

@@ -258,17 +258,8 @@ export const lessDefaults: LanguageServiceDefaults = new LanguageServiceDefaults
 
 // --- Registration to monaco editor ---
 
-declare var AMD: any;
-declare var require: any;
-
 function getMode(): Promise<typeof mode> {
-	if (AMD) {
-		return new Promise((resolve, reject) => {
-			require(['vs/language/css/cssMode'], resolve, reject);
-		});
-	} else {
 	return import('./cssMode');
-	}
 }
 
 languages.onLanguage('less', () => {

src/language/html/monaco.contribution.ts

@@ -228,17 +228,8 @@ export const razorDefaults = razorLanguageService.defaults;
 
 // --- Registration to monaco editor ---
 
-declare var AMD: any;
-declare var require: any;
-
 function getMode(): Promise<typeof mode> {
-	if (AMD) {
-		return new Promise((resolve, reject) => {
-			require(['vs/language/html/htmlMode'], resolve, reject);
-		});
-	} else {
 	return import('./htmlMode');
-	}
 }
 
 export interface LanguageServiceRegistration extends IDisposable {

src/language/json/monaco.contribution.ts

@@ -347,17 +347,8 @@ export const getWorker = (): Promise<(...uris: Uri[]) => Promise<IJSONWorker>> =
 
 // --- Registration to monaco editor ---
 
-declare var AMD: any;
-declare var require: any;
-
 function getMode(): Promise<typeof mode> {
-	if (AMD) {
-		return new Promise((resolve, reject) => {
-			require(['vs/language/json/jsonMode'], resolve, reject);
-		});
-	} else {
 	return import('./jsonMode');
-	}
 }
 
 languages.register({

src/language/typescript/monaco.contribution.ts

@@ -794,17 +794,8 @@ export const getJavaScriptWorker = (): Promise<(...uris: Uri[]) => Promise<TypeS
 
 // --- Registration to monaco editor ---
 
-declare var AMD: any;
-declare var require: any;
-
 function getMode(): Promise<typeof mode> {
-	if (AMD) {
-		return new Promise((resolve, reject) => {
-			require(['vs/language/typescript/tsMode'], resolve, reject);
-		});
-	} else {
 	return import('./tsMode');
-	}
 }
 
 languages.onLanguage('typescript', () => {

test/manual/dev-setup.js

@@ -68,8 +68,6 @@
 		PATH_PREFIX = PATH_PREFIX || '';
 
 		loadScript(`${PATH_PREFIX}${corePath}/loader.js`, () => {
-			global.AMD = true;
-
 			/** @type {{[name:string]: string;}} */
 			const loaderPathsConfig = {};
 			if (isRelease) {