@sutrata/editor 0.1.0

package/dist/editor/find-highlight-plugin.js

@@ -0,0 +1,57 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+const findHighlightKey = new PluginKey('findHighlight');
+// Module-level state pushed from FindReplace; the plugin reads this on each update.
+let currentMatches = [];
+let currentIndex = 0;
+let pluginView = null;
+/** Called by FindReplace whenever matches or active index change. */
+export function setFindHighlights(matches, activeIndex) {
+    currentMatches = matches;
+    currentIndex = activeIndex;
+    if (pluginView) {
+        // Dispatch a no-op meta transaction to trigger decoration recompute.
+        const tr = pluginView.state.tr.setMeta(findHighlightKey, true);
+        pluginView.dispatch(tr);
+    }
+}
+/** Called by FindReplace when the panel closes — clears all highlights. */
+export function clearFindHighlights() {
+    setFindHighlights([], 0);
+}
+function buildDecorations(matches, activeIndex, doc) {
+    if (matches.length === 0)
+        return DecorationSet.empty;
+    const decos = matches.map((m, i) => Decoration.inline(m.pmFrom, m.pmTo, {
+        class: i === activeIndex ? 'cs-find-active' : 'cs-find-match',
+    }));
+    return DecorationSet.create(doc, decos);
+}
+export function createFindHighlightPlugin() {
+    return new Plugin({
+        key: findHighlightKey,
+        view(view) {
+            pluginView = view;
+            return {
+                destroy() { pluginView = null; },
+            };
+        },
+        state: {
+            init(_config, state) {
+                return buildDecorations(currentMatches, currentIndex, state.doc);
+            },
+            apply(tr, _old, _oldState, newState) {
+                // Recompute on doc change (positions shift) or when we push a meta update.
+                if (tr.docChanged || tr.getMeta(findHighlightKey)) {
+                    return buildDecorations(currentMatches, currentIndex, newState.doc);
+                }
+                return _old;
+            },
+        },
+        props: {
+            decorations(state) {
+                return this.getState(state);
+            },
+        },
+    });
+}

package/dist/editor/frontmatter-field-view.d.ts

@@ -0,0 +1,10 @@
+import type { Node as PmNode } from 'prosemirror-model';
+import type { EditorView, NodeView } from 'prosemirror-view';
+export declare class FrontmatterFieldView implements NodeView {
+    dom: HTMLElement;
+    contentDOM: HTMLElement;
+    private counter;
+    constructor(node: PmNode, view: EditorView, getPos: () => number | undefined);
+    private updateCounter;
+    update(node: PmNode): boolean;
+}

package/dist/editor/frontmatter-field-view.js

@@ -0,0 +1,48 @@
+export class FrontmatterFieldView {
+    dom;
+    contentDOM;
+    counter = null;
+    constructor(node, view, getPos) {
+        this.dom = document.createElement('div');
+        this.dom.className = 'cs-fm-field';
+        this.dom.dataset['key'] = node.attrs['fmKey'];
+        this.contentDOM = document.createElement('span');
+        this.contentDOM.className = 'cs-fm-field-content';
+        this.dom.appendChild(this.contentDOM);
+        if (node.attrs['fmKey'] === 'logline') {
+            this.counter = document.createElement('span');
+            this.counter.className = 'cs-fm-logline-counter';
+            this.updateCounter(node.textContent);
+            this.dom.appendChild(this.counter);
+        }
+    }
+    updateCounter(text) {
+        if (!this.counter)
+            return;
+        const words = text.split(/\s+/).filter(Boolean).length;
+        this.counter.textContent = `${words} words`;
+        if (words > 50) {
+            this.counter.style.color = '#c5221f'; // red warning
+            this.counter.style.background = '#fce8e6';
+            this.counter.style.borderColor = '#fad2cf';
+        }
+        else if (words > 30) {
+            this.counter.style.color = '#b06000'; // orange warn/target
+            this.counter.style.background = '#fef7e0';
+            this.counter.style.borderColor = '#feebc8';
+        }
+        else {
+            this.counter.style.color = '#8a887f'; // clean gray
+            this.counter.style.background = '#f0efe9';
+            this.counter.style.borderColor = '#e2e0d8';
+        }
+    }
+    update(node) {
+        if (node.type.name !== 'frontmatter_field')
+            return false;
+        if (node.attrs['fmKey'] === 'logline' && this.counter) {
+            this.updateCounter(node.textContent);
+        }
+        return true;
+    }
+}

