@kerebron/editor-kits 0.4.1

package/esm/extension-codemirror/src/codeMirrorBlockNodeView.js

@@ -0,0 +1,328 @@
+import { drawSelection, EditorView as CodeMirror, highlightActiveLineGutter, keymap, lineNumbers, rectangularSelection, } from '@codemirror/view';
+import { selectNextOccurrence } from '@codemirror/search';
+import { bracketMatching, defaultHighlightStyle, foldGutter, foldKeymap, indentOnInput, syntaxHighlighting, } from '@codemirror/language';
+import { autocompletion, closeBrackets, closeBracketsKeymap, completionKeymap, } from '@codemirror/autocomplete';
+import { defaultKeymap, indentWithTab } from '@codemirror/commands';
+import { Compartment, EditorState } from '@codemirror/state';
+import { backspaceHandler, computeChange, forwardSelection, maybeEscape, setMode, setTheme, valueChanged, } from './utils.js';
+import { RemoteSyncConfig, remoteSyncFacet } from './remote-sync.js';
+import { yRemoteSelections, yRemoteSelectionsTheme, } from './remote-selections.js';
+import { languageServerExtensions, LSPPlugin } from './lsp/index.js';
+import { LSPExtension } from './lsp/LSPExtension.js';
+export const themeCallbacks = [];
+class CodeMirrorBlockNodeView {
+    constructor(node, view, getPos, settings, editor) {
+        Object.defineProperty(this, "node", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: node
+        });
+        Object.defineProperty(this, "view", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: view
+        });
+        Object.defineProperty(this, "getPos", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: getPos
+        });
+        Object.defineProperty(this, "settings", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: settings
+        });
+        Object.defineProperty(this, "editor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: editor
+        });
+        Object.defineProperty(this, "dom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "codeMirrorView", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "updating", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "createCopyButtonCB", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "selectDeleteCB", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "languageConf", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "uri", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'file:///' + Math.random() + '.ts'
+        });
+        Object.defineProperty(this, "diagListener", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.updating = false;
+        const dom = document.createElement('div');
+        this.dom = dom;
+        dom.className = 'codeblock-root';
+        this.languageConf = new Compartment();
+        const themeConfig = new Compartment();
+        const yCollab = () => {
+            const plugins = [];
+            const remoteSyncConfig = new RemoteSyncConfig(() => this.node, getPos, editor);
+            plugins.push(remoteSyncFacet.of(remoteSyncConfig));
+            plugins.push(yRemoteSelectionsTheme, yRemoteSelections);
+            return plugins;
+        };
+        const extensions = [
+            EditorState.readOnly.of(!!settings.readOnly),
+            CodeMirror.editable.of(!settings.readOnly),
+            lineNumbers(),
+            highlightActiveLineGutter(),
+            foldGutter(),
+            bracketMatching(),
+            closeBrackets(),
+            rectangularSelection(),
+            drawSelection({ cursorBlinkRate: 1000 }), // broken focus
+            syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+            this.languageConf.of([]),
+            indentOnInput(),
+            keymap.of([
+                { key: 'Mod-d', run: selectNextOccurrence, preventDefault: true },
+                {
+                    key: 'ArrowUp',
+                    run: (cmView) => maybeEscape('line', -1, cmView, view, getPos),
+                },
+                {
+                    key: 'ArrowLeft',
+                    run: (cmView) => maybeEscape('char', -1, cmView, view, getPos),
+                },
+                {
+                    key: 'ArrowDown',
+                    run: (cmView) => maybeEscape('line', 1, cmView, view, getPos),
+                },
+                {
+                    key: 'ArrowRight',
+                    run: (cmView) => maybeEscape('char', 1, cmView, view, getPos),
+                },
+                {
+                    key: 'Ctrl-Enter',
+                    run: () => {
+                        if (!editor.run.exitCode()) {
+                            return false;
+                        }
+                        view.focus();
+                        return true;
+                    },
+                },
+                {
+                    key: 'Mod-z',
+                    run: () => settings.undo?.(view.state, view.dispatch) || true,
+                    shift: () => settings.redo?.(view.state, view.dispatch) || true,
+                },
+                {
+                    key: 'Mod-y',
+                    run: () => settings.redo?.(view.state, view.dispatch) || true,
+                },
+                {
+                    key: 'Backspace',
+                    run: (cmView) => backspaceHandler(view, cmView, editor),
+                },
+                {
+                    key: 'Mod-Backspace',
+                    run: (cmView) => backspaceHandler(view, cmView, editor),
+                },
+                {
+                    key: 'Mod-a',
+                    run: () => {
+                        const result = editor.run.selectAll();
+                        view.focus();
+                        return result;
+                    },
+                },
+                ...defaultKeymap,
+                ...foldKeymap,
+                ...closeBracketsKeymap,
+                ...completionKeymap,
+                indentWithTab,
+                {
+                    key: 'Ctrl-`',
+                    run: () => {
+                        editor.chain().toggleDevToolkit().run();
+                        return true;
+                    },
+                },
+            ]),
+            ...(settings.theme ? settings.theme : []),
+            themeConfig.of([]),
+            yCollab(),
+        ];
+        const extensionLsp = editor.getExtension('lsp');
+        if (extensionLsp) {
+            const extension = new LSPExtension({
+                getPos: this.getPos,
+                extensions: languageServerExtensions(),
+            });
+            extensions.push(extension.plugin(extensionLsp, editor));
+        }
+        else {
+            // Define custom completions
+            const myCompletions = [
+                { label: 'console.log', type: 'function' },
+                { label: 'const', type: 'keyword' },
+                { label: 'let', type: 'keyword' },
+                { label: 'var', type: 'keyword' },
+                { label: 'function', type: 'keyword' },
+            ];
+            // Custom autocomplete function
+            const complete = (context) => {
+                let word = context.matchBefore(/\w*/);
+                if (!word) {
+                    return null;
+                }
+                if (word.from == word.to && !context.explicit)
+                    return null;
+                return {
+                    from: word.from,
+                    options: myCompletions,
+                };
+            };
+            extensions.push(autocompletion({
+                override: [
+                    complete,
+                ],
+            }));
+        }
+        const state = EditorState.create({
+            extensions,
+            doc: node.textContent,
+        });
+        const root = (editor.view && 'root' in editor.view)
+            ? editor.view.root
+            : document || document;
+        this.codeMirrorView = new CodeMirror({
+            state,
+            root,
+            dispatch: (tr) => {
+                this.codeMirrorView.update([tr]);
+                if (!this.updating) {
+                    const textUpdate = tr.state.toJSON().doc;
+                    valueChanged(textUpdate, this.node, getPos, view);
+                    forwardSelection(this.codeMirrorView, view, getPos);
+                    const lspPlugin = LSPPlugin.get(this.codeMirrorView);
+                    if (lspPlugin) {
+                        lspPlugin.update();
+                    }
+                }
+            },
+        });
+        dom.append(this.codeMirrorView.dom);
+        if (!(Array.isArray(settings.languageWhitelist) &&
+            settings.languageWhitelist.length === 1)) {
+            this.selectDeleteCB = settings.createSelect(settings, dom, node, view, getPos);
+        }
+        this.createCopyButtonCB = settings.createCopyButton(settings, dom, node, view, this.codeMirrorView, getPos);
+        setMode(node.attrs.lang, this.codeMirrorView, settings, this.languageConf);
+        const currentTheme = settings.getCurrentTheme?.();
+        setTheme(this.codeMirrorView, themeConfig, [
+            settings.themes.find((t) => t.name === currentTheme),
+        ]);
+        this.updateTheme = (theme) => {
+            setTheme(this.codeMirrorView, themeConfig, [
+                settings.themes.find((t) => t.name === theme),
+            ]);
+        };
+        themeCallbacks.push(this.updateTheme);
+    }
+    updateTheme(updateTheme) {
+        throw new Error('Method not implemented.');
+    }
+    selectNode() {
+        this.codeMirrorView.focus();
+    }
+    stopEvent(e) {
+        return this.settings.stopEvent(e, this.node, this.getPos, this.view, this.dom);
+    }
+    setSelection(anchor, head) {
+        this.codeMirrorView.focus();
+        this.updating = true;
+        this.codeMirrorView.dispatch({ selection: { anchor, head } });
+        this.updating = false;
+    }
+    update(updateNode, decorations, innerDecorations) {
+        const codeDecorations = [];
+        innerDecorations
+            .forEachSet((set) => set.find()
+            .map((d) => {
+            codeDecorations.push(d);
+        }));
+        // https://codemirror.net/examples/decoration/
+        if (updateNode.type.name !== this.node.type.name)
+            return false;
+        if (updateNode.attrs.lang !== this.node.attrs.lang) {
+            setMode(updateNode.attrs.lang, this.codeMirrorView, this.settings, this.languageConf);
+        }
+        const oldNode = this.node;
+        this.node = updateNode;
+        const change = computeChange(this.codeMirrorView.state.doc.toString(), this.node.textContent);
+        if (change) {
+            this.updating = true;
+            this.codeMirrorView.dispatch({
+                changes: {
+                    from: change.from,
+                    to: change.to,
+                    insert: change.text,
+                },
+                selection: { anchor: change.from + change.text.length },
+                // effects <- codeDecorations
+            });
+            this.updating = false;
+        }
+        this.settings.updateSelect(this.settings, this.dom, updateNode, this.view, this.getPos, oldNode);
+        return true;
+    }
+    ignoreMutation() {
+        return true;
+    }
+    destroy() {
+        if (this.selectDeleteCB) {
+            this.selectDeleteCB();
+        }
+        this.createCopyButtonCB();
+        themeCallbacks.splice(themeCallbacks.indexOf(this.updateTheme), 1);
+    }
+}
+export const codeMirrorBlockNodeView = (settings, editor) => {
+    return (pmNode, view, getPos) => {
+        return new CodeMirrorBlockNodeView(pmNode, view, getPos, settings, editor);
+    };
+};

