From 0c394c0c7cb8451abdb819622cf9531c0780580e Mon Sep 17 00:00:00 2001 From: Alexandru Dima Date: Fri, 12 Nov 2021 12:48:50 +0100 Subject: [PATCH] Adopt `esbuild` for `monaco-languages` --- build/utils.js | 2 + monaco-languages/build.js | 54 +++++++++++++++++++ monaco-languages/package.json | 4 +- .../src/abap/abap.contribution.ts | 13 ++++- .../src/apex/apex.contribution.ts | 13 ++++- .../src/azcli/azcli.contribution.ts | 13 ++++- monaco-languages/src/bat/bat.contribution.ts | 13 ++++- .../src/bicep/bicep.contribution.ts | 13 ++++- .../src/cameligo/cameligo.contribution.ts | 13 ++++- .../src/clojure/clojure.contribution.ts | 13 ++++- .../src/coffee/coffee.contribution.ts | 13 ++++- monaco-languages/src/cpp/cpp.contribution.ts | 23 +++++++- .../src/csharp/csharp.contribution.ts | 13 ++++- monaco-languages/src/csp/csp.contribution.ts | 13 ++++- monaco-languages/src/css/css.contribution.ts | 13 ++++- .../src/dart/dart.contribution.ts | 13 ++++- .../src/dockerfile/dockerfile.contribution.ts | 13 ++++- monaco-languages/src/ecl/ecl.contribution.ts | 13 ++++- .../src/elixir/elixir.contribution.ts | 13 ++++- .../src/fillers/monaco-editor-core-amd.ts | 12 ----- .../src/flow9/flow9.contribution.ts | 13 ++++- .../src/fsharp/fsharp.contribution.ts | 13 ++++- monaco-languages/src/go/go.contribution.ts | 13 ++++- .../src/graphql/graphql.contribution.ts | 13 ++++- .../src/handlebars/handlebars.contribution.ts | 13 ++++- monaco-languages/src/hcl/hcl.contribution.ts | 13 ++++- .../src/html/html.contribution.ts | 13 ++++- monaco-languages/src/ini/ini.contribution.ts | 13 ++++- .../src/java/java.contribution.ts | 13 ++++- .../src/javascript/javascript.contribution.ts | 13 ++++- .../src/julia/julia.contribution.ts | 13 ++++- .../src/kotlin/kotlin.contribution.ts | 13 ++++- .../src/less/less.contribution.ts | 13 ++++- .../src/lexon/lexon.contribution.ts | 13 ++++- .../src/liquid/liquid.contribution.ts | 13 ++++- monaco-languages/src/lua/lua.contribution.ts | 13 ++++- monaco-languages/src/m3/m3.contribution.ts | 13 ++++- .../src/markdown/markdown.contribution.ts | 13 ++++- .../src/mips/mips.contribution.ts | 13 ++++- .../src/msdax/msdax.contribution.ts | 13 ++++- .../src/mysql/mysql.contribution.ts | 13 ++++- .../objective-c/objective-c.contribution.ts | 13 ++++- .../src/pascal/pascal.contribution.ts | 13 ++++- .../src/pascaligo/pascaligo.contribution.ts | 13 ++++- .../src/perl/perl.contribution.ts | 13 ++++- .../src/pgsql/pgsql.contribution.ts | 13 ++++- monaco-languages/src/php/php.contribution.ts | 13 ++++- monaco-languages/src/pla/pla.contribution.ts | 13 ++++- .../src/postiats/postiats.contribution.ts | 13 ++++- .../src/powerquery/powerquery.contribution.ts | 13 ++++- .../src/powershell/powershell.contribution.ts | 13 ++++- .../src/protobuf/protobuf.contribution.ts | 13 ++++- monaco-languages/src/pug/pug.contribution.ts | 13 ++++- .../src/python/python.contribution.ts | 13 ++++- .../src/qsharp/qsharp.contribution.ts | 13 ++++- monaco-languages/src/r/r.contribution.ts | 13 ++++- .../src/razor/razor.contribution.ts | 13 ++++- .../src/redis/redis.contribution.ts | 13 ++++- .../src/redshift/redshift.contribution.ts | 13 ++++- .../restructuredtext.contribution.ts | 13 ++++- .../src/ruby/ruby.contribution.ts | 13 ++++- .../src/rust/rust.contribution.ts | 13 ++++- monaco-languages/src/sb/sb.contribution.ts | 13 ++++- .../src/scala/scala.contribution.ts | 13 ++++- .../src/scheme/scheme.contribution.ts | 13 ++++- .../src/scss/scss.contribution.ts | 13 ++++- .../src/shell/shell.contribution.ts | 13 ++++- .../src/solidity/solidity.contribution.ts | 13 ++++- .../src/sophia/sophia.contribution.ts | 13 ++++- .../src/sparql/sparql.contribution.ts | 13 ++++- monaco-languages/src/sql/sql.contribution.ts | 13 ++++- monaco-languages/src/st/st.contribution.ts | 13 ++++- .../src/swift/swift.contribution.ts | 13 ++++- .../systemverilog.contribution.ts | 23 +++++++- monaco-languages/src/tcl/tcl.contribution.ts | 13 ++++- monaco-languages/src/tsconfig.esm.json | 9 ---- .../src/twig/twig.contribution.ts | 13 ++++- .../src/typescript/typescript.contribution.ts | 13 ++++- monaco-languages/src/vb/vb.contribution.ts | 13 ++++- monaco-languages/src/xml/xml.contribution.ts | 13 ++++- .../src/yaml/yaml.contribution.ts | 13 ++++- 81 files changed, 987 insertions(+), 102 deletions(-) create mode 100644 monaco-languages/build.js delete mode 100644 monaco-languages/src/fillers/monaco-editor-core-amd.ts delete mode 100644 monaco-languages/src/tsconfig.esm.json diff --git a/build/utils.js b/build/utils.js index e5543fc6..26579a52 100644 --- a/build/utils.js +++ b/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({ diff --git a/monaco-languages/build.js b/monaco-languages/build.js new file mode 100644 index 00000000..e037c98e --- /dev/null +++ b/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}",[],()=>{` + }) + } + } +}); diff --git a/monaco-languages/package.json b/monaco-languages/package.json index b2f30805..c55b4b4d 100644 --- a/monaco-languages/package.json +++ b/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" } } diff --git a/monaco-languages/src/abap/abap.contribution.ts b/monaco-languages/src/abap/abap.contribution.ts index c515f9d2..549e1980 100644 --- a/monaco-languages/src/abap/abap.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/apex/apex.contribution.ts b/monaco-languages/src/apex/apex.contribution.ts index 58e86d59..89d0dfbf 100644 --- a/monaco-languages/src/apex/apex.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/azcli/azcli.contribution.ts b/monaco-languages/src/azcli/azcli.contribution.ts index b0f5bcc1..2eb7b19c 100644 --- a/monaco-languages/src/azcli/azcli.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/bat/bat.contribution.ts b/monaco-languages/src/bat/bat.contribution.ts index bc9cdd1f..7e4f7758 100644 --- a/monaco-languages/src/bat/bat.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/bicep/bicep.contribution.ts b/monaco-languages/src/bicep/bicep.contribution.ts index ae9837ec..7c5fd6b8 100644 --- a/monaco-languages/src/bicep/bicep.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/cameligo/cameligo.contribution.ts b/monaco-languages/src/cameligo/cameligo.contribution.ts index 07c7ec2e..8bfa0009 100644 --- a/monaco-languages/src/cameligo/cameligo.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/clojure/clojure.contribution.ts b/monaco-languages/src/clojure/clojure.contribution.ts index 139424ba..e6d8a1f3 100644 --- a/monaco-languages/src/clojure/clojure.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/coffee/coffee.contribution.ts b/monaco-languages/src/coffee/coffee.contribution.ts index 6af9a015..e36711d1 100644 --- a/monaco-languages/src/coffee/coffee.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/cpp/cpp.contribution.ts b/monaco-languages/src/cpp/cpp.contribution.ts index 523f4207..51a874d1 100644 --- a/monaco-languages/src/cpp/cpp.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/csharp/csharp.contribution.ts b/monaco-languages/src/csharp/csharp.contribution.ts index 06e44f0d..08498216 100644 --- a/monaco-languages/src/csharp/csharp.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/csp/csp.contribution.ts b/monaco-languages/src/csp/csp.contribution.ts index 59a7be78..1175ab99 100644 --- a/monaco-languages/src/csp/csp.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/css/css.contribution.ts b/monaco-languages/src/css/css.contribution.ts index 88d089fa..6352c221 100644 --- a/monaco-languages/src/css/css.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/dart/dart.contribution.ts b/monaco-languages/src/dart/dart.contribution.ts index 7b3cff5e..e2daa614 100644 --- a/monaco-languages/src/dart/dart.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/dockerfile/dockerfile.contribution.ts b/monaco-languages/src/dockerfile/dockerfile.contribution.ts index 51c73e3d..9869a595 100644 --- a/monaco-languages/src/dockerfile/dockerfile.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/ecl/ecl.contribution.ts b/monaco-languages/src/ecl/ecl.contribution.ts index dfa4ed90..638227ee 100644 --- a/monaco-languages/src/ecl/ecl.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/elixir/elixir.contribution.ts b/monaco-languages/src/elixir/elixir.contribution.ts index aaeafa94..38927938 100644 --- a/monaco-languages/src/elixir/elixir.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/fillers/monaco-editor-core-amd.ts b/monaco-languages/src/fillers/monaco-editor-core-amd.ts deleted file mode 100644 index 6af108be..00000000 --- a/monaco-languages/src/fillers/monaco-editor-core-amd.ts +++ /dev/null @@ -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 (self).monaco; -}); diff --git a/monaco-languages/src/flow9/flow9.contribution.ts b/monaco-languages/src/flow9/flow9.contribution.ts index 649114b4..0c2fc8ca 100644 --- a/monaco-languages/src/flow9/flow9.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/fsharp/fsharp.contribution.ts b/monaco-languages/src/fsharp/fsharp.contribution.ts index d754dde5..cad832f1 100644 --- a/monaco-languages/src/fsharp/fsharp.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/go/go.contribution.ts b/monaco-languages/src/go/go.contribution.ts index 1ee8d4bb..353a5bd3 100644 --- a/monaco-languages/src/go/go.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/graphql/graphql.contribution.ts b/monaco-languages/src/graphql/graphql.contribution.ts index 7fa911c9..3f77dc27 100644 --- a/monaco-languages/src/graphql/graphql.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/handlebars/handlebars.contribution.ts b/monaco-languages/src/handlebars/handlebars.contribution.ts index 68481549..9195c7e5 100644 --- a/monaco-languages/src/handlebars/handlebars.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/hcl/hcl.contribution.ts b/monaco-languages/src/hcl/hcl.contribution.ts index 116f4fc6..38a1165c 100644 --- a/monaco-languages/src/hcl/hcl.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/html/html.contribution.ts b/monaco-languages/src/html/html.contribution.ts index 3a943078..2bed4d8c 100644 --- a/monaco-languages/src/html/html.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/ini/ini.contribution.ts b/monaco-languages/src/ini/ini.contribution.ts index 7ca9805f..1944a883 100644 --- a/monaco-languages/src/ini/ini.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/java/java.contribution.ts b/monaco-languages/src/java/java.contribution.ts index 0254c6e5..35933718 100644 --- a/monaco-languages/src/java/java.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/javascript/javascript.contribution.ts b/monaco-languages/src/javascript/javascript.contribution.ts index 622ce789..56a7cdb5 100644 --- a/monaco-languages/src/javascript/javascript.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/julia/julia.contribution.ts b/monaco-languages/src/julia/julia.contribution.ts index 76f2780e..b25f2506 100644 --- a/monaco-languages/src/julia/julia.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/kotlin/kotlin.contribution.ts b/monaco-languages/src/kotlin/kotlin.contribution.ts index 0faa5ab6..67e95746 100644 --- a/monaco-languages/src/kotlin/kotlin.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/less/less.contribution.ts b/monaco-languages/src/less/less.contribution.ts index ed5b380a..cfcffea8 100644 --- a/monaco-languages/src/less/less.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/lexon/lexon.contribution.ts b/monaco-languages/src/lexon/lexon.contribution.ts index 3ff3b84f..a56609e5 100644 --- a/monaco-languages/src/lexon/lexon.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/liquid/liquid.contribution.ts b/monaco-languages/src/liquid/liquid.contribution.ts index e4c14a62..80f2134e 100644 --- a/monaco-languages/src/liquid/liquid.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/lua/lua.contribution.ts b/monaco-languages/src/lua/lua.contribution.ts index f88a08d5..395c8237 100644 --- a/monaco-languages/src/lua/lua.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/m3/m3.contribution.ts b/monaco-languages/src/m3/m3.contribution.ts index bbb84fb1..6e2cbd34 100644 --- a/monaco-languages/src/m3/m3.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/markdown/markdown.contribution.ts b/monaco-languages/src/markdown/markdown.contribution.ts index e13fd47e..18583a4c 100644 --- a/monaco-languages/src/markdown/markdown.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/mips/mips.contribution.ts b/monaco-languages/src/mips/mips.contribution.ts index e115abee..2fb0f63c 100644 --- a/monaco-languages/src/mips/mips.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/msdax/msdax.contribution.ts b/monaco-languages/src/msdax/msdax.contribution.ts index b1737dab..a9e25c82 100644 --- a/monaco-languages/src/msdax/msdax.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/mysql/mysql.contribution.ts b/monaco-languages/src/mysql/mysql.contribution.ts index c8f12626..23c04ea2 100644 --- a/monaco-languages/src/mysql/mysql.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/objective-c/objective-c.contribution.ts b/monaco-languages/src/objective-c/objective-c.contribution.ts index 27c4db39..f397fbc3 100644 --- a/monaco-languages/src/objective-c/objective-c.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/pascal/pascal.contribution.ts b/monaco-languages/src/pascal/pascal.contribution.ts index 62babbee..7aebf79c 100644 --- a/monaco-languages/src/pascal/pascal.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/pascaligo/pascaligo.contribution.ts b/monaco-languages/src/pascaligo/pascaligo.contribution.ts index 58cc0bb8..1d7e0922 100644 --- a/monaco-languages/src/pascaligo/pascaligo.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/perl/perl.contribution.ts b/monaco-languages/src/perl/perl.contribution.ts index d4458649..f0ac9ce2 100644 --- a/monaco-languages/src/perl/perl.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/pgsql/pgsql.contribution.ts b/monaco-languages/src/pgsql/pgsql.contribution.ts index 1eff0966..a4e825e0 100644 --- a/monaco-languages/src/pgsql/pgsql.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/php/php.contribution.ts b/monaco-languages/src/php/php.contribution.ts index 51b28a8b..b9f3b569 100644 --- a/monaco-languages/src/php/php.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/pla/pla.contribution.ts b/monaco-languages/src/pla/pla.contribution.ts index 9a3b13e9..8bf7695b 100644 --- a/monaco-languages/src/pla/pla.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/postiats/postiats.contribution.ts b/monaco-languages/src/postiats/postiats.contribution.ts index a57faf37..037c624f 100644 --- a/monaco-languages/src/postiats/postiats.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/powerquery/powerquery.contribution.ts b/monaco-languages/src/powerquery/powerquery.contribution.ts index 2c2b84a5..2e1f77a9 100644 --- a/monaco-languages/src/powerquery/powerquery.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/powershell/powershell.contribution.ts b/monaco-languages/src/powershell/powershell.contribution.ts index ad2878e5..0e5096f7 100644 --- a/monaco-languages/src/powershell/powershell.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/protobuf/protobuf.contribution.ts b/monaco-languages/src/protobuf/protobuf.contribution.ts index 3741ba94..5a974827 100644 --- a/monaco-languages/src/protobuf/protobuf.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/pug/pug.contribution.ts b/monaco-languages/src/pug/pug.contribution.ts index d097ee30..07f7b733 100644 --- a/monaco-languages/src/pug/pug.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/python/python.contribution.ts b/monaco-languages/src/python/python.contribution.ts index 47969bdb..82985dd8 100644 --- a/monaco-languages/src/python/python.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/qsharp/qsharp.contribution.ts b/monaco-languages/src/qsharp/qsharp.contribution.ts index 09c59b38..111678bb 100644 --- a/monaco-languages/src/qsharp/qsharp.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/r/r.contribution.ts b/monaco-languages/src/r/r.contribution.ts index d8062665..07bcb334 100644 --- a/monaco-languages/src/r/r.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/razor/razor.contribution.ts b/monaco-languages/src/razor/razor.contribution.ts index 57c2d479..94017d3c 100644 --- a/monaco-languages/src/razor/razor.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/redis/redis.contribution.ts b/monaco-languages/src/redis/redis.contribution.ts index 5bf1367f..c0f55bd6 100644 --- a/monaco-languages/src/redis/redis.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/redshift/redshift.contribution.ts b/monaco-languages/src/redshift/redshift.contribution.ts index 419b9203..4287adb4 100644 --- a/monaco-languages/src/redshift/redshift.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/restructuredtext/restructuredtext.contribution.ts b/monaco-languages/src/restructuredtext/restructuredtext.contribution.ts index 28c77b34..b8a937e1 100644 --- a/monaco-languages/src/restructuredtext/restructuredtext.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/ruby/ruby.contribution.ts b/monaco-languages/src/ruby/ruby.contribution.ts index 8c97bc7d..9fe76b1f 100644 --- a/monaco-languages/src/ruby/ruby.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/rust/rust.contribution.ts b/monaco-languages/src/rust/rust.contribution.ts index 972f6b15..e09006d2 100644 --- a/monaco-languages/src/rust/rust.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/sb/sb.contribution.ts b/monaco-languages/src/sb/sb.contribution.ts index c2e8777f..91448eca 100644 --- a/monaco-languages/src/sb/sb.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/scala/scala.contribution.ts b/monaco-languages/src/scala/scala.contribution.ts index ec15ca9f..b39b022b 100644 --- a/monaco-languages/src/scala/scala.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/scheme/scheme.contribution.ts b/monaco-languages/src/scheme/scheme.contribution.ts index f2793760..959610c7 100644 --- a/monaco-languages/src/scheme/scheme.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/scss/scss.contribution.ts b/monaco-languages/src/scss/scss.contribution.ts index 1c5b99a0..09589f4a 100644 --- a/monaco-languages/src/scss/scss.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/shell/shell.contribution.ts b/monaco-languages/src/shell/shell.contribution.ts index 3e899a08..be7fd3e1 100644 --- a/monaco-languages/src/shell/shell.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/solidity/solidity.contribution.ts b/monaco-languages/src/solidity/solidity.contribution.ts index 5f2837f6..80bb12fb 100644 --- a/monaco-languages/src/solidity/solidity.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/sophia/sophia.contribution.ts b/monaco-languages/src/sophia/sophia.contribution.ts index 0190f17e..80f744a5 100644 --- a/monaco-languages/src/sophia/sophia.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/sparql/sparql.contribution.ts b/monaco-languages/src/sparql/sparql.contribution.ts index 3a581e3e..830f4043 100644 --- a/monaco-languages/src/sparql/sparql.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/sql/sql.contribution.ts b/monaco-languages/src/sql/sql.contribution.ts index 5d20439d..ccfae915 100644 --- a/monaco-languages/src/sql/sql.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/st/st.contribution.ts b/monaco-languages/src/st/st.contribution.ts index 9371182d..e94b9b67 100644 --- a/monaco-languages/src/st/st.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/swift/swift.contribution.ts b/monaco-languages/src/swift/swift.contribution.ts index 3fa39b88..14228182 100644 --- a/monaco-languages/src/swift/swift.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/systemverilog/systemverilog.contribution.ts b/monaco-languages/src/systemverilog/systemverilog.contribution.ts index f8fbfc7f..37a942d0 100644 --- a/monaco-languages/src/systemverilog/systemverilog.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/tcl/tcl.contribution.ts b/monaco-languages/src/tcl/tcl.contribution.ts index dca4c4f8..7535b9cc 100644 --- a/monaco-languages/src/tcl/tcl.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/tsconfig.esm.json b/monaco-languages/src/tsconfig.esm.json deleted file mode 100644 index a159d132..00000000 --- a/monaco-languages/src/tsconfig.esm.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "compilerOptions": { - "module": "esnext", - "moduleResolution": "node", - "outDir": "../out/esm", - "target": "es5", - "lib": ["dom", "es5", "es2015.collection", "es2015.iterable", "es2015.promise"] - } -} diff --git a/monaco-languages/src/twig/twig.contribution.ts b/monaco-languages/src/twig/twig.contribution.ts index 2aa4d53c..0a758d37 100644 --- a/monaco-languages/src/twig/twig.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/typescript/typescript.contribution.ts b/monaco-languages/src/typescript/typescript.contribution.ts index 49590b9d..eaec2a91 100644 --- a/monaco-languages/src/typescript/typescript.contribution.ts +++ b/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: () => >import('./typescript') + loader: (): Promise => { + if (AMD) { + return new Promise((resolve, reject) => { + require(['vs/basic-languages/typescript/typescript'], resolve, reject); + }); + } else { + return import('./typescript'); + } + } }); diff --git a/monaco-languages/src/vb/vb.contribution.ts b/monaco-languages/src/vb/vb.contribution.ts index 9cf06059..383e3c85 100644 --- a/monaco-languages/src/vb/vb.contribution.ts +++ b/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'); + } + } }); diff --git a/monaco-languages/src/xml/xml.contribution.ts b/monaco-languages/src/xml/xml.contribution.ts index 53fb69ad..e274e640 100644 --- a/monaco-languages/src/xml/xml.contribution.ts +++ b/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.*)|(\\ import('./xml') + loader: () => { + if (AMD) { + return new Promise((resolve, reject) => { + require(['vs/basic-languages/xml/xml'], resolve, reject); + }); + } else { + return import('./xml'); + } + } }); diff --git a/monaco-languages/src/yaml/yaml.contribution.ts b/monaco-languages/src/yaml/yaml.contribution.ts index ff941e0f..db8cf27f 100644 --- a/monaco-languages/src/yaml/yaml.contribution.ts +++ b/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'); + } + } });