@kerebron/extension-codemirror 0.4.27 → 0.4.28

package/assets/codemirror.css

@@ -0,0 +1,80 @@
+.codeblock-select {
+  position: absolute;
+  right: 0;
+  z-index: 100;
+  opacity: 0;
+  transition: all 0.3s ease;
+  margin: 6px 14px;
+}
+
+.codeblock-root {
+  position: relative;
+}
+
+.codeblock-root:hover .codeblock-select {
+  opacity: 1;
+}
+
+/* Code block mobile optimization */
+@media (max-width: 767px) {
+  .kb-editor pre {
+    font-size: var(--kb-text-sm);
+    overflow-x: auto;
+    -webkit-overflow-scrolling: touch;
+  }
+
+  .codeblock-select {
+    opacity: 1;
+    position: static;
+    margin: var(--kb-space-sm);
+    display: flex;
+    justify-content: flex-end;
+  }
+
+  .codeblock-select select {
+    min-height: var(--kb-touch-target-min);
+    padding: var(--kb-space-sm);
+    border: 1px solid var(--kb-color-border);
+    border-radius: var(--kb-radius-sm);
+    background: var(--kb-color-surface);
+    color: var(--kb-color-text);
+  }
+}
+
+.kb-yjs__cursor {
+  position: fixed;
+  margin-left: -1px;
+  margin-right: -1px;
+  /*border-left: 1px solid black;*/
+  /*border-right: 1px solid black;*/
+  /*border-color: orange;*/
+  word-break: normal;
+  pointer-events: none;
+}
+
+/* This renders the username above the caret */
+.kb-yjs__cursor > div {
+  position: absolute;
+  top: -1.05em;
+  left: -1px;
+  font-size: 13px;
+  background-color: rgb(250, 129, 0);
+  font-family: serif;
+  font-style: normal;
+  font-weight: normal;
+  line-height: normal;
+  user-select: none;
+  color: white;
+  padding-left: 2px;
+  padding-right: 2px;
+  white-space: nowrap;
+}
+
+/* Collaborative cursor optimization for mobile */
+@media (max-width: 767px) {
+  .kb-yjs__cursor > div {
+    font-size: var(--kb-text-xs);
+    padding: 1px var(--kb-space-xs);
+    border-radius: var(--kb-radius-sm);
+  }
+}

package/esm/ExtensionCodeMirror.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from 'prosemirror-model';
+import { AnyExtensionOrReq, type Converter, type CoreEditor, Extension } from '@kerebron/editor';
+import { NodeCodeMirrorConfig } from './NodeCodeMirror.js';
+export * from './NodeCodeMirror.js';
+export interface ExtensionCodeMirrorConfig {
+    languageWhitelist?: NodeCodeMirrorConfig['languageWhitelist'];
+    theme?: NodeCodeMirrorConfig['theme'];
+    readOnly?: boolean;
+}
+export declare class ExtensionCodeMirror extends Extension {
+    protected config: ExtensionCodeMirrorConfig;
+    name: string;
+    requires: AnyExtensionOrReq[];
+    constructor(config: ExtensionCodeMirrorConfig);
+    getConverters(editor: CoreEditor, schema: Schema): Record<string, Converter>;
+}
+//# sourceMappingURL=ExtensionCodeMirror.d.ts.map

package/esm/ExtensionCodeMirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionCodeMirror.d.ts","sourceRoot":"","sources":["../src/ExtensionCodeMirror.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EACL,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,SAAS,EACV,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAkB,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3E,cAAc,qBAAqB,CAAC;AAEpC,MAAM,WAAW,yBAAyB;IACxC,iBAAiB,CAAC,EAAE,oBAAoB,CAAC,mBAAmB,CAAC,CAAC;IAC9D,KAAK,CAAC,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,qBAAa,mBAAoB,SAAQ,SAAS;cAIjB,MAAM,EAAE,yBAAyB;IAHvD,IAAI,SAAiB;IAC9B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;gBAEC,MAAM,EAAE,yBAAyB;IAWvD,aAAa,CACpB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;CA+C7B"}

package/esm/ExtensionCodeMirror.js