package/esm/extension-codemirror/src/defaults.d.ts

@@ -0,0 +1,6 @@
+import { Node } from 'prosemirror-model';
+import { EditorView } from 'prosemirror-view';
+import { CodeBlockSettings } from './types.js';
+export declare const defaultCreateSelect: (settings: CodeBlockSettings, dom: HTMLElement, node: Node, view: EditorView, getPos: () => number | undefined) => () => void;
+export declare const defaultSettings: CodeBlockSettings;
+//# sourceMappingURL=defaults.d.ts.map

package/esm/extension-codemirror/src/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/extension-codemirror/src/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,mBAAmB,GAC9B,UAAU,iBAAiB,EAC3B,KAAK,WAAW,EAChB,MAAM,IAAI,EACV,MAAM,UAAU,EAChB,QAAQ,MAAM,MAAM,GAAG,SAAS,eAyCjC,CAAC;AAmBF,eAAO,MAAM,eAAe,EAAE,iBAS7B,CAAC"}

package/esm/extension-codemirror/src/defaults.js

@@ -0,0 +1,58 @@
+export const defaultCreateSelect = (settings, dom, node, view, getPos) => {
+    if (!settings.languageLoaders)
+        return () => { };
+    const { languageLoaders } = settings;
+    const select = document.createElement('select');
+    select.className = 'codeblock-select';
+    const noneOption = document.createElement('option');
+    noneOption.value = 'none';
+    noneOption.textContent = settings.languageNameMap?.none || 'none';
+    select.append(noneOption);
+    Object.keys(languageLoaders)
+        .sort()
+        .forEach((lang) => {
+        if (settings.languageWhitelist &&
+            !settings.languageWhitelist.includes(lang)) {
+            return;
+        }
+        const option = document.createElement('option');
+        option.value = lang;
+        option.textContent = settings.languageNameMap?.[lang] || lang;
+        select.append(option);
+    });
+    select.value = node.attrs.lang || 'none';
+    dom.prepend(select);
+    select.onchange = (e) => {
+        if (!(e.target instanceof HTMLSelectElement))
+            return;
+        const lang = e.target.value;
+        const pos = getPos();
+        if (pos) {
+            view.dispatch(view.state.tr.setNodeMarkup(pos, undefined, {
+                ...node.attrs,
+                lang,
+            }));
+        }
+    };
+    // Delete code.
+    return () => { };
+};
+const defaultUpdateSelect = (settings, dom, node, view, getPos, oldNode) => {
+    if (oldNode.attrs.lang !== node.attrs.lang) {
+        const select = dom.querySelector('.codeblock-select');
+        if (!(select instanceof HTMLSelectElement))
+            return;
+        select.value = node.attrs.lang || 'none';
+    }
+};
+const defaultStopEvent = () => true;
+export const defaultSettings = {
+    createSelect: defaultCreateSelect,
+    updateSelect: defaultUpdateSelect,
+    createCopyButton: () => {
+        return () => { };
+    },
+    stopEvent: defaultStopEvent,
+    readOnly: false,
+    themes: [],
+};