package/dist/editor/frontmatter-field.d.ts

@@ -0,0 +1,21 @@
+import type { EditorView } from 'prosemirror-view';
+/**
+ * Sets a single flat (non-dotted) top-level frontmatter key, e.g. `style: classic`.
+ * Mirrors StatisticsDialog.tsx's actor-name updater (dotted-key, nested-map case) but
+ * for the simpler flat-key case: patches the live ProseMirror `title_page` node when a
+ * view is mounted and already has one, otherwise falls back to editing the raw text
+ * (also used when no title_page node exists yet — the editor's text-sync effect will
+ * rebuild the doc, including a fresh title_page node, from the new text).
+ */
+export declare function setFlatFrontmatterField(view: EditorView | null, text: string, setText: (next: string) => void, key: string, value: string): void;
+/** Raw-text fallback for when no ProseMirror view is mounted (or it has no title_page
+ *  node yet). Creates a frontmatter block from scratch if the document doesn't have one. */
+export declare function setFlatFrontmatterFieldInText(text: string, key: string, value: string): string;
+/**
+ * Replace the whole title page with the frontmatter of `nextText` (the full Sutra text
+ * after a title-page form save). When the formatted editor is mounted, this is one
+ * ProseMirror transaction that swaps the `title_page` node, so it is a single undo step and
+ * the caret and scroll position are kept; the editor's normal sync then updates the text.
+ * Otherwise (source mode, no view) the text is set directly.
+ */
+export declare function applyTitlePageText(view: EditorView | null, nextText: string, setText: (next: string) => void): void;

package/dist/editor/frontmatter-field.js

@@ -0,0 +1,116 @@
+import { parse } from '@sutrata/parser';
+import { schema } from './schema';
+import { sutraToProsemirror } from './sutra-to-prosemirror';
+/**
+ * Sets a single flat (non-dotted) top-level frontmatter key, e.g. `style: classic`.
+ * Mirrors StatisticsDialog.tsx's actor-name updater (dotted-key, nested-map case) but
+ * for the simpler flat-key case: patches the live ProseMirror `title_page` node when a
+ * view is mounted and already has one, otherwise falls back to editing the raw text
+ * (also used when no title_page node exists yet — the editor's text-sync effect will
+ * rebuild the doc, including a fresh title_page node, from the new text).
+ */
+export function setFlatFrontmatterField(view, text, setText, key, value) {
+    if (view) {
+        let titlePagePos = null;
+        view.state.doc.forEach((node, offset) => {
+            if (node.type.name === 'title_page')
+                titlePagePos = offset;
+        });
+        if (titlePagePos !== null) {
+            let tr = view.state.tr;
+            const tpNode = view.state.doc.nodeAt(titlePagePos);
+            let existingPos = null;
+            let pos = titlePagePos + 1;
+            tpNode.forEach(field => {
+                if (field.attrs['fmKey'] === key)
+                    existingPos = pos;
+                pos += field.nodeSize;
+            });
+            if (existingPos !== null) {
+                const fieldNode = view.state.doc.nodeAt(existingPos);
+                if (value === '') {
+                    tr = tr.delete(existingPos, existingPos + fieldNode.nodeSize);
+                }
+                else {
+                    tr = tr.replaceWith(existingPos + 1, existingPos + fieldNode.nodeSize - 1, schema.text(value));
+                }
+            }
+            else if (value !== '') {
+                const insertPos = titlePagePos + tpNode.nodeSize - 1;
+                const newField = schema.nodes['frontmatter_field'].create({ fmKey: key }, schema.text(value));
+                tr = tr.insert(insertPos, newField);
+            }
+            view.dispatch(tr);
+            return;
+        }
+    }
+    setText(setFlatFrontmatterFieldInText(text, key, value));
+}
+/** Raw-text fallback for when no ProseMirror view is mounted (or it has no title_page
+ *  node yet). Creates a frontmatter block from scratch if the document doesn't have one. */
+export function setFlatFrontmatterFieldInText(text, key, value) {
+    const lines = text.split('\n');
+    const fmStartIndex = lines.indexOf('---');
+    if (fmStartIndex === -1) {
+        if (value === '')
+            return text;
+        return `---\n${key}: ${value}\n---\n\n${text}`;
+    }
+    const fmEndIndex = lines.indexOf('---', fmStartIndex + 1);
+    if (fmEndIndex === -1)
+        return text;
+    const fmLines = lines.slice(fmStartIndex + 1, fmEndIndex);
+    let keyLineIdx = -1;
+    for (let i = 0; i < fmLines.length; i++) {
+        const match = /^([A-Za-z0-9_-]+):/.exec(fmLines[i]);
+        if (match && match[1] === key) {
+            keyLineIdx = i;
+            break;
+        }
+    }
+    if (keyLineIdx === -1) {
+        if (value !== '')
+            fmLines.push(`${key}: ${value}`);
+    }
+    else if (value === '') {
+        fmLines.splice(keyLineIdx, 1);
+    }
+    else {
+        fmLines[keyLineIdx] = `${key}: ${value}`;
+    }
+    return [...lines.slice(0, fmStartIndex + 1), ...fmLines, ...lines.slice(fmEndIndex)].join('\n');
+}
+/**
+ * Replace the whole title page with the frontmatter of `nextText` (the full Sutra text
+ * after a title-page form save). When the formatted editor is mounted, this is one
+ * ProseMirror transaction that swaps the `title_page` node, so it is a single undo step and
+ * the caret and scroll position are kept; the editor's normal sync then updates the text.
+ * Otherwise (source mode, no view) the text is set directly.
+ */
+export function applyTitlePageText(view, nextText, setText) {
+    if (!view) {
+        setText(nextText);
+        return;
+    }
+    const nextDoc = sutraToProsemirror(parse(nextText));
+    const first = nextDoc.firstChild;
+    const nextTp = first && first.type.name === 'title_page' ? first : null;
+    let tpPos = null;
+    let tpSize = 0;
+    view.state.doc.forEach((node, offset) => {
+        if (tpPos === null && node.type.name === 'title_page') {
+            tpPos = offset;
+            tpSize = node.nodeSize;
+        }
+    });
+    let tr = view.state.tr;
+    if (tpPos !== null && nextTp)
+        tr = tr.replaceWith(tpPos, tpPos + tpSize, nextTp);
+    else if (tpPos !== null)
+        tr = tr.delete(tpPos, tpPos + tpSize);
+    else if (nextTp)
+        tr = tr.insert(0, nextTp);
+    else
+        return;
+    view.dispatch(tr);
+}