@@ -0,0 +1,61 @@
+import { Extension, } from '@kerebron/editor';
+import { createNodeFromObject } from '@kerebron/editor/utilities';
+import { NodeCodeMirror } from './NodeCodeMirror.js';
+export * from './NodeCodeMirror.js';
+export class ExtensionCodeMirror extends Extension {
+    config;
+    name = 'code-mirror';
+    requires;
+    constructor(config) {
+        super(config);
+        this.config = config;
+        this.requires = [
+            new NodeCodeMirror({
+                languageWhitelist: config.languageWhitelist,
+                theme: config.theme,
+            }),
+        ];
+    }
+    getConverters(editor, schema) {
+        return {
+            'text/code-only': {
+                fromDoc: async (document) => {
+                    const retVal = [];
+                    if (document.content) {
+                        for (const node of document.content.toJSON()) {
+                            if ('code_block' === node.type && Array.isArray(node.content)) {
+                                for (const content of node.content) {
+                                    retVal.push(content.text);
+                                }
+                            }
+                        }
+                    }
+                    return new TextEncoder().encode(retVal.join(''));
+                },
+                toDoc: async (buffer) => {
+                    const code = new TextDecoder().decode(buffer);
+                    const content = {
+                        'type': 'doc_code',
+                        'content': [
+                            {
+                                'type': 'code_block',
+                                'attrs': {
+                                    'lang': schema.topNodeType.spec.defaultAttrs?.lang,
+                                },
+                                'content': [
+                                    {
+                                        'type': 'text',
+                                        'text': code,
+                                    },
+                                ],
+                            },
+                        ],
+                    };
+                    return createNodeFromObject(content, schema, {
+                        errorOnInvalidContent: false,
+                    });
+                },
+            },
+        };
+    }
+}

package/esm/NodeCodeMirror.d.ts

@@ -0,0 +1,20 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import type { NodeType } from 'prosemirror-model';
+import { type CoreEditor } from '@kerebron/editor';
+import { type CommandFactories, type CommandShortcuts } from '@kerebron/editor/commands';
+import { NodeCodeBlock } from '@kerebron/extension-basic-editor/NodeCodeBlock';
+import { CodeBlockSettings } from './types.js';
+export declare const codeMirrorBlockKey: PluginKey<any>;
+export interface NodeCodeMirrorConfig {
+    readOnly?: boolean;
+    languageWhitelist?: CodeBlockSettings['languageWhitelist'];
+    theme?: CodeBlockSettings['theme'];
+}
+export declare class NodeCodeMirror extends NodeCodeBlock {
+    config: NodeCodeMirrorConfig;
+    constructor(config: NodeCodeMirrorConfig);
+    getCommandFactories(editor: CoreEditor, type: NodeType): Partial<CommandFactories>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+    getProseMirrorPlugins(): Plugin[];
+}
+//# sourceMappingURL=NodeCodeMirror.d.ts.map

package/esm/NodeCodeMirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeCodeMirror.d.ts","sourceRoot":"","sources":["../src/NodeCodeMirror.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,MAAM,EACN,SAAS,EAGV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAE/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAK/C,eAAO,MAAM,kBAAkB,gBAAoC,CAAC;AA+CpE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;IAC3D,KAAK,CAAC,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;CACpC;AAED,qBAAa,cAAe,SAAQ,aAAa;IAC1B,MAAM,EAAE,oBAAoB;gBAA5B,MAAM,EAAE,oBAAoB;IAIxC,mBAAmB,CAC1B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC;IAWnB,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAUjD,qBAAqB,IAAI,MAAM,EAAE;CA6B3C"}

package/esm/NodeCodeMirror.js