package/esm/extension-codemirror/src/languageLoaders.d.ts

@@ -0,0 +1,5 @@
+import { LanguageLoaders } from './types.js';
+declare const languageLoaders: LanguageLoaders;
+export declare const legacyLanguageLoaders: LanguageLoaders;
+export default languageLoaders;
+//# sourceMappingURL=languageLoaders.d.ts.map

package/esm/extension-codemirror/src/languageLoaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageLoaders.d.ts","sourceRoot":"","sources":["../../../src/extension-codemirror/src/languageLoaders.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,QAAA,MAAM,eAAe,EAAE,eA6BtB,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,eAyWnC,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/esm/extension-codemirror/src/languageLoaders.js

@@ -0,0 +1,112 @@
+// deno-lint-ignore-file
+import { StreamLanguage } from '@codemirror/language';
+import { CodeBlockLanguages, LegacyLanguages } from './languages.js';
+const languageLoaders = {
+    [CodeBlockLanguages.cpp]: () => import('@codemirror/lang-cpp').then((i) => i.cpp()),
+    [CodeBlockLanguages.css]: () => import('@codemirror/lang-css').then((i) => i.css()),
+    [CodeBlockLanguages.html]: () => import('@codemirror/lang-html').then((i) => i.html()),
+    [CodeBlockLanguages.php]: () => import('@codemirror/lang-php').then((i) => i.php()),
+    [CodeBlockLanguages.sql]: () => import('@codemirror/lang-sql').then((i) => i.sql()),
+    [CodeBlockLanguages.xml]: () => import('@codemirror/lang-xml').then((i) => i.xml()),
+    [CodeBlockLanguages.javascript]: () => import('@codemirror/lang-javascript').then((i) => i.javascript()),
+    [CodeBlockLanguages.java]: () => import('@codemirror/lang-java').then((i) => i.java()),
+    [CodeBlockLanguages.json]: () => import('@codemirror/lang-json').then((i) => i.json()),
+    [CodeBlockLanguages.lezer]: () => import('@codemirror/lang-lezer').then((i) => i.lezer()),
+    [CodeBlockLanguages.markdown]: () => import('@codemirror/lang-markdown').then((i) => i.markdown()),
+    [CodeBlockLanguages.python]: () => import('@codemirror/lang-python').then((i) => i.python()),
+    [CodeBlockLanguages.rust]: () => import('@codemirror/lang-rust').then((i) => i.rust()),
+    [CodeBlockLanguages.wast]: () => import('@codemirror/lang-wast').then((i) => i.wast()),
+};
+export const legacyLanguageLoaders = {
+    [LegacyLanguages.apl]: () => import('@codemirror/legacy-modes/mode/apl').then(({ apl }) => StreamLanguage.define(apl)),
+    [LegacyLanguages.asciiarmor]: () => import('@codemirror/legacy-modes/mode/asciiarmor').then(({ asciiArmor }) => StreamLanguage.define(asciiArmor)),
+    [LegacyLanguages.asn1]: () => import('@codemirror/legacy-modes/mode/asn1').then(({ asn1 }) => StreamLanguage.define(asn1)),
+    [LegacyLanguages.asterisk]: () => import('@codemirror/legacy-modes/mode/asterisk').then(({ asterisk }) => StreamLanguage.define(asterisk)),
+    [LegacyLanguages.brainfuck]: () => import('@codemirror/legacy-modes/mode/brainfuck').then(({ brainfuck }) => StreamLanguage.define(brainfuck)),
+    [LegacyLanguages.clike]: () => import('@codemirror/legacy-modes/mode/clike').then(({ clike }) => StreamLanguage.define(clike)),
+    [LegacyLanguages.clojure]: () => import('@codemirror/legacy-modes/mode/clojure').then(({ clojure }) => StreamLanguage.define(clojure)),
+    [LegacyLanguages.cmake]: () => import('@codemirror/legacy-modes/mode/cmake').then(({ cmake }) => StreamLanguage.define(cmake)),
+    [LegacyLanguages.cobol]: () => import('@codemirror/legacy-modes/mode/cobol').then(({ cobol }) => StreamLanguage.define(cobol)),
+    [LegacyLanguages.coffeescript]: () => import('@codemirror/legacy-modes/mode/coffeescript').then(({ coffeeScript }) => StreamLanguage.define(coffeeScript)),
+    [LegacyLanguages.commonlisp]: () => import('@codemirror/legacy-modes/mode/commonlisp').then(({ commonLisp }) => StreamLanguage.define(commonLisp)),
+    [LegacyLanguages.crystal]: () => import('@codemirror/legacy-modes/mode/crystal').then(({ crystal }) => StreamLanguage.define(crystal)),
+    [LegacyLanguages.cypher]: () => import('@codemirror/legacy-modes/mode/cypher').then(({ cypher }) => StreamLanguage.define(cypher)),
+    [LegacyLanguages.d]: () => import('@codemirror/legacy-modes/mode/d').then(({ d }) => StreamLanguage.define(d)),
+    [LegacyLanguages.diff]: () => import('@codemirror/legacy-modes/mode/diff').then(({ diff }) => StreamLanguage.define(diff)),
+    [LegacyLanguages.dockerfile]: () => import('@codemirror/legacy-modes/mode/dockerfile').then(({ dockerFile }) => StreamLanguage.define(dockerFile)),
+    [LegacyLanguages.dtd]: () => import('@codemirror/legacy-modes/mode/dtd').then(({ dtd }) => StreamLanguage.define(dtd)),
+    [LegacyLanguages.dylan]: () => import('@codemirror/legacy-modes/mode/dylan').then(({ dylan }) => StreamLanguage.define(dylan)),
+    [LegacyLanguages.ebnf]: () => import('@codemirror/legacy-modes/mode/ebnf').then(({ ebnf }) => StreamLanguage.define(ebnf)),
+    [LegacyLanguages.ecl]: () => import('@codemirror/legacy-modes/mode/ecl').then(({ ecl }) => StreamLanguage.define(ecl)),
+    [LegacyLanguages.eiffel]: () => import('@codemirror/legacy-modes/mode/eiffel').then(({ eiffel }) => StreamLanguage.define(eiffel)),
+    [LegacyLanguages.elm]: () => import('@codemirror/legacy-modes/mode/elm').then(({ elm }) => StreamLanguage.define(elm)),
+    [LegacyLanguages.erlang]: () => import('@codemirror/legacy-modes/mode/erlang').then(({ erlang }) => StreamLanguage.define(erlang)),
+    [LegacyLanguages.factor]: () => import('@codemirror/legacy-modes/mode/factor').then(({ factor }) => StreamLanguage.define(factor)),
+    [LegacyLanguages.fcl]: () => import('@codemirror/legacy-modes/mode/fcl').then(({ fcl }) => StreamLanguage.define(fcl)),
+    [LegacyLanguages.forth]: () => import('@codemirror/legacy-modes/mode/forth').then(({ forth }) => StreamLanguage.define(forth)),
+    [LegacyLanguages.fortran]: () => import('@codemirror/legacy-modes/mode/fortran').then(({ fortran }) => StreamLanguage.define(fortran)),
+    [LegacyLanguages.gas]: () => import('@codemirror/legacy-modes/mode/gas').then(({ gas }) => StreamLanguage.define(gas)),
+    [LegacyLanguages.gherkin]: () => import('@codemirror/legacy-modes/mode/gherkin').then(({ gherkin }) => StreamLanguage.define(gherkin)),
+    [LegacyLanguages.go]: () => import('@codemirror/legacy-modes/mode/go').then(({ go }) => StreamLanguage.define(go)),
+    [LegacyLanguages.groovy]: () => import('@codemirror/legacy-modes/mode/groovy').then(({ groovy }) => StreamLanguage.define(groovy)),
+    [LegacyLanguages.haskell]: () => import('@codemirror/legacy-modes/mode/haskell').then(({ haskell }) => StreamLanguage.define(haskell)),
+    [LegacyLanguages.haxe]: () => import('@codemirror/legacy-modes/mode/haxe').then(({ haxe }) => StreamLanguage.define(haxe)),
+    [LegacyLanguages.http]: () => import('@codemirror/legacy-modes/mode/http').then(({ http }) => StreamLanguage.define(http)),
+    [LegacyLanguages.idl]: () => import('@codemirror/legacy-modes/mode/idl').then(({ idl }) => StreamLanguage.define(idl)),
+    [LegacyLanguages.jinja2]: () => import('@codemirror/legacy-modes/mode/jinja2').then(({ jinja2 }) => StreamLanguage.define(jinja2)),
+    [LegacyLanguages.julia]: () => import('@codemirror/legacy-modes/mode/julia').then(({ julia }) => StreamLanguage.define(julia)),
+    [LegacyLanguages.livescript]: () => import('@codemirror/legacy-modes/mode/livescript').then(({ liveScript }) => StreamLanguage.define(liveScript)),
+    [LegacyLanguages.lua]: () => import('@codemirror/legacy-modes/mode/lua').then(({ lua: legacyLua }) => StreamLanguage.define(legacyLua)),
+    [LegacyLanguages.mathematica]: () => import('@codemirror/legacy-modes/mode/mathematica').then(({ mathematica }) => StreamLanguage.define(mathematica)),
+    [LegacyLanguages.mbox]: () => import('@codemirror/legacy-modes/mode/mbox').then(({ mbox }) => StreamLanguage.define(mbox)),
+    [LegacyLanguages.mirc]: () => import('@codemirror/legacy-modes/mode/mirc').then(({ mirc }) => StreamLanguage.define(mirc)),
+    [LegacyLanguages.mllike]: () => import('@codemirror/legacy-modes/mode/mllike').then(({ oCaml }) => StreamLanguage.define(oCaml)),
+    [LegacyLanguages.modelica]: () => import('@codemirror/legacy-modes/mode/modelica').then(({ modelica }) => StreamLanguage.define(modelica)),
+    [LegacyLanguages.mscgen]: () => import('@codemirror/legacy-modes/mode/mscgen').then(({ mscgen }) => StreamLanguage.define(mscgen)),
+    [LegacyLanguages.mumps]: () => import('@codemirror/legacy-modes/mode/mumps').then(({ mumps }) => StreamLanguage.define(mumps)),
+    [LegacyLanguages.nginx]: () => import('@codemirror/legacy-modes/mode/nginx').then(({ nginx }) => StreamLanguage.define(nginx)),
+    [LegacyLanguages.nsis]: () => import('@codemirror/legacy-modes/mode/nsis').then(({ nsis }) => StreamLanguage.define(nsis)),
+    [LegacyLanguages.ntriples]: () => import('@codemirror/legacy-modes/mode/ntriples').then(({ ntriples }) => StreamLanguage.define(ntriples)),
+    [LegacyLanguages.octave]: () => import('@codemirror/legacy-modes/mode/octave').then(({ octave }) => StreamLanguage.define(octave)),
+    [LegacyLanguages.oz]: () => import('@codemirror/legacy-modes/mode/oz').then(({ oz }) => StreamLanguage.define(oz)),
+    [LegacyLanguages.pascal]: () => import('@codemirror/legacy-modes/mode/pascal').then(({ pascal }) => StreamLanguage.define(pascal)),
+    [LegacyLanguages.perl]: () => import('@codemirror/legacy-modes/mode/perl').then(({ perl }) => StreamLanguage.define(perl)),
+    [LegacyLanguages.pig]: () => import('@codemirror/legacy-modes/mode/pig').then(({ pig }) => StreamLanguage.define(pig)),
+    [LegacyLanguages.powershell]: () => import('@codemirror/legacy-modes/mode/powershell').then(({ powerShell }) => StreamLanguage.define(powerShell)),
+    [LegacyLanguages.properties]: () => import('@codemirror/legacy-modes/mode/properties').then(({ properties }) => StreamLanguage.define(properties)),
+    [LegacyLanguages.protobuf]: () => import('@codemirror/legacy-modes/mode/protobuf').then(({ protobuf }) => StreamLanguage.define(protobuf)),
+    [LegacyLanguages.puppet]: () => import('@codemirror/legacy-modes/mode/puppet').then(({ puppet }) => StreamLanguage.define(puppet)),
+    [LegacyLanguages.q]: () => import('@codemirror/legacy-modes/mode/q').then(({ q }) => StreamLanguage.define(q)),
+    [LegacyLanguages.r]: () => import('@codemirror/legacy-modes/mode/r').then(({ r }) => StreamLanguage.define(r)),
+    [LegacyLanguages.rpm]: () => import('@codemirror/legacy-modes/mode/rpm').then(({ rpmSpec }) => StreamLanguage.define(rpmSpec)),
+    [LegacyLanguages.ruby]: () => import('@codemirror/legacy-modes/mode/ruby').then(({ ruby }) => StreamLanguage.define(ruby)),
+    [LegacyLanguages.sas]: () => import('@codemirror/legacy-modes/mode/sas').then(({ sas }) => StreamLanguage.define(sas)),
+    [LegacyLanguages.scheme]: () => import('@codemirror/legacy-modes/mode/scheme').then(({ scheme }) => StreamLanguage.define(scheme)),
+    [LegacyLanguages.shell]: () => import('@codemirror/legacy-modes/mode/shell').then(({ shell }) => StreamLanguage.define(shell)),
+    [LegacyLanguages.smalltalk]: () => import('@codemirror/legacy-modes/mode/smalltalk').then(({ smalltalk }) => StreamLanguage.define(smalltalk)),
+    [LegacyLanguages.solr]: () => import('@codemirror/legacy-modes/mode/solr').then(({ solr }) => StreamLanguage.define(solr)),
+    [LegacyLanguages.sparql]: () => import('@codemirror/legacy-modes/mode/sparql').then(({ sparql }) => StreamLanguage.define(sparql)),
+    [LegacyLanguages.spreadsheet]: () => import('@codemirror/legacy-modes/mode/spreadsheet').then(({ spreadsheet }) => StreamLanguage.define(spreadsheet)),
+    [LegacyLanguages.stex]: () => import('@codemirror/legacy-modes/mode/stex').then(({ stex }) => StreamLanguage.define(stex)),
+    [LegacyLanguages.stylus]: () => import('@codemirror/legacy-modes/mode/stylus').then(({ stylus }) => StreamLanguage.define(stylus)),
+    [LegacyLanguages.swift]: () => import('@codemirror/legacy-modes/mode/swift').then(({ swift }) => StreamLanguage.define(swift)),
+    [LegacyLanguages.tcl]: () => import('@codemirror/legacy-modes/mode/tcl').then(({ tcl }) => StreamLanguage.define(tcl)),
+    [LegacyLanguages.textile]: () => import('@codemirror/legacy-modes/mode/textile').then(({ textile }) => StreamLanguage.define(textile)),
+    [LegacyLanguages.tiddlywiki]: () => import('@codemirror/legacy-modes/mode/tiddlywiki').then(({ tiddlyWiki }) => StreamLanguage.define(tiddlyWiki)),
+    [LegacyLanguages.tiki]: () => import('@codemirror/legacy-modes/mode/tiki').then(({ tiki }) => StreamLanguage.define(tiki)),
+    [LegacyLanguages.toml]: () => import('@codemirror/legacy-modes/mode/toml').then(({ toml }) => StreamLanguage.define(toml)),
+    [LegacyLanguages.troff]: () => import('@codemirror/legacy-modes/mode/troff').then(({ troff }) => StreamLanguage.define(troff)),
+    [LegacyLanguages.ttcn]: () => import('@codemirror/legacy-modes/mode/ttcn').then(({ ttcn }) => StreamLanguage.define(ttcn)),
+    [LegacyLanguages.turtle]: () => import('@codemirror/legacy-modes/mode/turtle').then(({ turtle }) => StreamLanguage.define(turtle)),
+    [LegacyLanguages.vb]: () => import('@codemirror/legacy-modes/mode/vb').then(({ vb }) => StreamLanguage.define(vb)),
+    [LegacyLanguages.vbscript]: () => import('@codemirror/legacy-modes/mode/vbscript').then(({ vbScript }) => StreamLanguage.define(vbScript)),
+    [LegacyLanguages.velocity]: () => import('@codemirror/legacy-modes/mode/velocity').then(({ velocity }) => StreamLanguage.define(velocity)),
+    [LegacyLanguages.verilog]: () => import('@codemirror/legacy-modes/mode/verilog').then(({ verilog }) => StreamLanguage.define(verilog)),
+    [LegacyLanguages.vhdl]: () => import('@codemirror/legacy-modes/mode/vhdl').then(({ vhdl }) => StreamLanguage.define(vhdl)),
+    [LegacyLanguages.webidl]: () => import('@codemirror/legacy-modes/mode/webidl').then(({ webIDL }) => StreamLanguage.define(webIDL)),
+    [LegacyLanguages.xquery]: () => import('@codemirror/legacy-modes/mode/xquery').then(({ xQuery }) => StreamLanguage.define(xQuery)),
+    [LegacyLanguages.yacas]: () => import('@codemirror/legacy-modes/mode/yacas').then(({ yacas }) => StreamLanguage.define(yacas)),
+    [LegacyLanguages.yaml]: () => import('@codemirror/legacy-modes/mode/yaml').then(({ yaml }) => StreamLanguage.define(yaml)),
+    [LegacyLanguages.z80]: () => import('@codemirror/legacy-modes/mode/z80').then(({ z80 }) => StreamLanguage.define(z80)),
+};
+export default languageLoaders;