package/dist/editor/grapheme-cursor.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from 'prosemirror-state';
+/**
+ * Move cursor one grapheme cluster left or right.
+ * Returns true if the command was applied, false if at a boundary.
+ */
+export declare function moveByGrapheme(dir: 'left' | 'right'): Command;
+/**
+ * Extend selection one grapheme cluster left or right.
+ */
+export declare function extendByGrapheme(dir: 'left' | 'right'): Command;

package/dist/editor/grapheme-cursor.js

@@ -0,0 +1,104 @@
+import { TextSelection } from 'prosemirror-state';
+/**
+ * Segment text into grapheme clusters using Intl.Segmenter.
+ * Falls back to codepoint-by-codepoint if Segmenter is unavailable.
+ */
+function getGraphemes(text) {
+    if (typeof Intl !== 'undefined' && 'Segmenter' in Intl) {
+        const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+        return Array.from(segmenter.segment(text), (s) => s.segment);
+    }
+    // Fallback: iterate by Unicode codepoint (Array.from handles surrogates)
+    return Array.from(text);
+}
+/**
+ * Move cursor one grapheme cluster left or right.
+ * Returns true if the command was applied, false if at a boundary.
+ */
+export function moveByGrapheme(dir) {
+    return (state, dispatch) => {
+        const { selection, doc } = state;
+        const { $cursor } = selection;
+        // Only apply to collapsed (cursor) selections
+        if (!$cursor)
+            return false;
+        const pos = $cursor.pos;
+        if (dir === 'right') {
+            // Get text from cursor to end of parent block
+            const end = $cursor.end();
+            if (pos >= end)
+                return false;
+            const text = doc.textBetween(pos, end);
+            const graphemes = getGraphemes(text);
+            if (graphemes.length === 0)
+                return false;
+            const advance = graphemes[0]?.length ?? 0;
+            if (advance === 0)
+                return false;
+            if (dispatch) {
+                const tr = state.tr.setSelection(TextSelection.create(doc, pos + advance));
+                dispatch(tr);
+            }
+            return true;
+        }
+        else {
+            // dir === 'left'
+            const start = $cursor.start();
+            if (pos <= start)
+                return false;
+            const text = doc.textBetween(start, pos);
+            const graphemes = getGraphemes(text);
+            if (graphemes.length === 0)
+                return false;
+            const retreat = graphemes[graphemes.length - 1]?.length ?? 0;
+            if (dispatch) {
+                const tr = state.tr.setSelection(TextSelection.create(doc, pos - retreat));
+                dispatch(tr);
+            }
+            return true;
+        }
+    };
+}
+/**
+ * Extend selection one grapheme cluster left or right.
+ */
+export function extendByGrapheme(dir) {
+    return (state, dispatch) => {
+        const { selection, doc } = state;
+        const { anchor, head } = selection;
+        if (dir === 'right') {
+            const $head = doc.resolve(head);
+            const end = $head.end();
+            if (head >= end)
+                return false;
+            const text = doc.textBetween(head, end);
+            const graphemes = getGraphemes(text);
+            if (graphemes.length === 0)
+                return false;
+            const advance = graphemes[0]?.length ?? 0;
+            if (advance === 0)
+                return false;
+            if (dispatch) {
+                const tr = state.tr.setSelection(TextSelection.create(doc, anchor, head + advance));
+                dispatch(tr);
+            }
+            return true;
+        }
+        else {
+            const $head = doc.resolve(head);
+            const start = $head.start();
+            if (head <= start)
+                return false;
+            const text = doc.textBetween(start, head);
+            const graphemes = getGraphemes(text);
+            if (graphemes.length === 0)
+                return false;
+            const retreat = graphemes[graphemes.length - 1]?.length ?? 0;
+            if (dispatch) {
+                const tr = state.tr.setSelection(TextSelection.create(doc, anchor, head - retreat));
+                dispatch(tr);
+            }
+            return true;
+        }
+    };
+}

