diff --git a/scripts/build.js b/scripts/build.js
index 90e5b6023f..d7bfa8b37c 100644
--- a/scripts/build.js
+++ b/scripts/build.js
@@ -157,13 +157,6 @@ const esmBuild = () =>
       'headless.ts',
       'templates/starter/index.ts',
       'editor/monaco/monaco.ts',
-      'editor/monaco/languages/monaco-lang-astro.ts',
-      'editor/monaco/languages/monaco-lang-clio.ts',
-      'editor/monaco/languages/monaco-lang-imba.ts',
-      'editor/monaco/languages/monaco-lang-minizinc.ts',
-      'editor/monaco/languages/monaco-lang-prolog.ts',
-      // 'editor/monaco/languages/monaco-lang-sql.ts',
-      'editor/monaco/languages/monaco-lang-wat.ts',
       'editor/codemirror/codemirror.ts',
       'editor/codejar/codejar.ts',
       'editor/blockly/blockly.ts',
diff --git a/src/livecodes/compiler/compile.worker.ts b/src/livecodes/compiler/compile.worker.ts
index 34180d33f4..b611303604 100644
--- a/src/livecodes/compiler/compile.worker.ts
+++ b/src/livecodes/compiler/compile.worker.ts
@@ -1,6 +1,6 @@
 import type TS from 'typescript';
 import { getCompilerOptions } from '../editor/ts-compiler-options';