package/esm/extension-codemirror/src/languages.d.ts

@@ -0,0 +1,109 @@
+export declare enum CodeBlockLanguages {
+    javascript = "javascript",
+    html = "html",
+    css = "css",
+    sql = "sql",
+    python = "python",
+    rust = "rust",
+    xml = "xml",
+    json = "json",
+    markdown = "markdown",
+    java = "java",
+    cpp = "cpp",
+    lezer = "lezer",
+    php = "php",
+    wast = "wast"
+}
+export declare enum LegacyLanguages {
+    apl = "apl",
+    asciiarmor = "asciiarmor",
+    asn1 = "asn1",
+    asterisk = "asterisk",
+    brainfuck = "brainfuck",
+    clike = "clike",
+    clojure = "clojure",
+    cmake = "cmake",
+    cobol = "cobol",
+    coffeescript = "coffeescript",
+    commonlisp = "commonlisp",
+    crystal = "crystal",
+    cypher = "cypher",
+    d = "d",
+    diff = "diff",
+    dockerfile = "dockerfile",
+    dtd = "dtd",
+    dylan = "dylan",
+    ebnf = "ebnf",
+    ecl = "ecl",
+    eiffel = "eiffel",
+    elm = "elm",
+    erlang = "erlang",
+    factor = "factor",
+    fcl = "fcl",
+    forth = "forth",
+    fortran = "fortran",
+    gas = "gas",
+    gherkin = "gherkin",
+    go = "go",
+    groovy = "groovy",
+    haskell = "haskell",
+    haxe = "haxe",
+    http = "http",
+    idl = "idl",
+    jinja2 = "jinja2",
+    julia = "julia",
+    livescript = "livescript",
+    lua = "lua",
+    mathematica = "mathematica",
+    mbox = "mbox",
+    mirc = "mirc",
+    mllike = "mllike",
+    modelica = "modelica",
+    mscgen = "mscgen",
+    mumps = "mumps",
+    nginx = "nginx",
+    nsis = "nsis",
+    ntriples = "ntriples",
+    octave = "octave",
+    oz = "oz",
+    pascal = "pascal",
+    perl = "perl",
+    pig = "pig",
+    powershell = "powershell",
+    properties = "properties",
+    protobuf = "protobuf",
+    puppet = "puppet",
+    q = "q",
+    r = "r",
+    rpm = "rpm",
+    ruby = "ruby",
+    sas = "sas",
+    scheme = "scheme",
+    shell = "shell",
+    smalltalk = "smalltalk",
+    solr = "solr",
+    sparql = "sparql",
+    spreadsheet = "spreadsheet",
+    stex = "stex",
+    stylus = "stylus",
+    swift = "swift",
+    tcl = "tcl",
+    textile = "textile",
+    tiddlywiki = "tiddlywiki",
+    tiki = "tiki",
+    toml = "toml",
+    troff = "troff",
+    ttcn = "ttcn",
+    turtle = "turtle",
+    vb = "vb",
+    vbscript = "vbscript",
+    velocity = "velocity",
+    verilog = "verilog",
+    vhdl = "vhdl",
+    webidl = "webidl",
+    xquery = "xquery",
+    yacas = "yacas",
+    yaml = "yaml",
+    z80 = "z80"
+}
+//# sourceMappingURL=languages.d.ts.map