package/dist/editor/ime-plugin.d.ts

@@ -0,0 +1,18 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * IME Composition plugin for ProseMirror.
+ *
+ * During IME composition (phonetic input for Indic/CJK scripts), the browser
+ * fires compositionstart → compositionupdate (many) → compositionend.
+ * ProseMirror's default behaviour re-renders the DOM on every transaction,
+ * which destroys the IME candidate window mid-composition.
+ *
+ * This plugin:
+ *  1. Tracks composition state via DOM events.
+ *  2. Holds incoming transactions in a queue while composition is active.
+ *  3. Flushes the queue on compositionend so the final committed text is
+ *     applied as a single transaction — no duplicates, no drops.
+ */
+export declare function createImePlugin(): Plugin<any>;
+export declare function createImePluginWithRef(): Plugin<any>;
+export declare function isComposing(): boolean;

package/dist/editor/ime-plugin.js

@@ -0,0 +1,71 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * IME Composition plugin for ProseMirror.
+ *
+ * During IME composition (phonetic input for Indic/CJK scripts), the browser
+ * fires compositionstart → compositionupdate (many) → compositionend.
+ * ProseMirror's default behaviour re-renders the DOM on every transaction,
+ * which destroys the IME candidate window mid-composition.
+ *
+ * This plugin:
+ *  1. Tracks composition state via DOM events.
+ *  2. Holds incoming transactions in a queue while composition is active.
+ *  3. Flushes the queue on compositionend so the final committed text is
+ *     applied as a single transaction — no duplicates, no drops.
+ */
+export function createImePlugin() {
+    return new Plugin({
+        view(editorView) {
+            return new ImePluginView(editorView);
+        },
+    });
+}
+class ImePluginView {
+    composing = false;
+    pendingTr = null;
+    view;
+    constructor(view) {
+        this.view = view;
+        this.onCompositionStart = this.onCompositionStart.bind(this);
+        this.onCompositionEnd = this.onCompositionEnd.bind(this);
+        view.dom.addEventListener('compositionstart', this.onCompositionStart);
+        view.dom.addEventListener('compositionend', this.onCompositionEnd);
+    }
+    onCompositionStart() {
+        this.composing = true;
+    }
+    onCompositionEnd() {
+        this.composing = false;
+        // Flush any pending transaction now that composition is done
+        if (this.pendingTr) {
+            const tr = this.pendingTr;
+            this.pendingTr = null;
+            this.view.dispatch(tr);
+        }
+    }
+    update() {
+        // Called by ProseMirror after each state update.
+        // Nothing to do here — we handle composition via DOM events.
+    }
+    destroy() {
+        this.view.dom.removeEventListener('compositionstart', this.onCompositionStart);
+        this.view.dom.removeEventListener('compositionend', this.onCompositionEnd);
+    }
+    /** Returns whether composition is currently active. */
+    isComposing() {
+        return this.composing;
+    }
+}
+/** Singleton accessor — lets EditorView.tsx skip DOM updates during composition. */
+let _imeView = null;
+export function createImePluginWithRef() {
+    return new Plugin({
+        view(editorView) {
+            _imeView = new ImePluginView(editorView);
+            return _imeView;
+        },
+    });
+}
+export function isComposing() {
+    return _imeView?.isComposing() ?? false;
+}