-import { languages, processors } from '../languages';
+import { getLanguageSpecs, languages, processors } from '../languages';
 import type {
   CompileOptions,
   CompileResult,
@@ -288,7 +288,10 @@ const initCodemirrorTS = doOnce(async () => {
   );
   const system = createSystem(tsvfsMap);
   const createTypeScriptEnvironment = (lang: Language) => {
-    const compilerOpts = getCompilerOptions(lang);
+    const compilerOpts = {
+      ...getCompilerOptions(),
+      ...((getLanguageSpecs(lang)?.editorSupport?.compilerOptions || {}) as TS.CompilerOptions),
+    };
     return createVirtualTypeScriptEnvironment(system, [], worker.ts, compilerOpts);
   };
   const language = codemirrorWorker.language || 'tsx';
diff --git a/src/livecodes/core.ts b/src/livecodes/core.ts
index 89cf9a65c6..8c7fbc3f24 100644
--- a/src/livecodes/core.ts
+++ b/src/livecodes/core.ts
@@ -41,7 +41,6 @@ import {
   upgradeAndValidate,
 } from './config';
 import { createCustomEditors, createEditor, getFontFamily } from './editor';
-import { hasJsx } from './editor/ts-compiler-options';
 import { createEventsManager, createPub } from './events';
 import { customEvents } from './events/custom-events';
 import { exportJSON } from './export/export-json';
@@ -80,6 +79,7 @@ import {
   getLanguageExtension,
   getLanguageSpecs,
   getLanguageTitle,
+  hasJsx,
   languageIsEnabled,
   languages,
   mapLanguage,
@@ -389,7 +389,7 @@ const loadModuleTypes = async (
       ...config.types,
       ...config.customSettings.types,
     };
-    const reactImport = hasJsx.includes(scriptLanguage) ? `import React from 'react';\n` : '';
+    const reactImport = hasJsx(scriptLanguage) ? `import React from 'react';\n` : '';
     const libs = await typeLoader.load(
       reactImport + getConfig().script.content + '\n' + getConfig().markup.content,
       configTypes,
@@ -791,7 +791,7 @@ const configureEditorTools = (language: Language) => {
   UI.getEditorToolbar().classList.remove('hidden');
 
   const langSpecs = getLanguageSpecs(language);
-  if (langSpecs?.formatter || langSpecs?.parser) {
+  if (langSpecs?.formatter) {
     UI.getFormatButton().classList.remove('disabled');
   } else {
     UI.getFormatButton().classList.add('disabled');
diff --git a/src/livecodes/editor/codejar/codejar.ts b/src/livecodes/editor/codejar/codejar.ts
index 400684159a..182496bfec 100644
--- a/src/livecodes/editor/codejar/codejar.ts
+++ b/src/livecodes/editor/codejar/codejar.ts
@@ -38,8 +38,8 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
 
   let { value, language } = options;
   let currentPosition: EditorPosition = { lineNumber: 1 };
-  const mapLanguage = options.mapLanguage || ((lang: Language) => lang);
-  let mappedLanguage = language === 'wat' ? 'wasm' : mapLanguage(language);
+  const mapLanguage = (lang: Language) => options.mapLanguage?.(lang, 'codejar');
+  let mappedLanguage = mapLanguage(language);
   let editorOptions: ReturnType<typeof convertOptions>;
 
   const preElement: HTMLElement = document.createElement('pre');
diff --git a/src/livecodes/editor/codemirror/codemirror.ts b/src/livecodes/editor/codemirror/codemirror.ts
index 9d48d8a80e..f2d7d0b940 100644
--- a/src/livecodes/editor/codemirror/codemirror.ts
+++ b/src/livecodes/editor/codemirror/codemirror.ts
@@ -29,6 +29,7 @@ import { colorPicker } from '@replit/codemirror-css-color-picker';
 
 // these are imported normally
 import { getEditorModeNode } from '../../UI/selectors';
+import { getLanguageSpecs } from '../../languages';
 import type {
   CodeEditor,
   CodemirrorTheme,
@@ -68,14 +69,25 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
   let editorSettings: EditorConfig = { ...options };
   if (!container) throw new Error('editor container not found');
 
-  const getLanguageSupport = async (language: Language): Promise<LanguageSupport> =>
-    editorLanguages[language]?.() || (editorLanguages.html?.() as Promise<LanguageSupport>);
+  const getLanguageSupport = async (lang: Language): Promise<LanguageSupport> => {
+    const langSupport = getLanguageSpecs(lang)?.editorSupport?.codemirror?.languageSupport;
+    if (!langSupport) {
+      return editorLanguages[lang]?.() || editorLanguages.html?.() || [];
+    }
+    const loadLanguage: () => Promise<LanguageSupport> =
+      typeof langSupport === 'string'
+        ? (await import(langSupport)).default
+        : typeof langSupport === 'function'
+          ? langSupport
+          : async () => [];
+    return loadLanguage();
+  };
 
   const mapLanguage = (lang: Language) => {
     if (lang.startsWith('vue')) return 'vue';
     if (lang.startsWith('svelte')) return 'svelte';
     if (lang === 'liquid') return 'liquid';
-    return options.mapLanguage?.(lang) || lang;
+    return options.mapLanguage?.(lang, 'codemirror') || lang;
   };
 
   const themes: Partial<Record<CodemirrorTheme, Extension>> = {
diff --git a/src/livecodes/editor/codemirror/editor-languages.ts b/src/livecodes/editor/codemirror/editor-languages.ts
index 9a3c6731f1..b921ceb36b 100644
--- a/src/livecodes/editor/codemirror/editor-languages.ts
+++ b/src/livecodes/editor/codemirror/editor-languages.ts
@@ -1,97 +1,11 @@
 /* eslint-disable import/no-unresolved */
-
-// @ts-ignore
-import { LanguageSupport, StreamLanguage, type StreamParser } from '@codemirror/language';
-// @ts-ignore
-import { html } from '@codemirror/lang-html';
-// @ts-ignore
-import { css } from '@codemirror/lang-css';
 // @ts-ignore
-import { javascript } from '@codemirror/lang-javascript';
+import type { LanguageSupport } from '@codemirror/language';
 // @ts-ignore
 import { json } from '@codemirror/lang-json';
 
 import type { Language } from '../../models';
-import { codeMirrorBaseUrl } from '../../vendors';
-
-const legacy = (parser: StreamParser<unknown>) =>
-  new LanguageSupport(StreamLanguage.define(parser));
-
-const getPath = (mod: string) => codeMirrorBaseUrl + mod;
-
-const moduleUrls = {
-  vue: getPath('codemirror-lang-vue.js'),
-  svelte: getPath('codemirror-lang-svelte.js'),
-  liquid: getPath('codemirror-lang-liquid.js'),
-  json: getPath('codemirror-lang-json.js'),
-  markdown: getPath('codemirror-lang-markdown.js'),
-  python: getPath('codemirror-lang-python.js'),
-  php: getPath('codemirror-lang-php.js'),
-  java: getPath('codemirror-lang-java.js'),
-  clike: getPath('codemirror-lang-clike.js'),
-  mllike: getPath('codemirror-lang-mllike.js'),
-  cpp: getPath('codemirror-lang-cpp.js'),
-  sql: getPath('codemirror-lang-sql.js'),
-  wast: getPath('codemirror-lang-wast.js'),
-  scss: getPath('codemirror-lang-scss.js'),
-  minizinc: getPath('codemirror-lang-minizinc.js'),
-  prolog: getPath('codemirror-lang-prolog.js'),
-  coffeescript: getPath('codemirror-lang-coffeescript.js'),
-  livescript: getPath('codemirror-lang-livescript.js'),
-  ruby: getPath('codemirror-lang-ruby.js'),
-  go: getPath('codemirror-lang-go.js'),
-  perl: getPath('codemirror-lang-perl.js'),
-  lua: getPath('codemirror-lang-lua.js'),
-  r: getPath('codemirror-lang-r.js'),
-  julia: getPath('codemirror-lang-julia.js'),
-  scheme: getPath('codemirror-lang-scheme.js'),
-  clojure: getPath('codemirror-lang-clojure.js'),
-  tcl: getPath('codemirror-lang-tcl.js'),
-  less: getPath('codemirror-lang-less.js'),
-  stylus: getPath('codemirror-lang-stylus.js'),
-  rust: getPath('codemirror-lang-rust.js'),
-  swift: getPath('codemirror-lang-swift.js'),
-};
 
 export const editorLanguages: Partial<{ [key in Language]: () => Promise<LanguageSupport> }> = {
-  html: async () => html(),
-  css: async () => css(),
-  javascript: async () => javascript(),
-  typescript: async () => javascript({ typescript: true }),
-  jsx: async () => javascript({ jsx: true }),
-  tsx: async () => javascript({ jsx: true, typescript: true }),
   json: async () => json(),
-  vue: async () => (await import(moduleUrls.vue)).vue(),
-  svelte: async () => (await import(moduleUrls.svelte)).svelte(),
-  liquid: async () => (await import(moduleUrls.liquid)).liquid(),
-  markdown: async () => (await import(moduleUrls.markdown)).markdown(),
-  python: async () => (await import(moduleUrls.python)).python(),
-  php: async () => (await import(moduleUrls.php)).php(),
-  go: async () => (await import(moduleUrls.go)).go(),
-  java: async () => (await import(moduleUrls.java)).java(),
-  cpp: async () => (await import(moduleUrls.cpp)).cpp(),
-  sql: async () => (await import(moduleUrls.sql)).sql(),
-  wat: async () => (await import(moduleUrls.wast)).wast(),
-  scss: async () => (await import(moduleUrls.scss)).sass(),
-  sass: async () => (await import(moduleUrls.scss)).sass({ indented: true }),
-  minizinc: async () => (await import(moduleUrls.minizinc)).MiniZinc(),
-  prolog: async () => (await import(moduleUrls.prolog)).prolog(),
-  coffeescript: async () => legacy((await import(moduleUrls.coffeescript)).coffeeScript),
-  livescript: async () => legacy((await import(moduleUrls.livescript)).liveScript),
-  ruby: async () => legacy((await import(moduleUrls.ruby)).ruby),
-  perl: async () => legacy((await import(moduleUrls.perl)).perl),
-  lua: async () => legacy((await import(moduleUrls.lua)).lua),
-  r: async () => legacy((await import(moduleUrls.r)).r),
-  julia: async () => legacy((await import(moduleUrls.julia)).julia),
-  scheme: async () => legacy((await import(moduleUrls.scheme)).scheme),
-  clojure: async () => legacy((await import(moduleUrls.clojure)).clojure),
-  tcl: async () => legacy((await import(moduleUrls.tcl)).tcl),
-  less: async () => legacy((await import(moduleUrls.less)).less),
-  stylus: async () => legacy((await import(moduleUrls.stylus)).stylus),
-  csharp: async () => legacy((await import(moduleUrls.clike)).csharp),
-  ocaml: async () => legacy((await import(moduleUrls.mllike)).oCaml),
-  // fsharp: async () => legacy((await import(moduleUrls.mllike)).fSharp),
-  // @ts-ignore
-  rust: async () => legacy((await import(moduleUrls.rust)).rust),
-  swift: async () => legacy((await import(moduleUrls.swift)).swift),
 };
diff --git a/src/livecodes/editor/codemirror/utils.ts b/src/livecodes/editor/codemirror/utils.ts
new file mode 100644
index 0000000000..a381e7d707
--- /dev/null
+++ b/src/livecodes/editor/codemirror/utils.ts
@@ -0,0 +1,12 @@
+export const codemirrorLegacy = async (parser: any) => {
+  const { LanguageSupport, StreamLanguage } = await import(codemirrorImports.language);
+  return new LanguageSupport(StreamLanguage.define(parser));
+};
+
+export const codemirrorImports = {
+  html: '@codemirror/lang-html',
+  css: '@codemirror/lang-css',
+  javascript: '@codemirror/lang-javascript',
+  json: '@codemirror/lang-json',
+  language: '@codemirror/language',
+};
diff --git a/src/livecodes/editor/monaco/languages/monaco-lang-astro.ts b/src/livecodes/editor/monaco/languages/monaco-lang-astro.ts
deleted file mode 100644
index 5f15506a50..0000000000
--- a/src/livecodes/editor/monaco/languages/monaco-lang-astro.ts
+++ /dev/null
@@ -1,222 +0,0 @@
-export default {
-  config: {
-    comments: {
-      blockComment: ['<!--', '-->'],
-    },
-    brackets: [
-      ['---', '---'],
-      ['<!--', '-->'],
-      ['<', '>'],
-      ['{', '}'],
-      ['(', ')'],
-    ],
-    autoClosingPairs: [
-      { open: '{', close: '}' },
-      { open: '[', close: ']' },
-      { open: '(', close: ')' },
-      { open: "'", close: "'" },
-      { open: '"', close: '"' },
-      { open: '<!--', close: '-->', notIn: ['comment', 'string'] },
-      { open: '/**', close: ' */', notIn: ['string'] },
-      { open: '<', close: '>', notIn: ['string'] },
-    ],
-    autoCloseBefore: ';:.,=}])>` \n\t',
-    surroundingPairs: [
-      { open: "'", close: "'" },
-      { open: '"', close: '"' },
-      { open: '{', close: '}' },
-      { open: '[', close: ']' },
-      { open: '(', close: ')' },
-      { open: '<', close: '>' },
-    ],
-    folding: {
-      markers: {
-        start: /^\\s*<!--\\s*#region\\b.*-->/,
-        end: /^\\s*<!--\\s*#endregion\\b.*-->/,
-      },
-    },
-  },
-
-  tokens: {
-    defaultToken: '',
-    tokenPostfix: '.astro',
-    ignoreCase: false,
-
-    // non matched elements
-    empty: [
-      'area',
-      'base',
-      'basefont',
-      'br',
-      'col',
-      'frame',
-      'hr',
-      'img',
-      'input',
-      'isindex',
-      'link',
-      'meta',
-      'param',
-    ],
-
-    // The main tokenizer for our languages
-    tokenizer: {
-      root: [
-        [/<!DOCTYPE/, 'metatag', '@doctype'],
-        [/<!--/, 'comment', '@comment'],
-        [/^---/, 'comment', '@frontmatter'],
-        [/{/, '', '@expression'],
-        [/(<)((?:[\w\-]+:)?[\w\-]+)(\s*)(\/>)/, ['delimiter', 'tag', '', 'delimiter']],
-        [/(<)(script)/, ['delimiter', { token: 'tag', next: '@script' }]],
-        [/(<)(style)/, ['delimiter', { token: 'tag', next: '@style' }]],
-        [/(<)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter', { token: 'tag', next: '@otherTag' }]],
-        [/(<\/)((?:[\w\-]+:)?[\w\-]+)/, ['delimiter', { token: 'tag', next: '@otherTag' }]],
-        [/</, 'delimiter'],
-        [/[^<{]+/], // text
-      ],
-
-      doctype: [
-        [/[^>]+/, 'metatag.content'],
-        [/>/, 'metatag', '@pop'],
-      ],
-
-      frontmatter: [
-        [/^---/, { token: 'comment', next: '@pop', nextEmbedded: '@pop' }],
-        [/./, { token: '@rematch', next: '@frontmatterEmbedded', nextEmbedded: 'text/javascript' }],
-      ],
-
-      frontmatterEmbedded: [
-        [/[^-]+|-[^-][^-]+/, { token: '@rematch', next: '@pop' }],
-        [/^---/, { token: 'comment', next: '@root', nextEmbedded: '@pop' }],
-      ],
-
-      expression: [
-        [
-          /[^<{}]/,
-          { token: '@rematch', next: '@expressionEmbedded', nextEmbedded: 'text/javascript' },
-        ],
-        [/</, { token: '@rematch', next: '@pop' }],
-        [/}/, { token: '', next: '@pop' }],
-      ],
-
-      expressionEmbedded: [
-        [/{/, '@rematch', '@push'],
-        [/</, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
-        [/}/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
-      ],
-
-      comment: [
-        [/-->/, 'comment', '@pop'],
-        [/[^-]+/, 'comment.content'],
-        [/./, 'comment.content'],
-      ],
-
-      otherTag: [
-        [/\/?>/, 'delimiter', '@pop'],
-        [/"([^"]*)"/, 'attribute.value'],
-        [/'([^']*)'/, 'attribute.value'],
-        [/[\w\-]+/, 'attribute.name'],
-        [/=/, 'delimiter'],
-        [/[ \t\r\n]+/], // whitespace
-      ],
-
-      // -- BEGIN <script> tags handling
-
-      // After <script
-      script: [
-        [/type/, 'attribute.name', '@scriptAfterType'],
-        [/"([^"]*)"/, 'attribute.value'],
-        [/'([^']*)'/, 'attribute.value'],
-        [/[\w\-]+/, 'attribute.name'],
-        [/=/, 'delimiter'],
-        [/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }],
-        [/[ \t\r\n]+/], // whitespace
-        [/(<\/)(script\s*)(>)/, ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }]],
-      ],
-
-      // After <script ... type
-      scriptAfterType: [
-        [/=/, 'delimiter', '@scriptAfterTypeEquals'],
-        [/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }], // cover invalid e.g. <script type>
-        [/[ \t\r\n]+/], // whitespace
-        [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
-      ],
-
-      // After <script ... type =
-      scriptAfterTypeEquals: [
-        [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
-        [/'([^']*)'/, { token: 'attribute.value', switchTo: '@scriptWithCustomType.$1' }],
-        [/>/, { token: 'delimiter', next: '@scriptEmbedded', nextEmbedded: 'text/javascript' }], // cover invalid e.g. <script type=>
-        [/[ \t\r\n]+/], // whitespace
-        [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
-      ],
-
-      // After <script ... type = $S2
-      scriptWithCustomType: [
-        [/>/, { token: 'delimiter', next: '@scriptEmbedded.$S2', nextEmbedded: '$S2' }],
-        [/"([^"]*)"/, 'attribute.value'],
-        [/'([^']*)'/, 'attribute.value'],
-        [/[\w\-]+/, 'attribute.name'],
-        [/=/, 'delimiter'],
-        [/[ \t\r\n]+/], // whitespace
-        [/<\/script\s*>/, { token: '@rematch', next: '@pop' }],
-      ],
-
-      scriptEmbedded: [
-        [/<\/script/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
-        [/[^<]+/, ''],
-      ],
-
-      // -- END <script> tags handling
-
-      // -- BEGIN <style> tags handling
-
-      // After <style
-      style: [
-        [/type/, 'attribute.name', '@styleAfterType'],
-        [/"([^"]*)"/, 'attribute.value'],
-        [/'([^']*)'/, 'attribute.value'],
-        [/[\w\-]+/, 'attribute.name'],
-        [/=/, 'delimiter'],
-        [/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }],
-        [/[ \t\r\n]+/], // whitespace
-        [/(<\/)(style\s*)(>)/, ['delimiter', 'tag', { token: 'delimiter', next: '@pop' }]],
-      ],
-
-      // After <style ... type
-      styleAfterType: [
-        [/=/, 'delimiter', '@styleAfterTypeEquals'],
-        [/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }], // cover invalid e.g. <style type>
-        [/[ \t\r\n]+/], // whitespace
-        [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
-      ],
-
-      // After <style ... type =
-      styleAfterTypeEquals: [
-        [/"([^"]*)"/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
-        [/'([^']*)'/, { token: 'attribute.value', switchTo: '@styleWithCustomType.$1' }],
-        [/>/, { token: 'delimiter', next: '@styleEmbedded', nextEmbedded: 'text/css' }], // cover invalid e.g. <style type=>
-        [/[ \t\r\n]+/], // whitespace
-        [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
-      ],
-
-      // After <style ... type = $S2
-      styleWithCustomType: [
-        [/>/, { token: 'delimiter', next: '@styleEmbedded.$S2', nextEmbedded: '$S2' }],
-        [/"([^"]*)"/, 'attribute.value'],
-        [/'([^']*)'/, 'attribute.value'],
-        [/[\w\-]+/, 'attribute.name'],
-        [/=/, 'delimiter'],
-        [/[ \t\r\n]+/], // whitespace
-        [/<\/style\s*>/, { token: '@rematch', next: '@pop' }],
-      ],
-
-      styleEmbedded: [
-        [/<\/style/, { token: '@rematch', next: '@pop', nextEmbedded: '@pop' }],
-        [/[^<]+/, ''],
-      ],
-
-      // -- END <style> tags handling
-    },
-  },
-};
diff --git a/src/livecodes/editor/monaco/languages/monaco-lang-clio.ts b/src/livecodes/editor/monaco/languages/monaco-lang-clio.ts
deleted file mode 100644
index e3fb6fa5cf..0000000000
--- a/src/livecodes/editor/monaco/languages/monaco-lang-clio.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-export default {
-  tokens: {
-    // Set defaultToken to invalid to see what you do not tokenize yet
-    // defaultToken: 'invalid',
-
-    keywords: [
-      'import',
-      'export',
-      'from',
-      'as',
-      'fn',
-      'await',
-      '[await]',
-      'if',
-      'else',
-      'true',
-      'false',
-      'and',
-      'or',
-      'not',
-      'type',
-      'list',
-    ],
-
-    typeKeywords: ['Number', 'String', 'Function', 'Array'],
-
-    operators: ['>', '<', ':', '=', '<=', '>=', '!=', '+', '-', '*', '/', '//', '|', '**', '%'],
-
-    // we include these common regular expressions
-    symbols: /[=><!~?:&|+\-*\/\^%]+/,
-
-    // C# style strings
-    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
-
-    // The main tokenizer for our languages
-    tokenizer: {
-      root: [
-        [/fn/, { token: 'keyword', next: '@function' }],
-        [/->/, { token: 'operators', next: '@chain' }],
-
-        // identifiers and keywords
-        [
-          /[a-zA-Z_$][\w$]*/i,
-          {
-            cases: {
-              '@typeKeywords': 'keyword',
-              '@keywords': 'keyword',
-              '@default': 'identifier',
-            },
-          },
-        ],
-
-        // whitespace
-        { include: '@whitespace' },
-
-        // delimiters and operators
-        [/[{}()\[\]]/, '@brackets'],
-        [/[<>](?!@symbols)/, '@brackets'],
-        [
-          /@symbols/,
-          {
-            cases: {
-              '@operators': 'operator',
-              '@default': '',
-            },
-          },
-        ],
-
-        // @ annotations.
-        // As an example, we emit a debugging log message on these tokens.
-        // Note: message are suppressed during the first load -- change some lines to see them.
-        [/@\s*[a-zA-Z_\$][\w\$]*/, { token: 'annotation' }],
-
-        // numbers
-        [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
-        [/0[xX][0-9a-fA-F]+/, 'number.hex'],
-        [/\d+/, 'number'],
-
-        // delimiter: after number because of .\d floats
-        [/[;,.]/, 'delimiter'],
-
-        // strings
-        [/"([^"\\]|\\.)*$/, 'string.invalid'], // non-terminated string
-        [/"/, { token: 'string.quote', bracket: '@open', next: '@string' }],
-
-        // single-quote strings
-        [/"([^'\\]|\\.)*$/, 'string.invalid'], // non-terminated string
-        [/'/, { token: 'string.quote', bracket: '@open', next: '@stringSingle' }],
-      ],
-
-      // eslint-disable-next-line id-blacklist
-      string: [
-        [/[^\\"]+/, 'string'],
-        [/@escapes/, 'string.escape'],
-        [/\\./, 'string.escape.invalid'],
-        [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
-      ],
-
-      stringSingle: [
-        [/[^\\']+/, 'string'],
-        [/@escapes/, 'string.escape'],
-        [/\\./, 'string.escape.invalid'],
-        [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
-      ],
-
-      whitespace: [
-        [/[ \t\r\n]+/, 'white'],
-        [/--.*$/, 'comment'],
-      ],
-
-      function: [[/[a-zA-Z0-9_]+/, { token: 'variable', next: '@pop' }]],
-
-      chain: [
-        [/\*/, 'operators'],
-        [/\[?await\]?/, 'keyword'],
-        [/[a-zA-Z]+/, { token: 'variable', next: '@pop' }],
-      ],
-    },
-  },
-};
diff --git a/src/livecodes/editor/monaco/languages/monaco-lang-imba.ts b/src/livecodes/editor/monaco/languages/monaco-lang-imba.ts
deleted file mode 100644
index e53aaac17a..0000000000
--- a/src/livecodes/editor/monaco/languages/monaco-lang-imba.ts
+++ /dev/null
@@ -1,1522 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-
-// from https://github.com/imba/imba.io/blob/master/scripts/lexer/grammar.imba
-// and https://github.com/imba/imba.io/blob/master/src/repl/languages/imba.imba
-
-function iter$__(a) {
-  let v;
-  return a ? ((v = a.toIterable) ? v.call(a) : a) : [];
-}
-
-/*body*/
-const eolpop = [/^/, { token: '@rematch', next: '@pop' }];
-const repop = { token: '@rematch', next: '@pop' };
-const toodeep = { token: 'white.indent', next: '@>illegal_indent' };
-
-const EOF = '§EOF§';
-
-function regexify(array, pattern = '#') {
-  if (typeof array == 'string') {
-    array = array.split(' ');
-  }
-
-  let items = array.slice().sort(function (_0, _1) {
-    return _1.length - _0.length;
-  });
-  items = items.map(function (item) {
-    let escaped = item.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&');
-    return pattern.replace('#', escaped);
-  });
-  return new RegExp('(?:' + items.join('|') + ')');
-}
-
-function denter(indent, outdent, stay, o = {}) {
-  var v$φ;
-
-  if (indent == null) {
-    indent = toodeep;
-  } else if (indent == 1) {
-    indent = { next: '@>' };
-  } else if (indent == 2) {
-    indent = { next: '@>_indent&-_indent' };
-  } else if (typeof indent == 'string') {
-    indent = { next: indent };
-  }
-
-  if (outdent == -1) {
-    outdent = repop;
-  }
-  if (stay == -1) {
-    stay = repop;
-  } else if (stay == 0) {
-    o.comment == null ? (o.comment = true) : o.comment;
-
-    stay = {};
-  }
-
-  indent = Object.assign({ token: 'white.tabs' }, indent || {});
-  stay = Object.assign({ token: 'white.tabs' }, stay || {});
-  outdent = Object.assign({ token: '@rematch', next: '@pop' }, outdent || {});
-
-  let cases = {
-    '$1==$S2\t': indent,
-    '$1==$S2': {
-      cases: { '$1==$S6': stay, '@default': { token: '@rematch', switchTo: '@*$1' } },
-    },
-    '@default': outdent,
-  };
-  v$φ = 0;
-  for (let k of ['next', 'switchTo']) {
-    let v = v$φ++;
-    if (indent[k] && indent[k].indexOf('*') == -1) {
-      indent[k] += '*$1';
-    }
-  }
-
-  // for own k,v of cases
-  let rule = [/^(\t*)(?=[^ \t\n])/, { cases: cases }];
-  if (o.comment) {
-    let clones = {};
-    for (let iφ = 0, keysφ = Object.keys(cases), lφ = keysφ.length, k, v; iφ < lφ; iφ++) {
-      k = keysφ[iφ];
-      v = cases[k];
-      let clone = Object.assign({}, v);
-      if (!clone.next && !clone.switchTo) {
-        clone.next = '@>_comment';
-      }
-      clones[k] = clone;
-    }
-    return [[/^(\t*)(?=#\s|#$)/, { cases: clones }], rule];
-  }
-
-  return rule;
-}
-
-const states = {
-  root: [
-    [/^@comment/, 'comment', '@>_comment'], // want to push this state _ before the token
-    [
-      /^(\t+)(?=[^\t\n])/,
-      {
-        cases: {
-          '$1==$S2\t': { token: 'white.indent', next: '@>_indent*$1' },
-          '@default': 'white.indent',
-        },
-      },
-    ],
-    'block_',
-  ],
-
-  _comment: [
-    [/^([\t\s\n]*)$/, 'comment'],
-    [
-      /^(\t*)([\S\s]*)/,
-      {
-        cases: {
-          // same or deeper indentation
-          '$1~$S2\t*': { token: 'comment' },
-          '@default': { token: '@rematch', next: '@pop' },
-        },
-      },
-    ],
-    [/[\S\s]+/, 'comment'],
-  ],
-
-  illegal_indent: [denter()],
-
-  identifier_: [
-    [/\$\w+\$/, 'identifier.env'],
-    [/\$\d+/, 'identifier.special'],
-    [/\#+@id/, 'identifier.symbol'],
-    [/\¶@id/, 'ivar'], // imba1
-    [
-      /@id\!?/,
-      {
-        cases: {
-          this: 'this',
-          self: 'self',
-          '@keywords': 'keyword.$#',
-          '$0~[A-Z].*': 'identifier.uppercase.$F',
-          '@default': 'identifier.$F',
-        },
-      },
-    ],
-  ],
-
-  block_: [
-    // 'common_'
-    [/^(\t+)(?=[\r\n]|$)/, 'white.tabs'],
-    'class_',
-    'tagclass_',
-    'var_',
-    'func_',
-    'import_',
-    'export_',
-    'flow_',
-    'for_',
-    'try_',
-    'catch_',
-    'while_',
-    'css_',
-    'tag_',
-    'do_',
-    'block_comment_',
-    'expr_',
-    [/[ ]+/, 'white'],
-    'common_',
-  ],
-
-  indentable_: [
-    [/^[ ]+/, 'white'],
-    denter('@>_paren_indent&-_indent', null, null),
-    [/^(\t+)(?=[\r\n]|$)/, 'white.tabs'],
-    'whitespace',
-  ],
-
-  _indent: [denter(2, -1, 0), 'block_'],
-
-  _paren_indent: [denter(2, -1, 0), 'block_', [/\)|\}|\]/, '@rematch', '@pop']],
-
-  block: [denter('@>', -1, 0), 'block_'],
-  bool_: [[/(true|false|yes|no|undefined|null)(?![\:\-\w\.\_])/, 'boolean']],
-
-  op_: [
-    [/\s+\:\s+/, 'operator.ternary'],
-    // [/\s*(\=)/]
-    [
-      /(@unspaced_ops)/,
-      {
-        cases: {
-          '@spread': 'operator.spread',
-          '@access': 'operator.access',
-          '@default': 'operator',
-        },
-      },
-    ],
-    [/\/(?!\/)/, 'operator.math'],
-    [/\&(?=[,\)])/, 'operator.special.blockparam'],
-    [
-      /(\s*)(@symbols)(\s*)/,
-      {
-        cases: {
-          '$2@assignments': 'operator.assign',
-          '$2@math': 'operator.math',
-          '$2@operators': 'operator',
-          '$2@logic': 'operator.logic',
-          '$2@access': 'operator.access',
-          '@default': 'delimiter',
-        },
-      },
-    ],
-    [/\&\b/, 'operator'],
-  ],
-
-  keyword_: [
-    [/new@B/, 'keyword.new'],
-    [/isa@B/, 'keyword.isa'],
-    [/is@B/, 'keyword.is'],
-    [/(switch|when|throw|continue|break|then|await|typeof|by)@B/, 'keyword.$1'],
-    [/delete@B/, 'keyword.delete'],
-    [/and@B|or@B/, 'operator.flow'],
-  ],
-
-  return_: [[/return@B/, 'keyword.new']],
-
-  primitive_: ['string_', 'number_', 'regexp_', 'bool_'],
-
-  value_: [
-    'primitive_',
-    'keyword_',
-    'implicit_call_',
-    'parens_', // call will always capture?
-    'key_',
-    'access_',
-    'identifier_',
-    'array_',
-    'object_',
-  ],
-
-  expr_: ['comment_', 'inline_var_', 'return_', 'value_', 'tag_', 'op_', 'type_', 'spread_'],
-
-  attr_expr_: [
-    'primitive_',
-    'parens_',
-    'access_',
-    'identifier_',
-    'array_',
-    'object_',
-    'tag_',
-    'op_',
-  ],
-
-  access_: [
-    [
-      /(\.\.?)(@propid\!?)/,
-      {
-        cases: {
-          '$2~[A-Z].*': ['operator.access', 'accessor.uppercase'],
-          '$2~#.*': ['operator.access', 'accessor.symbol'],
-          '@default': ['operator.access', 'accessor'],
-        },
-      },
-    ],
-  ],
-
-  call_: [[/\(/, '(', '@call_body']],
-
-  key_: [
-    [/(\#+@id)(\:\s*)/, ['key.symbol', 'operator.assign.key-value']],
-    [
-      /(@propid)(\:\s*)/,
-      {
-        cases: {
-          '@default': ['key', 'operator.assign.key-value'],
-        },
-      },
-    ],
-  ],
-
-  implicit_call_: [
-    [
-      /(\.\.?)(@propid)@implicitCall/,
-      {
-        cases: {
-          '$2~[A-Z].*': ['operator.access', 'accessor.uppercase', '@implicit_call_body'],
-          '@default': ['operator.access', 'accessor', '@implicit_call_body'],
-        },
-      },
-    ],
-    [
-      /(@propid)@implicitCall/,
-      {
-        cases: {
-          '$2~[A-Z].*': ['identifier.uppercase', '@implicit_call_body'],
-          '@default': ['identifier', '@implicit_call_body'],
-        },
-      },
-    ],
-  ],
-
-  implicit_call_body: [eolpop, [/\)|\}|\]|\>/, '@rematch', '@pop'], 'arglist_', 'whitespace'],
-
-  arglist_: ['do_', 'expr_', [/\s*\,\s*/, 'delimiter.comma']],
-
-  params_: [
-    [/\[/, 'array.[', '@array_var_body=decl-param'],
-    [/\{/, 'object.{', '@object_body=decl-param'],
-    [/(@variable)/, 'identifier.decl-param'],
-    // [/(\s*\=\s*)(?=(for|while|until|if|unless)\s)/,'operator','@pop']
-    'spread_',
-    'type_',
-    [/\s*\=\s*/, 'operator', '@var_value='],
-    [/\s*\,\s*/, 'separator'],
-  ],
-
-  object_: [[/\{/, 'object.{', '@object_body']],
-
-  parens_: [[/\(/, 'parens.(', '@parens_body']],
-
-  parens_body: [[/\)/, ')', '@pop'], 'indentable_', 'arglist_'],
-
-  array_: [[/\[/, 'array.[', '@array_body']],
-
-  array_body: [
-    [/\]@implicitCall/, { token: ']', switchTo: '@implicit_call_body=' }],
-    [/\]/, ']', '@pop'],
-    [/\)|\}/, 'invalid'],
-    'indentable_',
-    'expr_',
-    [',', 'delimiter'],
-  ],
-
-  object_body: [
-    [/\}/, '}', '@pop'],
-    [/(@id)(\s*:\s*)/, ['key', 'operator.assign.key-value', '@object_value']],
-    [/(@id)/, 'identifier.$F'],
-    [/\[/, '[', '@object_dynamic_key='], //
-    [/\s*=\s*/, 'operator.assign', '@object_value='],
-    [/:/, 'operator.assign.key-value', '@object_value='],
-    [/\,/, 'delimiter.comma'],
-    'indentable_',
-    'expr_',
-  ],
-
-  object_value: [
-    eolpop,
-    // couldnt this be indented as well?
-    // [/(?=,|\})/, 'delimiter', '@pop']
-    [/,|\}|\]|\)/, '@rematch', '@pop'],
-    'expr_',
-  ],
-
-  object_dynamic_key: [[']', ']', '@pop'], 'expr_'],
-
-  comment_: [[/#(\s.*)?(\n|$)/, 'comment']],
-
-  block_comment_: [[/###/, 'comment.start', '@_block_comment']],
-
-  _block_comment: [
-    [/###/, 'comment.end', '@pop'],
-    [/[^#]+/, 'comment'],
-    [/#(?!##)/, 'comment'],
-  ],
-
-  // add try_start that accepts catch on the same line?
-  try_: [[/try@B/, 'keyword.try', '@>_try&try']],
-
-  catch_: [
-    [/(catch\s+)(?=@id(\s|$))/, 'keyword.catch', '@catch_start&catch'],
-    [/catch@B/, 'keyword.catch', '@catch_start&catch'],
-  ],
-
-  catch_start: [
-    [/@id/, 'identifier.decl-const', { switchTo: '@>_catch' }],
-    [/.?/, '@rematch', { switchTo: '@>_catch' }],
-  ],
-
-  _catch: [denter('@>block', -1, 0), 'block_'],
-
-  _try: [denter('@>block', -1, 0), 'block_'],
-
-  do_: [
-    // [/(do)(\()/,['keyword.do','(','@>_do_params&do']]
-    [/do(?=\()/, 'keyword.do', '@>do_start&do'],
-    [/do(?=\s*\|)/, 'keyword.do', '@>do_piped&do'],
-    [/do@B/, 'keyword.do', '@>_do&do'],
-  ],
-
-  do_start: [
-    denter(null, -1, -1),
-    [/\(/, '(', { switchTo: '@_do_params' }],
-    [/./, '@rematch', { switchTo: '@_do' }],
-  ],
-
-  do_piped: [
-    denter(null, -1, -1),
-    [/\s*\|/, 'args.open', { switchTo: '@_do_piped_params' }],
-    [/./, '@rematch', { switchTo: '@_do' }],
-  ],
-
-  _do_piped_params: [[/\|/, 'args.close', { switchTo: '@_do' }], 'params_'],
-
-  _do_params: [[/\)/, ')', { switchTo: '@_do' }], 'params_'],
-
-  _do: [
-    denter(2, -1, 0),
-    // block in general, no?
-    [/(\}|\)|\])/, '@rematch', '@pop'],
-    'block_',
-  ],
-
-  class_: [
-    [/(extend)(?=\s+class )/, 'keyword.$1'],
-    [/(global)(?=\s+class )/, 'keyword.$1'],
-    [
-      /(class)(\s)(@id)/,
-      ['keyword.$1', 'white.$1name', 'entity.name.class.decl-const', '@class_start='],
-    ],
-    [/(class)(?=\n)/, 'keyword.$1', '@>_class&class='],
-  ],
-
-  class_start: [
-    [/(\s+\<\s+)(@id)/, ['keyword.extends', 'identifier.superclass']],
-    [/@comment/, 'comment'],
-    [/^/, '@rematch', { switchTo: '@>_class&class=' }],
-  ],
-
-  tagclass_: [
-    [/(extend)(?=\s+tag )/, 'keyword.$1'],
-    [/(global)(?=\s+tag )/, 'keyword.$1'],
-    [
-      /(tag)(\s)(@constant)/,
-      ['keyword.tag', 'white.tagname', 'entity.name.component.local', '@tagclass_start='],
-    ], // only when uppercase
-    [
-      /(tag)(\s)(@id)/,
-      ['keyword.tag', 'white.tagname', 'entity.name.component.global', '@tagclass_start='],
-    ], // only when uppercase
-  ],
-
-  tagclass_start: [
-    [/(\s+\<\s+)(@id)/, ['keyword.extends', 'identifier.superclass']],
-    [/@comment/, 'comment'],
-    [/^/, '@rematch', { switchTo: '@>_tagclass&component=' }],
-  ],
-
-  import_: [
-    [/(import)(?=\s+['"])/, 'keyword.import', '@>import_source'],
-    [
-      /(import)(\s+type)(?=\s[\w\$\@\{])/,
-      ['keyword.import', 'keyword.type', '@>import_body&-_imports=decl-import/part'],
-    ],
-    [/(import)@B/, 'keyword.import', '@>import_body&-_imports=decl-import/part'],
-  ],
-
-  import_body: [
-    denter(null, -1, 0),
-    [
-      /(@esmIdentifier)( +from)/,
-      ['identifier.$F.default', 'keyword.from', { switchTo: '@import_source' }],
-    ],
-    [
-      /(\*)(\s+as\s+)(@esmIdentifier)(\s+from)/,
-      [
-        'keyword.star',
-        'keyword.as',
-        'identifier.$F.ns',
-        'keyword.from',
-        { switchTo: '@import_source' },
-      ],
-    ],
-    [
-      /(@esmIdentifier)(\s*,\s*)(\*)(\s+as\s+)(@esmIdentifier)(from)/,
-      [
-        'identifier.$F.default',
-        'delimiter.comma',
-        'keyword.star',
-        'keyword.as',
-        'identifier.$F.ns',
-        'keyword.from',
-        { switchTo: '@import_source' },
-      ],
-    ],
-    // [/(\*)(\s+as\s+)(@esmIdentifier)/, ['keyword.star','keyword.as','identifier.const.import',switchTo: '@/delim']]
-    // [/(@esmIdentifier)(\s+as\s+)(@esmIdentifier)/, ['alias','keyword.as','identifier.const.import']]
-    [/\ *from/, 'keyword.from', { switchTo: '@import_source' }],
-    [/\{/, 'specifiers.{', '@esm_specifiers/part'],
-    [/(@esmIdentifier)/, 'identifier.$F', { switchTo: '@/delim' }],
-    [/\s*\,\s*/, 'delimiter.comma', { switchTo: '@/part' }],
-    'comma_',
-    'common_',
-  ],
-
-  import_source: [denter(null, -1, 0), [/["']/, 'path.open', '@_path=$#'], eolpop],
-
-  export_: [
-    [/(export)( +)(default)@B/, ['keyword.export', 'white', 'keyword.default']], // ,'@>import_body'
-    [/(export)(?= +(let|const|var|class|tag)@B)/, 'keyword.export'], // ,'@>import_body'
-    [/(export)( +)(global)@B/, ['keyword.export', 'white', 'keyword.global']], // ,'@>import_body'
-
-    [
-      /(export)(\s+\*\s+)(from)@B/,
-      ['keyword.export', 'operator.star', 'keyword.from', '@>import_source'],
-    ],
-    [/(export)@B/, 'keyword.export', '@>export_body'],
-  ],
-
-  export_body: [
-    denter(null, -1, 0),
-    [/(\*)(\s+as\s+)(@esmIdentifier)/, ['keyword.star', 'keyword.as', 'identifier.const.export']],
-    [/(@esmIdentifier)(\s+as\s+)(default)/, ['alias', 'keyword.as', 'alias.default']],
-    [
-      /(@esmIdentifier)(\s+as\s+)(@esmIdentifier)/,
-      ['alias', 'keyword.as', 'identifier.const.export'],
-    ],
-    [/from/, 'keyword.from', { switchTo: '@import_source' }],
-    [/\{/, '{', '@esm_specifiers=export/part'],
-    [/(@esmIdentifier)/, 'identifier.const.export'],
-    [/\*/, 'operator.star'],
-    'comma_',
-    'common_',
-  ],
-
-  esm_specifiers: [
-    [/\}/, '}', '@pop'],
-    [
-      /(@esmIdentifier)(\s+as\s+)(@esmIdentifier)/,
-      ['alias', 'keyword.as', 'identifier.const.$F', { switchTo: '@/delim' }],
-    ],
-    [
-      /@esmIdentifier/,
-      {
-        cases: {
-          '$/==part': { token: 'identifier.const.$S4', switchTo: '@/delim' },
-          '@default': { token: 'invalid' },
-        },
-      },
-    ],
-    [/\s*\,\s*/, 'delimiter.comma', { switchTo: '@/part' }],
-    'whitespace',
-  ],
-
-  _path: [
-    [/[^"'\`\{\\]+/, 'path'],
-    [/@escapes/, 'path.escape'],
-    [/\./, 'path.escape.invalid'],
-    [/\{/, 'invalid'],
-    [/["'`]/, { cases: { '$#==$F': { token: 'path.close', next: '@pop' }, '@default': 'path' } }],
-  ],
-
-  member_: [
-    // [/static(?=\s+(get|set|def) )/,'keyword.static'] # only in class and tagclass?
-    [/(constructor)@B/, 'entity.name.constructor', '@>def_params&def/def'],
-    [
-      /(def|get|set)(\s)(@defid)/,
-      ['keyword.$1', 'white.entity', 'entity.name.$1', '@>def_params&$1/$1'],
-    ],
-    [/(def|get|set)(\s)(\[)/, ['keyword.$1', 'white.entity', '$$', '@>def_dynamic_name/$1']],
-  ],
-
-  func_: [
-    [/export(?=\s+(get|set|def|global) )/, 'keyword.export'], // only in class and tagclass?
-    [/global(?=\s+(get|set|def) )/, 'keyword.global'], // only in class and tagclass?
-    [
-      /(def)(\s)(@id)(\.)(@defid)/,
-      [
-        'keyword.$1',
-        'white.entity',
-        'identifier.target',
-        'operator',
-        'entity.name.def',
-        '@>def_params&$1/$1',
-      ],
-    ],
-
-    [
-      /(def)(\s)(@defid)/,
-      ['keyword.$1', 'white.entity', 'entity.name.function.decl-const-func', '@>def_params&$1/$1'],
-    ],
-  ],
-
-  flow_: [
-    // [/(else)(?=\s|$)/, ['keyword.$1','@flow_start.$S2.flow.$S4']]
-    [/(if|else|elif|unless)(?=\s|$)/, ['keyword.$1', '@flow_start=$1']],
-  ],
-
-  flow_start: [
-    denter({ switchTo: '@>_flow&$F' }, -1, -1),
-    // denter({switchTo: '@>_flow&-body'},-1,-1)
-    // denter('@>_flow&block',-1,-1)
-    [/[ \t]+/, 'white'],
-    'expr_',
-  ],
-
-  for_: [
-    [/for(?: own)?@B/, 'keyword.$#', '@for_start&forscope=decl-for'],
-    // [/for@B/,'keyword.$#','@for_start&flow=let']
-  ],
-
-  while_: [[/(while|until)@B/, 'keyword.$#', '@>while_body']],
-  while_body: [denter(2, -1, 0), 'block_'],
-
-  for_start: [
-    denter({ switchTo: '@>for_body' }, -1, -1),
-    [/\[/, 'array.[', '@array_var_body'],
-    [/\{/, 'object.{', '@object_body'], // object_var_body?
-    [/(@variable)/, 'identifier.$F'],
-    [/(\s*\,\s*)/, 'separator', '@=decl-for-index'],
-    [/\s(in|of)@B/, 'keyword.$1', { switchTo: '@>for_source=' }],
-    [/[ \t]+/, 'white'],
-    'type_',
-  ],
-  for_source: [
-    denter({ switchTo: '@>for_body' }, -1, { switchTo: '@for_body' }),
-    'expr_',
-    [/[ \t]+/, 'white'],
-  ],
-
-  for_body: [denter(2, -1, 0), 'block_'],
-
-  decorator_: [
-    [/(@decid)(\()/, ['decorator', '$2', '@_decorator_params']],
-    [/(@decid)/, 'decorator'],
-  ],
-
-  _decorator_params: [[/\)/, ')', '@pop'], 'params_'],
-
-  field_: [
-    [
-      /((?:lazy )?)((?:static )?)(const|let|attr)(?=\s|$)/,
-      ['keyword.lazy', 'keyword.static', 'keyword.$1', '@_vardecl=field-$3'],
-    ], // $2_body.$S2.$2.$S4
-    [/(static\s+)(?=@fieldid)/, 'keyword.static'],
-    [/(@fieldid)(?=$)/, 'entity.name.field'],
-    [/(@fieldid)/, ['entity.name.field', '@_field_1']],
-  ],
-
-  _field_1: [
-    denter(null, -1, -1),
-    'type_',
-    [/(\s*=)(?!\=)/, ['operator.assign', '@>_field_value&field']],
-    [/(\s*(?:\@)set\s*)/, ['keyword.spy', '@>_def&spy']],
-  ],
-
-  _field_value: [
-    denter(2, -1, 0),
-    'block_', // sure?
-    [/(\s*(?:\@)set\s*)/, ['@rematch', '@pop']],
-  ],
-
-  var_: [
-    [
-      /((?:export )?)(const|let)(?=\s[\[\{\$a-zA-Z]|\s*$)/,
-      ['keyword.export', 'keyword.$1', '@_vardecl=decl-$2'],
-    ], // $2_body.$S2.$2.$S4
-    [/((?:export )?)(const|let)(?=\s|$)/, ['keyword.export', 'keyword.$1']],
-  ],
-
-  inline_var_: [
-    [/(const|let)(?=\s[\[\{\$a-zA-Z]|\s*$)/, ['keyword.$1', '@inline_var_body=decl-$1']],
-  ],
-
-  string_: [
-    [/"""/, 'string', '@_herestring="""'],
-    [/'''/, 'string', "@_herestring='''"],
-    [/["'`]/, 'string.open', '@_string=$#'],
-  ],
-
-  number_: [
-    [/0[xX][0-9a-fA-F_]+/, 'number.hex'],
-    [/0[b][01_]+/, 'number.binary'],
-    [/0[o][0-9_]+/, 'number.octal'],
-    [/(\d+)([a-z]+|\%)/, ['number', 'unit']],
-    [/(\d*\.\d+(?:[eE][\-+]?\d+)?)([a-z]+|\%)/, ['number.float', 'unit']],
-    [/\d+[eE]([\-+]?\d+)?/, 'number.float'],
-    [/\d[\d_]*\.\d[\d_]*([eE][\-+]?\d+)?/, 'number.float'],
-    [/\d[\d_]*/, 'number.integer'],
-    [/0[0-7]+(?!\d)/, 'number.octal'],
-    [/\d+/, 'number'],
-  ],
-
-  _string: [
-    [/[^"'\`\{\\]+/, 'string'],
-    [/@escapes/, 'string.escape'],
-    [/\./, 'string.escape.invalid'],
-    [
-      /\{/,
-      {
-        cases: {
-          "$F=='": 'string',
-          '@default': { token: 'string.bracket.open', next: '@interpolation_body' },
-        },
-      },
-    ],
-    [
-      /["'`]/,
-      { cases: { '$#==$F': { token: 'string.close', next: '@pop' }, '@default': 'string' } },
-    ],
-    [/#/, 'string'],
-  ],
-
-  _herestring: [
-    [/("""|''')/, { cases: { '$1==$F': { token: 'string', next: '@pop' }, '@default': 'string' } }],
-    [/[^#\\'"\{]+/, 'string'],
-    [/['"]+/, 'string'],
-    [/@escapes/, 'string.escape'],
-    [/\./, 'string.escape.invalid'],
-    [
-      /\{/,
-      {
-        cases: {
-          '$F=="""': { token: 'string', next: '@interpolation_body' },
-          '@default': 'string',
-        },
-      },
-    ],
-    [/#/, 'string'],
-  ],
-
-  interpolation_body: [[/\}/, 'string.bracket.close', '@pop'], 'expr_'],
-
-  _class: [
-    denter(toodeep, -1, 0),
-    // 'var_'
-    'css_',
-    'member_',
-    'comment_',
-    'decorator_',
-    [/(get|set|def|static|prop|attr)@B/, 'keyword.$0'],
-    'field_',
-    'common_',
-  ],
-
-  _tagclass: [
-    '_class',
-    [/(?=\<self)/, 'entity.name.def.render', '@_render&def'],
-    // self def
-  ],
-
-  def_params: [
-    // denter({switchTo: '@>_def'},-1,{switchTo: '@>_def'})
-    [/\(/, '(', '@def_parens'],
-    [/^/, '@rematch', { switchTo: '@_def' }],
-    [/do@B/, 'keyword.do', { switchTo: '@_def' }],
-    'params_',
-    [/@comment/, 'comment'],
-  ],
-
-  def_parens: [[/\)/, ')', '@pop'], 'params_'],
-
-  def_dynamic_name: [[']', { token: 'square.close', switchTo: '@def_params&$/' }], 'expr_'],
-
-  _render: [denter(2, -1, -1), 'block_'],
-
-  _def: [denter(2, -1, 0), 'block_'],
-
-  _flow: [denter(2, -1, 0), 'block_'],
-
-  _varblock: [
-    denter(1, -1, -1),
-    [/\[/, 'array.[', '@array_var_body'],
-    [/\{/, 'object.{', '@object_body'],
-    [/(@variable)/, 'identifier.$F'],
-    [/\s*\,\s*/, 'separator'],
-    [/(\s*\=\s*)(?=(for|while|until|if|unless|try)\s)/, 'operator', '@pop'],
-    [/(\s*\=\s*)/, 'operator', '@var_value='],
-    'type_',
-    [/#(\s.*)?\n?$/, 'comment'],
-  ],
-
-  _vardecl: [
-    denter(null, -1, -1),
-    [/\[/, 'array.[', '@array_var_body'],
-    [/\{/, 'object.{', '@object_body'],
-    [/(@variable)(?=\n|,|$)/, 'identifier.$F', '@pop'],
-    [/(@variable)/, 'identifier.$F'],
-    [/(\s*\=\s*)/, 'operator.declval', { switchTo: '@var_value&value=' }], // ,switchTo: '@var_value='
-    'type_',
-  ],
-
-  array_var_body: [
-    [/\]/, ']', '@pop'],
-    [/\{/, 'object.{', '@object_body'],
-    [/\[/, 'array.[', '@array_var_body'],
-    'spread_',
-    [/(@variable)/, 'identifier.$F'],
-    [/(\s*\=\s*)/, 'operator.assign', '@array_var_body_value='],
-    // 'expr_'
-    [',', 'delimiter'],
-  ],
-
-  array_var_body_value: [[/(?=,|\)|]|})/, 'delimiter', '@pop'], 'expr_'],
-
-  inline_var_body: [
-    [/\[/, 'array.[', '@array_var_body'],
-    [/\{/, 'object.{', '@object_body'],
-    [/(@variable)/, 'identifier.$F'],
-    [/(\s*\=\s*)/, 'operator', '@pop'], // ,switchTo: '@var_value='
-    'type_',
-  ],
-
-  var_value: [
-    [/(?=,|\)|]|})/, 'delimiter', '@pop'],
-    denter({ switchTo: '@>block' }, -1, -1),
-    'block_',
-    // 'do_'
-    // 'expr_'
-    // 'common_'
-  ],
-
-  common_: [[/^(\t+)(?=\n|$)/, 'white.tabs'], 'whitespace'],
-  comma_: [[/\s*,\s*/, 'delimiter.comma']],
-
-  spread_: [[/\.\.\./, 'operator.spread']],
-
-  type_: [[/\\/, '@rematch', '@_type&-_type/0']],
-
-  _type: [
-    denter(-1, -1, -1),
-    [/\\/, 'delimiter.type.prefix'],
-    // these should probably stack and pair
-    [/\[/, 'delimiter.type', '@/]'],
-    [/\(/, 'delimiter.type', '@/)'],
-    [/\{/, 'delimiter.type', '@/}'],
-    [/\</, 'delimiter.type', '@/>'],
-    [/\|/, 'delimiter.type.union'],
-    [
-      /\,|\s|\=|\./,
-      {
-        cases: {
-          '$/==0': { token: '@rematch', next: '@pop' },
-          '@default': 'type',
-        },
-      },
-    ],
-    [
-      /[\]\}\)\>]/,
-      {
-        cases: {
-          '$#==$/': { token: 'delimiter.type', next: '@pop' },
-          '@default': { token: '@rematch', next: '@pop' },
-        },
-      },
-    ],
-    [/[\w\-\$]+/, 'type'],
-  ],
-
-  css_: [
-    [/global(?=\s+css@B)/, 'keyword.$#'],
-    [/css(?:\s+)?/, 'keyword.css', '@>css_selector&rule-_sel'],
-  ],
-
-  sel_: [
-    [/(\%)((?:@id)?)/, ['style.selector.mixin.prefix', 'style.selector.mixin']],
-    [/(\@)(\.{0,2}[\w\-\<\>\!]*\+?)/, 'style.selector.modifier'],
-    [/(\@)(\.{0,2}[\w\-\<\>\!]*)/, 'style.selector.modifier'],
-    [/\.([\w\-]+)/, 'style.selector.class-name'],
-    [/\#([\w\-]+)/, 'style.selector.id'],
-    [/([\w\-]+)/, 'style.selector.element'],
-    [/(>+|~|\+)/, 'style.selector.operator'],
-    [/(\*+)/, 'style.selector.element.any'],
-    [/(\$)((?:@id)?)/, ['style.selector.reference.prefix', 'style.selector.reference']],
-    [/\&/, 'style.selector.context'],
-    [/\(/, 'delimiter.selector.parens.open', '@css_selector_parens'],
-    [/\[/, 'delimiter.selector.attr.open', '@css_selector_attr'],
-    [/\s+/, 'white'],
-    [/,/, 'style.selector.delimiter'],
-    [/#(\s.*)?\n?$/, 'comment'],
-  ],
-
-  css_props: [
-    denter(null, -1, 0),
-    [/(?=@cssPropertyKey2)/, '', '@css_property&-_styleprop-_stylepropkey'],
-    [/#(\s.*)?\n?$/, 'comment'],
-    [/(?=[\%\*\w\&\$\>\.\[\@\!]|\#[\w\-])/, '', '@>css_selector&rule-_sel'],
-    [/\s+/, 'white'],
-  ],
-
-  css_selector: [
-    denter({ switchTo: '@css_props' }, -1, { token: '@rematch', switchTo: '@css_props&_props' }),
-    [/(\}|\)|\])/, '@rematch', '@pop'],
-    [/(?=\s*@cssPropertyKey2)/, '', { switchTo: '@css_props&_props' }],
-    [/\s*#\s/, '@rematch', { switchTo: '@css_props&_props' }],
-    'sel_',
-  ],
-
-  css_inline: [
-    [/\]/, 'style.close', '@pop'],
-    [/(?=@cssPropertyKey2)/, '', '@css_property&-_styleprop-_stylepropkey'],
-    [/(?=@cssPropertyPath\])/, '', '@css_property&-_styleprop-_stylepropkey'],
-  ],
-
-  css_selector_parens: [[/\)/, 'delimiter.selector.parens.close', '@pop'], 'sel_'],
-
-  css_selector_attr: [[/\]/, 'delimiter.selector.parens.close', '@pop'], 'sel_'],
-
-  css_property: [
-    denter(null, -1, -1),
-    [/\]/, '@rematch', '@pop'],
-    [/(\d+)(@id)/, ['style.property.unit.number', 'style.property.unit.name']],
-    [/((--|\$)@id)/, 'style.property.var'],
-    [/(-*@id)/, 'style.property.name'],
-    // [/(\@+)([\>\<\!]?[\w\-]+)/, ['style.property.modifier.start','style.property.modifier']]
-    [/@cssModifier/, 'style.property.modifier'],
-    [/(\@+|\.+)(@id\-?)/, ['style.property.modifier.start', 'style.property.modifier']],
-    [/\+(@id)/, 'style.property.scope'],
-    [
-      /\s*([\:]\s*)(?=@br|$)/,
-      'style.property.operator',
-      { switchTo: '@>css_multiline_value&_stylevalue' },
-    ],
-    [/\s*([\:]\s*)/, 'style.property.operator', { switchTo: '@>css_value&_stylevalue' }],
-  ],
-
-  css_value_: [
-    [/(x?xs|sm\-?|md\-?|lg\-?|xx*l|\dxl|hg|x+h)\b/, 'style.value.size'],
-    [/\#[0-9a-fA-F]+/, 'style.value.color.hex'],
-    [/((--|\$)@id)/, 'style.value.var'],
-    [
-      /(@optid)(\@+|\.+)(@optid)/,
-      ['style.property.name', 'style.property.modifier.prefix', 'style.property.modifier'],
-    ],
-    'op_',
-    'string_',
-    'number_',
-    'comment_',
-    [/\s+/, 'style.value.white'],
-    [/\(/, 'delimiter.style.parens.open', '@css_expressions'],
-    [/\{/, 'delimiter.style.curly.open', '@css_interpolation&-_styleinterpolation'],
-    [/(@id)/, 'style.value'],
-  ],
-
-  css_value: [
-    denter({ switchTo: '@>css_multiline_value' }, -1, -1),
-    // [/@cssModifier/, '@rematch', '@pop']
-    [/@cssPropertyKey2/, '@rematch', '@pop'],
-    [/;/, 'style.delimiter', '@pop'],
-    [/(\}|\)|\])/, '@rematch', '@pop'],
-    'css_value_',
-  ],
-
-  css_multiline_value: [denter(null, -1, 0), [/@cssPropertyKey2/, 'invalid'], 'css_value_'],
-
-  css_expressions: [
-    [/\)/, 'delimiter.style.parens.close', '@pop'],
-    [/\(/, 'delimiter.style.parens.open', '@css_expressions'],
-    'css_value',
-  ],
-
-  css_interpolation: [[/\}/, 'delimiter.style.curly.close', '@pop'], 'expr_'],
-
-  expressions: [[/\,/, 'delimiter.comma']],
-
-  whitespace: [
-    [/[\r\n]+/, 'br'],
-    [/[ \t\r\n]+/, 'white'],
-  ],
-
-  space: [[/[ \t]+/, 'white']],
-
-  tag_: [
-    [/(\s*)(<)(?=\.)/, ['white', 'tag.open', '@_tag/flag']],
-    [/(\s*)(<)(?=\w|\{|\[|\%|\#|>)/, ['white', 'tag.open', '@_tag/name']],
-  ],
-  tag_content: [
-    denter(2, -1, 0),
-    [/\)|\}|\]/, '@rematch', '@pop'],
-    'common_',
-    'flow_',
-    'var_',
-    'for_',
-    'css_',
-    'expr_',
-    'do_',
-    // dont support object keys directly here
-  ],
-
-  tag_children: [],
-
-  _tag: [
-    [/\/>/, 'tag.close', '@pop'],
-    [/>/, 'tag.close', { switchTo: '@>tag_content=&-_tagcontent' }],
-    // '@>css_selector&rule-_sel'
-    [/>/, 'tag.close', '@pop'],
-    [/(\-?\d+)/, 'tag.$S3'],
-    [/(\%)(@id)/, ['tag.mixin.prefix', 'tag.mixin']],
-    [/\#@id/, 'tag.id'],
-
-    [
-      /\./,
-      {
-        cases: {
-          '$/==event': { token: 'tag.event-modifier.start', switchTo: '@/event-modifier' },
-          '$/==event-modifier': { token: 'tag.event-modifier.start', switchTo: '@/event-modifier' },
-          '$/==modifier': { token: 'tag.modifier.start', switchTo: '@/modifier' },
-          '$/==rule': { token: 'tag.rule-modifier.start', switchTo: '@/rule-modifier' },
-          '$/==rule-modifier': { token: 'tag.rule-modifier.start', switchTo: '@/rule-modifier' },
-          '@default': { token: 'tag.flag.start', switchTo: '@/flag' },
-        },
-      },
-    ],
-
-    [
-      /(\$@id)/,
-      {
-        cases: {
-          '$/==name': 'tag.reference',
-          '@default': 'tag.$/',
-        },
-      },
-    ],
-
-    [/\{/, 'tag.$/.interpolation.open', '@_tag_interpolation'],
-    [/\[/, 'style.open', '@css_inline'],
-    [/(\s*\=\s*)/, 'operator.equals.tagop.tag-$/', '@_tag_value&-value'],
-    [/\:/, { token: 'tag.event.start', switchTo: '@/event' }],
-    'tag_event_',
-    // 'tag_attr_'
-    [
-      /(\-?@tagIdentifier)(\:@id)?/,
-      {
-        cases: {
-          '$/==attr': { token: '@rematch', next: '@_tag_attr&-_tagattr' },
-          '@default': { token: 'tag.$/' },
-        },
-      },
-    ],
-    // [/\@/,token: 'tag.event.start', switchTo: '@/event']
-    // [/\{/,token: 'tag.$/.braces.open', next: '@_tag_interpolation/0']
-    [/\(/, { token: 'tag.$/.parens.open', next: '@_tag_parens/0' }],
-    [/\s+/, { token: 'tag.white', switchTo: '@/attr' }],
-    'comment_',
-  ],
-  tag_event_: [
-    // add an additional slot for name etc?
-    // [/(\@)(@optid)/,['tag.event.start','tag.event.name','@_tag_event&_tagevent/$2']]
-    [/(?=\@@optid)/, '', '@_tag_event&-_listener'],
-  ],
-
-  _tag_part: [[/\)|\}|\]|\>/, '@rematch', '@pop']],
-  _tag_event: [
-    '_tag_part',
-    [/(\@)(@optid)/, ['tag.event.start', 'tag.event.name']],
-    [/(\.)(@optid)/, ['tag.event-modifier.start', 'tag.event-modifier.name']],
-    [/\(/, { token: 'tag.$/.parens.open', next: '@_tag_parens/0' }],
-    [/(\s*\=\s*)/, 'operator.equals.tagop.tag-$/', '@_tag_value&handler'],
-    [/\s+/, '@rematch', '@pop'],
-  ],
-
-  tag_attr_: [
-    // add an additional slot for name etc?
-    // [/(\@)(@optid)/,['tag.event.start','tag.event.name','@_tag_event&_tagevent/$2']]
-    [/(?=@tagIdentifier(\:@id)?)/, '', '@_tag_attr&-_attribute'],
-  ],
-
-  _tag_attr: [
-    '_tag_part',
-    [/(\-?@tagIdentifier)(\:@id)?/, 'tag.attr'],
-    [/\.(@optid)/, 'tag.event-modifierzz'],
-    [/\(/, { token: 'tag.parens.open.$/', next: '@_tag_parens/0' }],
-    [/(\s*\=\s*)/, 'operator.equals.tagop.tag-$/', '@_tag_value&-tagattrvalue'],
-    [/\s+/, '@rematch', '@pop'],
-  ],
-
-  _tag_interpolation: [[/\}/, 'tag.$/.interpolation.close', '@pop'], 'expr_', [/\)|\]/, 'invalid']],
-
-  _tag_parens: [[/\)/, 'tag.$/.parens.close', '@pop'], 'arglist_', [/\]|\}/, 'invalid']],
-
-  _tag_value: [[/(?=(\/?\>|\s))/, '', '@pop'], 'attr_expr_'],
-
-  regexp_: [
-    [
-      /\/(?!\ )(?=([^\\\/]|\\.)+\/)/,
-      { token: 'regexp.slash.open', bracket: '@open', next: '@_regexp' },
-    ],
-    [/\/\/\//, { token: 'regexp.slash.open', bracket: '@open', next: '@_hereregexp' }],
-    [/(\/)(\/)/, ['regexp.slash.open', 'regexp.slash.close']],
-  ],
-
-  _regexp: [
-    [
-      /(\{)(\d+(?:,\d*)?)(\})/,
-      ['regexp.escape.control', 'regexp.escape.control', 'regexp.escape.control'],
-    ],
-    [
-      /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
-      ['regexp.escape.control', { token: 'regexp.escape.control', next: '@_regexrange' }],
-    ],
-    [/(\()(\?:|\?=|\?!)/, ['regexp.escape.control', 'regexp.escape.control']],
-    [/[()]/, 'regexp.escape.control'],
-    [/@regexpctl/, 'regexp.escape.control'],
-    [/[^\\\/]/, 'regexp'],
-    [/@regexpesc/, 'regexp.escape'],
-    [/\\:/, 'regexp.escape'],
-    [/\\\./, 'regexp.invalid'],
-    [/(\/)(\w+)/, [{ token: 'regexp.slash.close' }, { token: 'regexp.flags', next: '@pop' }]],
-    ['/', { token: 'regexp.slash.close', next: '@pop' }],
-    [/./, 'regexp.invalid'],
-  ],
-
-  _regexrange: [
-    [/-/, 'regexp.escape.control'],
-    [/\^/, 'regexp.invalid'],
-    [/@regexpesc/, 'regexp.escape'],
-    [/[^\]]/, 'regexp'],
-    [/\]/, 'regexp.escape.control', '@pop'],
-  ],
-
-  _hereregexp: [
-    [/[^\\\/#]/, 'regexp'],
-    [/\\./, 'regexp'],
-    [/#.*$/, 'comment'],
-    ['///[igm]*', 'regexp', '@pop'],
-    [/\//, 'regexp'],
-    'comment_',
-  ],
-};
-
-// states are structured:
-// 1 = the monarch state
-// 2 = the current indentation (I)
-// 3 = the current scope name/type (&)
-// 4 = various flags (F)
-// 5 = the monarch substate -- for identifiers++
-function rewriteΞstate(raw) {
-  let state = ['$S1', '$S2', '$S3', '$S4', '$S5', '$S6'];
-
-  if (raw.match(/\@(pop|push|popall)/)) {
-    return raw;
-  }
-
-  if (raw[0] == '@') {
-    raw = raw.slice(1);
-  }
-
-  if (raw.indexOf('.') >= 0) {
-    return raw;
-  }
-
-  raw = rewriteΞtoken(raw);
-  // if raw.match(/^[\w\$\.\-]+$/)
-  // return raw
-
-  if (raw[0] == '>') {
-    state[1] = '$S6\t';
-    raw = raw.slice(1);
-  }
-
-  for (
-    let iφ2 = 0, itemsφ = iter$__(raw.split(/(?=[\/\&\=\*])/)), lenφ = itemsφ.length;
-    iφ2 < lenφ;
-    iφ2++
-  ) {
-    let part = itemsφ[iφ2];
-    if (part[0] == '&') {
-      if (part[1] == '-' || part[1] == '_') {
-        state[2] = '$S3' + part.slice(1);
-      } else {
-        state[2] = '$S3-' + part.slice(1);
-      }
-    } else if (part[0] == '+') {
-      state[3] = '$S4-' + part.slice(1);
-    } else if (part[0] == '=') {
-      state[3] = part.slice(1);
-    } else if (part[0] == '/') {
-      state[4] = part.slice(1);
-    } else if (part[0] == '*') {
-      state[5] = part.slice(1);
-    } else {
-      state[0] = part;
-    }
-  }
-  return state.join('.');
-}
-
-function rewriteΞtoken(raw) {
-  let orig = raw;
-  raw = raw.replace('$/', '$S5');
-  raw = raw.replace('$F', '$S4');
-  raw = raw.replace('$&', '$S3');
-  raw = raw.replace('$I', '$S2');
-  raw = raw.replace('$T', '$S2');
-
-  // if orig != raw
-  // console.log 'rewriting token',orig,raw
-  return raw;
-}
-
-function rewriteΞactions(actions, add) {
-  if (typeof actions == 'string') {
-    // and parts.indexOf('$') >= 0
-
-    actions = { token: actions };
-  }
-
-  if (actions && actions.token != undefined) {
-    actions.token = rewriteΞtoken(actions.token);
-
-    if (typeof add == 'string') {
-      actions.next = add;
-    } else if (add) {
-      Object.assign(actions, add);
-    }
-
-    if (actions.next) {
-      actions.next = rewriteΞstate(actions.next);
-    }
-    if (actions.switchTo) {
-      actions.switchTo = rewriteΞstate(actions.switchTo);
-    }
-  } else if (actions && actions.cases) {
-    // console.log 'found cases to transform!!'
-    let cases = {};
-    for (
-      let oφ = actions.cases, iφ3 = 0, keysφ2 = Object.keys(oφ), lφ2 = keysφ2.length, k, v;
-      iφ3 < lφ2;
-      iφ3++
-    ) {
-      k = keysφ2[iφ3];
-      v = oφ[k];
-      let newkey = rewriteΞtoken(k);
-      cases[newkey] = rewriteΞactions(v);
-    }
-    actions.cases = cases;
-  } else if (actions instanceof Array) {
-    let result = [];
-    let curr = null;
-    for (let i = 0, itemsφ2 = iter$__(actions), lenφ2 = itemsφ2.length; i < lenφ2; i++) {
-      let action = itemsφ2[i];
-      if (action[0] == '@' && i == actions.length - 1 && curr) {
-        action = { next: action };
-      }
-
-      if (typeof action == 'object') {
-        if (action.token != undefined || action.cases) {
-          result.push((curr = Object.assign({}, action)));
-        } else {
-          Object.assign(curr, action);
-        }
-      } else if (typeof action == 'string') {
-        result.push((curr = { token: rewriteΞtoken(action) }));
-      }
-    }
-    actions = result;
-  }
-
-  if (actions instanceof Array) {
-    for (let i = 0, itemsφ3 = iter$__(actions), lenφ3 = itemsφ3.length; i < lenφ3; i++) {
-      let action = itemsφ3[i];
-      if (action.token && action.token.indexOf('$$') >= 0) {
-        action.token = action.token.replace('$$', '$' + (i + 1));
-      }
-      if (action.next) {
-        action.next = rewriteΞstate(action.next);
-      }
-      if (action.switchTo) {
-        action.switchTo = rewriteΞstate(action.switchTo);
-      }
-    }
-  }
-
-  return actions;
-}
-
-function rewriteΞrule(owner, key) {
-  let rule;
-
-  return (rule = owner[key]);
-}
-
-for (let iφ4 = 0, keysφ3 = Object.keys(states), lφ3 = keysφ3.length, key, rules; iφ4 < lφ3; iφ4++) {
-  key = keysφ3[iφ4];
-  rules = states[key];
-  let i = 0;
-  while (i < rules.length) {
-    let rule = rules[i];
-    if (rule[0] instanceof Array) {
-      rules.splice(i, 1, ...rule);
-      continue;
-    } else if (typeof rule == 'string') {
-      rules[i] = { include: rule };
-    } else if (rule[1] instanceof Array) {
-      rule[1] = rewriteΞactions(rule[1]);
-    } else if (rule instanceof Array) {
-      rule.splice(1, 2, rewriteΞactions(rule[1], rule[2]));
-    }
-    i++;
-  }
-}
-
-const grammar = {
-  defaultToken: 'invalid',
-  ignoreCase: false,
-  tokenPostfix: '',
-  brackets: [
-    { open: '{', close: '}', token: 'bracket.curly' },
-    { open: '[', close: ']', token: 'bracket.square' },
-    { open: '(', close: ')', token: 'bracket.parenthesis' },
-  ],
-  keywords: [
-    'def',
-    'and',
-    'or',
-    'is',
-    'isnt',
-    'not',
-    'on',
-    'yes',
-    '@',
-    'no',
-    'off',
-    'true',
-    'false',
-    'null',
-    'this',
-    'self',
-    'as',
-    'new',
-    'delete',
-    'typeof',
-    'in',
-    'instanceof',
-    'return',
-    'throw',
-    'break',
-    'continue',
-    'debugger',
-    'if',
-    'elif',
-    'else',
-    'switch',
-    'for',
-    'while',
-    'do',
-    'try',
-    'catch',
-    'finally',
-    'class',
-    'extends',
-    'super',
-    'undefined',
-    'then',
-    'unless',
-    'until',
-    'loop',
-    'of',
-    'by',
-    'when',
-    'tag',
-    'prop',
-    'attr',
-    'export',
-    'import',
-    'extend',
-    'var',
-    'let',
-    'const',
-    'require',
-    'isa',
-    'await',
-  ],
-  boolean: ['true', 'false', 'yes', 'no', 'undefined', 'null'],
-  operators: [
-    '=',
-    '!',
-    '~',
-    '?',
-    ':',
-    '!!',
-    '??',
-    '&',
-    '|',
-    '^',
-    '%',
-    '<<',
-    '!&',
-    '>>',
-    '>>>',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '&=',
-    '|=',
-    '?=',
-    '??=',
-    '^=',
-    '%=',
-    '~=',
-    '<<=',
-    '>>=',
-    '>>>=',
-    '..',
-    '...',
-    '||=',
-    `&&=`,
-    '**=',
-    '**',
-    '|=?',
-    '~=?',
-    '^=?',
-    '=?',
-    'and',
-    'or',
-  ],
-  assignments: [
-    '=',
-    '|=?',
-    '~=?',
-    '^=?',
-    '=?',
-    '^=',
-    '%=',
-    '~=',
-    '<<=',
-    '>>=',
-    '>>>=',
-    '||=',
-    `&&=`,
-    '?=',
-    '??=',
-    '+=',
-    '-=',
-    '*=',
-    '/=',
-    '&=',
-    '|=',
-    '**=',
-  ],
-  logic: ['>', '<', '==', '<=', '>=', '!=', '&&', '||', '===', '!=='],
-  ranges: ['..', '...'],
-  spread: ['...'],
-  dot: ['.'],
-  access: ['.', '..'],
-  math: ['+', '-', '*', '/', '++', '--'],
-
-  unspaced_ops: regexify('... . .. + * ++ --'),
-  comment: /#(\s.*)?(\n|$)/,
-  // we include these common regular expressions
-  symbols: /[=><!~?&%|+\-*\^,]+/,
-  escapes: /\\(?:[abfnrtv\\"'$]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
-  postaccess: /(:(?=\w))?/,
-  ivar: /\@[a-zA-Z_]\w*/,
-  B: /(?=\s|$)/,
-  br: /[\r\n]+/,
-  constant: /[A-Z][\w\$]*(?:\-+[\w\$]+)*/,
-  // subIdentifier: /(?:\-*[\w\$]+)*/
-  // identifier: /[a-z_]@subIdentifier/
-  // anyIdentifier: /[A-Za-z_\$][\w\$]*(?:\-+[\w\$]+)*/
-  // anyIdentifierOpt: /(?:@anyIdentifier)?/
-  id: /[A-Za-z_\$][\w\$]*(?:\-+[\w\$]+)*\??/,
-  plainid: /[A-Za-z_\$][\w\$]*(?:\-+[\w\$]+)*\??/,
-  fieldid: /[\@\#]*@plainid/,
-  propid: /[\@\#]*@plainid/,
-  defid: /[\@\#]*@plainid/,
-  decid: /\@@plainid/,
-  symid: /\#+@plainid/,
-  symref: /\#\#@plainid/,
-  optid: /(?:@id)?/,
-  // (?:\-+[\w\$]+)*\??
-  esmIdentifier: /[A-Za-z_\$\@][\w\$]*(?:\-+[\w\$]+)*\??/,
-  propertyPath: /(?:[A-Za-z_\$][A-Za-z\d\-\_\$]*\.)?(?:[A-Za-z_\$][A-Za-z\d\-\_\$]*)/,
-  tagNameIdentifier: /(?:[\w\-]+\:)?\w+(?:\-\w+)*/,
-  variable: /[\w\$]+(?:-[\w\$]*)*\??/,
-  varKeyword: /var|let|const/,
-  tagIdentifier: /-*[a-zA-Z][\w\-]*/,
-  implicitCall: /(?!\s(?:and|or|is|isa)\s)(?=\s[\w\'\"\/\[\{])/, // not true for or etc
-  cssModifier: /(?:\@+[\<\>\!]?[\w\-]+\+?|\.+@id\-?)/,
-  cssPropertyPath: /[\@\.]*[\w\-\$]+(?:[\@\.]+[\w\-\$]+)*/,
-  cssPropertyKey: /[\@\.]*[\w\-\$]+(?:[\@\.]+[\w\-\$]+)*(?:\s*\:)/,
-
-  cssVariable: /(?:--|\$)[\w\-\$]+/,
-  cssPropertyName: /[\w\-\$]+/,
-  // cssModifier: /\@[\w\-\$]+/
-  cssPropertyKey2: /(?:@cssPropertyName(?:@cssModifier)*|@cssModifier+)(?:\s*\:)/,
-  cssUpModifier: /\.\.[\w\-\$]+/,
-  cssIsModifier: /\.[\w\-\$]+/,
-
-  regEx: /\/(?!\/\/)(?:[^\/\\]|\\.)*\/[igm]*/,
-  regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
-  regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
-  // The main tokenizer for our languages
-  tokenizer: states,
-};
-
-export default {
-  tokens: grammar,
-
-  config: {
-    wordPattern:
-      /(-?\d*\.\d\w*)|([^\`\~\!\@\#%\^\&\*\(\)\=\$\-\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
-    comments: {
-      blockComment: ['###', '###'],
-      lineComment: '#',
-    },
-    brackets: [
-      ['{', '}', 'delimiter.curly'],
-      ['[', ']', 'delimiter.square'],
-      ['(', ')', 'delimiter.parenthesis'],
-      ['<', '>', 'delimiter.angle'],
-    ],
-    autoClosingPairs: [
-      { open: '"', close: '"', notIn: ['string', 'comment'] },
-      { open: "'", close: "'", notIn: ['string', 'comment'] },
-      { open: '{', close: '}', notIn: ['comment'] },
-      { open: '[', close: ']', notIn: ['string', 'comment'] },
-      { open: '(', close: ')', notIn: ['string', 'comment'] },
-      { open: '<', close: '>', notIn: ['string', 'comment', 'operators'] },
-    ],
-    onEnterRules: [
-      {
-        beforeText:
-          /^\s*(?:def|get \w|set \w|class|for|if|elif|else|while|try|with|finally|except|async).*?$/,
-        action: { indentAction: 1 },
-      },
-      {
-        beforeText: /\s*(?:do)\s*(\|.*\|\s*)?$/,
-        action: { indentAction: 1 },
-      },
-    ],
-  },
-};
diff --git a/src/livecodes/editor/monaco/languages/monaco-lang-minizinc.ts b/src/livecodes/editor/monaco/languages/monaco-lang-minizinc.ts
deleted file mode 100644
index 12bec7ac62..0000000000
--- a/src/livecodes/editor/monaco/languages/monaco-lang-minizinc.ts
+++ /dev/null
@@ -1,381 +0,0 @@
-/* eslint-disable id-blacklist */
-/* eslint-disable no-template-curly-in-string */
-import type { languages } from 'monaco-editor';
-
-const config: languages.LanguageConfiguration = {
-  comments: {
-    lineComment: '%',
-    blockComment: ['/*', '*/'],
-  },
-  brackets: [
-    ['{', '}'],
-    ['[', ']'],
-    ['(', ')'],
-  ],
-  autoClosingPairs: [
-    { open: '{', close: '}' },
-    { open: '[', close: ']' },
-    { open: '(', close: ')' },
-    { open: '"', close: '"', notIn: ['string'] },
-    { open: "'", close: "'", notIn: ['string', 'comment'] },
-  ],
-  surroundingPairs: [
-    { open: '{', close: '}' },
-    { open: '[', close: ']' },
-    { open: '(', close: ')' },
-    { open: '"', close: '"' },
-    { open: "'", close: "'" },
-  ],
-  folding: {
-    markers: {
-      start: new RegExp('^\\s*%.*region\\b'),
-      end: new RegExp('^\\s*%.*endregion\\b'),
-    },
-  },
-};
-
-const tokens: languages.IMonarchLanguage = {
-  defaultToken: '',
-  tokenPostfix: '.mzn',
-
-  keywords: [
-    'ann',
-    'annotation',
-    'any',
-    'array',
-    'bool',
-    'constraint',
-    'default',
-    'diff',
-    'div',
-    'else',
-    'elseif',
-    'endif',
-    'enum',
-    'false',
-    'float',
-    'function',
-    'if',
-    'in',
-    'include',
-    'int',
-    'intersect',
-    'let',
-    'maximize',
-    'minimize',
-    'mod',
-    'not',
-    'of',
-    'op',
-    'opt',
-    'output',
-    'par',
-    'predicate',
-    'record',
-    'satisfy',
-    'set',
-    'solve',
-    'string',
-    'subset',
-    'superset',
-    'symdiff',
-    'test',
-    'then',
-    'true',
-    'tuple',
-    'type',
-    'union',
-    'var',
-    'where',
-    'xor',
-  ],
-
-  // Standard library functions (kept from original, as grammar doesn't enumerate stdlib)
-  builtins: [
-    'abs',
-    'acos',
-    'acosh',
-    'all_different',
-    'alldifferent',
-    'asin',
-    'asinh',
-    'assert',
-    'atan',
-    'atanh',
-    'bool2int',
-    'card',
-    'ceil',
-    'concat',
-    'cos',
-    'cosh',
-    'count',
-    'cumulative',
-    'dom',
-    'dom_array',
-    'dom_bounds_array',
-    'dom_size',
-    'exp',
-    'fix',
-    'floor',
-    'forall',
-    'index_set',
-    'index_set_1of2',
-    'index_set_2of2',
-    'int2float',
-    'is_fixed',
-    'join',
-    'lb',
-    'lb_array',
-    'length',
-    'ln',
-    'log',
-    'log10',
-    'log2',
-    'max',
-    'min',
-    'pow',
-    'product',
-    'round',
-    'set2array',
-    'show',
-    'show_float',
-    'show_int',
-    'sin',
-    'sinh',
-    'sqrt',
-    'sum',
-    'tan',
-    'tanh',
-    'trace',
-    'ub',
-    'ub_array',
-  ],
-
-  operators: [
-    '=',
-    '==',
-    '!=',
-    '<',
-    '<=',
-    '>',
-    '>=',
-    '+',
-    '-',
-    '*',
-    '/',
-    '++',
-    '->',
-    '<-',
-    '<->',
-    '\\/',
-    '/\\',
-    '..',
-    '::',
-    // Unicode operators from grammar
-    '⟷',
-    '⇔',
-    '→',
-    '⇒',
-    '←',
-    '⇐',
-    '∨',
-    '∧',
-    '⊻',
-    '≠',
-    '≤',
-    '≥',
-    '∈',
-    '⊆',
-    '⊇',
-    '∪',
-    '∩',
-    '∖',
-    '¬',
-  ],
-
-  // Special constants
-  constants: ['infinity', '∞', '∅'],
-
-  // Regular expressions
-  symbols: /[=><!~?:&|+\-*\/\^%]+/,
-
-  // Escape sequences in strings
-  escapes: /\\(?:[0-7]{1,3}|x[0-9A-Fa-f]{1,2}|["\\nrt])/,
-
-  tokenizer: {
-    root: [
-      // Identifiers and keywords
-      [
-        /[a-z_][\w_]*/,
-        {
-          cases: {
-            '@keywords': 'keyword',
-            '@builtins': 'predefined',
-            '@constants': 'constant',
-            '@default': 'identifier',
-          },
-        },
-      ],
-      // Quoted identifiers (e.g. 'My Variable')
-      [/'[^']*'/, 'identifier.quote'],
-
-      // Type identifiers (Capitalized)
-      [/[A-Z][\w_]*/, 'type.identifier'],
-
-      // Anonymous variable
-      [/_/, 'keyword'],
-
-      // Annotations (:: identifier)
-      [/::\s*[a-zA-Z_]\w*/, 'annotation'],
-
-      // Whitespace
-      { include: '@whitespace' },
-
-      // Delimiters and operators
-      [/[{}()\[\]]/, '@brackets'],
-      [/[<>](?!@symbols)/, '@brackets'],
-
-      // Unicode operators and standard symbols
-      [/@symbols/, { cases: { '@operators': 'operator', '@default': '' } }],
-      [/[\u2190-\u22FF]/, { cases: { '@operators': 'operator', '@default': '' } }], // Catch-all for math symbols if not explicitly listed
-
-      // Numbers
-      [/0x[0-9a-fA-F]+/, 'number.hex'],
-      [/0o[0-7]+/, 'number.octal'],
-      [/0b[0-1]+/, 'number.binary'],
-      [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
-      [/\d+([eE][\-+]?\d+)?/, 'number'],
-
-      // Strings
-      [/"/, { token: 'string.quote', bracket: '@open', next: '@string' }],
-    ],
-
-    string: [
-      [/[^\\"]+/, 'string'],
-      [/@escapes/, 'string.escape'],
-      // String Interpolation: \( expression )
-      [/\\\(/, { token: 'string.escape', bracket: '@open', next: '@interpolation' }],
-      [/\\./, 'string.escape.invalid'],
-      [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
-    ],
-
-    interpolation: [
-      // When inside \( ... ), we switch back to root tokenization until we hit the closing )
-      [/\)/, { token: 'string.escape', bracket: '@close', next: '@pop' }],
-      { include: '@root' },
-    ],
-
-    whitespace: [
-      [/[ \t\r\n]+/, 'white'],
-      [/%(?!\{).*/, 'comment'], // Single line comment
-      [/\/\*/, 'comment', '@comment'], // Block comment start /*
-    ],
-
-    comment: [
-      [/[^*/]+/, 'comment'],
-      [/\/\*/, 'comment', '@push'], // Nested comment
-      [/\*\//, 'comment', '@pop'], // Block comment end */
-      [/[*/]/, 'comment'],
-    ],
-  },
-};
-
-// Completion Item Provider
-const completions: languages.CompletionItemProvider = {
-  provideCompletionItems: (model, position) => {
-    const word = model.getWordUntilPosition(position);
-    const range = {
-      startLineNumber: position.lineNumber,
-      endLineNumber: position.lineNumber,
-      startColumn: word.startColumn,
-      endColumn: word.endColumn,
-    };
-
-    // Helper to create completion items
-    const createItem = (
-      label: string,
-      kind: languages.CompletionItemKind,
-      insertText: string,
-      detail?: string,
-    ) => ({
-      label,
-      kind,
-      insertText,
-      detail: detail || 'MiniZinc Keyword',
-      range,
-    });
-
-    // Keywords from the language definition
-    const keywords = tokens.keywords as string[];
-    const builtins = tokens.builtins as string[];
-
-    const snippets = [
-      {
-        label: 'constraint',
-        insertText: 'constraint ${1:expression};',
-        detail: 'Constraint declaration',
-      },
-      {
-        label: 'solve satisfy',
-        insertText: 'solve satisfy;',
-        detail: 'Solve goal',
-      },
-      {
-        label: 'solve minimize',
-        insertText: 'solve minimize ${1:variable};',
-        detail: 'Optimization goal',
-      },
-      {
-        label: 'solve maximize',
-        insertText: 'solve maximize ${1:variable};',
-        detail: 'Optimization goal',
-      },
-      {
-        label: 'array',
-        insertText: 'array[${1:1..n}] of var ${2:int}: ${3:x};',
-        detail: 'Array declaration',
-      },
-      {
-        label: 'output',
-        insertText: 'output ["${1:text} = ", show(${2:var}), "\\n"];',
-        detail: 'Output statement',
-      },
-      {
-        label: 'if-then-else',
-        insertText: 'if ${1:condition} then\n\t${2:expression}\nelse\n\t${3:expression}\nendif',
-        detail: 'If-Then-Else',
-      },
-      {
-        label: 'let',
-        insertText: 'let {\n\t${1:local_var}\n} in (\n\t${2:expression}\n)',
-        detail: 'Let expression',
-      },
-      {
-        label: 'predicate',
-        insertText: 'predicate ${1:name}(${2:params}) = \n\t${3:body};',
-        detail: 'Predicate definition',
-      },
-    ];
-
-    const suggestions = [
-      ...keywords.map((k) => createItem(k, 17 /* Keyword */, k)),
-      ...builtins.map((b) => createItem(b, 18 /* Function */, b, 'Built-in Function')),
-      ...snippets.map((s) => ({
-        label: s.label,
-        kind: 27 /* Snippet */,
-        insertText: s.insertText,
-        insertTextRules: 4 /* InsertAsSnippet */,
-        documentation: s.detail,
-        range,
-      })),
-    ];
-
-    return { suggestions };
-  },
-};
-
-export default {
-  config,
-  tokens,
-  completions,
-};
diff --git a/src/livecodes/editor/monaco/languages/monaco-lang-prolog.ts b/src/livecodes/editor/monaco/languages/monaco-lang-prolog.ts
deleted file mode 100644
index e8f83de13e..0000000000
--- a/src/livecodes/editor/monaco/languages/monaco-lang-prolog.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-export default {
-  config: {
-    comments: {
-      lineComment: '%',
-      blockComment: ['/*', '*/'],
-    },
-    brackets: [
-      ['{', '}'],
-      ['[', ']'],
-      ['(', ')'],
-    ],
-    autoClosingPairs: [
-      { open: '{', close: '}' },
-      { open: '[', close: ']' },
-      { open: '(', close: ')' },
-      { open: "'", close: "'", notIn: ['string', 'comment'] },
-      { open: '"', close: '"', notIn: ['string', 'comment'] },
-    ],
-    surroundingPairs: [
-      { open: '{', close: '}' },
-      { open: '[', close: ']' },
-      { open: '(', close: ')' },
-      { open: "'", close: "'" },
-      { open: '"', close: '"' },
-    ],
-  },
-  tokens: {
-    defaultToken: '',
-    tokenPostfix: '.prolog',
-
-    // Common regular expressions
-    atom: /[a-z][a-zA-Z0-9_]*/,
-    variable: /[A-Z_][a-zA-Z0-9_]*/,
-
-    builtins: [
-      'write',
-      'writeln',
-      'nl',
-      'read',
-      'get',
-      'put',
-      'assert',
-      'retract',
-      'consult',
-      'fail',
-      'true',
-      'is',
-      'mod',
-      'rem',
-      'not',
-      'repeat',
-      '!',
-      'member',
-      'append',
-      'length',
-      'findall',
-      'bagof',
-      'setof',
-    ],
-
-    tokenizer: {
-      root: [
-        // --- FIXED COMMENT LOGIC ---
-        // Match % followed by anything that is NOT a newline
-        [/%[^\n\r]*/, 'comment'],
-
-        // Block comments
-        [/\/\*/, 'comment', '@commentBlock'],
-
-        // Strings (Double quotes)
-        [/"/, 'string', '@stringDouble'],
-
-        // Quoted Atoms (Single quotes)
-        [/'/, 'string.atom', '@stringSingle'],
-
-        // Cut operator
-        [/!/, 'keyword.cut'],
-
-        // Comparison and Math Operators
-        [/:-|-->/, 'keyword.operator'],
-        [/[=><\\+\-\*\/]+/, 'operator'],
-
-        // Variables
-        [/@variable/, 'variable'],
-
-        // Built-in predicates vs Normal Atoms
-        [
-          /@atom/,
-          {
-            cases: {
-              '@builtins': 'predefined',
-              '@default': 'type.identifier',
-            },
-          },
-        ],
-
-        // Numbers
-        [/\d+(\.\d+)?/, 'number'],
-
-        // Brackets and punctuation
-        [/[[]\{\}\(\)\.,|]/, 'delimiter'],
-
-        // Whitespace
-        [/\s+/, 'white'],
-      ],
-
-      commentBlock: [
-        [/[^\/*]+/, 'comment'],
-        [/\*\//, 'comment', '@pop'],
-        [/[\/*]/, 'comment'],
-      ],
-
-      stringDouble: [
-        [/[^\\"]+/, 'string'],
-        [/\\./, 'string.escape'],
-        [/"/, 'string', '@pop'],
-      ],
-
-      stringSingle: [
-        [/[^\\']+/, 'string.atom'],
-        [/\\./, 'string.escape'],
-        [/'/, 'string.atom', '@pop'],
-      ],
-    },
-  },
-};
diff --git a/src/livecodes/editor/monaco/languages/monaco-lang-sql.ts b/src/livecodes/editor/monaco/languages/monaco-lang-sql.ts
deleted file mode 100644
index 79741e114d..0000000000
--- a/src/livecodes/editor/monaco/languages/monaco-lang-sql.ts
+++ /dev/null
@@ -1,1401 +0,0 @@
-/* eslint-disable id-blacklist */
-// from https://github.com/DTStack/monaco-sql-languages/blob/main/src/sql/sql.ts
-
-export default {
-  config: {
-    comments: {
-      lineComment: '--',
-      blockComment: ['/*', '*/'],
-    },
-    brackets: [
-      ['{', '}'],
-      ['[', ']'],
-      ['(', ')'],
-    ],
-    autoClosingPairs: [
-      { open: '{', close: '}' },
-      { open: '[', close: ']' },
-      { open: '(', close: ')' },
-      { open: '"', close: '"' },
-      { open: "'", close: "'" },
-    ],
-    surroundingPairs: [
-      { open: '{', close: '}' },
-      { open: '[', close: ']' },
-      { open: '(', close: ')' },
-      { open: '"', close: '"' },
-      { open: "'", close: "'" },
-    ],
-  },
-
-  tokens: {
-    defaultToken: '',
-    tokenPostfix: '.sql',
-    ignoreCase: true,
-
-    brackets: [
-      { open: '[', close: ']', token: 'delimiter.square' },
-      { open: '(', close: ')', token: 'delimiter.parenthesis' },
-    ],
-
-    keywords: [
-      'ABORT_AFTER_WAIT',
-      'ABSENT',
-      'ABSOLUTE',
-      'ACCENT_SENSITIVITY',
-      'ACTION',
-      'ACTIVATION',
-      'ACTIVE',
-      'ADD',
-      'ADDRESS',
-      'ADMIN',
-      'AES',
-      'AES_128',
-      'AES_192',
-      'AES_256',
-      'AFFINITY',
-      'AFTER',
-      'AGGREGATE',
-      'ALGORITHM',
-      'ALL_CONSTRAINTS',
-      'ALL_ERRORMSGS',
-      'ALL_INDEXES',
-      'ALL_LEVELS',
-      'ALL_SPARSE_COLUMNS',
-      'ALLOW_CONNECTIONS',
-      'ALLOW_MULTIPLE_EVENT_LOSS',
-      'ALLOW_PAGE_LOCKS',
-      'ALLOW_ROW_LOCKS',
-      'ALLOW_SINGLE_EVENT_LOSS',
-      'ALLOW_SNAPSHOT_ISOLATION',
-      'ALLOWED',
-      'ALTER',
-      'ANONYMOUS',
-      'ANSI_DEFAULTS',
-      'ANSI_NULL_DEFAULT',
-      'ANSI_NULL_DFLT_OFF',
-      'ANSI_NULL_DFLT_ON',
-      'ANSI_NULLS',
-      'ANSI_PADDING',
-      'ANSI_WARNINGS',
-      'APPEND',
-      'APPLICATION',
-      'APPLICATION_LOG',
-      'ARITHABORT',
-      'ARITHIGNORE',
-      'AS',
-      'ASC',
-      'ASSEMBLY',
-      'ASYMMETRIC',
-      'ASYNCHRONOUS_COMMIT',
-      'AT',
-      'ATOMIC',
-      'ATTACH',
-      'ATTACH_REBUILD_LOG',
-      'AUDIT',
-      'AUDIT_GUID',
-      'AUTHENTICATION',
-      'AUTHORIZATION',
-      'AUTO',
-      'AUTO_CLEANUP',
-      'AUTO_CLOSE',
-      'AUTO_CREATE_STATISTICS',
-      'AUTO_SHRINK',
-      'AUTO_UPDATE_STATISTICS',
-      'AUTO_UPDATE_STATISTICS_ASYNC',
-      'AUTOMATED_BACKUP_PREFERENCE',
-      'AUTOMATIC',
-      'AVAILABILITY',
-      'AVAILABILITY_MODE',
-      'BACKUP',
-      'BACKUP_PRIORITY',
-      'BASE64',
-      'BATCHSIZE',
-      'BEGIN',
-      'BEGIN_DIALOG',
-      'BIGINT',
-      'BINARY',
-      'BINDING',
-      'BIT',
-      'BLOCKERS',
-      'BLOCKSIZE',
-      'BOUNDING_BOX',
-      'BREAK',
-      'BROKER',
-      'BROKER_INSTANCE',
-      'BROWSE',
-      'BUCKET_COUNT',
-      'BUFFER',
-      'BUFFERCOUNT',
-      'BULK',
-      'BULK_LOGGED',
-      'BY',
-      'CACHE',
-      'CALL',
-      'CALLED',
-      'CALLER',
-      'CAP_CPU_PERCENT',
-      'CASCADE',
-      'CASE',
-      'CATALOG',
-      'CATCH',
-      'CELLS_PER_OBJECT',
-      'CERTIFICATE',
-      'CHANGE_RETENTION',
-      'CHANGE_TRACKING',
-      'CHANGES',
-      'CHAR',
-      'CHARACTER',
-      'CHECK',
-      'CHECK_CONSTRAINTS',
-      'CHECK_EXPIRATION',
-      'CHECK_POLICY',
-      'CHECKALLOC',
-      'CHECKCATALOG',
-      'CHECKCONSTRAINTS',
-      'CHECKDB',
-      'CHECKFILEGROUP',
-      'CHECKIDENT',
-      'CHECKPOINT',
-      'CHECKTABLE',
-      'CLASSIFIER_FUNCTION',
-      'CLEANTABLE',
-      'CLEANUP',
-      'CLEAR',
-      'CLOSE',
-      'CLUSTER',
-      'CLUSTERED',
-      'CODEPAGE',
-      'COLLATE',
-      'COLLECTION',
-      'COLUMN',
-      'COLUMN_SET',
-      'COLUMNS',
-      'COLUMNSTORE',
-      'COLUMNSTORE_ARCHIVE',
-      'COMMIT',
-      'COMMITTED',
-      'COMPATIBILITY_LEVEL',
-      'COMPRESSION',
-      'COMPUTE',
-      'CONCAT',
-      'CONCAT_NULL_YIELDS_NULL',
-      'CONFIGURATION',
-      'CONNECT',
-      'CONSTRAINT',
-      'CONTAINMENT',
-      'CONTENT',
-      'CONTEXT',
-      'CONTINUE',
-      'CONTINUE_AFTER_ERROR',
-      'CONTRACT',
-      'CONTRACT_NAME',
-      'CONTROL',
-      'CONVERSATION',
-      'COOKIE',
-      'COPY_ONLY',
-      'COUNTER',
-      'CPU',
-      'CREATE',
-      'CREATE_NEW',
-      'CREATION_DISPOSITION',
-      'CREDENTIAL',
-      'CRYPTOGRAPHIC',
-      'CUBE',
-      'CURRENT',
-      'CURRENT_DATE',
-      'CURSOR',
-      'CURSOR_CLOSE_ON_COMMIT',
-      'CURSOR_DEFAULT',
-      'CYCLE',
-      'DATA',
-      'DATA_COMPRESSION',
-      'DATA_PURITY',
-      'DATABASE',
-      'DATABASE_DEFAULT',
-      'DATABASE_MIRRORING',
-      'DATABASE_SNAPSHOT',
-      'DATAFILETYPE',
-      'DATE',
-      'DATE_CORRELATION_OPTIMIZATION',
-      'DATEFIRST',
-      'DATEFORMAT',
-      'DATETIME',
-      'DATETIME2',
-      'DATETIMEOFFSET',
-      'DAY',
-      'DAYOFYEAR',
-      'DAYS',
-      'DB_CHAINING',
-      'DBCC',
-      'DBREINDEX',
-      'DDL_DATABASE_LEVEL_EVENTS',
-      'DEADLOCK_PRIORITY',
-      'DEALLOCATE',
-      'DEC',
-      'DECIMAL',
-      'DECLARE',
-      'DECRYPTION',
-      'DEFAULT',
-      'DEFAULT_DATABASE',
-      'DEFAULT_FULLTEXT_LANGUAGE',
-      'DEFAULT_LANGUAGE',
-      'DEFAULT_SCHEMA',
-      'DEFINITION',
-      'DELAY',
-      'DELAYED_DURABILITY',
-      'DELETE',
-      'DELETED',
-      'DENSITY_VECTOR',
-      'DENY',
-      'DEPENDENTS',
-      'DES',
-      'DESC',
-      'DESCRIPTION',
-      'DESX',
-      'DHCP',
-      'DIAGNOSTICS',
-      'DIALOG',
-      'DIFFERENTIAL',
-      'DIRECTORY_NAME',
-      'DISABLE',
-      'DISABLE_BROKER',
-      'DISABLED',
-      'DISK',
-      'DISTINCT',
-      'DISTRIBUTED',
-      'DOCUMENT',
-      'DOUBLE',
-      'DROP',
-      'DROP_EXISTING',
-      'DROPCLEANBUFFERS',
-      'DUMP',
-      'DURABILITY',
-      'DYNAMIC',
-      'EDITION',
-      'ELEMENTS',
-      'ELSE',
-      'EMERGENCY',
-      'EMPTY',
-      'EMPTYFILE',
-      'ENABLE',
-      'ENABLE_BROKER',
-      'ENABLED',
-      'ENCRYPTION',
-      'END',
-      'ENDPOINT',
-      'ENDPOINT_URL',
-      'ERRLVL',
-      'ERROR',
-      'ERROR_BROKER_CONVERSATIONS',
-      'ERRORFILE',
-      'ESCAPE',
-      'ESTIMATEONLY',
-      'EVENT',
-      'EVENT_RETENTION_MODE',
-      'EXEC',
-      'EXECUTABLE',
-      'EXECUTE',
-      'EXIT',
-      'EXPAND',
-      'EXPIREDATE',
-      'EXPIRY_DATE',
-      'EXPLICIT',
-      'EXTENDED_LOGICAL_CHECKS',
-      'EXTENSION',
-      'EXTERNAL',
-      'EXTERNAL_ACCESS',
-      'FAIL_OPERATION',
-      'FAILOVER',
-      'FAILOVER_MODE',
-      'FAILURE_CONDITION_LEVEL',
-      'FALSE',
-      'FAN_IN',
-      'FAST',
-      'FAST_FORWARD',
-      'FETCH',
-      'FIELDTERMINATOR',
-      'FILE',
-      'FILEGROUP',
-      'FILEGROWTH',
-      'FILELISTONLY',
-      'FILENAME',
-      'FILEPATH',
-      'FILESTREAM',
-      'FILESTREAM_ON',
-      'FILETABLE_COLLATE_FILENAME',
-      'FILETABLE_DIRECTORY',
-      'FILETABLE_FULLPATH_UNIQUE_CONSTRAINT_NAME',
-      'FILETABLE_NAMESPACE',
-      'FILETABLE_PRIMARY_KEY_CONSTRAINT_NAME',
-      'FILETABLE_STREAMID_UNIQUE_CONSTRAINT_NAME',
-      'FILLFACTOR',
-      'FILTERING',
-      'FIRE_TRIGGERS',
-      'FIRST',
-      'FIRSTROW',
-      'FLOAT',
-      'FMTONLY',
-      'FOLLOWING',
-      'FOR',
-      'FORCE',
-      'FORCE_FAILOVER_ALLOW_DATA_LOSS',
-      'FORCE_SERVICE_ALLOW_DATA_LOSS',
-      'FORCED',
-      'FORCEPLAN',
-      'FORCESCAN',
-      'FORCESEEK',
-      'FOREIGN',
-      'FORMATFILE',
-      'FORMSOF',
-      'FORWARD_ONLY',
-      'FREE',
-      'FREEPROCCACHE',
-      'FREESESSIONCACHE',
-      'FREESYSTEMCACHE',
-      'FROM',
-      'FULL',
-      'FULLSCAN',
-      'FULLTEXT',
-      'FUNCTION',
-      'GB',
-      'GEOGRAPHY_AUTO_GRID',
-      'GEOGRAPHY_GRID',
-      'GEOMETRY_AUTO_GRID',
-      'GEOMETRY_GRID',
-      'GET',
-      'GLOBAL',
-      'GO',
-      'GOTO',
-      'GOVERNOR',
-      'GRANT',
-      'GRIDS',
-      'GROUP',
-      'GROUP_MAX_REQUESTS',
-      'HADR',
-      'HASH',
-      'HASHED',
-      'HAVING',
-      'HEADERONLY',
-      'HEALTH_CHECK_TIMEOUT',
-      'HELP',
-      'HIERARCHYID',
-      'HIGH',
-      'HINT',
-      'HISTOGRAM',
-      'HOLDLOCK',
-      'HONOR_BROKER_PRIORITY',
-      'HOUR',
-      'HOURS',
-      'IDENTITY',
-      'IDENTITY_INSERT',
-      'IDENTITY_VALUE',
-      'IDENTITYCOL',
-      'IF',
-      'IGNORE_CONSTRAINTS',
-      'IGNORE_DUP_KEY',
-      'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX',
-      'IGNORE_TRIGGERS',
-      'IMAGE',
-      'IMMEDIATE',
-      'IMPERSONATE',
-      'IMPLICIT_TRANSACTIONS',
-      'IMPORTANCE',
-      'INCLUDE',
-      'INCREMENT',
-      'INCREMENTAL',
-      'INDEX',
-      'INDEXDEFRAG',
-      'INFINITE',
-      'INFLECTIONAL',
-      'INIT',
-      'INITIATOR',
-      'INPUT',
-      'INPUTBUFFER',
-      'INSENSITIVE',
-      'INSERT',
-      'INSERTED',
-      'INSTEAD',
-      'INT',
-      'INTEGER',
-      'INTO',
-      'IO',
-      'IP',
-      'ISABOUT',
-      'ISOLATION',
-      'JOB',
-      'KB',
-      'KEEP',
-      'KEEP_CDC',
-      'KEEP_NULLS',
-      'KEEP_REPLICATION',
-      'KEEPDEFAULTS',
-      'KEEPFIXED',
-      'KEEPIDENTITY',
-      'KEEPNULLS',
-      'KERBEROS',
-      'KEY',
-      'KEY_SOURCE',
-      'KEYS',
-      'KEYSET',
-      'KILL',
-      'KILOBYTES_PER_BATCH',
-      'LABELONLY',
-      'LANGUAGE',
-      'LAST',
-      'LASTROW',
-      'LEVEL',
-      'LEVEL_1',
-      'LEVEL_2',
-      'LEVEL_3',
-      'LEVEL_4',
-      'LIFETIME',
-      'LIMIT',
-      'LINENO',
-      'LIST',
-      'LISTENER',
-      'LISTENER_IP',
-      'LISTENER_PORT',
-      'LOAD',
-      'LOADHISTORY',
-      'LOB_COMPACTION',
-      'LOCAL',
-      'LOCAL_SERVICE_NAME',
-      'LOCK_ESCALATION',
-      'LOCK_TIMEOUT',
-      'LOGIN',
-      'LOGSPACE',
-      'LOOP',
-      'LOW',
-      'MANUAL',
-      'MARK',
-      'MARK_IN_USE_FOR_REMOVAL',
-      'MASTER',
-      'MAX_CPU_PERCENT',
-      'MAX_DISPATCH_LATENCY',
-      'MAX_DOP',
-      'MAX_DURATION',
-      'MAX_EVENT_SIZE',
-      'MAX_FILES',
-      'MAX_IOPS_PER_VOLUME',
-      'MAX_MEMORY',
-      'MAX_MEMORY_PERCENT',
-      'MAX_QUEUE_READERS',
-      'MAX_ROLLOVER_FILES',
-      'MAX_SIZE',
-      'MAXDOP',
-      'MAXERRORS',
-      'MAXLENGTH',
-      'MAXRECURSION',
-      'MAXSIZE',
-      'MAXTRANSFERSIZE',
-      'MAXVALUE',
-      'MB',
-      'MEDIADESCRIPTION',
-      'MEDIANAME',
-      'MEDIAPASSWORD',
-      'MEDIUM',
-      'MEMBER',
-      'MEMORY_OPTIMIZED',
-      'MEMORY_OPTIMIZED_DATA',
-      'MEMORY_OPTIMIZED_ELEVATE_TO_SNAPSHOT',
-      'MEMORY_PARTITION_MODE',
-      'MERGE',
-      'MESSAGE',
-      'MESSAGE_FORWARD_SIZE',
-      'MESSAGE_FORWARDING',
-      'MICROSECOND',
-      'MILLISECOND',
-      'MIN_CPU_PERCENT',
-      'MIN_IOPS_PER_VOLUME',
-      'MIN_MEMORY_PERCENT',
-      'MINUTE',
-      'MINUTES',
-      'MINVALUE',
-      'MIRROR',
-      'MIRROR_ADDRESS',
-      'MODIFY',
-      'MONEY',
-      'MONTH',
-      'MOVE',
-      'MULTI_USER',
-      'MUST_CHANGE',
-      'NAME',
-      'NANOSECOND',
-      'NATIONAL',
-      'NATIVE_COMPILATION',
-      'NCHAR',
-      'NEGOTIATE',
-      'NESTED_TRIGGERS',
-      'NEW_ACCOUNT',
-      'NEW_BROKER',
-      'NEW_PASSWORD',
-      'NEWNAME',
-      'NEXT',
-      'NO',
-      'NO_BROWSETABLE',
-      'NO_CHECKSUM',
-      'NO_COMPRESSION',
-      'NO_EVENT_LOSS',
-      'NO_INFOMSGS',
-      'NO_TRUNCATE',
-      'NO_WAIT',
-      'NOCHECK',
-      'NOCOUNT',
-      'NOEXEC',
-      'NOEXPAND',
-      'NOFORMAT',
-      'NOINDEX',
-      'NOINIT',
-      'NOLOCK',
-      'NON',
-      'NON_TRANSACTED_ACCESS',
-      'NONCLUSTERED',
-      'NONE',
-      'NORECOMPUTE',
-      'NORECOVERY',
-      'NORESEED',
-      'NORESET',
-      'NOREWIND',
-      'NORMAL',
-      'NOSKIP',
-      'NOTIFICATION',
-      'NOTRUNCATE',
-      'NOUNLOAD',
-      'NOWAIT',
-      'NTEXT',
-      'NTLM',
-      'NUMANODE',
-      'NUMERIC',
-      'NUMERIC_ROUNDABORT',
-      'NVARCHAR',
-      'OBJECT',
-      'OF',
-      'OFF',
-      'OFFLINE',
-      'OFFSET',
-      'OFFSETS',
-      'OLD_ACCOUNT',
-      'OLD_PASSWORD',
-      'ON',
-      'ON_FAILURE',
-      'ONLINE',
-      'ONLY',
-      'OPEN',
-      'OPEN_EXISTING',
-      'OPENTRAN',
-      'OPTIMISTIC',
-      'OPTIMIZE',
-      'OPTION',
-      'ORDER',
-      'OUT',
-      'OUTPUT',
-      'OUTPUTBUFFER',
-      'OVER',
-      'OVERRIDE',
-      'OWNER',
-      'OWNERSHIP',
-      'PAD_INDEX',
-      'PAGE',
-      'PAGE_VERIFY',
-      'PAGECOUNT',
-      'PAGLOCK',
-      'PARAMETERIZATION',
-      'PARSEONLY',
-      'PARTIAL',
-      'PARTITION',
-      'PARTITIONS',
-      'PARTNER',
-      'PASSWORD',
-      'PATH',
-      'PER_CPU',
-      'PER_NODE',
-      'PERCENT',
-      'PERMISSION_SET',
-      'PERSISTED',
-      'PHYSICAL_ONLY',
-      'PLAN',
-      'POISON_MESSAGE_HANDLING',
-      'POOL',
-      'POPULATION',
-      'PORT',
-      'PRECEDING',
-      'PRECISION',
-      'PRIMARY',
-      'PRIMARY_ROLE',
-      'PRINT',
-      'PRIOR',
-      'PRIORITY',
-      'PRIORITY_LEVEL',
-      'PRIVATE',
-      'PRIVILEGES',
-      'PROC',
-      'PROCCACHE',
-      'PROCEDURE',
-      'PROCEDURE_NAME',
-      'PROCESS',
-      'PROFILE',
-      'PROPERTY',
-      'PROPERTY_DESCRIPTION',
-      'PROPERTY_INT_ID',
-      'PROPERTY_SET_GUID',
-      'PROVIDER',
-      'PROVIDER_KEY_NAME',
-      'PUBLIC',
-      'PUT',
-      'QUARTER',
-      'QUERY',
-      'QUERY_GOVERNOR_COST_LIMIT',
-      'QUEUE',
-      'QUEUE_DELAY',
-      'QUOTED_IDENTIFIER',
-      'RAISERROR',
-      'RANGE',
-      'RAW',
-      'RC2',
-      'RC4',
-      'RC4_128',
-      'READ',
-      'READ_COMMITTED_SNAPSHOT',
-      'READ_ONLY',
-      'READ_ONLY_ROUTING_LIST',
-      'READ_ONLY_ROUTING_URL',
-      'READ_WRITE',
-      'READ_WRITE_FILEGROUPS',
-      'READCOMMITTED',
-      'READCOMMITTEDLOCK',
-      'READONLY',
-      'READPAST',
-      'READTEXT',
-      'READUNCOMMITTED',
-      'READWRITE',
-      'REAL',
-      'REBUILD',
-      'RECEIVE',
-      'RECOMPILE',
-      'RECONFIGURE',
-      'RECOVERY',
-      'RECURSIVE',
-      'RECURSIVE_TRIGGERS',
-      'REFERENCES',
-      'REGENERATE',
-      'RELATED_CONVERSATION',
-      'RELATED_CONVERSATION_GROUP',
-      'RELATIVE',
-      'REMOTE',
-      'REMOTE_PROC_TRANSACTIONS',
-      'REMOTE_SERVICE_NAME',
-      'REMOVE',
-      'REORGANIZE',
-      'REPAIR_ALLOW_DATA_LOSS',
-      'REPAIR_FAST',
-      'REPAIR_REBUILD',
-      'REPEATABLE',
-      'REPEATABLEREAD',
-      'REPLICA',
-      'REPLICATION',
-      'REQUEST_MAX_CPU_TIME_SEC',
-      'REQUEST_MAX_MEMORY_GRANT_PERCENT',
-      'REQUEST_MEMORY_GRANT_TIMEOUT_SEC',
-      'REQUIRED',
-      'RESAMPLE',
-      'RESEED',
-      'RESERVE_DISK_SPACE',
-      'RESET',
-      'RESOURCE',
-      'RESTART',
-      'RESTORE',
-      'RESTRICT',
-      'RESTRICTED_USER',
-      'RESULT',
-      'RESUME',
-      'RETAINDAYS',
-      'RETENTION',
-      'RETURN',
-      'RETURNS',
-      'REVERT',
-      'REVOKE',
-      'REWIND',
-      'REWINDONLY',
-      'ROBUST',
-      'ROLE',
-      'ROLLBACK',
-      'ROLLUP',
-      'ROOT',
-      'ROUTE',
-      'ROW',
-      'ROWCOUNT',
-      'ROWGUIDCOL',
-      'ROWLOCK',
-      'ROWS',
-      'ROWS_PER_BATCH',
-      'ROWTERMINATOR',
-      'ROWVERSION',
-      'RSA_1024',
-      'RSA_2048',
-      'RSA_512',
-      'RULE',
-      'SAFE',
-      'SAFETY',
-      'SAMPLE',
-      'SAVE',
-      'SCHEDULER',
-      'SCHEMA',
-      'SCHEMA_AND_DATA',
-      'SCHEMA_ONLY',
-      'SCHEMABINDING',
-      'SCHEME',
-      'SCROLL',
-      'SCROLL_LOCKS',
-      'SEARCH',
-      'SECOND',
-      'SECONDARY',
-      'SECONDARY_ONLY',
-      'SECONDARY_ROLE',
-      'SECONDS',
-      'SECRET',
-      'SECURITY_LOG',
-      'SECURITYAUDIT',
-      'SELECT',
-      'SELECTIVE',
-      'SELF',
-      'SEND',
-      'SENT',
-      'SEQUENCE',
-      'SERIALIZABLE',
-      'SERVER',
-      'SERVICE',
-      'SERVICE_BROKER',
-      'SERVICE_NAME',
-      'SESSION',
-      'SESSION_TIMEOUT',
-      'SET',
-      'SETS',
-      'SETUSER',
-      'SHOW_STATISTICS',
-      'SHOWCONTIG',
-      'SHOWPLAN',
-      'SHOWPLAN_ALL',
-      'SHOWPLAN_TEXT',
-      'SHOWPLAN_XML',
-      'SHRINKDATABASE',
-      'SHRINKFILE',
-      'SHUTDOWN',
-      'SID',
-      'SIGNATURE',
-      'SIMPLE',
-      'SINGLE_BLOB',
-      'SINGLE_CLOB',
-      'SINGLE_NCLOB',
-      'SINGLE_USER',
-      'SINGLETON',
-      'SIZE',
-      'SKIP',
-      'SMALLDATETIME',
-      'SMALLINT',
-      'SMALLMONEY',
-      'SNAPSHOT',
-      'SORT_IN_TEMPDB',
-      'SOURCE',
-      'SPARSE',
-      'SPATIAL',
-      'SPATIAL_WINDOW_MAX_CELLS',
-      'SPECIFICATION',
-      'SPLIT',
-      'SQL',
-      'SQL_VARIANT',
-      'SQLPERF',
-      'STANDBY',
-      'START',
-      'START_DATE',
-      'STARTED',
-      'STARTUP_STATE',
-      'STAT_HEADER',
-      'STATE',
-      'STATEMENT',
-      'STATIC',
-      'STATISTICAL_SEMANTICS',
-      'STATISTICS',
-      'STATISTICS_INCREMENTAL',
-      'STATISTICS_NORECOMPUTE',
-      'STATS',
-      'STATS_STREAM',
-      'STATUS',
-      'STATUSONLY',
-      'STOP',
-      'STOP_ON_ERROR',
-      'STOPAT',
-      'STOPATMARK',
-      'STOPBEFOREMARK',
-      'STOPLIST',
-      'STOPPED',
-      'SUBJECT',
-      'SUBSCRIPTION',
-      'SUPPORTED',
-      'SUSPEND',
-      'SWITCH',
-      'SYMMETRIC',
-      'SYNCHRONOUS_COMMIT',
-      'SYNONYM',
-      'SYSNAME',
-      'SYSTEM',
-      'TABLE',
-      'TABLERESULTS',
-      'TABLESAMPLE',
-      'TABLOCK',
-      'TABLOCKX',
-      'TAKE',
-      'TAPE',
-      'TARGET',
-      'TARGET_RECOVERY_TIME',
-      'TB',
-      'TCP',
-      'TEXT',
-      'TEXTIMAGE_ON',
-      'TEXTSIZE',
-      'THEN',
-      'THESAURUS',
-      'THROW',
-      'TIES',
-      'TIME',
-      'TIMEOUT',
-      'TIMER',
-      'TIMESTAMP',
-      'TINYINT',
-      'TO',
-      'TOP',
-      'TORN_PAGE_DETECTION',
-      'TRACEOFF',
-      'TRACEON',
-      'TRACESTATUS',
-      'TRACK_CAUSALITY',
-      'TRACK_COLUMNS_UPDATED',
-      'TRAN',
-      'TRANSACTION',
-      'TRANSFER',
-      'TRANSFORM_NOISE_WORDS',
-      'TRIGGER',
-      'TRIPLE_DES',
-      'TRIPLE_DES_3KEY',
-      'TRUE',
-      'TRUNCATE',
-      'TRUNCATEONLY',
-      'TRUSTWORTHY',
-      'TRY',
-      'TSQL',
-      'TWO_DIGIT_YEAR_CUTOFF',
-      'TYPE',
-      'TYPE_WARNING',
-      'UNBOUNDED',
-      'UNCHECKED',
-      'UNCOMMITTED',
-      'UNDEFINED',
-      'UNIQUE',
-      'UNIQUEIDENTIFIER',
-      'UNKNOWN',
-      'UNLIMITED',
-      'UNLOAD',
-      'UNSAFE',
-      'UPDATE',
-      'UPDATETEXT',
-      'UPDATEUSAGE',
-      'UPDLOCK',
-      'URL',
-      'USE',
-      'USED',
-      'USER',
-      'USEROPTIONS',
-      'USING',
-      'VALID_XML',
-      'VALIDATION',
-      'VALUE',
-      'VALUES',
-      'VARBINARY',
-      'VARCHAR',
-      'VARYING',
-      'VERIFYONLY',
-      'VERSION',
-      'VIEW',
-      'VIEW_METADATA',
-      'VIEWS',
-      'VISIBILITY',
-      'WAIT_AT_LOW_PRIORITY',
-      'WAITFOR',
-      'WEEK',
-      'WEIGHT',
-      'WELL_FORMED_XML',
-      'WHEN',
-      'WHERE',
-      'WHILE',
-      'WINDOWS',
-      'WITH',
-      'WITHIN',
-      'WITHOUT',
-      'WITNESS',
-      'WORK',
-      'WORKLOAD',
-      'WRITETEXT',
-      'XACT_ABORT',
-      'XLOCK',
-      'XMAX',
-      'XMIN',
-      'XML',
-      'XMLDATA',
-      'XMLNAMESPACES',
-      'XMLSCHEMA',
-      'XQUERY',
-      'XSINIL',
-      'YEAR',
-      'YMAX',
-      'YMIN',
-    ],
-    operators: [
-      // Logical
-      'ALL',
-      'AND',
-      'ANY',
-      'BETWEEN',
-      'EXISTS',
-      'IN',
-      'LIKE',
-      'NOT',
-      'OR',
-      'SOME',
-      // Set
-      'EXCEPT',
-      'INTERSECT',
-      'UNION',
-      // Join
-      'APPLY',
-      'CROSS',
-      'FULL',
-      'INNER',
-      'JOIN',
-      'LEFT',
-      'OUTER',
-      'RIGHT',
-      // Predicates
-      'CONTAINS',
-      'FREETEXT',
-      'IS',
-      'NULL',
-      // Pivoting
-      'PIVOT',
-      'UNPIVOT',
-      // Merging
-      'MATCHED',
-    ],
-    builtinFunctions: [
-      // Aggregate
-      'AVG',
-      'CHECKSUM_AGG',
-      'COUNT',
-      'COUNT_BIG',
-      'GROUPING',
-      'GROUPING_ID',
-      'MAX',
-      'MIN',
-      'SUM',
-      'STDEV',
-      'STDEVP',
-      'VAR',
-      'VARP',
-      // Analytic
-      'CUME_DIST',
-      'FIRST_VALUE',
-      'LAG',
-      'LAST_VALUE',
-      'LEAD',
-      'PERCENTILE_CONT',
-      'PERCENTILE_DISC',
-      'PERCENT_RANK',
-      // Collation
-      'COLLATE',
-      'COLLATIONPROPERTY',
-      'TERTIARY_WEIGHTS',
-      // Azure
-      'FEDERATION_FILTERING_VALUE',
-      // Conversion
-      'CAST',
-      'CONVERT',
-      'PARSE',
-      'TRY_CAST',
-      'TRY_CONVERT',
-      'TRY_PARSE',
-      // Cryptographic
-      'ASYMKEY_ID',
-      'ASYMKEYPROPERTY',
-      'CERTPROPERTY',
-      'CERT_ID',
-      'CRYPT_GEN_RANDOM',
-      'DECRYPTBYASYMKEY',
-      'DECRYPTBYCERT',
-      'DECRYPTBYKEY',
-      'DECRYPTBYKEYAUTOASYMKEY',
-      'DECRYPTBYKEYAUTOCERT',
-      'DECRYPTBYPASSPHRASE',
-      'ENCRYPTBYASYMKEY',
-      'ENCRYPTBYCERT',
-      'ENCRYPTBYKEY',
-      'ENCRYPTBYPASSPHRASE',
-      'HASHBYTES',
-      'IS_OBJECTSIGNED',
-      'KEY_GUID',
-      'KEY_ID',
-      'KEY_NAME',
-      'SIGNBYASYMKEY',
-      'SIGNBYCERT',
-      'SYMKEYPROPERTY',
-      'VERIFYSIGNEDBYCERT',
-      'VERIFYSIGNEDBYASYMKEY',
-      // Cursor
-      'CURSOR_STATUS',
-      // Datatype
-      'DATALENGTH',
-      'IDENT_CURRENT',
-      'IDENT_INCR',
-      'IDENT_SEED',
-      'IDENTITY',
-      'SQL_VARIANT_PROPERTY',
-      // Datetime
-      'CURRENT_TIMESTAMP',
-      'DATEADD',
-      'DATEDIFF',
-      'DATEFROMPARTS',
-      'DATENAME',
-      'DATEPART',
-      'DATETIME2FROMPARTS',
-      'DATETIMEFROMPARTS',
-      'DATETIMEOFFSETFROMPARTS',
-      'DAY',
-      'EOMONTH',
-      'GETDATE',
-      'GETUTCDATE',
-      'ISDATE',
-      'MONTH',
-      'SMALLDATETIMEFROMPARTS',
-      'SWITCHOFFSET',
-      'SYSDATETIME',
-      'SYSDATETIMEOFFSET',
-      'SYSUTCDATETIME',
-      'TIMEFROMPARTS',
-      'TODATETIMEOFFSET',
-      'YEAR',
-      // Logical
-      'CHOOSE',
-      'COALESCE',
-      'IIF',
-      'NULLIF',
-      // Mathematical
-      'ABS',
-      'ACOS',
-      'ASIN',
-      'ATAN',
-      'ATN2',
-      'CEILING',
-      'COS',
-      'COT',
-      'DEGREES',
-      'EXP',
-      'FLOOR',
-      'LOG',
-      'LOG10',
-      'PI',
-      'POWER',
-      'RADIANS',
-      'RAND',
-      'ROUND',
-      'SIGN',
-      'SIN',
-      'SQRT',
-      'SQUARE',
-      'TAN',
-      // Metadata
-      'APP_NAME',
-      'APPLOCK_MODE',
-      'APPLOCK_TEST',
-      'ASSEMBLYPROPERTY',
-      'COL_LENGTH',
-      'COL_NAME',
-      'COLUMNPROPERTY',
-      'DATABASE_PRINCIPAL_ID',
-      'DATABASEPROPERTYEX',
-      'DB_ID',
-      'DB_NAME',
-      'FILE_ID',
-      'FILE_IDEX',
-      'FILE_NAME',
-      'FILEGROUP_ID',
-      'FILEGROUP_NAME',
-      'FILEGROUPPROPERTY',
-      'FILEPROPERTY',
-      'FULLTEXTCATALOGPROPERTY',
-      'FULLTEXTSERVICEPROPERTY',
-      'INDEX_COL',
-      'INDEXKEY_PROPERTY',
-      'INDEXPROPERTY',
-      'OBJECT_DEFINITION',
-      'OBJECT_ID',
-      'OBJECT_NAME',
-      'OBJECT_SCHEMA_NAME',
-      'OBJECTPROPERTY',
-      'OBJECTPROPERTYEX',
-      'ORIGINAL_DB_NAME',
-      'PARSENAME',
-      'SCHEMA_ID',
-      'SCHEMA_NAME',
-      'SCOPE_IDENTITY',
-      'SERVERPROPERTY',
-      'STATS_DATE',
-      'TYPE_ID',
-      'TYPE_NAME',
-      'TYPEPROPERTY',
-      // Ranking
-      'DENSE_RANK',
-      'NTILE',
-      'RANK',
-      'ROW_NUMBER',
-      // Replication
-      'PUBLISHINGSERVERNAME',
-      // Rowset
-      'OPENDATASOURCE',
-      'OPENQUERY',
-      'OPENROWSET',
-      'OPENXML',
-      // Security
-      'CERTENCODED',
-      'CERTPRIVATEKEY',
-      'CURRENT_USER',
-      'HAS_DBACCESS',
-      'HAS_PERMS_BY_NAME',
-      'IS_MEMBER',
-      'IS_ROLEMEMBER',
-      'IS_SRVROLEMEMBER',
-      'LOGINPROPERTY',
-      'ORIGINAL_LOGIN',
-      'PERMISSIONS',
-      'PWDENCRYPT',
-      'PWDCOMPARE',
-      'SESSION_USER',
-      'SESSIONPROPERTY',
-      'SUSER_ID',
-      'SUSER_NAME',
-      'SUSER_SID',
-      'SUSER_SNAME',
-      'SYSTEM_USER',
-      'USER',
-      'USER_ID',
-      'USER_NAME',
-      // String
-      'ASCII',
-      'CHAR',
-      'CHARINDEX',
-      'CONCAT',
-      'DIFFERENCE',
-      'FORMAT',
-      'LEFT',
-      'LEN',
-      'LOWER',
-      'LTRIM',
-      'NCHAR',
-      'PATINDEX',
-      'QUOTENAME',
-      'REPLACE',
-      'REPLICATE',
-      'REVERSE',
-      'RIGHT',
-      'RTRIM',
-      'SOUNDEX',
-      'SPACE',
-      'STR',
-      'STUFF',
-      'SUBSTRING',
-      'UNICODE',
-      'UPPER',
-      // System
-      'BINARY_CHECKSUM',
-      'CHECKSUM',
-      'CONNECTIONPROPERTY',
-      'CONTEXT_INFO',
-      'CURRENT_REQUEST_ID',
-      'ERROR_LINE',
-      'ERROR_NUMBER',
-      'ERROR_MESSAGE',
-      'ERROR_PROCEDURE',
-      'ERROR_SEVERITY',
-      'ERROR_STATE',
-      'FORMATMESSAGE',
-      'GETANSINULL',
-      'GET_FILESTREAM_TRANSACTION_CONTEXT',
-      'HOST_ID',
-      'HOST_NAME',
-      'ISNULL',
-      'ISNUMERIC',
-      'MIN_ACTIVE_ROWVERSION',
-      'NEWID',
-      'NEWSEQUENTIALID',
-      'ROWCOUNT_BIG',
-      'XACT_STATE',
-      // TextImage
-      'TEXTPTR',
-      'TEXTVALID',
-      // Trigger
-      'COLUMNS_UPDATED',
-      'EVENTDATA',
-      'TRIGGER_NESTLEVEL',
-      'UPDATE',
-      // ChangeTracking
-      'CHANGETABLE',
-      'CHANGE_TRACKING_CONTEXT',
-      'CHANGE_TRACKING_CURRENT_VERSION',
-      'CHANGE_TRACKING_IS_COLUMN_IN_MASK',
-      'CHANGE_TRACKING_MIN_VALID_VERSION',
-      // FullTextSearch
-      'CONTAINSTABLE',
-      'FREETEXTTABLE',
-      // SemanticTextSearch
-      'SEMANTICKEYPHRASETABLE',
-      'SEMANTICSIMILARITYDETAILSTABLE',
-      'SEMANTICSIMILARITYTABLE',
-      // FileStream
-      'FILETABLEROOTPATH',
-      'GETFILENAMESPACEPATH',
-      'GETPATHLOCATOR',
-      'PATHNAME',
-      // ServiceBroker
-      'GET_TRANSMISSION_STATUS',
-    ],
-    builtinVariables: [
-      // Configuration
-      '@@DATEFIRST',
-      '@@DBTS',
-      '@@LANGID',
-      '@@LANGUAGE',
-      '@@LOCK_TIMEOUT',
-      '@@MAX_CONNECTIONS',
-      '@@MAX_PRECISION',
-      '@@NESTLEVEL',
-      '@@OPTIONS',
-      '@@REMSERVER',
-      '@@SERVERNAME',
-      '@@SERVICENAME',
-      '@@SPID',
-      '@@TEXTSIZE',
-      '@@VERSION',
-      // Cursor
-      '@@CURSOR_ROWS',
-      '@@FETCH_STATUS',
-      // Datetime
-      '@@DATEFIRST',
-      // Metadata
-      '@@PROCID',
-      // System
-      '@@ERROR',
-      '@@IDENTITY',
-      '@@ROWCOUNT',
-      '@@TRANCOUNT',
-      // Stats
-      '@@CONNECTIONS',
-      '@@CPU_BUSY',
-      '@@IDLE',
-      '@@IO_BUSY',
-      '@@PACKET_ERRORS',
-      '@@PACK_RECEIVED',
-      '@@PACK_SENT',
-      '@@TIMETICKS',
-      '@@TOTAL_ERRORS',
-      '@@TOTAL_READ',
-      '@@TOTAL_WRITE',
-    ],
-    pseudoColumns: ['$ACTION', '$IDENTITY', '$ROWGUID', '$PARTITION'],
-    tokenizer: {
-      root: [
-        { include: '@comments' },
-        { include: '@whitespace' },
-        { include: '@pseudoColumns' },
-        { include: '@numbers' },
-        { include: '@strings' },
-        { include: '@complexIdentifiers' },
-        { include: '@scopes' },
-        [/[;,.]/, 'delimiter'],
-        [/[()]/, '@brackets'],
-        [
-          /[\w@#$]+/,
-          {
-            cases: {
-              '@keywords': 'keyword',
-              '@operators': 'operator',
-              '@builtinVariables': 'predefined',
-              '@builtinFunctions': 'predefined',
-              '@default': 'identifier',
-            },
-          },
-        ],
-        [/[<>=!%&+\-*/|~^]/, 'operator'],
-      ],
-      whitespace: [[/\s+/, 'white']],
-      comments: [
-        [/--+.*/, 'comment'],
-        [/\/\*/, { token: 'comment.quote', next: '@comment' }],
-      ],
-      comment: [
-        [/[^*/]+/, 'comment'],
-        // Not supporting nested comments, as nested comments seem to not be standard?
-        // i.e. http://stackoverflow.com/questions/728172/are-there-multiline-comment-delimiters-in-sql-that-are-vendor-agnostic
-        // [/\/\*/, { token: 'comment.quote', next: '@push' }],    // nested comment not allowed :-(
-        [/\*\//, { token: 'comment.quote', next: '@pop' }],
-        [/./, 'comment'],
-      ],
-      pseudoColumns: [
-        [
-          /[$][A-Za-z_][\w@#$]*/,
-          {
-            cases: {
-              '@pseudoColumns': 'predefined',
-              '@default': 'identifier',
-            },
-          },
-        ],
-      ],
-      numbers: [
-        [/0[xX][0-9a-fA-F]*/, 'number'],
-        [/[$][+-]*\d*(\.\d*)?/, 'number'],
-        [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number'],
-      ],
-      strings: [
-        [/N'/, { token: 'string', next: '@string' }],
-        [/'/, { token: 'string', next: '@string' }],
-      ],
-      string: [
-        [/[^']+/, 'string'],
-        [/''/, 'string'],
-        [/'/, { token: 'string', next: '@pop' }],
-      ],
-      complexIdentifiers: [
-        [/\[/, { token: 'identifier.quote', next: '@bracketedIdentifier' }],
-        [/"/, { token: 'identifier.quote', next: '@quotedIdentifier' }],
-      ],
-      bracketedIdentifier: [
-        [/[^\]]+/, 'identifier'],
-        [/]]/, 'identifier'],
-        [/]/, { token: 'identifier.quote', next: '@pop' }],
-      ],
-      quotedIdentifier: [
-        [/[^"]+/, 'identifier'],
-        [/""/, 'identifier'],
-        [/"/, { token: 'identifier.quote', next: '@pop' }],
-      ],
-      scopes: [
-        [/BEGIN\s+(DISTRIBUTED\s+)?TRAN(SACTION)?\b/i, 'keyword'],
-        [/BEGIN\s+TRY\b/i, { token: 'keyword.try' }],
-        [/END\s+TRY\b/i, { token: 'keyword.try' }],
-        [/BEGIN\s+CATCH\b/i, { token: 'keyword.catch' }],
-        [/END\s+CATCH\b/i, { token: 'keyword.catch' }],
-        [/(BEGIN|CASE)\b/i, { token: 'keyword.block' }],
-        [/END\b/i, { token: 'keyword.block' }],
-        [/WHEN\b/i, { token: 'keyword.choice' }],
-        [/THEN\b/i, { token: 'keyword.choice' }],
-      ],
-    },
-  },
-};
diff --git a/src/livecodes/editor/monaco/languages/monaco-lang-wat.ts b/src/livecodes/editor/monaco/languages/monaco-lang-wat.ts
deleted file mode 100644
index 488e348c53..0000000000
--- a/src/livecodes/editor/monaco/languages/monaco-lang-wat.ts
+++ /dev/null
@@ -1,710 +0,0 @@
-// 'WebAssembly Text Format' Monarch language
-// from https://github.com/AssemblyScript/website/blob/main/src/.vuepress/public/scripts/wat.js
-export default {
-  config: {
-    brackets: [
-      ['(', ')'],
-      ['if', 'end'],
-      ['loop', 'end'],
-      ['block', 'end'],
-    ],
-    autoClosingPairs: [
-      { open: '(', close: ')' },
-      { open: 'if', close: 'end' },
-      { open: 'loop', close: 'end' },
-      { open: 'block', close: 'end' },
-    ],
-    surroundingPairs: [
-      { open: '(', close: ')' },
-      { open: 'if', close: 'end' },
-      { open: 'loop', close: 'end' },
-      { open: 'block', close: 'end' },
-    ],
-  },
-  tokens: {
-    keywords: [
-      'module',
-      'import',
-      'export',
-      'memory',
-      'data',
-      'table',
-      'elem',
-      'start',
-      'func',
-      'tag',
-      'type',
-      'param',
-      'result',
-      'global',
-      'local',
-      'mut',
-      'struct',
-      'array',
-      'field',
-    ],
-    types: [
-      'i8',
-      'i16',
-      'i32',
-      'i64',
-      'f32',
-      'f64',
-      'v128',
-      'i31ref',
-      'eqref',
-      'anyref',
-      'dataref',
-      'externref',
-      'funcref',
-      'exnref',
-      'extern',
-      'null',
-      'any',
-      'eq',
-    ],
-    instructions: [
-      'pop',
-      'nop',
-      'drop',
-      'data.drop',
-      'elem.drop',
-      'local.get',
-      'local.set',
-      'local.tee',
-      'global.get',
-      'global.set',
-      'tuple.make',
-      'tuple.extract',
-      'select',
-      'v128.const',
-      'v128.and',
-      'v128.or',
-      'v128.xor',
-      'v128.not',
-      'v128.andnot',
-      'v128.bitselect',
-      'v128.load',
-      'v128.load8x8_s',
-      'v128.load8x8_u',
-      'v128.load16x4_s',
-      'v128.load16x4_u',
-      'v128.load32x2_s',
-      'v128.load32x2_u',
-      'v128.load8_lane',
-      'v128.load16_lane',
-      'v128.load32_lane',
-      'v128.load64_lane',
-      'v128.load8_splat',
-      'v128.load16_splat',
-      'v128.load32_splat',
-      'v128.load64_splat',
-      'v128.load32_zero',
-      'v128.load64_zero',
-      'v128.store',
-      'v128.store8_lane',
-      'v128.store16_lane',
-      'v128.store32_lane',
-      'v128.store64_lane',
-      'v128.any_true',
-      'i8x16.shuffle',
-      'i8x16.swizzle',
-      'i8x16.bitmask',
-      'i8x16.splat',
-      'i8x16.popcnt',
-      'i8x16.replace_lane',
-      'i8x16.extract_lane_s',
-      'i8x16.extract_lane_u',
-      'i8x16.all_true',
-      'i8x16.abs',
-      'i8x16.add',
-      'i8x16.add_sat_s',
-      'i8x16.add_sat_u',
-      'i8x16.sub',
-      'i8x16.sub_sat_s',
-      'i8x16.sub_sat_u',
-      'i8x16.mul',
-      'i8x16.neg',
-      'i8x16.shl',
-      'i8x16.shr_s',
-      'i8x16.shr_u',
-      'i8x16.eq',
-      'i8x16.ne',
-      'i8x16.lt_s',
-      'i8x16.lt_u',
-      'i8x16.le_s',
-      'i8x16.le_u',
-      'i8x16.gt_s',
-      'i8x16.gt_u',
-      'i8x16.ge_s',
-      'i8x16.ge_u',
-      'i8x16.min_s',
-      'i8x16.min_u',
-      'i8x16.max_s',
-      'i8x16.max_u',
-      'i8x16.avgr_u',
-      'i8x16.narrow_i16x8_s',
-      'i8x16.narrow_i16x8_u',
-      'i16x8.bitmask',
-      'i16x8.splat',
-      'i16x8.load_8x8_s',
-      'i16x8.load_8x8_u',
-      'i16x8.replace_lane',
-      'i16x8.extract_lane_s',
-      'i16x8.extract_lane_u',
-      'i16x8.extend_low_i8x16_s',
-      'i16x8.extend_high_i8x16_s',
-      'i16x8.extend_low_i8x16_u',
-      'i16x8.extend_high_i8x16_u',
-      'i16x8.all_true',
-      'i16x8.abs',
-      'i16x8.add',
-      'i16x8.add_sat_s',
-      'i16x8.add_sat_u',
-      'i16x8.extadd_pairwise_i8x16_s',
-      'i16x8.extadd_pairwise_i8x16_u',
-      'i16x8.sub',
-      'i16x8.sub_sat_s',
-      'i16x8.sub_sat_u',
-      'i16x8.q15mulr_sat_s',
-      'i16x8.mul',
-      'i16x8.extmul_low_i8x16_s',
-      'i16x8.extmul_high_i8x16_s',
-      'i16x8.extmul_low_i8x16_u',
-      'i16x8.extmul_high_i8x16_u',
-      'i16x8.neg',
-      'i16x8.shl',
-      'i16x8.shr_s',
-      'i16x8.shr_u',
-      'i16x8.eq',
-      'i16x8.ne',
-      'i16x8.lt_s',
-      'i16x8.lt_u',
-      'i16x8.le_s',
-      'i16x8.le_u',
-      'i16x8.gt_s',
-      'i16x8.gt_u',
-      'i16x8.ge_s',
-      'i16x8.ge_u',
-      'i16x8.min_s',
-      'i16x8.min_u',
-      'i16x8.max_s',
-      'i16x8.max_u',
-      'i16x8.avgr_u',
-      'i16x8.narrow_i32x4_s',
-      'i16x8.narrow_i32x4_u',
-      'i32x4.bitmask',
-      'i32x4.splat',
-      'i32x4.load_16x4_s',
-      'i32x4.load_16x4_u',
-      'i32x4.replace_lane',
-      'i32x4.extract_lane',
-      'i32x4.extend_low_i16x8_s',
-      'i32x4.extend_high_i16x8_s',
-      'i32x4.extend_low_i16x8_u',
-      'i32x4.extend_high_i16x8_u',
-      'i32x4.all_true',
-      'i32x4.abs',
-      'i32x4.add',
-      'i32x4.extadd_pairwise_i16x8_s',
-      'i32x4.extadd_pairwise_i16x8_u',
-      'i32x4.sub',
-      'i32x4.mul',
-      'i32x4.extmul_low_i16x8_s',
-      'i32x4.extmul_high_i16x8_s',
-      'i32x4.extmul_low_i16x8_u',
-      'i32x4.extmul_high_i16x8_u',
-      'i32x4.neg',
-      'i32x4.shl',
-      'i32x4.shr_s',
-      'i32x4.shr_u',
-      'i32x4.eq',
-      'i32x4.ne',
-      'i32x4.lt_s',
-      'i32x4.lt_u',
-      'i32x4.le_s',
-      'i32x4.le_u',
-      'i32x4.gt_s',
-      'i32x4.gt_u',
-      'i32x4.ge_s',
-      'i32x4.ge_u',
-      'i32x4.min_s',
-      'i32x4.min_u',
-      'i32x4.max_s',
-      'i32x4.max_u',
-      'i32x4.trunc_sat_f32x4_s',
-      'i32x4.trunc_sat_f32x4_u',
-      'i32x4.trunc_sat_f64x2_s_zero',
-      'i32x4.trunc_sat_f64x2_u_zero',
-      'i32x4.dot_i16x8_s',
-      'i64x2.bitmask',
-      'i64x2.splat',
-      'i64x2.load32x2_s',
-      'i64x2.load32x2_u',
-      'i64x2.replace_lane',
-      'i64x2.extract_lane',
-      'i64x2.extend_low_i32x4_s',
-      'i64x2.extend_high_i32x4_s',
-      'i64x2.extend_low_i32x4_u',
-      'i64x2.extend_high_i32x4_u',
-      'i64x2.all_true',
-      'i64x2.abs',
-      'i64x2.add',
-      'i64x2.sub',
-      'i64x2.mul',
-      'i64x2.neg',
-      'i64x2.shl',
-      'i64x2.shr_s',
-      'i64x2.shr_u',
-      'f32x4.splat',
-      'f32x4.replace_lane',
-      'f32x4.extract_lane',
-      'f32x4.add',
-      'f32x4.sub',
-      'f32x4.mul',
-      'i64x2.extmul_low_i32x4_s',
-      'i64x2.extmul_high_i32x4_s',
-      'i64x2.extmul_low_i32x4_u',
-      'i64x2.extmul_high_i32x4_u',
-      'i64x2.eq',
-      'i64x2.ne',
-      'i64x2.lt_s',
-      'i64x2.le_s',
-      'i64x2.gt_s',
-      'i64x2.ge_s',
-      'f32x4.neg',
-      'f32x4.eq',
-      'f32x4.ne',
-      'f32x4.lt',
-      'f32x4.le',
-      'f32x4.gt',
-      'f32x4.ge',
-      'f32x4.abs',
-      'f32x4.min',
-      'f32x4.pmin',
-      'f32x4.max',
-      'f32x4.pmax',
-      'f32x4.div',
-      'f32x4.sqrt',
-      'f32x4.ceil',
-      'f32x4.floor',
-      'f32x4.trunc',
-      'f32x4.nearest',
-      'f32x4.demote_f64x2_zero',
-      'f32x4.convert_i32x4_s',
-      'f32x4.convert_i32x4_u',
-      'f64x2.splat',
-      'f64x2.replace_lane',
-      'f64x2.extract_lane',
-      'f64x2.add',
-      'f64x2.sub',
-      'f64x2.mul',
-      'f64x2.neg',
-      'f64x2.eq',
-      'f64x2.ne',
-      'f64x2.lt',
-      'f64x2.le',
-      'f64x2.gt',
-      'f64x2.ge',
-      'f64x2.abs',
-      'f64x2.min',
-      'f64x2.max',
-      'f64x2.pmin',
-      'f64x2.pmax',
-      'f64x2.div',
-      'f64x2.sqrt',
-      'f64x2.ceil',
-      'f64x2.floor',
-      'f64x2.trunc',
-      'f64x2.nearest',
-      'f64x2.promote_low_f32x4',
-      'f64x2.convert_low_i32x4_s',
-      'f64x2.convert_low_i32x4_u',
-      'i32.atomic.load',
-      'i32.atomic.load8_u',
-      'i32.atomic.load16_u',
-      'i32.atomic.store',
-      'i32.atomic.store8',
-      'i32.atomic.store16',
-      'i32.atomic.rmw.add',
-      'i32.atomic.rmw.sub',
-      'i32.atomic.rmw.and',
-      'i32.atomic.rmw.or',
-      'i32.atomic.rmw.xor',
-      'i32.atomic.rmw.xchg',
-      'i32.atomic.rmw.cmpxchg',
-      'i32.atomic.rmw8.add_u',
-      'i32.atomic.rmw8.sub_u',
-      'i32.atomic.rmw8.and_u',
-      'i32.atomic.rmw8.or_u',
-      'i32.atomic.rmw8.xor_u',
-      'i32.atomic.rmw8.xchg_u',
-      'i32.atomic.rmw8.cmpxchg_u',
-      'i32.atomic.rmw16.add_u',
-      'i32.atomic.rmw16.sub_u',
-      'i32.atomic.rmw16.and_u',
-      'i32.atomic.rmw16.or_u',
-      'i32.atomic.rmw16.xor_u',
-      'i32.atomic.rmw16.xchg_u',
-      'i32.atomic.rmw16.cmpxchg_u',
-      'i64.atomic.load',
-      'i64.atomic.load8_u',
-      'i64.atomic.load16_u',
-      'i64.atomic.load32_u',
-      'i64.atomic.store',
-      'i64.atomic.store8',
-      'i64.atomic.store16',
-      'i64.atomic.store32',
-      'i64.atomic.rmw.add',
-      'i64.atomic.rmw.sub',
-      'i64.atomic.rmw.and',
-      'i64.atomic.rmw.or',
-      'i64.atomic.rmw.xor',
-      'i64.atomic.rmw.xchg',
-      'i64.atomic.rmw.cmpxchg',
-      'i64.atomic.rmw8.add_u',
-      'i64.atomic.rmw8.sub_u',
-      'i64.atomic.rmw8.and_u',
-      'i64.atomic.rmw8.or_u',
-      'i64.atomic.rmw8.xor_u',
-      'i64.atomic.rmw8.xchg_u',
-      'i64.atomic.rmw8.cmpxchg_u',
-      'i64.atomic.rmw16.add_u',
-      'i64.atomic.rmw16.sub_u',
-      'i64.atomic.rmw16.and_u',
-      'i64.atomic.rmw16.or_u',
-      'i64.atomic.rmw16.xor_u',
-      'i64.atomic.rmw16.xchg_u',
-      'i64.atomic.rmw16.cmpxchg_u',
-      'i64.atomic.rmw32.add_u',
-      'i64.atomic.rmw32.sub_u',
-      'i64.atomic.rmw32.and_u',
-      'i64.atomic.rmw32.or_u',
-      'i64.atomic.rmw32.xor_u',
-      'i64.atomic.rmw32.xchg_u',
-      'i64.atomic.rmw32.cmpxchg_u',
-      'atomic.fence',
-      'func.bind',
-      'ref',
-      'ref.eq',
-      'ref.null',
-      'ref.is_null',
-      'ref.is_func',
-      'ref.is_data',
-      'ref.is_i31',
-      'ref.as_func',
-      'ref.as_non_null',
-      'ref.as_data',
-      'ref.as_i31',
-      'ref.func',
-      'ref.cast',
-      'ref.cast_static',
-      'ref.test',
-      'ref.test_static',
-      'table.get',
-      'table.set',
-      'table.size',
-      'table.grow',
-      'table.fill',
-      'table.init',
-      'table.copy',
-      'throw',
-      'rethrow',
-      'i32.load',
-      'i32.load8_s',
-      'i32.load8_u',
-      'i32.load16_s',
-      'i32.load16_u',
-      'i32.store',
-      'i32.store8',
-      'i32.store16',
-      'i32.const',
-      'i32.eqz',
-      'i32.eq',
-      'i32.ne',
-      'i32.lt_s',
-      'i32.lt_u',
-      'i32.le_s',
-      'i32.le_u',
-      'i32.gt_s',
-      'i32.gt_u',
-      'i32.ge_s',
-      'i32.ge_u',
-      'i32.clz',
-      'i32.ctz',
-      'i32.popcnt',
-      'i32.add',
-      'i32.sub',
-      'i32.mul',
-      'i32.div_s',
-      'i32.div_u',
-      'i32.rem_s',
-      'i32.rem_u',
-      'i32.and',
-      'i32.or',
-      'i32.xor',
-      'i32.shl',
-      'i32.shr_s',
-      'i32.shr_u',
-      'i32.rotl',
-      'i32.rotr',
-      'i32.wrap_i64',
-      'i32.trunc_f32_s',
-      'i32.trunc_f32_u',
-      'i32.trunc_f64_s',
-      'i32.trunc_f64_u',
-      'i32.reinterpret_f32',
-      'i64.load',
-      'i64.load8_s',
-      'i64.load8_u',
-      'i64.load16_s',
-      'i64.load16_u',
-      'i64.load32_s',
-      'i64.load32_u',
-      'i64.store',
-      'i64.store8',
-      'i64.store16',
-      'i64.store32',
-      'i64.const',
-      'i64.eqz',
-      'i64.eq',
-      'i64.ne',
-      'i64.lt_s',
-      'i64.lt_u',
-      'i64.le_s',
-      'i64.le_u',
-      'i64.gt_s',
-      'i64.gt_u',
-      'i64.ge_s',
-      'i64.ge_u',
-      'i64.clz',
-      'i64.ctz',
-      'i64.popcnt',
-      'i64.add',
-      'i64.sub',
-      'i64.mul',
-      'i64.div_s',
-      'i64.div_u',
-      'i64.rem_s',
-      'i64.rem_u',
-      'i64.and',
-      'i64.or',
-      'i64.xor',
-      'i64.shl',
-      'i64.shr_s',
-      'i64.shr_u',
-      'i64.rotl',
-      'i64.rotr',
-      'i64.extend_i32_s',
-      'i64.extend_i32_u',
-      'i64.trunc_f32_s',
-      'i64.trunc_f32_u',
-      'i64.trunc_f64_s',
-      'i64.trunc_f64_u',
-      'i64.reinterpret_f64',
-      'f32.load',
-      'f32.store',
-      'f32.const',
-      'f32.eq',
-      'f32.ne',
-      'f32.lt',
-      'f32.le',
-      'f32.gt',
-      'f32.ge',
-      'f32.abs',
-      'f32.neg',
-      'f32.ceil',
-      'f32.floor',
-      'f32.trunc',
-      'f32.nearest',
-      'f32.sqrt',
-      'f32.add',
-      'f32.sub',
-      'f32.mul',
-      'f32.div',
-      'f32.min',
-      'f32.max',
-      'f32.copysign',
-      'f32.convert_i32_s',
-      'f32.convert_i32_u',
-      'f32.convert_i64_s',
-      'f32.convert_i64_u',
-      'f32.demote_f64',
-      'f32.reinterpret_i32',
-      'f64.load',
-      'f64.store',
-      'f64.const',
-      'f64.eq',
-      'f64.ne',
-      'f64.lt',
-      'f64.le',
-      'f64.gt',
-      'f64.ge',
-      'f64.abs',
-      'f64.neg',
-      'f64.ceil',
-      'f64.floor',
-      'f64.trunc',
-      'f64.nearest',
-      'f64.sqrt',
-      'f64.add',
-      'f64.sub',
-      'f64.mul',
-      'f64.div',
-      'f64.min',
-      'f64.max',
-      'f64.copysign',
-      'f64.convert_i32_s',
-      'f64.convert_i32_u',
-      'f64.convert_i64_s',
-      'f64.convert_i64_u',
-      'f64.promote_f32',
-      'f64.reinterpret_i64',
-      'i32.extend8_s',
-      'i32.extend16_s',
-      'i64.extend8_s',
-      'i64.extend16_s',
-      'i64.extend32_s',
-      'i32.trunc_sat_f32_s',
-      'i32.trunc_sat_f32_u',
-      'i32.trunc_sat_f64_s',
-      'i32.trunc_sat_f64_u',
-      'i64.trunc_sat_f32_s',
-      'i64.trunc_sat_f32_u',
-      'i64.trunc_sat_f64_s',
-      'i64.trunc_sat_f64_u',
-      'memory.size',
-      'memory.grow',
-      'memory.copy',
-      'memory.fill',
-      'memory.init',
-      'memory.atomic.notify',
-      'memory.atomic.wait32',
-      'memory.atomic.wait64',
-      'i31.new',
-      'i31.get_u',
-      'i31.get_s',
-      'array.new',
-      'array.new_default',
-      'array.init',
-      'array.init_static',
-      'array.get',
-      'array.get_s',
-      'array.get_u',
-      'array.set',
-      'array.len',
-      'array.copy',
-      'struct.new',
-      'struct.new_default',
-      'struct.new_with_rtt',
-      'struct.new_default_with_rtt',
-      'struct.get',
-      'struct.get_s',
-      'struct.get_u',
-      'struct.set',
-      'rtt.canon',
-      'rtt.sub',
-      'rtt.fresh_sub',
-    ],
-    controlInstructions: [
-      'block',
-      'loop',
-      'if',
-      'else',
-      'then',
-      'end',
-      'do',
-      'let',
-      'br',
-      'br_if',
-      'br_table',
-      'br_on_exn',
-      'br_on_null',
-      'br_on_non_null',
-      'br_on_cast',
-      'br_on_cast_static',
-      'br_on_cast_fail',
-      'br_on_cast_static_fail',
-      'br_on_func',
-      'br_on_non_func',
-      'br_on_data',
-      'br_on_non_data',
-      'br_on_i31',
-      'br_on_non_i31',
-      'call',
-      'call_indirect',
-      'call_ref',
-      'return',
-      'return_call',
-      'return_call_indirect',
-      'return_call_ref',
-      'try',
-      'catch',
-      'catch_all',
-      'delegate',
-      'unreachable',
-    ],
-
-    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
-    digits: /\d+(_+\d+)*/,
-    octaldigits: /[0-7]+(_+[0-7]+)*/,
-    binarydigits: /[0-1]+(_+[0-1]+)*/,
-    hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
-
-    tokenizer: {
-      root: [
-        // whitespace
-        { include: '@whitespace' },
-
-        // strings
-        [/"([^"\\]|\\.)*$/, 'string.invalid'], // non-terminated string
-        [/"/, 'string', '@string'],
-
-        // numbers (not all of these are generated, but here to be sure)
-        [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, 'number.float'],
-        [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, 'number.float'],
-        [/0[xX](@hexdigits)[Ll]?/, 'number.hex'],
-        [/0(@octaldigits)[Ll]?/, 'number.octal'],
-        [/0[bB](@binarydigits)[Ll]?/, 'number.binary'],
-        [/(@digits)[fFdD]/, 'number.float'],
-        [/(@digits)[lL]?/, 'number'],
-
-        // variable names
-        [/\$[^\s\)]*/, { token: 'identifier' }],
-
-        // instructions and types
-        [
-          /[a-z0-9_]+(?:\.[a-z0-9_]+)*/,
-          {
-            cases: {
-              '@types': { token: 'type.$0' },
-              '@keywords': { token: 'keyword.$0' },
-              '@controlInstructions': { token: 'controlInstruction.$0' },
-              '@instructions': { token: 'instruction.$0' },
-              '@default': 'identifier',
-            },
-          },
-        ],
-      ],
-
-      // eslint-disable-next-line id-blacklist
-      string: [
-        [/[^\\"]+/, 'string'],
-        [/@escapes/, 'string.escape'],
-        [/\\./, 'string.escape.invalid'],
-        [/"/, 'string', '@pop'],
-      ],
-
-      whitespace: [
-        [/[ \t\r\n]+/, ''],
-        [/(;; )(ERROR |FAILURE )([^\n]*)/, ['comment', 'error', '']],
-        [/(;; )(WARNING )([^\n]*)/, ['comment', 'warning', '']],
-        [/(;; )(INFO )([^\n]*)/, ['comment', 'info', '']],
-        [/(;; )(PEDANTIC )([^\n]*)/, ['comment', 'pedantic', '']],
-        [/(;;  +)(~+|\^)$/, ['comment', 'underline']],
-        [/(;;  )([^\n]*)/, ['comment', '']],
-        [/;;[^\n]*/, 'comment'],
-      ],
-    },
-  },
-};
diff --git a/src/livecodes/editor/monaco/monaco.ts b/src/livecodes/editor/monaco/monaco.ts
index 13a244c096..f99f06b4ee 100644
--- a/src/livecodes/editor/monaco/monaco.ts
+++ b/src/livecodes/editor/monaco/monaco.ts
@@ -2,6 +2,7 @@ import type * as Monaco from 'monaco-editor';
 
 import { getEditorModeNode } from '../../UI/selectors';
 import { getImports } from '../../compiler/import-map';
+import { getLanguageSpecs, hasJsx } from '../../languages';
 import type {
   APIError,
   CodeEditor,
@@ -24,11 +25,11 @@ import {
   monacoBaseUrl,
   monacoEmacsUrl,
   monacoVimUrl,
-  monacoVolarUrl,
+  typescriptVersion,
   vendorsBaseUrl,
 } from '../../vendors';
 import { getEditorTheme } from '../themes';
-import { getCompilerOptions, hasJsx } from '../ts-compiler-options';
+import { getCompilerOptions } from '../ts-compiler-options';
 import { customThemes, monacoThemes } from './monaco-themes';
 import { registerTwoSlash } from './register-twoslash';
 
@@ -37,17 +38,15 @@ type Options = Monaco.editor.IStandaloneEditorConstructionOptions;
 let monacoGloballyLoaded = false;
 const disposeEmmet: { html?: any; css?: any; jsx?: any; disabled?: boolean } = {};
 let monaco: typeof Monaco;
+const loadedLanguages = new Set<Language>();
 const loadedThemes = new Set<string>();
 // let codeiumProvider: { dispose: () => void } | undefined;
 let editors: Monaco.editor.IStandaloneCodeEditor[] = [];
 let tailwindcssConfig: any;
-let vueRegistered = false;
-let shikiThemes: Record<string, string> = {};
 
 export const createEditor = async (options: EditorOptions): Promise<CodeEditor> => {
   const {
     container,
-    baseUrl,
     readonly,
     theme,
     editorTheme,
@@ -64,8 +63,6 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
   const loadMonaco = () => import(monacoBaseUrl + 'monaco.js');
 
   let editorMode: any | undefined;
-  let currentTheme = theme;
-  let currentEditorTheme = editorTheme;
 
   const convertOptions = (opt: EditorConfig): Options => ({
     fontFamily: getFontFamily(opt.fontFamily),
@@ -82,17 +79,6 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
 
   const baseOptions = convertOptions(options);
 
-  const monacoMapLanguage = (language: Language): Language =>
-    language === 'livescript'
-      ? 'coffeescript'
-      : ['rescript', 'reason', 'ocaml'].includes(language)
-        ? 'csharp'
-        : language.startsWith('vue')
-          ? 'vue'
-          : ['svelte', 'malina', 'riot'].includes(language)
-            ? ('razor' as Language) // avoid mixing code between markup & script editors when formatting
-            : mapLanguage(language);
-
   try {
     (window as any).monaco = (window as any).monaco || (await loadMonaco()).monaco;
     monaco = (window as any).monaco;
@@ -134,9 +120,7 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
 
   const setTheme = (theme: Theme, editorTheme: Config['editorTheme']) => {
     loadTheme(theme, editorTheme).then((newTheme) => {
-      monaco.editor.setTheme(shikiThemes[newTheme] ?? newTheme);
-      currentTheme = theme;
-      currentEditorTheme = editorTheme;
+      monaco.editor.setTheme(newTheme);
     });
   };
 
@@ -219,12 +203,16 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
     const isJSLang = JSLangs.includes(language);
     if (
       !['script', 'tests', 'editorSettings'].includes(editorId) ||
-      !['javascript', 'typescript'].includes(monacoMapLanguage(language))
+      !['javascript', 'typescript'].includes(mapLanguage(language, 'monaco'))
     ) {
       return;
     }
 
-    const compilerOptions = getCompilerOptions(language);
+    const compilerOptions = {
+      ...getCompilerOptions(),
+      ...((getLanguageSpecs(language)?.editorSupport?.compilerOptions ||
+        {}) as Monaco.languages.typescript.CompilerOptions),
+    };
 
     monaco.languages.typescript.typescriptDefaults.setCompilerOptions(compilerOptions);
     monaco.languages.typescript.javascriptDefaults.setCompilerOptions(compilerOptions);
@@ -249,53 +237,32 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
     listeners.forEach((fn) => editor.getModel()?.onDidChangeContent(fn));
   };
 
-  const customLanguages: Partial<Record<Language, string>> = {
-    astro: baseUrl + '{{hash:monaco-lang-astro.js}}',
-    clio: baseUrl + '{{hash:monaco-lang-clio.js}}',
-    imba: baseUrl + '{{hash:monaco-lang-imba.js}}',
-    minizinc: baseUrl + '{{hash:monaco-lang-minizinc.js}}',
-    prolog: baseUrl + '{{hash:monaco-lang-prolog.js}}',
-    // sql: baseUrl + '{{hash:monaco-lang-sql.js}}', // TODO: add autocomplete
-    wat: baseUrl + '{{hash:monaco-lang-wat.js}}',
+  const loadMonacoLanguage = async (lang: Language) => {
+    const langSupport = getLanguageSpecs(lang)?.editorSupport?.monaco?.languageSupport;
+    if (langSupport && !loadedLanguages.has(lang)) {
+      loadedLanguages.add(lang);
+      const loadLanguage =
+        typeof langSupport === 'string'
+          ? (await import(langSupport)).default
+          : typeof langSupport === 'function'
+            ? langSupport
+            : () => undefined;
+      await loadLanguage(monaco, () => editor);
+    }
   };
 
-  interface CustomLanguageDefinition {
-    config?: Monaco.languages.LanguageConfiguration;
-    tokens?: Monaco.languages.IMonarchLanguage;
-    completions?: Monaco.languages.CompletionItemProvider;
-  }
-
-  const addVueSupport = async () => {
-    if (vueRegistered) return;
-    vueRegistered = true;
-    const { registerVue, registerHighlighter } = await import(monacoVolarUrl);
-    const tsCompilerOptions = { ...getCompilerOptions('vue'), jsx: 'preserve' };
-    await registerVue({ editor, monaco, tsCompilerOptions, silent: true });
-    shikiThemes = registerHighlighter(monaco);
-    shikiThemes['custom-vs-light'] = shikiThemes.vs;
-    shikiThemes['custom-vs-dark'] = shikiThemes['vs-dark'];
-    setTheme(currentTheme, currentEditorTheme);
-  };
+  await loadMonacoLanguage(language);
 
-  const loadMonacoLanguage = async (lang: Language) => {
-    if (monacoMapLanguage(lang) === 'vue') {
-      await addVueSupport();
-      return;
-    }
-    const langUrl = customLanguages[lang];
-    if (langUrl && !monaco.languages.getLanguages().find((l) => l.id === lang)) {
-      const mod: CustomLanguageDefinition = (await import(langUrl)).default;
-      monaco.languages.register({ id: lang });
-      if (mod.config) {
-        monaco.languages.setLanguageConfiguration(lang, mod.config);
-      }
-      if (mod.tokens) {
-        monaco.languages.setMonarchTokensProvider(lang, mod.tokens);
-      }
-      if (mod.completions) {
-        monaco.languages.registerCompletionItemProvider(lang, mod.completions);
+  const getOrCreateModel = (value: string, lang: string | undefined, uri: Monaco.Uri) => {
+    const model = monaco.editor.getModel(uri);
+    if (model) {
+      if (model.getLanguageId() === mapLanguage(lang as Language, 'monaco')) {
+        model.setValue(value);
+        return model;
       }
+      model.dispose();
     }
+    return monaco.editor.createModel(value, lang, uri);
   };
 
   let modelUri = '';
@@ -307,14 +274,18 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
     const random = getRandomString();
     const ext = getLanguageExtension(language);
     const extension =
-      monacoMapLanguage(language) === 'typescript' && !ext?.endsWith('ts') && !ext?.endsWith('tsx')
+      mapLanguage(language, 'monaco') === 'typescript' &&
+      !ext?.endsWith('ts') &&
+      !ext?.endsWith('tsx')
         ? ext + '.tsx'
         : ext;
-    modelUri = `file:///${editorId}.${random}.${extension}`;
+    modelUri = editorId.includes('.')
+      ? `file:///${editorId}`
+      : `file:///${editorId}.${random}.${extension}`;
     const oldModel = editor.getModel();
-    const model = monaco.editor.createModel(
+    const model = getOrCreateModel(
       value || '',
-      monacoMapLanguage(language),
+      mapLanguage(language, 'monaco'),
       monaco.Uri.parse(modelUri),
     );
     editor.setModel(model);
@@ -325,29 +296,11 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
 
   const editor = monaco.editor.create(container, {
     ...editorOptions,
-    language: language.startsWith('vue') ? 'html' : monacoMapLanguage(language),
+    language: mapLanguage(language, 'monaco'),
   });
-  setModel(editor, options.value, language.startsWith('vue') ? 'html' : language);
-  loadMonacoLanguage(language);
-
-  // avoid a race condition that prevents loading vue worker
-  if (language.startsWith('vue')) {
-    setTimeout(() => {
-      setLanguage(language);
-    }, 50);
-  }
-
-  const getOrCreateModel = (value: string, lang: string | undefined, uri: Monaco.Uri) => {
-    const model = monaco.editor.getModel(uri);
-    if (model) {
-      model.setValue(value);
-      return model;
-    }
-    return monaco.editor.createModel(value, lang, uri);
-  };
+  setModel(editor, options.value, mapLanguage(language, 'monaco'));
 
-  const contentEditors: Array<EditorOptions['editorId']> = ['markup', 'style', 'script', 'tests'];
-  if (contentEditors.includes(editorId)) {
+  if (editorId.includes('.')) {
     editors.push(editor);
   }
 
@@ -452,19 +405,12 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
 
   const getLanguage = () => language;
   const setLanguage = (lang: Language, value?: string) => {
+    if (!lang) return;
     language = lang;
     clearTypes(false);
     const valueToInsert = value ?? editor.getValue();
-    if (monacoMapLanguage(lang) === 'vue') {
-      // avoid race condition of value changing while valor is loading
-      setValue(valueToInsert);
-    } else {
-      setModel(editor, valueToInsert, language);
-    }
     loadMonacoLanguage(lang).then(() => {
-      if (monacoMapLanguage(lang) === 'vue') {
-        setModel(editor, editor.getValue(), language);
-      }
+      setModel(editor, valueToInsert, language);
     });
   };
 
@@ -556,25 +502,15 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
   configureEditorMode(options.editorMode);
 
   const registerFormatter = (formatFn: FormatFn | undefined) => {
-    let editorModel = editor.getModel();
-    if (!formatFn || !editorModel) return;
-
-    monaco.languages.registerDocumentFormattingEditProvider(monacoMapLanguage(language), {
-      provideDocumentFormattingEdits: async () => {
-        let currentEditor = editor;
-        // avoid referring to editors destroyed after closing modals
-        if (!editor.getModel()) {
-          currentEditor =
-            editors.find((ed) => ed.getModel()?.getLanguageId() === monacoMapLanguage(language)) ||
-            editor;
-        }
-        editorModel = currentEditor.getModel();
-        if (!editorModel) return [];
-        const val = currentEditor.getValue() || '';
+    if (!formatFn) return;
+    monaco.languages.registerDocumentFormattingEditProvider(mapLanguage(language, 'monaco'), {
+      provideDocumentFormattingEdits: async (model) => {
+        if (!model || model.isDisposed()) return [];
+        const val = model.getValue() || '';
         const prettyVal = await formatFn(val, 0, getFormatterConfig());
         return [
           {
-            range: editorModel.getFullModelRange(),
+            range: model.getFullModelRange(),
             text: prettyVal.formatted,
           },
         ];
@@ -744,8 +680,8 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
     const model = editor.getModel();
     if (
       !model ||
-      !addCloseLanguages.includes(monacoMapLanguage(language)) ||
-      (monacoMapLanguage(language) === 'typescript' && !hasJsx.includes(language)) || // avoid autocompleting TS generics
+      !addCloseLanguages.includes(mapLanguage(language, 'monaco')) ||
+      (mapLanguage(language, 'monaco') === 'typescript' && !hasJsx(language)) || // avoid autocompleting TS generics
       editorOptions.autoClosingBrackets === 'never'
     ) {
       return;
@@ -899,8 +835,69 @@ export const createEditor = async (options: EditorOptions): Promise<CodeEditor>
     monaco.languages.registerHoverProvider('html', npmPackageHoverProvider);
   };
 
+  const enableGoToDefinition = () => {
+    // https://github.com/microsoft/vscode/pull/177064
+    monaco.editor.registerEditorOpener({
+      async openCodeEditor(_source, resource, selectionOrPosition) {
+        const lineNumber = !selectionOrPosition
+          ? null
+          : 'lineNumber' in selectionOrPosition
+            ? selectionOrPosition.lineNumber
+            : selectionOrPosition.startLineNumber;
+
+        if (resource.path.startsWith('/lib.')) {
+          const lib = resource.path.replace('/lib.', '');
+          window.open(
+            `https://app.unpkg.com/typescript@${typescriptVersion}/files/lib/lib.${lib}${lineNumber ? '#L' + lineNumber : ''}`,
+            '_blank',
+          );
+          return true;
+        }
+
+        if (resource.path.startsWith('/node_modules/')) {
+          const [part1, part2, ...rest] = resource.path.replace('/node_modules/', '').split('/');
+          const lib = part1.startsWith('@') ? `${part1}/${part2}` : part1;
+          const path = part1.startsWith('@') ? rest.join('/') : `${part2}/${rest.join('/')}`;
+          window.open(
+            `https://app.unpkg.com/${lib}/files/${path}${lineNumber ? '#L' + lineNumber : ''}`,
+            '_blank',
+          );
+          return true;
+        }
+
+        const targetEditor = editors.find((e) => e.getModel()?.uri.path === resource.path);
+        if (targetEditor) {
+          const targetEditorId = resource.path.slice(1); // remove leading slash
+
+          if (targetEditorId) {
+            // const targetEditorTab = getEditorTab(targetEditorId);
+            // targetEditorTab?.click();
+
+            if (monaco.Range.isIRange(selectionOrPosition)) {
+              targetEditor?.revealRangeInCenterIfOutsideViewport(
+                selectionOrPosition,
+                monaco.editor.ScrollType.Smooth,
+              );
+              targetEditor?.setSelection(selectionOrPosition);
+            } else if (selectionOrPosition) {
+              targetEditor?.revealPositionInCenterIfOutsideViewport(
+                selectionOrPosition,
+                monaco.editor.ScrollType.Smooth,
+              );
+              targetEditor?.setPosition(selectionOrPosition);
+            }
+            return true;
+          }
+        }
+
+        return false;
+      },
+    });
+  };
+
   if (!monacoGloballyLoaded) {
     registerShowPackageInfo();
+    enableGoToDefinition();
   }
 
   monacoGloballyLoaded = true;
diff --git a/src/livecodes/editor/ts-compiler-options.ts b/src/livecodes/editor/ts-compiler-options.ts
index 1445a9e86c..ae9f6cab87 100644
--- a/src/livecodes/editor/ts-compiler-options.ts
+++ b/src/livecodes/editor/ts-compiler-options.ts
@@ -1,65 +1,17 @@
 import type * as Monaco from 'monaco-editor';
-import type { Language } from '../models';
 
-type CompilerOptions = Monaco.languages.typescript.CompilerOptions;
-
-export const hasJsx = [
-  'jsx',
-  'tsx',
-  'react',
-  'react-tsx',
-  'sucrase',
-  'babel',
-  'flow',
-  'solid',
-  'solid.tsx',
-  'stencil',
-  'react-native',
-  'react-native-tsx',
-  'vue',
-];
-
-export const getCompilerOptions = (language: Language): CompilerOptions => {
-  const JSLangs = ['javascript', 'jsx', 'react', 'flow', 'solid', 'react-native'];
-  const isJSLang = JSLangs.includes(language);
-  const isJsx = hasJsx.includes(language);
-  const nonReactJsx = ['solid', 'solid.tsx', 'stencil', 'vue'].includes(language);
-
-  const settings: CompilerOptions = {
-    allowJs: true,
-    checkJs: !isJSLang,
-    strictNullChecks: !isJSLang,
-    allowNonTsExtensions: true,
-    experimentalDecorators: true,
-    emitDecoratorMetadata: true,
-    allowSyntheticDefaultImports: true,
-    allowUmdGlobalAccess: true,
-    esModuleInterop: true,
-    target: 7, // monaco.languages.typescript.ScriptTarget.ES2020,
-    module: 99, // monaco.languages.typescript.ModuleKind.ESNext,
-    moduleResolution: 2, // monaco.languages.typescript.ModuleResolutionKind.NodeJs,
-    lib: ['es2021', 'dom', 'dom.iterable'],
-  };
-
-  const jsxSettings: CompilerOptions = {
-    jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
-    // jsxFactory: 'React.createElement',
-    // reactNamespace: 'React',
-    // jsxFragmentFactory: 'React.Fragment',
-  };
-
-  const nonReactJsxSettings: CompilerOptions = {
-    jsx: 1, // monaco.languages.typescript.JsxEmit.Preserve,
-    jsxFactory: 'h',
-    ...(['solid', 'solid.tsx'].includes(language)
-      ? { jsxImportSource: 'solid-js', jsxFactory: 'JSX' }
-      : {}),
-    jsxFragmentFactory: 'Fragment',
-  };
-
-  return {
-    ...settings,
-    ...(isJsx ? jsxSettings : {}),
-    ...(nonReactJsx ? nonReactJsxSettings : {}),
-  };
-};
+export const getCompilerOptions = (): Monaco.languages.typescript.CompilerOptions => ({
+  allowJs: true,
+  checkJs: false,
+  strictNullChecks: false,
+  allowNonTsExtensions: true,
+  experimentalDecorators: true,
+  emitDecoratorMetadata: true,
+  allowSyntheticDefaultImports: true,
+  allowUmdGlobalAccess: true,
+  esModuleInterop: true,
+  target: 7, // monaco.languages.typescript.ScriptTarget.ES2020,
+  module: 99, // monaco.languages.typescript.ModuleKind.ESNext,
+  moduleResolution: 2, // monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+  lib: ['es2021', 'dom', 'dom.iterable'],
+});
diff --git a/src/livecodes/formatter/format.worker.ts b/src/livecodes/formatter/format.worker.ts
index a6769c2bd9..1242887d91 100644
--- a/src/livecodes/formatter/format.worker.ts
+++ b/src/livecodes/formatter/format.worker.ts
@@ -1,6 +1,6 @@
 import { defaultConfig } from '../config/default-config';
 import { languages, parserPlugins, prettierUrl } from '../languages';
-import type { FormatFn, FormatterConfig, Language, Parser } from '../models';
+import type { FormatFn, FormatterConfig, Language, PrettierParser } from '../models';
 import type { FormatterMessage, FormatterMessageEvent } from './models';
 
 const worker: Worker = self as any;
@@ -9,7 +9,7 @@ declare const prettierPlugins: { [key: string]: { parsers: any } };
 declare const importScripts: (...args: string[]) => void;
 
 let baseUrl: string;
-const parsers: { [key: string]: Parser } = {};
+const parsers: { [key: string]: PrettierParser } = {};
 const plugins: { [key: string]: any } = {};
 const formatters: { [key: string]: FormatFn } = {};
 
@@ -17,9 +17,11 @@ const loadPrettier = () => {
   importScripts(prettierUrl);
 };
 
-const getParser = (language: Language): Parser | undefined => {
-  const parser = languages.find((lang) => lang.name === language)?.parser;
-  if (!parser) return undefined;
+const getParser = (language: Language): PrettierParser | undefined => {
+  const formatter = languages.find((lang) => lang.name === language)?.formatter;
+  if (!formatter || !('prettier' in formatter)) return;
+  const parser = formatter.prettier;
+  if (!parser) return;
   if (parser.pluginUrls.find((url) => url.includes('babel'))) {
     return {
       ...parser,
@@ -46,7 +48,7 @@ const load = (languages: Language[]) => {
   }
 };
 
-function loadParser(language: Language): Parser | undefined {
+function loadParser(language: Language): PrettierParser | undefined {
   if (!(self as any).prettier) {
     loadPrettier();
   }
@@ -93,7 +95,7 @@ const loadFormatter = (language: Language): FormatFn | undefined => {
   }
 
   const formatter = getFormatter(language);
-  if (!formatter) return;
+  if (!formatter || !('factory' in formatter)) return;
 
   formatters[language] = formatter.factory(baseUrl, language);
   return formatters[language];
diff --git a/src/livecodes/languages/art-template/lang-art-template.ts b/src/livecodes/languages/art-template/lang-art-template.ts
index 264c70a9a8..d499e9a5fc 100644
--- a/src/livecodes/languages/art-template/lang-art-template.ts
+++ b/src/livecodes/languages/art-template/lang-art-template.ts
@@ -6,9 +6,11 @@ export const artTemplate: LanguageSpecs = {
   name: 'art-template',
   title: 'art',
   longTitle: 'art-template',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: artTemplateUrl,
diff --git a/src/livecodes/languages/assemblyscript/lang-assemblyscript.ts b/src/livecodes/languages/assemblyscript/lang-assemblyscript.ts
index bc4129de38..7375924f38 100644
--- a/src/livecodes/languages/assemblyscript/lang-assemblyscript.ts
+++ b/src/livecodes/languages/assemblyscript/lang-assemblyscript.ts
@@ -8,9 +8,11 @@ export const assemblyscript: LanguageSpecs = {
   name: 'assemblyscript',
   title: 'AS',
   longTitle: 'AssemblyScript',
-  parser: {
-    name: 'babel-ts',
-    pluginUrls: [parserPlugins.babel],
+  formatter: {
+    prettier: {
+      name: 'babel-ts',
+      pluginUrls: [parserPlugins.babel],
+    },
   },
   compiler: {
     url: assemblyscriptUrl,
diff --git a/src/livecodes/languages/astro/lang-astro.ts b/src/livecodes/languages/astro/lang-astro.ts
index b284fb3c28..91860cc29c 100644
--- a/src/livecodes/languages/astro/lang-astro.ts
+++ b/src/livecodes/languages/astro/lang-astro.ts
@@ -7,9 +7,11 @@ const compilerURL = astroBaseUrl + 'compiler.min.js';
 export const astro: LanguageSpecs = {
   name: 'astro',
   title: 'Astro',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html, parserPlugins.babel],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html, parserPlugins.babel],
+    },
   },
   compiler: {
     url: compilerURL,
diff --git a/src/livecodes/languages/babel/lang-babel.ts b/src/livecodes/languages/babel/lang-babel.ts
index 61a3d17370..d23cf797cf 100644
--- a/src/livecodes/languages/babel/lang-babel.ts
+++ b/src/livecodes/languages/babel/lang-babel.ts
@@ -6,9 +6,11 @@ import { parserPlugins } from '../prettier';
 export const babel: LanguageSpecs = {
   name: 'babel',
   title: 'Babel',
-  parser: {
-    name: 'babel',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     url: babelUrl,
@@ -33,4 +35,9 @@ export const babel: LanguageSpecs = {
   extensions: ['es', 'babel'],
   editor: 'script',
   editorLanguage: 'typescript',
+  editorSupport: {
+    compilerOptions: {
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/clojurescript/lang-clojurescript.ts b/src/livecodes/languages/clojurescript/lang-clojurescript.ts
index 60199edeee..1b359ca540 100644
--- a/src/livecodes/languages/clojurescript/lang-clojurescript.ts
+++ b/src/livecodes/languages/clojurescript/lang-clojurescript.ts
@@ -1,6 +1,7 @@
 import { compileInCompiler } from '../../compiler';
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
-import { cherryCljsBaseUrl, squintCljsBaseUrl } from '../../vendors';
+import { cherryCljsBaseUrl, codeMirrorBaseUrl, squintCljsBaseUrl } from '../../vendors';
 import { parenFormatter } from '../commonlisp';
 
 export const clojurescript: LanguageSpecs = {
@@ -36,4 +37,10 @@ export const clojurescript: LanguageSpecs = {
   extensions: ['cljs', 'clj', 'cljc', 'edn', 'clojure'],
   editor: 'script',
   editorLanguage: 'clojure',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-clojure.js')).clojure),
+    },
+  },
 };
diff --git a/src/livecodes/languages/coffeescript/lang-coffeescript.ts b/src/livecodes/languages/coffeescript/lang-coffeescript.ts
index 10e8d21e14..8064d8b3d9 100644
--- a/src/livecodes/languages/coffeescript/lang-coffeescript.ts
+++ b/src/livecodes/languages/coffeescript/lang-coffeescript.ts
@@ -1,6 +1,7 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { getLanguageCustomSettings } from '../../utils';
-import { coffeeScriptUrl } from '../../vendors';
+import { codeMirrorBaseUrl, coffeeScriptUrl } from '../../vendors';
 
 export const coffeescript: LanguageSpecs = {
   name: 'coffeescript',
@@ -18,4 +19,12 @@ export const coffeescript: LanguageSpecs = {
   },
   extensions: ['coffee'],
   editor: 'script',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy(
+          (await import(codeMirrorBaseUrl + 'codemirror-lang-coffeescript.js')).coffeescript,
+        ),
+    },
+  },
 };
diff --git a/src/livecodes/languages/commonlisp/lang-commonlisp.ts b/src/livecodes/languages/commonlisp/lang-commonlisp.ts
index eb033cc31f..c348a637a0 100644
--- a/src/livecodes/languages/commonlisp/lang-commonlisp.ts
+++ b/src/livecodes/languages/commonlisp/lang-commonlisp.ts
@@ -1,5 +1,5 @@
 import type { LanguageSpecs } from '../../models';
-import { jsclUrl, parinferUrl } from '../../vendors';
+import { jsclUrl, monacoLanguagesBaseUrl, parinferUrl } from '../../vendors';
 
 export const parenFormatter = () => {
   const url = parinferUrl;
@@ -25,5 +25,9 @@ export const commonlisp: LanguageSpecs = {
   },
   extensions: ['lisp', 'common-lisp'],
   editor: 'script',
-  editorLanguage: 'scheme',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'commonlisp.js' },
+    codemirror: { language: 'scheme' },
+    codejar: { language: 'scheme' },
+  },
 };
diff --git a/src/livecodes/languages/cpp/lang-cpp.ts b/src/livecodes/languages/cpp/lang-cpp.ts
index 725dabdfff..4e55562b23 100644
--- a/src/livecodes/languages/cpp/lang-cpp.ts
+++ b/src/livecodes/languages/cpp/lang-cpp.ts
@@ -1,5 +1,5 @@
 import type { LanguageSpecs } from '../../models';
-import { vendorsBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl, vendorsBaseUrl } from '../../vendors';
 
 export const cdnUrl = vendorsBaseUrl + 'jscpp/JSCPP.es5.min.js';
 
@@ -14,4 +14,11 @@ export const cpp: LanguageSpecs = {
   },
   extensions: ['cpp', 'c', 'C', 'cp', 'cxx', 'c++', 'cppm', 'ixx', 'ii', 'hpp', 'h'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'cpp.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-cpp.js')).cpp(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/csharp-wasm/lang-csharp-wasm.ts b/src/livecodes/languages/csharp-wasm/lang-csharp-wasm.ts
index 77049be033..6ee1ace3dc 100644
--- a/src/livecodes/languages/csharp-wasm/lang-csharp-wasm.ts
+++ b/src/livecodes/languages/csharp-wasm/lang-csharp-wasm.ts
@@ -1,12 +1,16 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 export const csharpWasm: LanguageSpecs = {
   name: 'csharp-wasm',
   title: 'C# (Wasm)',
-  parser: {
-    name: 'java',
-    pluginUrls: [parserPlugins.java],
+  formatter: {
+    prettier: {
+      name: 'java',
+      pluginUrls: [parserPlugins.java],
+    },
   },
   compiler: {
     factory: () => async (code) => code,
@@ -17,6 +21,13 @@ export const csharpWasm: LanguageSpecs = {
   },
   extensions: ['cs', 'csharp', 'wasm.cs', 'cs-wasm'],
   editor: 'script',
-  editorLanguage: 'csharp',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'csharp.js' },
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-clike.js')).csharp),
+    },
+    codejar: { language: 'csharp' },
+  },
   largeDownload: true,
 };
diff --git a/src/livecodes/languages/css/lang-css.ts b/src/livecodes/languages/css/lang-css.ts
index 29d5ac73fc..4100e2ad6e 100644
--- a/src/livecodes/languages/css/lang-css.ts
+++ b/src/livecodes/languages/css/lang-css.ts
@@ -1,3 +1,4 @@
+import { codemirrorImports } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { parserPlugins } from '../prettier';
 
@@ -5,13 +6,23 @@ export const css: LanguageSpecs = {
   name: 'css',
   title: 'CSS',
   info: false,
-  parser: {
-    name: 'css',
-    pluginUrls: [parserPlugins.postcss],
+  formatter: {
+    prettier: {
+      name: 'css',
+      pluginUrls: [parserPlugins.postcss],
+    },
   },
   compiler: {
     factory: () => async (code) => code,
   },
   extensions: ['css'],
   editor: 'style',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () => {
+        const { css } = await import(codemirrorImports.css);
+        return css();
+      },
+    },
+  },
 };
diff --git a/src/livecodes/languages/diagrams/lang-diagrams.ts b/src/livecodes/languages/diagrams/lang-diagrams.ts
index 4d067d4a57..642cf2498a 100644
--- a/src/livecodes/languages/diagrams/lang-diagrams.ts
+++ b/src/livecodes/languages/diagrams/lang-diagrams.ts
@@ -9,9 +9,11 @@ export const runOutsideWorker: CompilerFunction = async (code: string, { baseUrl
 export const diagrams: LanguageSpecs = {
   name: 'diagrams',
   title: 'Diagrams',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     factory: () => async (code) => code || '',
diff --git a/src/livecodes/languages/dot/lang-dot.ts b/src/livecodes/languages/dot/lang-dot.ts
index 8e5a4b5946..410f999dd3 100644
--- a/src/livecodes/languages/dot/lang-dot.ts
+++ b/src/livecodes/languages/dot/lang-dot.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const dot: LanguageSpecs = {
   name: 'dot',
   title: 'doT',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: dotUrl,
diff --git a/src/livecodes/languages/ejs/lang-ejs.ts b/src/livecodes/languages/ejs/lang-ejs.ts
index a18c844071..0d819b3e7e 100644
--- a/src/livecodes/languages/ejs/lang-ejs.ts
+++ b/src/livecodes/languages/ejs/lang-ejs.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const ejs: LanguageSpecs = {
   name: 'ejs',
   title: 'EJS',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: ejsUrl,
diff --git a/src/livecodes/languages/eta/lang-eta.ts b/src/livecodes/languages/eta/lang-eta.ts
index 3b3cdfa8b7..fd7c678034 100644
--- a/src/livecodes/languages/eta/lang-eta.ts
+++ b/src/livecodes/languages/eta/lang-eta.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const eta: LanguageSpecs = {
   name: 'eta',
   title: 'Eta',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: etaUrl,
diff --git a/src/livecodes/languages/flow/lang-flow.ts b/src/livecodes/languages/flow/lang-flow.ts
index 198df902b8..ee2e4c7aaf 100644
--- a/src/livecodes/languages/flow/lang-flow.ts
+++ b/src/livecodes/languages/flow/lang-flow.ts
@@ -6,9 +6,11 @@ import { parserPlugins } from '../prettier';
 export const flow: LanguageSpecs = {
   name: 'flow',
   title: 'Flow',
-  parser: {
-    name: 'babel-flow',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel-flow',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     url: vendorsBaseUrl + 'flow-remove-types/flow-remove-types.js',
@@ -25,4 +27,9 @@ export const flow: LanguageSpecs = {
   extensions: ['flow'],
   editor: 'script',
   editorLanguage: 'typescript',
+  editorSupport: {
+    compilerOptions: {
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/gleam/lang-gleam.ts b/src/livecodes/languages/gleam/lang-gleam.ts
index 42f8fe1e05..fb329580bc 100644
--- a/src/livecodes/languages/gleam/lang-gleam.ts
+++ b/src/livecodes/languages/gleam/lang-gleam.ts
@@ -1,4 +1,6 @@
-import type { Language, LanguageSpecs } from '../../models';
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
+import type { LanguageSpecs } from '../../models';
+import { codeMirrorBaseUrl } from '../../vendors';
 
 export const gleam: LanguageSpecs = {
   name: 'gleam',
@@ -17,5 +19,12 @@ export const gleam: LanguageSpecs = {
   },
   extensions: ['gleam'],
   editor: 'script',
-  editorLanguage: 'swift' as Language,
+  editorSupport: {
+    monaco: { language: 'swift' },
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-swift.js')).swift),
+    },
+    codejar: { language: 'swift' },
+  },
 };
diff --git a/src/livecodes/languages/go/lang-go.ts b/src/livecodes/languages/go/lang-go.ts
index ffb9f63515..1eee686d1d 100644
--- a/src/livecodes/languages/go/lang-go.ts
+++ b/src/livecodes/languages/go/lang-go.ts
@@ -1,5 +1,5 @@
 import type { LanguageSpecs } from '../../models';
-import { go2jsBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, go2jsBaseUrl, monacoLanguagesBaseUrl } from '../../vendors';
 
 declare const importScripts: (...args: string[]) => void;
 
@@ -46,4 +46,10 @@ export const go: LanguageSpecs = {
   },
   extensions: ['go', 'golang'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'go.js' },
+    codemirror: {
+      languageSupport: async () => (await import(codeMirrorBaseUrl + 'codemirror-lang-go.js')).go(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/handlebars/lang-handlebars.ts b/src/livecodes/languages/handlebars/lang-handlebars.ts
index 54a0311508..ad29749bd4 100644
--- a/src/livecodes/languages/handlebars/lang-handlebars.ts
+++ b/src/livecodes/languages/handlebars/lang-handlebars.ts
@@ -8,9 +8,11 @@ export const runtimeUrl = handlebarsBaseUrl + 'handlebars.runtime.min.js';
 export const handlebars: LanguageSpecs = {
   name: 'handlebars',
   title: 'Handlebars',
-  parser: {
-    name: 'glimmer',
-    pluginUrls: [parserPlugins.glimmer],
+  formatter: {
+    prettier: {
+      name: 'glimmer',
+      pluginUrls: [parserPlugins.glimmer],
+    },
   },
   compiler: {
     url,
diff --git a/src/livecodes/languages/html/lang-html.ts b/src/livecodes/languages/html/lang-html.ts
index b323d67252..3237932f26 100644
--- a/src/livecodes/languages/html/lang-html.ts
+++ b/src/livecodes/languages/html/lang-html.ts
@@ -1,3 +1,4 @@
+import { codemirrorImports } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { parserPlugins } from '../prettier';
 
@@ -5,13 +6,23 @@ export const html: LanguageSpecs = {
   name: 'html',
   title: 'HTML',
   info: false,
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     factory: () => async (code) => code,
   },
   extensions: ['html', 'htm'],
   editor: 'markup',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () => {
+        const { html } = await import(codemirrorImports.html);
+        return html();
+      },
+    },
+  },
 };
diff --git a/src/livecodes/languages/java/lang-java.ts b/src/livecodes/languages/java/lang-java.ts
index 3d1e03723d..a0912cdf1e 100644
--- a/src/livecodes/languages/java/lang-java.ts
+++ b/src/livecodes/languages/java/lang-java.ts
@@ -1,12 +1,15 @@
 import type { LanguageSpecs } from '../../models';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 export const java: LanguageSpecs = {
   name: 'java',
   title: 'Java',
-  parser: {
-    name: 'java',
-    pluginUrls: [parserPlugins.java],
+  formatter: {
+    prettier: {
+      name: 'java',
+      pluginUrls: [parserPlugins.java],
+    },
   },
   compiler: {
     factory: () => async (code) => code,
@@ -17,5 +20,12 @@ export const java: LanguageSpecs = {
   },
   extensions: ['java'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'java.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-java.js')).java(),
+    },
+  },
   largeDownload: true,
 };
diff --git a/src/livecodes/languages/javascript/lang-javascript.ts b/src/livecodes/languages/javascript/lang-javascript.ts
index a7c3d62974..ef34679444 100644
--- a/src/livecodes/languages/javascript/lang-javascript.ts
+++ b/src/livecodes/languages/javascript/lang-javascript.ts
@@ -1,3 +1,4 @@
+import { codemirrorImports } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { parserPlugins } from '../prettier';
 
@@ -5,13 +6,23 @@ export const javascript: LanguageSpecs = {
   name: 'javascript',
   title: 'JS',
   longTitle: 'JavaScript',
-  parser: {
-    name: 'babel',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     factory: () => async (code) => code,
   },
   extensions: ['js', 'mjs'],
   editor: 'script',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () => {
+        const { javascript } = await import(codemirrorImports.javascript);
+        return javascript();
+      },
+    },
+  },
 };
diff --git a/src/livecodes/languages/jsx/lang-jsx.ts b/src/livecodes/languages/jsx/lang-jsx.ts
index 75043344df..94ecf9b00a 100644
--- a/src/livecodes/languages/jsx/lang-jsx.ts
+++ b/src/livecodes/languages/jsx/lang-jsx.ts
@@ -1,15 +1,29 @@
+import { codemirrorImports } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { parserPlugins } from '../prettier';
 
 export const jsx: LanguageSpecs = {
   name: 'jsx',
   title: 'JSX',
-  parser: {
-    name: 'babel',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: 'typescript',
   extensions: ['jsx'],
   editor: 'script',
   editorLanguage: 'javascript',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () => {
+        const { javascript } = await import(codemirrorImports.javascript);
+        return javascript({ jsx: true });
+      },
+    },
+    compilerOptions: {
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/jsx/lang-tsx.ts b/src/livecodes/languages/jsx/lang-tsx.ts
index 969228af34..7b8f52a5b9 100644
--- a/src/livecodes/languages/jsx/lang-tsx.ts
+++ b/src/livecodes/languages/jsx/lang-tsx.ts
@@ -1,15 +1,31 @@
+import { codemirrorImports } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { parserPlugins } from '../prettier';
 
 export const tsx: LanguageSpecs = {
   name: 'tsx',
   title: 'TSX',
-  parser: {
-    name: 'babel-ts',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel-ts',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: 'typescript',
   extensions: ['tsx'],
   editor: 'script',
   editorLanguage: 'typescript',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () => {
+        const { javascript } = await import(codemirrorImports.javascript);
+        return javascript({ jsx: true, typescript: true });
+      },
+    },
+    compilerOptions: {
+      checkJs: true,
+      strictNullChecks: true,
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/julia/lang-julia.ts b/src/livecodes/languages/julia/lang-julia.ts
index 3d2e2dd37f..61822ed51c 100644
--- a/src/livecodes/languages/julia/lang-julia.ts
+++ b/src/livecodes/languages/julia/lang-julia.ts
@@ -1,4 +1,6 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
+import { codeMirrorBaseUrl } from '../../vendors';
 
 export const julia: LanguageSpecs = {
   name: 'julia',
@@ -12,5 +14,11 @@ export const julia: LanguageSpecs = {
   },
   extensions: ['jl'],
   editor: 'script',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-julia.js')).julia),
+    },
+  },
   largeDownload: true,
 };
diff --git a/src/livecodes/languages/less/lang-less.ts b/src/livecodes/languages/less/lang-less.ts
index 5c9e2b2a26..a1dc9fb8a1 100644
--- a/src/livecodes/languages/less/lang-less.ts
+++ b/src/livecodes/languages/less/lang-less.ts
@@ -1,14 +1,17 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { getLanguageCustomSettings } from '../../utils';
-import { vendorsBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, vendorsBaseUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 export const less: LanguageSpecs = {
   name: 'less',
   title: 'Less',
-  parser: {
-    name: 'less',
-    pluginUrls: [parserPlugins.postcss],
+  formatter: {
+    prettier: {
+      name: 'less',
+      pluginUrls: [parserPlugins.postcss],
+    },
   },
   compiler: {
     url: vendorsBaseUrl + 'less/less.js',
@@ -23,4 +26,10 @@ export const less: LanguageSpecs = {
   },
   extensions: ['less'],
   editor: 'style',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-less.js')).less),
+    },
+  },
 };
diff --git a/src/livecodes/languages/liquid/lang-liquid.ts b/src/livecodes/languages/liquid/lang-liquid.ts
index f2707129d5..d43f343d11 100644
--- a/src/livecodes/languages/liquid/lang-liquid.ts
+++ b/src/livecodes/languages/liquid/lang-liquid.ts
@@ -1,13 +1,15 @@
 import type { LanguageSpecs } from '../../models';
-import { liquidJsUrl } from '../../vendors';
+import { codeMirrorBaseUrl, liquidJsUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 export const liquid: LanguageSpecs = {
   name: 'liquid',
   title: 'Liquid',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: liquidJsUrl,
@@ -19,4 +21,10 @@ export const liquid: LanguageSpecs = {
   extensions: ['liquid', 'liquidjs'],
   editor: 'markup',
   editorLanguage: 'html',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-liquid.js')).liquid(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/livescript/lang-livescript.ts b/src/livecodes/languages/livescript/lang-livescript.ts
index a8db1be7fd..ce13d30db7 100644
--- a/src/livecodes/languages/livescript/lang-livescript.ts
+++ b/src/livecodes/languages/livescript/lang-livescript.ts
@@ -1,6 +1,7 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { getLanguageCustomSettings } from '../../utils';
-import { vendorsBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, vendorsBaseUrl } from '../../vendors';
 
 export const livescript: LanguageSpecs = {
   name: 'livescript',
@@ -18,4 +19,13 @@ export const livescript: LanguageSpecs = {
   },
   extensions: ['ls'],
   editor: 'script',
+  editorSupport: {
+    monaco: { language: 'coffeescript' },
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy(
+          (await import(codeMirrorBaseUrl + 'codemirror-lang-livescript.js')).livescript,
+        ),
+    },
+  },
 };
diff --git a/src/livecodes/languages/lua/lang-lua.ts b/src/livecodes/languages/lua/lang-lua.ts
index 73789c52fe..91f9336b30 100644
--- a/src/livecodes/languages/lua/lang-lua.ts
+++ b/src/livecodes/languages/lua/lang-lua.ts
@@ -1,5 +1,6 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageFormatter, LanguageSpecs } from '../../models';
-import { luaUrl, vendorsBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, luaUrl, monacoLanguagesBaseUrl, vendorsBaseUrl } from '../../vendors';
 
 const luaFmtUrl = vendorsBaseUrl + 'lua-fmt/lua-fmt.js';
 
@@ -25,4 +26,13 @@ export const lua: LanguageSpecs = {
   },
   extensions: ['lua'],
   editor: 'script',
+  editorSupport: {
+    monaco: {
+      languageSupport: monacoLanguagesBaseUrl + 'lua.js',
+    },
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-lua.js')).lua),
+    },
+  },
 };
diff --git a/src/livecodes/languages/malina/lang-malina.ts b/src/livecodes/languages/malina/lang-malina.ts
index c659286fd5..0fd70fa4b8 100644
--- a/src/livecodes/languages/malina/lang-malina.ts
+++ b/src/livecodes/languages/malina/lang-malina.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const malina: LanguageSpecs = {
   name: 'malina',
   title: 'Malina.js',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html, parserPlugins.babel],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html, parserPlugins.babel],
+    },
   },
   compiler: {
     factory: (_config, baseUrl) => {
@@ -20,4 +22,5 @@ export const malina: LanguageSpecs = {
   },
   extensions: ['xht'],
   editor: 'script',
+  editorLanguage: 'html',
 };
diff --git a/src/livecodes/languages/markdown/lang-markdown.ts b/src/livecodes/languages/markdown/lang-markdown.ts
index 228630bf59..e22eb60c22 100644
--- a/src/livecodes/languages/markdown/lang-markdown.ts
+++ b/src/livecodes/languages/markdown/lang-markdown.ts
@@ -1,14 +1,16 @@
 import type { LanguageSpecs } from '../../models';
 import { getLanguageCustomSettings } from '../../utils';
-import { markedUrl } from '../../vendors';
+import { codeMirrorBaseUrl, markedUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 export const markdown: LanguageSpecs = {
   name: 'markdown',
   title: 'Markdown',
-  parser: {
-    name: 'markdown',
-    pluginUrls: [parserPlugins.markdown, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'markdown',
+      pluginUrls: [parserPlugins.markdown, parserPlugins.html],
+    },
   },
   compiler: {
     url: markedUrl,
@@ -19,4 +21,10 @@ export const markdown: LanguageSpecs = {
   },
   extensions: ['md', 'markdown', 'mdown', 'mkdn'],
   editor: 'markup',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-markdown.js')).markdown(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/mdx/lang-mdx.ts b/src/livecodes/languages/mdx/lang-mdx.ts
index 34335ed11b..2b7bd2de76 100644
--- a/src/livecodes/languages/mdx/lang-mdx.ts
+++ b/src/livecodes/languages/mdx/lang-mdx.ts
@@ -38,9 +38,11 @@ createRoot(document.querySelector('#__livecodes_mdx_root__')).render(<MDXContent
 export const mdx: LanguageSpecs = {
   name: 'mdx',
   title: 'MDX',
-  parser: {
-    name: 'markdown',
-    pluginUrls: [parserPlugins.markdown, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'markdown',
+      pluginUrls: [parserPlugins.markdown, parserPlugins.html],
+    },
   },
   compiler: {
     factory: () => async (code) => code,
diff --git a/src/livecodes/languages/minizinc/lang-minizinc.ts b/src/livecodes/languages/minizinc/lang-minizinc.ts
index ed17daab6a..8e488e852a 100644
--- a/src/livecodes/languages/minizinc/lang-minizinc.ts
+++ b/src/livecodes/languages/minizinc/lang-minizinc.ts
@@ -1,12 +1,15 @@
 import type { LanguageSpecs } from '../../models';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 export const minizinc: LanguageSpecs = {
   name: 'minizinc',
   title: 'MiniZinc',
-  parser: {
-    name: 'minizinc',
-    pluginUrls: [parserPlugins.minizinc],
+  formatter: {
+    prettier: {
+      name: 'minizinc',
+      pluginUrls: [parserPlugins.minizinc],
+    },
   },
   compiler: {
     factory: () => async (code) => code,
@@ -16,4 +19,11 @@ export const minizinc: LanguageSpecs = {
   },
   extensions: ['mzn', 'dzn', 'minizinc'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'minizinc.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-minizinc.js')).MiniZinc(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/mjml/lang-mjml.ts b/src/livecodes/languages/mjml/lang-mjml.ts
index e2b4130b7c..08d6384c7a 100644
--- a/src/livecodes/languages/mjml/lang-mjml.ts
+++ b/src/livecodes/languages/mjml/lang-mjml.ts
@@ -6,9 +6,11 @@ import { parserPlugins } from '../prettier';
 export const mjml: LanguageSpecs = {
   name: 'mjml',
   title: 'MJML',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: mjmlUrl,
diff --git a/src/livecodes/languages/mustache/lang-mustache.ts b/src/livecodes/languages/mustache/lang-mustache.ts
index 1b7f283e8f..5cf63f2325 100644
--- a/src/livecodes/languages/mustache/lang-mustache.ts
+++ b/src/livecodes/languages/mustache/lang-mustache.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const mustache: LanguageSpecs = {
   name: 'mustache',
   title: 'Mustache',
-  parser: {
-    name: 'glimmer',
-    pluginUrls: [parserPlugins.glimmer],
+  formatter: {
+    prettier: {
+      name: 'glimmer',
+      pluginUrls: [parserPlugins.glimmer],
+    },
   },
   compiler: {
     url: mustacheUrl,
diff --git a/src/livecodes/languages/nunjucks/lang-nunjucks.ts b/src/livecodes/languages/nunjucks/lang-nunjucks.ts
index 2aa99f9fae..47e30c1f5f 100644
--- a/src/livecodes/languages/nunjucks/lang-nunjucks.ts
+++ b/src/livecodes/languages/nunjucks/lang-nunjucks.ts
@@ -8,9 +8,11 @@ export const runtimeUrl = nunjucksBaseUrl + 'nunjucks-slim.min.js';
 export const nunjucks: LanguageSpecs = {
   name: 'nunjucks',
   title: 'Nunjucks',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url,
diff --git a/src/livecodes/languages/ocaml/lang-ocaml.ts b/src/livecodes/languages/ocaml/lang-ocaml.ts
index 82249864e3..e99087f5cc 100644
--- a/src/livecodes/languages/ocaml/lang-ocaml.ts
+++ b/src/livecodes/languages/ocaml/lang-ocaml.ts
@@ -1,4 +1,6 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
+import { codeMirrorBaseUrl } from '../../vendors';
 
 export const ocaml: LanguageSpecs = {
   name: 'ocaml',
@@ -6,5 +8,11 @@ export const ocaml: LanguageSpecs = {
   compiler: 'rescript',
   extensions: ['ml', 'mli'],
   editor: 'script',
-  editorLanguage: 'javascript',
+  editorSupport: {
+    monaco: { language: 'csharp' },
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-mllike.js')).oCaml),
+    },
+  },
 };
diff --git a/src/livecodes/languages/perl/lang-perl.ts b/src/livecodes/languages/perl/lang-perl.ts
index 3c8802ac5b..a15a18834e 100644
--- a/src/livecodes/languages/perl/lang-perl.ts
+++ b/src/livecodes/languages/perl/lang-perl.ts
@@ -1,5 +1,6 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
-import { vendorsBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, vendorsBaseUrl } from '../../vendors';
 
 export const perl: LanguageSpecs = {
   name: 'perl',
@@ -14,4 +15,10 @@ export const perl: LanguageSpecs = {
   },
   extensions: ['pl', 'pm'],
   editor: 'script',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-perl.js')).perl),
+    },
+  },
 };
diff --git a/src/livecodes/languages/php-wasm/lang-php-wasm.ts b/src/livecodes/languages/php-wasm/lang-php-wasm.ts
index e2a2afd057..da11a8359a 100644
--- a/src/livecodes/languages/php-wasm/lang-php-wasm.ts
+++ b/src/livecodes/languages/php-wasm/lang-php-wasm.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const phpWasm: LanguageSpecs = {
   name: 'php-wasm',
   title: 'PHP (Wasm)',
-  parser: {
-    name: 'php',
-    pluginUrls: [parserPlugins.php],
+  formatter: {
+    prettier: {
+      name: 'php',
+      pluginUrls: [parserPlugins.php],
+    },
   },
   compiler: {
     factory: () => async (code) => code,
diff --git a/src/livecodes/languages/php/lang-php.ts b/src/livecodes/languages/php/lang-php.ts
index 6b1a36b6d0..1f790834fa 100644
--- a/src/livecodes/languages/php/lang-php.ts
+++ b/src/livecodes/languages/php/lang-php.ts
@@ -1,13 +1,15 @@
 import type { LanguageSpecs } from '../../models';
-import { uniterUrl } from '../../vendors';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl, uniterUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 export const php: LanguageSpecs = {
   name: 'php',
   title: 'PHP',
-  parser: {
-    name: 'php',
-    pluginUrls: [parserPlugins.php],
+  formatter: {
+    prettier: {
+      name: 'php',
+      pluginUrls: [parserPlugins.php],
+    },
   },
   compiler: {
     factory: () => async (code) => {
@@ -27,4 +29,11 @@ export const php: LanguageSpecs = {
   },
   extensions: ['php'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'php.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-php.js')).php(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/prolog/lang-prolog.ts b/src/livecodes/languages/prolog/lang-prolog.ts
index bb78e59019..e53896d8ad 100644
--- a/src/livecodes/languages/prolog/lang-prolog.ts
+++ b/src/livecodes/languages/prolog/lang-prolog.ts
@@ -1,5 +1,5 @@
 import type { LanguageSpecs } from '../../models';
-import { tauPrologBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl, tauPrologBaseUrl } from '../../vendors';
 
 export const prolog: LanguageSpecs = {
   name: 'prolog',
@@ -24,4 +24,11 @@ export const prolog: LanguageSpecs = {
   },
   extensions: ['prolog.pl', 'prolog'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'prolog.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-prolog.js')).prolog(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/pug/lang-pug.ts b/src/livecodes/languages/pug/lang-pug.ts
index d96e8db06a..f3058c1ed6 100644
--- a/src/livecodes/languages/pug/lang-pug.ts
+++ b/src/livecodes/languages/pug/lang-pug.ts
@@ -1,6 +1,5 @@
 import type { LanguageSpecs } from '../../models';
 import { vendorsBaseUrl } from '../../vendors';
-import { parserPlugins } from '../prettier';
 
 export const pug: LanguageSpecs = {
   name: 'pug',
@@ -8,10 +7,12 @@ export const pug: LanguageSpecs = {
 
   // disable formatter, till @prettier/plugin-pug supports prettier v3
   // (https://github.com/prettier/plugin-pug/pull/411)
-  parser: {
-    name: 'pug',
-    pluginUrls: [parserPlugins.pug],
-  },
+  // formatter: {
+  //   prettier: {
+  //     name: 'pug',
+  //     pluginUrls: [parserPlugins.pug],
+  //   },
+  // },
 
   compiler: {
     url: vendorsBaseUrl + 'pug/pug.min.js',
diff --git a/src/livecodes/languages/python/lang-python.ts b/src/livecodes/languages/python/lang-python.ts
index 7d66c78c73..110d013785 100644
--- a/src/livecodes/languages/python/lang-python.ts
+++ b/src/livecodes/languages/python/lang-python.ts
@@ -1,6 +1,6 @@
 import type { LanguageSpecs } from '../../models';
 import { getLanguageCustomSettings } from '../../utils/utils';
-import { brythonBaseUrl } from '../../vendors';
+import { brythonBaseUrl, codeMirrorBaseUrl, monacoLanguagesBaseUrl } from '../../vendors';
 
 const brythonUrl = brythonBaseUrl + 'brython.min.js';
 const stdlibUrl = brythonBaseUrl + 'brython_stdlib.js';
@@ -21,4 +21,11 @@ export const python: LanguageSpecs = {
   },
   extensions: ['py'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'python.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-python.js')).python(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/r/lang-r.ts b/src/livecodes/languages/r/lang-r.ts
index c36df5574a..03dab7ba55 100644
--- a/src/livecodes/languages/r/lang-r.ts
+++ b/src/livecodes/languages/r/lang-r.ts
@@ -1,4 +1,6 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl } from '../../vendors';
 
 export const r: LanguageSpecs = {
   name: 'r',
@@ -26,5 +28,12 @@ export const r: LanguageSpecs = {
   },
   extensions: ['r', 'rlang', 'rstats', 'r-wasm'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'r.js' },
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-r.js')).r),
+    },
+  },
   largeDownload: true,
 };
diff --git a/src/livecodes/languages/react-native/lang-react-native-tsx.ts b/src/livecodes/languages/react-native/lang-react-native-tsx.ts
index 8e55b94dff..023090f62b 100644
--- a/src/livecodes/languages/react-native/lang-react-native-tsx.ts
+++ b/src/livecodes/languages/react-native/lang-react-native-tsx.ts
@@ -5,12 +5,21 @@ export const reactNativeTsx: LanguageSpecs = {
   name: 'react-native-tsx',
   title: 'RN (TSX)',
   longTitle: 'React Native (TSX)',
-  parser: {
-    name: 'babel-ts',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel-ts',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: 'react-native',
   extensions: ['react-native.tsx'],
   editor: 'script',
   editorLanguage: 'typescript',
+  editorSupport: {
+    compilerOptions: {
+      checkJs: true,
+      strictNullChecks: true,
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/react-native/lang-react-native.ts b/src/livecodes/languages/react-native/lang-react-native.ts
index 7d42309368..786bbbbffd 100644
--- a/src/livecodes/languages/react-native/lang-react-native.ts
+++ b/src/livecodes/languages/react-native/lang-react-native.ts
@@ -10,9 +10,11 @@ export const reactNative: LanguageSpecs = {
   name: 'react-native',
   title: 'RN',
   longTitle: 'React Native',
-  parser: {
-    name: 'babel',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     dependencies: ['typescript'],
@@ -33,4 +35,9 @@ export const reactNative: LanguageSpecs = {
   extensions: ['react-native.jsx'],
   editor: 'script',
   editorLanguage: 'javascript',
+  editorSupport: {
+    compilerOptions: {
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/react/lang-react-tsx.ts b/src/livecodes/languages/react/lang-react-tsx.ts
index ac3bdd9de8..b41f60dc13 100644
--- a/src/livecodes/languages/react/lang-react-tsx.ts
+++ b/src/livecodes/languages/react/lang-react-tsx.ts
@@ -4,12 +4,21 @@ import { parserPlugins } from '../prettier';
 export const reactTsx: LanguageSpecs = {
   name: 'react-tsx',
   title: 'React (TSX)',
-  parser: {
-    name: 'babel-ts',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel-ts',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: 'react',
   extensions: ['react.tsx'],
   editor: 'script',
   editorLanguage: 'typescript',
+  editorSupport: {
+    compilerOptions: {
+      checkJs: true,
+      strictNullChecks: true,
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/react/lang-react.ts b/src/livecodes/languages/react/lang-react.ts
index 9ed448adf1..01e843923b 100644
--- a/src/livecodes/languages/react/lang-react.ts
+++ b/src/livecodes/languages/react/lang-react.ts
@@ -6,9 +6,11 @@ import { getLanguageCustomSettings } from '../utils';
 export const react: LanguageSpecs = {
   name: 'react',
   title: 'React',
-  parser: {
-    name: 'babel',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     dependencies: ['babel'],
@@ -39,4 +41,9 @@ export const react: LanguageSpecs = {
   extensions: ['react.jsx', 'react-jsx'],
   editor: 'script',
   editorLanguage: 'javascript',
+  editorSupport: {
+    compilerOptions: {
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/reason/lang-reason.ts b/src/livecodes/languages/reason/lang-reason.ts
index 5d87d8d246..ff9975dc84 100644
--- a/src/livecodes/languages/reason/lang-reason.ts
+++ b/src/livecodes/languages/reason/lang-reason.ts
@@ -11,4 +11,5 @@ export const reason: LanguageSpecs = {
   extensions: ['re', 'rei'],
   editor: 'script',
   editorLanguage: 'javascript',
+  editorSupport: { monaco: { language: 'csharp' } },
 };
diff --git a/src/livecodes/languages/rescript/lang-rescript-formatter.ts b/src/livecodes/languages/rescript/lang-rescript-formatter.ts
index 6851d6cb7d..0c2204168d 100644
--- a/src/livecodes/languages/rescript/lang-rescript-formatter.ts
+++ b/src/livecodes/languages/rescript/lang-rescript-formatter.ts
@@ -1,10 +1,10 @@
-import type { LanguageFormatter } from '../../models';
+import type { FormatFn, Language } from '../../models';
 import { getAbsoluteUrl } from '../../utils';
 import { rescriptCdnBaseUrl } from '../../vendors';
 
 declare const importScripts: any;
 
-const createRescriptFormatter: LanguageFormatter['factory'] = (baseUrl, language) => {
+const createRescriptFormatter = (baseUrl: string, language: Language): FormatFn => {
   if (!(self as any).rescript_compiler) {
     importScripts(getAbsoluteUrl(rescriptCdnBaseUrl + 'compiler.js', baseUrl));
   }
diff --git a/src/livecodes/languages/rescript/lang-rescript.ts b/src/livecodes/languages/rescript/lang-rescript.ts
index 96ea1041fb..bd200504a0 100644
--- a/src/livecodes/languages/rescript/lang-rescript.ts
+++ b/src/livecodes/languages/rescript/lang-rescript.ts
@@ -1,4 +1,4 @@
-import type { CompilerFunction, LanguageFormatter, LanguageSpecs } from '../../models';
+import type { CompilerFunction, FormatFn, Language, LanguageSpecs } from '../../models';
 
 declare const importScripts: (...args: string[]) => void;
 
@@ -7,7 +7,7 @@ export const runOutsideWorker: CompilerFunction = async (code: string, { baseUrl
   return rescriptCompiler(code, { baseUrl, language });
 };
 
-export const formatterFactory: LanguageFormatter['factory'] = (baseUrl, language) => {
+export const formatterFactory = (baseUrl: string, language: Language): FormatFn => {
   importScripts(baseUrl + '{{hash:lang-rescript-formatter.js}}');
   return (self as any).createRescriptFormatter(baseUrl, language);
 };
@@ -26,4 +26,5 @@ export const rescript: LanguageSpecs = {
   extensions: ['res', 'resi'],
   editor: 'script',
   editorLanguage: 'javascript',
+  editorSupport: { monaco: { language: 'csharp' } },
 };
diff --git a/src/livecodes/languages/riot/lang-riot.ts b/src/livecodes/languages/riot/lang-riot.ts
index eb0e5bf11b..809fdb23c1 100644
--- a/src/livecodes/languages/riot/lang-riot.ts
+++ b/src/livecodes/languages/riot/lang-riot.ts
@@ -8,9 +8,11 @@ const cdnUrl = riotBaseUrl + 'riot.min.js';
 export const riot: LanguageSpecs = {
   name: 'riot',
   title: 'Riot.js',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html, parserPlugins.babel],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html, parserPlugins.babel],
+    },
   },
   compiler: {
     url: compilerCdnUrl,
@@ -23,4 +25,5 @@ export const riot: LanguageSpecs = {
   },
   extensions: ['riot', 'riotjs'],
   editor: 'script',
+  editorLanguage: 'html',
 };
diff --git a/src/livecodes/languages/ruby/lang-ruby.ts b/src/livecodes/languages/ruby/lang-ruby.ts
index 888622cca7..6da7830bd7 100644
--- a/src/livecodes/languages/ruby/lang-ruby.ts
+++ b/src/livecodes/languages/ruby/lang-ruby.ts
@@ -1,6 +1,7 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
 import { getLanguageCustomSettings } from '../../utils';
-import { opalBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl, opalBaseUrl } from '../../vendors';
 
 declare const importScripts: (...args: string[]) => void;
 
@@ -43,4 +44,11 @@ export const ruby: LanguageSpecs = {
   },
   extensions: ['rb'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'ruby.js' },
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-ruby.js')).ruby),
+    },
+  },
 };
diff --git a/src/livecodes/languages/scheme/lang-scheme.ts b/src/livecodes/languages/scheme/lang-scheme.ts
index 5a167988de..4fc33a02a9 100644
--- a/src/livecodes/languages/scheme/lang-scheme.ts
+++ b/src/livecodes/languages/scheme/lang-scheme.ts
@@ -1,5 +1,6 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
-import { biwaschemeUrl } from '../../vendors';
+import { biwaschemeUrl, codeMirrorBaseUrl, monacoLanguagesBaseUrl } from '../../vendors';
 import { parenFormatter } from '../commonlisp';
 
 export const scheme: LanguageSpecs = {
@@ -16,4 +17,11 @@ export const scheme: LanguageSpecs = {
   },
   extensions: ['scm'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'scheme.js' },
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-scheme.js')).scheme),
+    },
+  },
 };
diff --git a/src/livecodes/languages/scss/lang-sass.ts b/src/livecodes/languages/scss/lang-sass.ts
index 1559a13880..0fc3bc8dd9 100644
--- a/src/livecodes/languages/scss/lang-sass.ts
+++ b/src/livecodes/languages/scss/lang-sass.ts
@@ -1,4 +1,5 @@
 import type { LanguageSpecs } from '../../models';
+import { codeMirrorBaseUrl } from '../../vendors';
 
 export const sass: LanguageSpecs = {
   name: 'sass',
@@ -6,4 +7,10 @@ export const sass: LanguageSpecs = {
   compiler: 'scss',
   extensions: ['sass'],
   editor: 'style',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-scss.js')).sass({ indented: true }),
+    },
+  },
 };
diff --git a/src/livecodes/languages/scss/lang-scss.ts b/src/livecodes/languages/scss/lang-scss.ts
index 4affdd6687..94aaf49fbb 100644
--- a/src/livecodes/languages/scss/lang-scss.ts
+++ b/src/livecodes/languages/scss/lang-scss.ts
@@ -1,13 +1,15 @@
 import type { LanguageSpecs } from '../../models';
-import { vendorsBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, vendorsBaseUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 export const scss: LanguageSpecs = {
   name: 'scss',
   title: 'SCSS',
-  parser: {
-    name: 'scss',
-    pluginUrls: [parserPlugins.postcss],
+  formatter: {
+    prettier: {
+      name: 'scss',
+      pluginUrls: [parserPlugins.postcss],
+    },
   },
   compiler: {
     url: vendorsBaseUrl + 'sass/sass.js',
@@ -18,4 +20,10 @@ export const scss: LanguageSpecs = {
   },
   extensions: ['scss'],
   editor: 'style',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-scss.js')).sass(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/solid/lang-solid-tsx.ts b/src/livecodes/languages/solid/lang-solid-tsx.ts
index bde8639ca5..a4f90bcd05 100644
--- a/src/livecodes/languages/solid/lang-solid-tsx.ts
+++ b/src/livecodes/languages/solid/lang-solid-tsx.ts
@@ -4,12 +4,24 @@ import { parserPlugins } from '../prettier';
 export const solidTsx: LanguageSpecs = {
   name: 'solid.tsx',
   title: 'Solid (TS)',
-  parser: {
-    name: 'babel-ts',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel-ts',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: 'solid',
   extensions: ['solid.tsx'],
   editor: 'script',
   editorLanguage: 'typescript',
+  editorSupport: {
+    compilerOptions: {
+      checkJs: true,
+      strictNullChecks: true,
+      jsx: 1, // monaco.languages.typescript.JsxEmit.Preserve,
+      jsxImportSource: 'solid-js',
+      jsxFactory: 'JSX',
+      jsxFragmentFactory: 'Fragment',
+    },
+  },
 };
diff --git a/src/livecodes/languages/solid/lang-solid.ts b/src/livecodes/languages/solid/lang-solid.ts
index b0c2210cac..bc8cf21b91 100644
--- a/src/livecodes/languages/solid/lang-solid.ts
+++ b/src/livecodes/languages/solid/lang-solid.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const solid: LanguageSpecs = {
   name: 'solid',
   title: 'Solid',
-  parser: {
-    name: 'babel',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     dependencies: ['babel'],
@@ -20,4 +22,12 @@ export const solid: LanguageSpecs = {
   extensions: ['solid.jsx'],
   editor: 'script',
   editorLanguage: 'javascript',
+  editorSupport: {
+    compilerOptions: {
+      jsx: 1, // monaco.languages.typescript.JsxEmit.Preserve,
+      jsxImportSource: 'solid-js',
+      jsxFactory: 'JSX',
+      jsxFragmentFactory: 'Fragment',
+    },
+  },
 };
diff --git a/src/livecodes/languages/sql/lang-sql.ts b/src/livecodes/languages/sql/lang-sql.ts
index d2444753cd..62c2446cba 100644
--- a/src/livecodes/languages/sql/lang-sql.ts
+++ b/src/livecodes/languages/sql/lang-sql.ts
@@ -1,5 +1,10 @@
 import type { LanguageSpecs } from '../../models';
-import { sqlFormatterUrl, sqljsBaseUrl } from '../../vendors';
+import {
+  codeMirrorBaseUrl,
+  monacoLanguagesBaseUrl,
+  sqlFormatterUrl,
+  sqljsBaseUrl,
+} from '../../vendors';
 
 declare const importScripts: (...args: string[]) => void;
 
@@ -29,4 +34,11 @@ export const sql: LanguageSpecs = {
   },
   extensions: ['sql', 'sqlite', 'sqlite3'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'sql.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-sql.js')).sql(),
+    },
+  },
 };
diff --git a/src/livecodes/languages/stencil/lang-stencil.ts b/src/livecodes/languages/stencil/lang-stencil.ts
index 906ee582ac..1fe7844153 100644
--- a/src/livecodes/languages/stencil/lang-stencil.ts
+++ b/src/livecodes/languages/stencil/lang-stencil.ts
@@ -6,9 +6,11 @@ import { parserPlugins } from '../prettier';
 export const stencil: LanguageSpecs = {
   name: 'stencil',
   title: 'Stencil',
-  parser: {
-    name: 'babel-ts',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel-ts',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     url: stencilUrl,
@@ -34,4 +36,11 @@ export const stencil: LanguageSpecs = {
   extensions: ['stencil.tsx'],
   editor: 'script',
   editorLanguage: 'typescript',
+  editorSupport: {
+    compilerOptions: {
+      jsx: 1, // monaco.languages.typescript.JsxEmit.Preserve,
+      jsxFactory: 'h',
+      jsxFragmentFactory: 'Fragment',
+    },
+  },
 };
diff --git a/src/livecodes/languages/stylus/lang-stylus.ts b/src/livecodes/languages/stylus/lang-stylus.ts
index 8db5baa648..0b7d8b3e1b 100644
--- a/src/livecodes/languages/stylus/lang-stylus.ts
+++ b/src/livecodes/languages/stylus/lang-stylus.ts
@@ -1,5 +1,6 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
-import { vendorsBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, vendorsBaseUrl } from '../../vendors';
 
 export const stylus: LanguageSpecs = {
   name: 'stylus',
@@ -10,4 +11,10 @@ export const stylus: LanguageSpecs = {
   },
   extensions: ['styl'],
   editor: 'style',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-stylus.js')).stylus),
+    },
+  },
 };
diff --git a/src/livecodes/languages/sucrase/lang-sucrase.ts b/src/livecodes/languages/sucrase/lang-sucrase.ts
index 9459ac9fde..2b7f11b9da 100644
--- a/src/livecodes/languages/sucrase/lang-sucrase.ts
+++ b/src/livecodes/languages/sucrase/lang-sucrase.ts
@@ -6,9 +6,11 @@ import { parserPlugins } from '../prettier';
 export const sucrase: LanguageSpecs = {
   name: 'sucrase',
   title: 'Sucrase',
-  parser: {
-    name: 'babel',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     url: vendorsBaseUrl + 'sucrase/sucrase.js',
@@ -23,4 +25,9 @@ export const sucrase: LanguageSpecs = {
   extensions: ['sucrase'],
   editor: 'script',
   editorLanguage: 'typescript',
+  editorSupport: {
+    compilerOptions: {
+      jsx: 4, // monaco.languages.typescript.JsxEmit.ReactJSX,
+    },
+  },
 };
diff --git a/src/livecodes/languages/svelte/lang-svelte.ts b/src/livecodes/languages/svelte/lang-svelte.ts
index 9af5eb0a2e..c5e6b2cf91 100644
--- a/src/livecodes/languages/svelte/lang-svelte.ts
+++ b/src/livecodes/languages/svelte/lang-svelte.ts
@@ -1,14 +1,17 @@
 import type { LanguageSpecs } from '../../models';
 import { modulesService } from '../../services';
-import { svelteBaseUrl } from '../../vendors';
+import { codeMirrorBaseUrl, monacoLanguagesBaseUrl, svelteBaseUrl } from '../../vendors';
 import { parserPlugins } from '../prettier';
+import { vue } from '../vue/lang-vue';
 
 export const svelte: LanguageSpecs = {
   name: 'svelte',
   title: 'Svelte',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html, parserPlugins.babel],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html, parserPlugins.babel],
+    },
   },
   compiler: {
     url: svelteBaseUrl + 'compiler/index.js',
@@ -45,6 +48,14 @@ export const svelte: LanguageSpecs = {
   },
   extensions: ['svelte'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'svelte.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-svelte.js')).svelte(),
+    },
+    codejar: { language: 'html' },
+  },
 };
 
 export const svelteApp: LanguageSpecs = {
@@ -53,5 +64,5 @@ export const svelteApp: LanguageSpecs = {
   compiler: 'svelte',
   extensions: ['app.svelte'],
   editor: 'markup',
-  editorLanguage: 'html',
+  editorSupport: { ...vue.editorSupport, monaco: { language: 'svelte' } }, // avoid duplicate registration
 };
diff --git a/src/livecodes/languages/tcl/lang-tcl.ts b/src/livecodes/languages/tcl/lang-tcl.ts
index 83f5148438..ec898bab7a 100644
--- a/src/livecodes/languages/tcl/lang-tcl.ts
+++ b/src/livecodes/languages/tcl/lang-tcl.ts
@@ -1,5 +1,6 @@
+import { codemirrorLegacy } from '../../editor/codemirror/utils';
 import type { LanguageSpecs } from '../../models';
-import { requireUrl } from '../../vendors';
+import { codeMirrorBaseUrl, requireUrl } from '../../vendors';
 
 export const tcl: LanguageSpecs = {
   name: 'tcl',
@@ -12,4 +13,10 @@ export const tcl: LanguageSpecs = {
   },
   extensions: ['tcl'],
   editor: 'script',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () =>
+        codemirrorLegacy((await import(codeMirrorBaseUrl + 'codemirror-lang-tcl.js')).tcl),
+    },
+  },
 };
diff --git a/src/livecodes/languages/twig/lang-twig.ts b/src/livecodes/languages/twig/lang-twig.ts
index e262f951f9..7e220aef57 100644
--- a/src/livecodes/languages/twig/lang-twig.ts
+++ b/src/livecodes/languages/twig/lang-twig.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const twig: LanguageSpecs = {
   name: 'twig',
   title: 'Twig',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: twigUrl,
diff --git a/src/livecodes/languages/typescript/lang-typescript.ts b/src/livecodes/languages/typescript/lang-typescript.ts
index aaf3fa4781..bb0053a6da 100644
--- a/src/livecodes/languages/typescript/lang-typescript.ts
+++ b/src/livecodes/languages/typescript/lang-typescript.ts
@@ -1,3 +1,4 @@
+import { codemirrorImports } from '../../editor/codemirror/utils';
 import type { Config, LanguageSpecs } from '../../models';
 import { getLanguageCustomSettings } from '../../utils';
 import { typescriptUrl } from '../../vendors';
@@ -11,7 +12,7 @@ export const hasCustomJsxRuntime = (code: string, config: Config) => {
   return Boolean(
     customTSConfig.jsx ||
       customTSConfig.jsxFactory ||
-      new RegExp(/\/\*\*[\s\*]*@jsx\s/g).test(code),
+      new RegExp(/\/\*\*[\s\*]*((@jsx)|(@jsxImportSource))\s/g).test(code),
   );
 };
 
@@ -26,9 +27,11 @@ export const typescript: LanguageSpecs = {
   name: 'typescript',
   title: 'TS',
   longTitle: 'TypeScript',
-  parser: {
-    name: 'babel-ts',
-    pluginUrls: [parserPlugins.babel, parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'babel-ts',
+      pluginUrls: [parserPlugins.babel, parserPlugins.html],
+    },
   },
   compiler: {
     url: typescriptUrl,
@@ -46,4 +49,16 @@ export const typescript: LanguageSpecs = {
   },
   extensions: ['ts', 'mts', 'typescript'],
   editor: 'script',
+  editorSupport: {
+    codemirror: {
+      languageSupport: async () => {
+        const { javascript } = await import(codemirrorImports.javascript);
+        return javascript({ typescript: true });
+      },
+    },
+    compilerOptions: {
+      checkJs: true,
+      strictNullChecks: true,
+    },
+  },
 };
diff --git a/src/livecodes/languages/utils.ts b/src/livecodes/languages/utils.ts
index 903ca3aa17..efdc294df9 100644
--- a/src/livecodes/languages/utils.ts
+++ b/src/livecodes/languages/utils.ts
@@ -36,8 +36,23 @@ export const getLanguageCompiler = (alias: string = ''): Compiler | undefined =>
   return compiler;
 };
 
-export const mapLanguage = (language: Language): Language =>
-  getLanguageSpecs(language)?.editorLanguage || language;
+export const hasJsx = (alias: string = '') => {
+  const languageSpecs = getLanguageSpecs(alias);
+  const compilerOptions = languageSpecs?.editorSupport?.compilerOptions;
+  if (!compilerOptions) return false;
+  return Boolean(
+    compilerOptions.jsx || compilerOptions.jsxImportSource || compilerOptions.jsxFactory,
+  );
+};
+
+export const mapLanguage = (
+  language: Language,
+  editor?: Exclude<Config['editor'], 'auto' | undefined>,
+): Language =>
+  (editor ? getLanguageSpecs(language)?.editorSupport?.[editor]?.language : undefined) ||
+  getLanguageSpecs(language)?.editorLanguage ||
+  getLanguageByAlias(language) ||
+  'html';
 
 export const languageIsEnabled = (language: Language, config: Config) => {
   const lang = getLanguageByAlias(language);
diff --git a/src/livecodes/languages/vento/lang-vento.ts b/src/livecodes/languages/vento/lang-vento.ts
index a917ef9835..5f016232e9 100644
--- a/src/livecodes/languages/vento/lang-vento.ts
+++ b/src/livecodes/languages/vento/lang-vento.ts
@@ -5,9 +5,11 @@ import { parserPlugins } from '../prettier';
 export const vento: LanguageSpecs = {
   name: 'vento',
   title: 'Vento',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: vendorsBaseUrl + 'vento/vento.js',
diff --git a/src/livecodes/languages/vue/lang-vue.ts b/src/livecodes/languages/vue/lang-vue.ts
index aca5efd655..fb15cfe26a 100644
--- a/src/livecodes/languages/vue/lang-vue.ts
+++ b/src/livecodes/languages/vue/lang-vue.ts
@@ -1,5 +1,11 @@
 import type { LanguageSpecs } from '../../models';
-import { vendorsBaseUrl, vueRuntimeUrl, vueSDKUrl } from '../../vendors';
+import {
+  codeMirrorBaseUrl,
+  monacoLanguagesBaseUrl,
+  vendorsBaseUrl,
+  vueRuntimeUrl,
+  vueSDKUrl,
+} from '../../vendors';
 import { parserPlugins } from '../prettier';
 
 const compilerUrl = vendorsBaseUrl + 'vue-compiler-sfc/vue-compiler-sfc.js';
@@ -8,9 +14,11 @@ export const vue: LanguageSpecs = {
   name: 'vue',
   title: 'Vue',
   longTitle: 'Vue SFC',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     url: compilerUrl,
@@ -25,7 +33,19 @@ export const vue: LanguageSpecs = {
   },
   extensions: ['vue', 'vue3'],
   editor: 'script',
-  editorLanguage: 'html',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'vue.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-vue.js')).vue(),
+    },
+    codejar: { language: 'html' },
+    compilerOptions: {
+      jsx: 1, // monaco.languages.typescript.JsxEmit.Preserve,
+      jsxFactory: 'h',
+      jsxFragmentFactory: 'Fragment',
+    },
+  },
 };
 
 export const vueApp: LanguageSpecs = {
@@ -34,5 +54,5 @@ export const vueApp: LanguageSpecs = {
   compiler: 'vue',
   extensions: ['app.vue'],
   editor: 'markup',
-  editorLanguage: 'html',
+  editorSupport: { ...vue.editorSupport, monaco: { language: 'vue' } }, // avoid duplicate registration
 };
diff --git a/src/livecodes/languages/vue2/lang-vue2.ts b/src/livecodes/languages/vue2/lang-vue2.ts
index d150a15fb3..a826ed98b0 100644
--- a/src/livecodes/languages/vue2/lang-vue2.ts
+++ b/src/livecodes/languages/vue2/lang-vue2.ts
@@ -8,9 +8,11 @@ export const vue2: LanguageSpecs = {
   name: 'vue2',
   title: 'Vue 2',
   longTitle: 'Vue 2 SFC',
-  parser: {
-    name: 'html',
-    pluginUrls: [parserPlugins.html],
+  formatter: {
+    prettier: {
+      name: 'html',
+      pluginUrls: [parserPlugins.html],
+    },
   },
   compiler: {
     factory: (_config, baseUrl) => {
diff --git a/src/livecodes/languages/wat/lang-wat.ts b/src/livecodes/languages/wat/lang-wat.ts
index 7aa2495dbc..9a8f3111c1 100644
--- a/src/livecodes/languages/wat/lang-wat.ts
+++ b/src/livecodes/languages/wat/lang-wat.ts
@@ -1,5 +1,10 @@
 import type { LanguageSpecs } from '../../models';
-import { vendorsBaseUrl, wabtjsUrl } from '../../vendors';
+import {
+  codeMirrorBaseUrl,
+  monacoLanguagesBaseUrl,
+  vendorsBaseUrl,
+  wabtjsUrl,
+} from '../../vendors';
 
 declare const importScripts: (...args: string[]) => void;
 
@@ -40,4 +45,12 @@ export const wat: LanguageSpecs = {
   },
   extensions: ['wat', 'wast', 'webassembly', 'wasm'],
   editor: 'script',
+  editorSupport: {
+    monaco: { languageSupport: monacoLanguagesBaseUrl + 'wat.js' },
+    codemirror: {
+      languageSupport: async () =>
+        (await import(codeMirrorBaseUrl + 'codemirror-lang-wast.js')).wast(),
+    },
+    codejar: { language: 'wasm' },
+  },
 };
diff --git a/src/livecodes/styles/app.scss b/src/livecodes/styles/app.scss
index 5d5bd5c654..3325fa20b7 100644
--- a/src/livecodes/styles/app.scss
+++ b/src/livecodes/styles/app.scss
@@ -2211,10 +2211,6 @@ body {
     z-index: 49; // keep under monaco hover menu
   }
 
-  #toolbar {
-    z-index: 500;
-  }
-
   .copy-button {
     z-index: 900;
   }
diff --git a/src/livecodes/utils/utils.ts b/src/livecodes/utils/utils.ts
index 06497ef7e3..47df8efc0c 100644
--- a/src/livecodes/utils/utils.ts
+++ b/src/livecodes/utils/utils.ts
@@ -230,7 +230,7 @@ export const loadStylesheet = (url: string, id?: string, insertBefore?: string)
 };
 
 export const typedArrayToBuffer = /* @__PURE__ */ (array: Uint8Array): ArrayBuffer =>
-  array.buffer.slice(array.byteOffset, array.byteLength + array.byteOffset);
+  array.buffer.slice(array.byteOffset, array.byteLength + array.byteOffset) as ArrayBuffer;
 
 export const getDate = /* @__PURE__ */ () => {
   let date = new Date();
diff --git a/src/livecodes/vendors.ts b/src/livecodes/vendors.ts
index 844ed86c29..e48b0713d1 100644
--- a/src/livecodes/vendors.ts
+++ b/src/livecodes/vendors.ts
@@ -306,6 +306,10 @@ export const monacoBaseUrl = /* @__PURE__ */ getUrl('@live-codes/monaco-editor@0
 
 export const monacoEmacsUrl = /* @__PURE__ */ getUrl('monaco-emacs@0.3.0/dist/monaco-emacs.js');
 
+export const monacoLanguagesBaseUrl = /* @__PURE__ */ getUrl(
+  '@live-codes/monaco-languages@0.2.0/dist/',
+);
+
 export const monacoThemesBaseUrl = /* @__PURE__ */ getUrl('monaco-themes@0.4.4/themes/');
 
 export const monacoVimUrl = /* @__PURE__ */ getUrl('monaco-vim@0.4.1/dist/monaco-vim.js');
@@ -448,7 +452,8 @@ export const tesseractUrl = /* @__PURE__ */ getUrl('tesseract.js@6.0.1/dist/tess
 
 export const twigUrl = /* @__PURE__ */ getUrl('twig@1.17.1/twig.min.js');
 
-export const typescriptUrl = /* @__PURE__ */ getUrl(`typescript@5.9.3/lib/typescript.js`);
+export const typescriptVersion = '5.9.3';
+export const typescriptUrl = getUrl(`typescript@${typescriptVersion}/lib/typescript.js`);
 
 export const uniterUrl = /* @__PURE__ */ getUrl('uniter@2.18.0/dist/uniter.js');
 
diff --git a/src/sdk/models.ts b/src/sdk/models.ts
index 7195f0f6dd..49be17752c 100644
--- a/src/sdk/models.ts
+++ b/src/sdk/models.ts
@@ -1057,6 +1057,7 @@ export type Language =
   | 'cljc'
   | 'edn'
   | 'gleam'
+  | 'swift'
   | 'rescript'
   | 'res'
   | 'resi'
@@ -1188,6 +1189,26 @@ export interface EditorLanguages {
   script: Language;
 }
 
+export type LanguageEditorSupport = {
+  monaco?: {
+    language?: Language;
+    languageSupport?:
+      | string
+      | ((
+          monaco: any,
+        ) => void | Promise<void> | { dispose: () => void } | Promise<{ dispose: () => void }>);
+  };
+  codemirror?: {
+    language?: Language;
+    languageSupport?: string | (() => void | Promise<void>);
+  };
+  codejar?: {
+    language?: Language;
+  };
+} & {
+  compilerOptions?: Record<string, unknown>;
+};
+
 export interface Types {
   [key: string]:
     | string
@@ -1204,12 +1225,12 @@ export interface LanguageSpecs {
   title: string;
   longTitle?: string;
   info?: boolean;
-  parser?: Parser;
   formatter?: LanguageFormatter;
   compiler: Compiler | Language;
   extensions: Language[];
   editor: EditorId;
   editorLanguage?: Language;
+  editorSupport?: LanguageEditorSupport;
   preset?: CssPresetId;
   largeDownload?: boolean;
 }
@@ -1262,7 +1283,7 @@ export type ParserName =
   | 'java'
   | 'minizinc';
 
-export interface Parser {
+export interface PrettierParser {
   name: ParserName;
   plugins?: any[];
   pluginUrls: string[];
@@ -1273,9 +1294,11 @@ export type FormatFn = (
   formatterConfig?: Partial<FormatterConfig>,
 ) => Promise<{ formatted: string; cursorOffset: number }>;
 
-export interface LanguageFormatter {
-  factory: (baseUrl: string, language: Language) => FormatFn;
-}
+export type LanguageFormatter =
+  | {
+      factory: (baseUrl: string, language: Language) => FormatFn;
+    }
+  | { prettier: PrettierParser };
 
 export type CssPresetId = '' | 'normalize.css' | 'reset-css';
 
@@ -1619,7 +1642,10 @@ export interface EditorOptions extends EditorConfig {
   isLite: boolean;
   isHeadless: boolean;
   getLanguageExtension: (alias: string) => Language | undefined;
-  mapLanguage: (language: Language) => Language;
+  mapLanguage: (
+    language: Language,
+    editor?: Exclude<Config['editor'], 'auto' | undefined>,
+  ) => Language;
   getFormatterConfig: () => Partial<FormatterConfig>;
   getFontFamily: (font: string | undefined) => string;
 }
diff --git a/tsconfig.json b/tsconfig.json
index 60d238baef..ebb5d652a0 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -43,7 +43,7 @@
     // "emitDecoratorMetadata": true /* Enables experimental support for emitting type metadata for decorators. */,
 
     "jsx": "react-jsx",
-    "lib": ["es2021", "dom", "dom.iterable"],
+    "lib": ["es2022", "dom", "dom.iterable"],
     "types": ["node", "jest"],
     "typeRoots": ["node_modules/@types"]
   },