package/esm/extension-codemirror/src/languages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languages.d.ts","sourceRoot":"","sources":["../../../src/extension-codemirror/src/languages.ts"],"names":[],"mappings":"AAAA,oBAAY,kBAAkB;IAC5B,UAAU,eAAe;IACzB,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,KAAK,UAAU;IACf,GAAG,QAAQ;IACX,IAAI,SAAS;CACd;AAED,oBAAY,eAAe;IACzB,GAAG,QAAQ;IACX,UAAU,eAAe;IACzB,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,SAAS,cAAc;IACvB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,YAAY,iBAAiB;IAC7B,UAAU,eAAe;IACzB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,CAAC,MAAM;IACP,IAAI,SAAS;IACb,UAAU,eAAe;IACzB,GAAG,QAAQ;IACX,KAAK,UAAU;IACf,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,GAAG,QAAQ;IACX,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,EAAE,OAAO;IACT,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,UAAU,eAAe;IACzB,GAAG,QAAQ;IACX,WAAW,gBAAgB;IAC3B,IAAI,SAAS;IACb,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,KAAK,UAAU;IACf,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,EAAE,OAAO;IACT,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,UAAU,eAAe;IACzB,UAAU,eAAe;IACzB,QAAQ,aAAa;IACrB,MAAM,WAAW;IACjB,CAAC,MAAM;IACP,CAAC,MAAM;IACP,GAAG,QAAQ;IACX,IAAI,SAAS;IACb,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,WAAW,gBAAgB;IAC3B,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,KAAK,UAAU;IACf,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,EAAE,OAAO;IACT,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,KAAK,UAAU;IACf,IAAI,SAAS;IACb,GAAG,QAAQ;CACZ"}