package/dist/editor/insert-helper.d.ts

@@ -0,0 +1 @@
+export declare function insertSutra(sutraText: string, mode: 'formatted' | 'source'): void;

package/dist/editor/insert-helper.js

@@ -0,0 +1,42 @@
+import { Fragment, Slice } from 'prosemirror-model';
+import { parse } from '@sutrata/parser';
+import { sutraToProsemirror } from './sutra-to-prosemirror';
+import { getEditorView, getSourceView } from './editor-bus';
+export function insertSutra(sutraText, mode) {
+    if (mode === 'formatted') {
+        const view = getEditorView();
+        if (!view)
+            return;
+        const ast = parse(sutraText);
+        const pmDoc = sutraToProsemirror(ast);
+        // Extract nodes from the parsed doc, skipping title_page
+        const nodes = [];
+        pmDoc.content.forEach(node => {
+            if (node.type.name !== 'title_page') {
+                nodes.push(node);
+            }
+        });
+        if (nodes.length > 0) {
+            const fragment = Fragment.from(nodes);
+            const slice = new Slice(fragment, 0, 0);
+            const tr = view.state.tr.replaceSelection(slice);
+            view.dispatch(tr);
+            view.focus();
+        }
+    }
+    else {
+        const cm = getSourceView();
+        if (!cm)
+            return;
+        const transaction = cm.state.update({
+            changes: {
+                from: cm.state.selection.main.from,
+                to: cm.state.selection.main.to,
+                insert: sutraText,
+            },
+            selection: { anchor: cm.state.selection.main.from + sutraText.length }
+        });
+        cm.dispatch(transaction);
+        cm.focus();
+    }
+}

package/dist/editor/keymap.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'prosemirror-state';
+export declare const keymapBindings: Record<string, Command>;
+export declare function buildKeymap(): import("prosemirror-state").Plugin<any>;

package/dist/editor/keymap.js