@@ -0,0 +1,95 @@
+import { Plugin, PluginKey, Selection, } from 'prosemirror-state';
+import { getShadowRoot } from '@kerebron/editor/utilities';
+import { NodeCodeBlock } from '@kerebron/extension-basic-editor/NodeCodeBlock';
+import { codeMirrorBlockNodeView } from './codeMirrorBlockNodeView.js';
+import { defaultSettings } from './defaults.js';
+import languageLoaders, { legacyLanguageLoaders } from './languageLoaders.js';
+export const codeMirrorBlockKey = new PluginKey('codemirror-block');
+function arrowHandler(dir) {
+    return (state, dispatch, view) => {
+        if (state.selection.empty && view && view.endOfTextblock(dir)) {
+            let side = dir == 'left' || dir == 'up' ? -1 : 1;
+            let $head = state.selection.$head;
+            let nextPos = Selection.near(state.doc.resolve(side > 0 ? $head.after() : $head.before()), side);
+            if (nextPos.$head && nextPos.$head.parent.type.name == 'code_block') {
+                if (dispatch) {
+                    dispatch(state.tr.setSelection(nextPos));
+                }
+                return true;
+            }
+        }
+        return false;
+    };
+}
+const LANGS = [
+    'diff',
+    'dockerfile',
+    'http',
+    'nginx',
+    'properties',
+    'shell',
+    'toml',
+    'yaml',
+    'sql',
+    'javascript',
+    'cpp',
+    'css',
+    'xml',
+    'java',
+    'json',
+    'markdown',
+    'rust',
+    'html',
+];
+export class NodeCodeMirror extends NodeCodeBlock {
+    config;
+    constructor(config) {
+        super(config);
+        this.config = config;
+    }
+    getCommandFactories(editor, type) {
+        return {
+            'setCodeBlock': (lang) => editor.commandFactories.setBlockType(type, { lang }),
+            ArrowLeft: () => arrowHandler('left'),
+            ArrowRight: () => arrowHandler('right'),
+            ArrowUp: () => arrowHandler('up'),
+            ArrowDown: () => arrowHandler('down'),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Shift-Ctrl-"': 'setCodeBlock',
+            'ArrowLeft': 'ArrowLeft',
+            'ArrowRight': 'ArrowRight',
+            'ArrowUp': 'ArrowUp',
+            'ArrowDown': 'ArrowDown',
+        };
+    }
+    getProseMirrorPlugins() {
+        const shadowRoot = getShadowRoot(this.editor.config.element);
+        const settings = {
+            languageWhitelist: this.config.languageWhitelist || LANGS,
+            shadowRoot,
+            ...defaultSettings,
+            readOnly: this.editor.config.readOnly || this.config.readOnly,
+            languageLoaders: { ...languageLoaders, ...legacyLanguageLoaders },
+            undo: () => {
+                this.editor.chain().undo().run();
+            },
+            redo: () => {
+                this.editor.chain().redo().run();
+            },
+            theme: [...(this.config.theme || [])],
+        };
+        return [
+            new Plugin({
+                key: codeMirrorBlockKey,
+                props: {
+                    nodeViews: {
+                        [this.name]: codeMirrorBlockNodeView(settings, this.editor),
+                    },
+                },
+            }),
+        ];
+    }
+}

package/esm/codeMirrorBlockNodeView.d.ts

@@ -0,0 +1,7 @@
+import { Node } from 'prosemirror-model';
+import { Decoration, DecorationSource, EditorView, NodeView } from 'prosemirror-view';
+import { CoreEditor } from '@kerebron/editor';
+import { CodeBlockSettings } from './types.js';
+export declare const themeCallbacks: Array<(theme: string) => void>;
+export declare const codeMirrorBlockNodeView: (settings: CodeBlockSettings, editor: CoreEditor) => (node: Node, view: EditorView, getPos: () => number | undefined, decorations: readonly Decoration[], innerDecorations: DecorationSource) => NodeView;
+//# sourceMappingURL=codeMirrorBlockNodeView.d.ts.map

package/esm/codeMirrorBlockNodeView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeMirrorBlockNodeView.d.ts","sourceRoot":"","sources":["../src/codeMirrorBlockNodeView.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,UAAU,EAEV,QAAQ,EACT,MAAM,kBAAkB,CAAC;AA8B1B,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAY9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAS/C,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAM,CAAC;AAoUjE,eAAO,MAAM,uBAAuB,EAAE,CACpC,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,UAAU,KACf,CACH,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,MAAM,GAAG,SAAS,EAChC,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,gBAAgB,EAAE,gBAAgB,KAC/B,QAQJ,CAAC"}

package/esm/codeMirrorBlockNodeView.js

@@ -0,0 +1,268 @@
+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 {
+    node;
+    view;
+    getPos;
+    settings;
+    editor;
+    dom;
+    codeMirrorView;
+    updating;
+    createCopyButtonCB;
+    selectDeleteCB;
+    languageConf;
+    uri = 'file:///' + Math.random() + '.ts';
+    diagListener;
+    constructor(node, view, getPos, settings, editor) {
+        this.node = node;
+        this.view = view;
+        this.getPos = getPos;
+        this.settings = settings;
+        this.editor = editor;
+        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/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/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../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/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/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/languageLoaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"languageLoaders.d.ts","sourceRoot":"","sources":["../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"}