@@ -0,0 +1,131 @@
+import { keymap } from 'prosemirror-keymap';
+import { undo, redo } from 'prosemirror-history';
+import { toggleMark } from 'prosemirror-commands';
+import { TextSelection } from 'prosemirror-state';
+import { schema } from './schema';
+import { moveByGrapheme, extendByGrapheme } from './grapheme-cursor';
+const smartEnter = (state, dispatch) => {
+    const { $from } = state.selection;
+    const node = $from.parent;
+    if (node.type === schema.nodes['frontmatter_field']) {
+        // Enter moves to the next field, or exits into the body. New fields are
+        // added via the pencil menu, never by splitting.
+        if (dispatch) {
+            const after = $from.after();
+            dispatch(state.tr.setSelection(TextSelection.near(state.doc.resolve(after), 1)));
+        }
+        return true;
+    }
+    if (node.type === schema.nodes['scene_heading'] && $from.pos === $from.end()) {
+        if (dispatch) {
+            const actionType = schema.nodes['action'];
+            const insertPos = $from.after();
+            const tr = state.tr.insert(insertPos, actionType.create());
+            dispatch(tr.setSelection(TextSelection.near(tr.doc.resolve(insertPos + 1))));
+        }
+        return true;
+    }
+    if (node.type === schema.nodes['character']) {
+        if (dispatch) {
+            const dialogueType = schema.nodes['dialogue'];
+            const insertPos = $from.after();
+            const tr = state.tr.insert(insertPos, dialogueType.create());
+            dispatch(tr.setSelection(TextSelection.near(tr.doc.resolve(insertPos + 1))));
+        }
+        return true;
+    }
+    if (node.type === schema.nodes['dialogue'] || node.type === schema.nodes['parenthetical']) {
+        if (dispatch) {
+            const actionType = schema.nodes['action'];
+            const insertPos = $from.after();
+            const tr = state.tr.insert(insertPos, actionType.create());
+            dispatch(tr.setSelection(TextSelection.near(tr.doc.resolve(insertPos + 1))));
+        }
+        return true;
+    }
+    // Every other block type (action, transition, centered, lyrics, section,
+    // scene_metadata, note, comment…) has no dedicated rule above: split into
+    // another node of the SAME type. Without an explicit `typesAfter`, PM's
+    // default splitBlock command picks the first node type declared in the
+    // `block` group in schema.ts (scene_heading) rather than preserving the
+    // current type — so plain baseKeymap fallthrough silently turns the next
+    // line into a scene heading.
+    if (dispatch) {
+        const tr = state.tr.split($from.pos, 1, [{ type: node.type }]);
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};
+export const keymapBindings = {
+    // Editing
+    'Mod-z': undo,
+    'Mod-y': redo,
+    'Mod-Shift-Z': redo,
+    'Mod-b': (state, dispatch) => {
+        const mark = schema.marks['bold'];
+        if (state.selection.empty)
+            return false;
+        return toggleMark(mark)(state, dispatch);
+    },
+    'Mod-i': (state, dispatch) => {
+        const mark = schema.marks['italic'];
+        if (state.selection.empty)
+            return false;
+        return toggleMark(mark)(state, dispatch);
+    },
+    'Mod-u': (state, dispatch) => {
+        const mark = schema.marks['underline'];
+        if (state.selection.empty)
+            return false;
+        return toggleMark(mark)(state, dispatch);
+    },
+    'Enter': smartEnter,
+    'Shift-Enter': (state, dispatch) => {
+        const { $from } = state.selection;
+        if ($from.parent.type !== schema.nodes['frontmatter_field'])
+            return false;
+        if (dispatch) {
+            const br = schema.nodes['hard_break'].create();
+            dispatch(state.tr.replaceSelectionWith(br).scrollIntoView());
+        }
+        return true;
+    },
+    'Tab': (state, _dispatch, view) => {
+        const { $from } = state.selection;
+        if ($from.parent.type !== schema.nodes['scene_heading'])
+            return false;
+        if (!view)
+            return false;
+        const pos = $from.before();
+        const domNode = view.nodeDOM(pos);
+        const el = domNode instanceof HTMLElement ? domNode : domNode?.parentElement;
+        const input = el?.querySelector('input.cs-scene-id-input');
+        if (input) {
+            input.focus();
+            input.select();
+            return true;
+        }
+        return false;
+    },
+    'ArrowDown': (state, dispatch) => {
+        const { $from } = state.selection;
+        if ($from.parent.type !== schema.nodes['scene_heading'])
+            return false;
+        // PM's built-in ArrowDown gets confused by the sibling scene-number input.
+        // Explicitly jump to the start of the node after the scene heading.
+        const afterPos = $from.after();
+        if (afterPos > state.doc.content.size)
+            return false;
+        if (dispatch) {
+            dispatch(state.tr.setSelection(TextSelection.near(state.doc.resolve(afterPos), 1)));
+        }
+        return true;
+    },
+    'ArrowLeft': moveByGrapheme('left'),
+    'ArrowRight': moveByGrapheme('right'),
+    'Shift-ArrowLeft': extendByGrapheme('left'),
+    'Shift-ArrowRight': extendByGrapheme('right'),
+};
+export function buildKeymap() {
+    return keymap(keymapBindings);
+}

package/dist/editor/language-class-plugin.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from 'prosemirror-state';
+import { DecorationSet } from 'prosemirror-view';
+/**
+ * ProseMirror plugin that applies language-specific CSS classes to block nodes
+ * based on detected or specified language (from metadata or inline tags)
+ */
+export declare function createLanguageClassPlugin(): Plugin<DecorationSet>;