@kerebron/extension-basic-editor 0.4.27 → 0.4.28

package/esm/NodeHardBreak.js

@@ -0,0 +1,67 @@
+import { Node } from '@kerebron/editor';
+import { firstCommand } from '@kerebron/editor/commands';
+export class NodeHardBreak extends Node {
+    name = 'br';
+    requires = ['doc'];
+    options = {
+        keepMarks: true,
+    };
+    getNodeSpec() {
+        return {
+            inline: true,
+            group: 'inline',
+            selectable: false,
+            linebreakReplacement: true,
+            parseDOM: [{ tag: 'br' }],
+            toDOM() {
+                return ['br'];
+            },
+        };
+    }
+    getCommandFactories(editor, type) {
+        // TODO: refactor commands
+        // const comm2: Command = (state: EditorState, dispatch?: (tr: Transaction) => void) => {
+        //   const { selection, storedMarks } = state
+        //   if (selection.$from.parent.type.spec.isolating) {
+        //       return false
+        //   }
+        //   const { keepMarks } = this.options
+        //   // const { splittableMarks } = editor.extensionManager
+        //   const splittableMarks = [];
+        //   const marks = storedMarks
+        //       || (selection.$to.parentOffset && selection.$from.marks())
+        //   return editor.chain()
+        //     .insertContent({ type: this.name })
+        //     .command(({ tr, dispatch }) => {
+        //         if (dispatch && marks && keepMarks) {
+        //           for (const mark of marks) {
+        //             console.log('mteset', mark.type);
+        //           }
+        //             const filteredMarks = marks
+        //                 .filter(mark => splittableMarks.includes(mark.type.name))
+        //             tr.ensureMarks(filteredMarks)
+        //         }
+        //         return true
+        //     })
+        //     .run();
+        // }
+        const setHardBreak = firstCommand(editor.run.exitCode);
+        return {
+            'setHardBreak': () => setHardBreak,
+        };
+    }
+    getKeyboardShortcuts() {
+        // https://stackoverflow.com/a/73619128
+        const mac = typeof navigator != 'undefined'
+            ? /Mac|iP(hone|[oa]d)/.test(navigator?.platform)
+            : false;
+        const shortcuts = {
+            'Ctrl-Enter': 'setHardBreak',
+        };
+        if (mac) {
+            shortcuts['Mod-Enter'] = 'setHardBreak';
+            shortcuts['Shift-Enter'] = 'setHardBreak';
+        }
+        return shortcuts;
+    }
+}

package/esm/NodeHeading.d.ts

@@ -0,0 +1,13 @@
+import type { NodeSpec, NodeType } from 'prosemirror-model';
+import { type CoreEditor, Node } from '@kerebron/editor';
+import { type CommandFactories, type CommandShortcuts } from '@kerebron/editor/commands';
+import { type InputRule } from '@kerebron/editor/plugins/input-rules';
+export declare class NodeHeading extends Node {
+    name: string;
+    requires: string[];
+    getNodeSpec(): NodeSpec;
+    getInputRules(type: NodeType): InputRule[];
+    getCommandFactories(editor: CoreEditor, type: NodeType): Partial<CommandFactories>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+}
+//# sourceMappingURL=NodeHeading.d.ts.map

package/esm/NodeHeading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeHeading.d.ts","sourceRoot":"","sources":["../src/NodeHeading.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE5D,OAAO,EAAE,KAAK,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,SAAS,EAEf,MAAM,sCAAsC,CAAC;AAI9C,qBAAa,WAAY,SAAQ,IAAI;IAC1B,IAAI,SAAa;IAC1B,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;IAoBvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAc1C,mBAAmB,CAC1B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC;IAWnB,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAS3D"}

package/esm/NodeHeading.js

@@ -0,0 +1,49 @@
+import { Node } from '@kerebron/editor';
+import { textblockTypeInputRule, } from '@kerebron/editor/plugins/input-rules';
+const maxLevel = 6;
+export class NodeHeading extends Node {
+    name = 'heading';
+    requires = ['doc'];
+    getNodeSpec() {
+        return {
+            attrs: { level: { default: 1 } },
+            content: 'inline*',
+            group: 'block',
+            defining: true,
+            parseDOM: [
+                { tag: 'h1', attrs: { level: 1 } },
+                { tag: 'h2', attrs: { level: 2 } },
+                { tag: 'h3', attrs: { level: 3 } },
+                { tag: 'h4', attrs: { level: 4 } },
+                { tag: 'h5', attrs: { level: 5 } },
+                { tag: 'h6', attrs: { level: 6 } },
+            ],
+            toDOM(node) {
+                return ['h' + node.attrs.level, 0];
+            },
+        };
+    }
+    getInputRules(type) {
+        /// Given a node type and a maximum level, creates an input rule that
+        /// turns up to that number of `#` characters followed by a space at
+        /// the start of a textblock into a heading whose level corresponds to
+        /// the number of `#` signs.
+        return [
+            textblockTypeInputRule(new RegExp('^(#{1,' + maxLevel + '})\\s$'), type, (match) => ({ level: match[1].length })),
+        ];
+    }
+    getCommandFactories(editor, type) {
+        const commands = {};
+        for (let i = 1; i <= maxLevel; i++) {
+            commands['setHeading' + i] = () => editor.commandFactories.setBlockType(type, { level: i });
+        }
+        return commands;
+    }
+    getKeyboardShortcuts() {
+        const keys = {};
+        for (let i = 1; i <= maxLevel; i++) {
+            keys['Shift-Ctrl-' + i] = 'setHeading' + i;
+        }
+        return keys;
+    }
+}

package/esm/NodeHorizontalRule.d.ts

@@ -0,0 +1,11 @@
+import type { NodeSpec, NodeType } from 'prosemirror-model';
+import { type CoreEditor, Node } from '@kerebron/editor';
+import type { CommandFactories, CommandShortcuts } from '@kerebron/editor/commands';
+export declare class NodeHorizontalRule extends Node {
+    name: string;
+    requires: string[];
+    getNodeSpec(): NodeSpec;
+    getCommandFactories(editor: CoreEditor, type: NodeType): Partial<CommandFactories>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+}
+//# sourceMappingURL=NodeHorizontalRule.d.ts.map

package/esm/NodeHorizontalRule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeHorizontalRule.d.ts","sourceRoot":"","sources":["../src/NodeHorizontalRule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAE,KAAK,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,kBAAmB,SAAQ,IAAI;IACjC,IAAI,SAAQ;IACrB,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;IAUvB,mBAAmB,CAC1B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC;IAanB,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAK3D"}

package/esm/NodeHorizontalRule.js

@@ -0,0 +1,29 @@
+import { Node } from '@kerebron/editor';
+export class NodeHorizontalRule extends Node {
+    name = 'hr';
+    requires = ['doc'];
+    getNodeSpec() {
+        return {
+            group: 'block',
+            parseDOM: [{ tag: 'hr' }],
+            toDOM() {
+                return ['hr'];
+            },
+        };
+    }
+    getCommandFactories(editor, type) {
+        return {
+            'setHorizontalRule': () => (state, dispatch) => {
+                if (dispatch) {
+                    dispatch(state.tr.replaceSelectionWith(type.create()).scrollIntoView());
+                }
+                return true;
+            },
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Mod-_': 'setHorizontalRule',
+        };
+    }
+}

package/esm/NodeImage.d.ts

@@ -0,0 +1,8 @@
+import { type NodeSpec } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+export declare class NodeImage extends Node {
+    name: string;
+    requires: string[];
+    getNodeSpec(): NodeSpec;
+}
+//# sourceMappingURL=NodeImage.d.ts.map

package/esm/NodeImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeImage.d.ts","sourceRoot":"","sources":["../src/NodeImage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,qBAAa,SAAU,SAAQ,IAAI;IACxB,IAAI,SAAW;IACxB,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;CA4BjC"}

package/esm/NodeImage.js

@@ -0,0 +1,33 @@
+import { Node } from '@kerebron/editor';
+export class NodeImage extends Node {
+    name = 'image';
+    requires = ['doc'];
+    getNodeSpec() {
+        return {
+            inline: true,
+            attrs: {
+                src: {},
+                alt: { default: null },
+                title: { default: null },
+            },
+            group: 'inline',
+            draggable: true,
+            parseDOM: [
+                {
+                    tag: 'img[src]',
+                    getAttrs(dom) {
+                        return {
+                            src: dom.getAttribute('src'),
+                            title: dom.getAttribute('title'),
+                            alt: dom.getAttribute('alt'),
+                        };
+                    },
+                },
+            ],
+            toDOM(node) {
+                const { src, alt, title } = node.attrs;
+                return ['img', { src, alt, title }];
+            },
+        };
+    }
+}

package/esm/NodeInlineShortCode.d.ts

@@ -0,0 +1,11 @@
+import { NodeSpec, NodeType } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+import { type InputRule } from '@kerebron/editor/plugins/input-rules';
+export declare function fixCharacters(text: string): string;
+export declare class NodeInlineShortCode extends Node {
+    name: string;
+    requires: string[];
+    getNodeSpec(): NodeSpec;
+    getInputRules(type: NodeType): InputRule[];
+}
+//# sourceMappingURL=NodeInlineShortCode.d.ts.map

package/esm/NodeInlineShortCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeInlineShortCode.d.ts","sourceRoot":"","sources":["../src/NodeInlineShortCode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EACL,KAAK,SAAS,EAIf,MAAM,sCAAsC,CAAC;AAE9C,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,UASzC;AAED,qBAAa,mBAAoB,SAAQ,IAAI;IAClC,IAAI,SAAsB;IACnC,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;IAgBvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;CAcpD"}

package/esm/NodeInlineShortCode.js

@@ -0,0 +1,39 @@
+import { Node } from '@kerebron/editor';
+import { replaceInlineNode, } from '@kerebron/editor/plugins/input-rules';
+export function fixCharacters(text) {
+    return text
+        .replace(/’/g, "'")
+        .replace(/“/g, '"')
+        .replace(/”/g, '"')
+        // deno-lint-ignore no-control-regex
+        .replace(/\x0b/g, ' ')
+        .replace(/\u201d/g, '"')
+        .replace(/\u201c/g, '"');
+}
+export class NodeInlineShortCode extends Node {
+    name = 'shortcode-inline';
+    requires = ['doc'];
+    getNodeSpec() {
+        return {
+            inline: true,
+            group: 'inline',
+            selectable: true,
+            attrs: {
+                content: {},
+            },
+            atom: true,
+            parseDOM: [{ tag: 'span.kb-shortcode-inline' }],
+            toDOM(node) {
+                return ['span', { class: 'kb-shortcode-inline' }, node.attrs.content];
+            },
+        };
+    }
+    getInputRules(type) {
+        return [
+            replaceInlineNode(/\{\{[^}]+\}\}/, type, (match) => {
+                const content = fixCharacters(match[0].substring(2, match[0].length - 2));
+                return { content };
+            }),
+        ];
+    }
+}

package/esm/NodeListItem.d.ts

@@ -0,0 +1,14 @@
+import { type Attrs, NodeSpec, type NodeType } from 'prosemirror-model';
+import { type CoreEditor, Node } from '@kerebron/editor';
+import { type Command, type CommandFactories, type CommandShortcuts } from '@kerebron/editor/commands';
+export declare function splitListItem(itemType: NodeType, itemAttrs?: Attrs): Command;
+export declare function liftListItem(itemType: NodeType): Command;
+export declare function sinkListItem(itemType: NodeType): Command;
+export declare class NodeListItem extends Node {
+    name: string;
+    requires: string[];
+    getNodeSpec(): NodeSpec;
+    getCommandFactories(editor: CoreEditor, type: NodeType): Partial<CommandFactories>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+}
+//# sourceMappingURL=NodeListItem.d.ts.map

package/esm/NodeListItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeListItem.d.ts","sourceRoot":"","sources":["../src/NodeListItem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,KAAK,EAGV,QAAQ,EACR,KAAK,QAAQ,EAEd,MAAM,mBAAmB,CAAC;AAO3B,OAAO,EAAE,KAAK,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,2BAA2B,CAAC;AAUnC,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,KAAK,GAAG,OAAO,CAsE5E;AAwBD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAgBxD;AAuGD,wBAAgB,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CA0CxD;AAED,qBAAa,YAAa,SAAQ,IAAI;IAC3B,IAAI,SAAe;IAC5B,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;IAWvB,mBAAmB,CAC1B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC;IAQnB,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAO3D"}

package/esm/NodeListItem.js

@@ -0,0 +1,201 @@
+import { Fragment, NodeRange, Slice, } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+import { Node } from '@kerebron/editor';
+import { canJoin, canSplit, liftTarget, ReplaceAroundStep, } from 'prosemirror-transform';
+/// Build a command that splits a non-empty textblock at the top level
+/// of a list item by also splitting that list item.
+export function splitListItem(itemType, itemAttrs) {
+    const cmd = function (state, dispatch) {
+        const { $from, $to, node } = state.selection;
+        if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to)) {
+            return false;
+        }
+        const grandParent = $from.node(-1);
+        if (grandParent.type != itemType)
+            return false;
+        if ($from.parent.content.size == 0 &&
+            $from.node(-1).childCount == $from.indexAfter(-1)) {
+            // In an empty block. If this is a nested list, the wrapping
+            // list item should be split. Otherwise, bail out and let next
+            // command handle lifting.
+            if ($from.depth == 3 || $from.node(-3).type != itemType ||
+                $from.index(-2) != $from.node(-2).childCount - 1)
+                return false;
+            if (dispatch) {
+                let wrap = Fragment.empty;
+                const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3;
+                // Build a fragment containing empty versions of the structure
+                // from the outer list item to the parent node of the cursor
+                for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d--) {
+                    wrap = Fragment.from($from.node(d).copy(wrap));
+                }
+                let depthAfter = $from.indexAfter(-1) < $from.node(-2).childCount
+                    ? 1
+                    : $from.indexAfter(-2) < $from.node(-3).childCount
+                        ? 2
+                        : 3;
+                // Add a second list item with an empty default start node
+                wrap = wrap.append(Fragment.from(itemType.createAndFill()));
+                let start = $from.before($from.depth - (depthBefore - 1));
+                let tr = state.tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0));
+                let sel = -1;
+                tr.doc.nodesBetween(start, tr.doc.content.size, (node, pos) => {
+                    if (sel > -1)
+                        return false;
+                    if (node.isTextblock && node.content.size == 0)
+                        sel = pos + 1;
+                });
+                if (sel > -1)
+                    tr.setSelection(Selection.near(tr.doc.resolve(sel)));
+                dispatch(tr.scrollIntoView());
+            }
+            return true;
+        }
+        let nextType = $to.pos == $from.end()
+            ? grandParent.contentMatchAt(0).defaultType
+            : null;
+        let tr = state.tr.delete($from.pos, $to.pos);
+        let types = nextType
+            ? [itemAttrs ? { type: itemType, attrs: itemAttrs } : null, {
+                    type: nextType,
+                }]
+            : undefined;
+        if (!canSplit(tr.doc, $from.pos, 2, types))
+            return false;
+        if (dispatch)
+            dispatch(tr.split($from.pos, 2, types).scrollIntoView());
+        return true;
+    };
+    cmd.displayName = `splitListItem(${itemType.name})`;
+    return cmd;
+}
+/// Acts like [`splitListItem`](#schema-list.splitListItem), but
+/// without resetting the set of active marks at the cursor.
+function splitListItemKeepMarks(itemType, itemAttrs) {
+    let split = splitListItem(itemType, itemAttrs);
+    return (state, dispatch) => {
+        return split(state, dispatch && ((tr) => {
+            let marks = state.storedMarks ||
+                (state.selection.$to.parentOffset && state.selection.$from.marks());
+            if (marks)
+                tr.ensureMarks(marks);
+            dispatch(tr);
+        }));
+    };
+}
+/// Create a command to lift the list item around the selection up into
+/// a wrapping list.
+export function liftListItem(itemType) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to, (node) => node.childCount > 0 && node.firstChild.type == itemType);
+        if (!range)
+            return false;
+        if (!dispatch)
+            return true;
+        if ($from.node(range.depth - 1).type == itemType) { // Inside a parent list
+            return liftToOuterList(state, dispatch, itemType, range);
+        } // Outer list node
+        else {
+            return liftOutOfList(state, dispatch, range);
+        }
+    };
+}
+function liftToOuterList(state, dispatch, itemType, range) {
+    let tr = state.tr, end = range.end, endOfList = range.$to.end(range.depth);
+    if (end < endOfList) {
+        // There are siblings after the lifted items, which must become
+        // children of the last item
+        tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new Slice(Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true));
+        range = new NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
+    }
+    const target = liftTarget(range);
+    if (target == null)
+        return false;
+    tr.lift(range, target);
+    let $after = tr.doc.resolve(tr.mapping.map(end, -1) - 1);
+    if (canJoin(tr.doc, $after.pos) &&
+        $after.nodeBefore.type == $after.nodeAfter.type)
+        tr.join($after.pos);
+    dispatch(tr.scrollIntoView());
+    return true;
+}
+function liftOutOfList(state, dispatch, range) {
+    let tr = state.tr, list = range.parent;
+    // Merge the list items into a single big item
+    for (let pos = range.end, i = range.endIndex - 1, e = range.startIndex; i > e; i--) {
+        pos -= list.child(i).nodeSize;
+        tr.delete(pos - 1, pos + 1);
+    }
+    let $start = tr.doc.resolve(range.start), item = $start.nodeAfter;
+    if (tr.mapping.map(range.end) != range.start + $start.nodeAfter.nodeSize) {
+        return false;
+    }
+    let atStart = range.startIndex == 0, atEnd = range.endIndex == list.childCount;
+    let parent = $start.node(-1), indexBefore = $start.index(-1);
+    if (!parent.canReplace(indexBefore + (atStart ? 0 : 1), indexBefore + 1, item.content.append(atEnd ? Fragment.empty : Fragment.from(list)))) {
+        return false;
+    }
+    let start = $start.pos, end = start + item.nodeSize;
+    // Strip off the surrounding list. At the sides where we're not at
+    // the end of the list, the existing list is closed. At sides where
+    // this is the end, it is overwritten to its end.
+    tr.step(new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new Slice((atStart ? Fragment.empty : Fragment.from(list.copy(Fragment.empty)))
+        .append(atEnd ? Fragment.empty : Fragment.from(list.copy(Fragment.empty))), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1));
+    dispatch(tr.scrollIntoView());
+    return true;
+}
+/// Create a command to sink the list item around the selection down
+/// into an inner list.
+export function sinkListItem(itemType) {
+    return function (state, dispatch) {
+        const { $from, $to } = state.selection;
+        const range = $from.blockRange($to, (node) => node.childCount > 0 && node.firstChild.type == itemType);
+        if (!range)
+            return false;
+        const startIndex = range.startIndex;
+        if (startIndex == 0)
+            return false;
+        const parent = range.parent, nodeBefore = parent.child(startIndex - 1);
+        if (nodeBefore.type != itemType)
+            return false;
+        if (dispatch) {
+            const nestedBefore = nodeBefore.lastChild &&
+                nodeBefore.lastChild.type == parent.type;
+            const inner = Fragment.from(nestedBefore ? itemType.create() : null);
+            const slice = new Slice(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
+            const before = range.start, after = range.end;
+            dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true))
+                .scrollIntoView());
+        }
+        return true;
+    };
+}
+export class NodeListItem extends Node {
+    name = 'list_item';
+    requires = ['doc'];
+    getNodeSpec() {
+        return {
+            content: 'paragraph block*',
+            parseDOM: [{ tag: 'li' }],
+            defining: true,
+            toDOM() {
+                return ['li', 0];
+            },
+        };
+    }
+    getCommandFactories(editor, type) {
+        return {
+            'splitListItem': () => splitListItem(type),
+            'liftListItem': () => liftListItem(type),
+            'sinkListItem': () => sinkListItem(type),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Enter': 'splitListItem',
+            'Tab': 'sinkListItem',
+            'Shift-Tab': 'liftListItem',
+        };
+    }
+}

package/esm/NodeMath.d.ts

@@ -0,0 +1,8 @@
+import { type NodeSpec } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+export declare class NodeMath extends Node {
+    name: string;
+    requires: string[];
+    getNodeSpec(): NodeSpec;
+}
+//# sourceMappingURL=NodeMath.d.ts.map

package/esm/NodeMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeMath.d.ts","sourceRoot":"","sources":["../src/NodeMath.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAMxC,qBAAa,QAAS,SAAQ,IAAI;IACvB,IAAI,SAAU;IACvB,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;CA8CjC"}

package/esm/NodeMath.js

@@ -0,0 +1,99 @@
+import { Node } from '@kerebron/editor';
+// import { MathMLToLaTeX } from 'mathml-to-latex';
+// const latex = MathMLToLaTeX.convert(mathMl);
+// https://mathlive.io/mathfield/
+export class NodeMath extends Node {
+    name = 'math';
+    requires = ['doc'];
+    getNodeSpec() {
+        return {
+            inline: true,
+            attrs: {
+                lang: { default: 'mathml' },
+                content: {},
+            },
+            group: 'inline',
+            draggable: true,
+            // parseDOM: [
+            //   {
+            //     tag: 'math',
+            //     getAttrs(dom: HTMLElement) {
+            //       return {
+            //         content: dom.outerHTML,
+            //       };
+            //     },
+            //   },
+            // ],
+            parseDOM: [{
+                    tag: 'math',
+                    getAttrs: (dom) => ({
+                        lang: 'mathml',
+                        content: new XMLSerializer().serializeToString(dom),
+                    }),
+                }],
+            toDOM(node) {
+                const parser = new DOMParser();
+                const parsed = parser.parseFromString(node.attrs.content, 'application/xml');
+                // Check for parsing errors (e.g., invalid XML)
+                const errorNode = parsed.getElementsByTagName('parsererror');
+                if (errorNode.length > 0) {
+                    return ['span', { class: 'mathml-error' }, 'Invalid MathML'];
+                }
+                // Import and return the parsed MathML element
+                return document.importNode(parsed.documentElement, true);
+                // const { xml } = node.attrs;
+                // return ['math', {}, []];
+            },
+        };
+    }
+}
+/*
+MathML vs. LaTeX: Which is Better for Web Math Equations?
+Neither is universally "better"—it depends on your goals (authoring, rendering, accessibility, or storage). MathML and LaTeX serve different primary purposes but can complement each other on the web (e.g., via converters like MathJax). Here's a comparison focused on web use:
+Key Differences
+
+Purpose:
+
+LaTeX: A human-readable markup language for typesetting math (e.g., $E=mc^2$). It's concise and widely used for authoring documents, papers, and web input. Not native to HTML; requires a processor (e.g., MathJax, KaTeX) to render as HTML/CSS/SVG.
+MathML: An XML-based standard (part of HTML5) for describing math structure and presentation (Presentation MathML for visuals; Content MathML for semantics). Designed for direct embedding in web pages (e.g., <math><mi>E</mi>=<mi>m</mi><msup><mi>c</mi><mn>2</mn></msup></math>). Browsers like Firefox and Safari support it natively; others need polyfills.
+
+
+Ease of Authoring:
+
+LaTeX: Wins for humans—shorter, intuitive syntax familiar to mathematicians. Easier to write/edit manually or in editors like Overleaf. Verbose MathML is painful for hand-coding complex equations.
+MathML: Better for programmatic generation (e.g., from tools or APIs) due to its structured XML. Use WYSIWYG editors (like those above) to avoid writing tags.
+
+
+Rendering on Web:
+
+LaTeX: Requires a JS library (MathJax ~300KB, KaTeX lighter ~100KB) for cross-browser display. Renders beautifully everywhere but adds load time and JS dependency. No native browser support.
+MathML: Native in Firefox/Safari (fast, no JS). Improving in Chrome/Edge (as of 2023+), but still needs MathJax fallback for full support. Outputs scalable HTML/CSS without images.
+
+
+Accessibility:
+
+MathML: Superior—semantic structure allows screen readers (e.g., NVDA with MathCAT, JAWS) to read equations meaningfully (e.g., "E equals m times c squared"). Essential for WCAG/ADA compliance.
+LaTeX: Poor native accessibility; screen readers treat it as plain text. MathJax can convert to MathML internally for better support, but raw LaTeX fails.
+
+
+Performance & Compatibility:
+
+LaTeX: Faster authoring, but rendering depends on the library. Universal via JS, but increases page weight.
+MathML: Lightweight native rendering where supported; more robust for search engines/parsing (e.g., Google indexes MathML). Less portable outside web (LaTeX dominates PDFs/print).
+
+
+Storage/Interoperability:
+
+LaTeX: Compact for databases/files. Easy to convert to MathML (via tools like texmath or Pandoc).
+MathML: Better for web standards (XML parsable), but bulkier. Ideal for exchange between math tools.
+
+
+
+Recommendation
+
+Use LaTeX if your focus is easy input/authoring (e.g., users typing equations) and you're okay with a renderer like MathJax. It's more practical for most web projects today due to familiarity and tools. Store as LaTeX, render via JS, and convert to MathML for accessibility if needed.
+Use MathML if prioritizing native web standards, accessibility, or programmatic output (e.g., from editors). It's "better" for semantic web math and future-proofing (browser support is growing), but pair with LaTeX input for usability.
+Hybrid Approach: Best for web—author in LaTeX, convert/output MathML for display/storage. Libraries like MathJax handle both seamlessly (input LaTeX, output rendered MathML). This gives LaTeX's simplicity with MathML's benefits.
+
+If accessibility is key, always generate MathML (even from LaTeX source). Test in browsers: LaTeX+MathJax works everywhere; pure MathML shines in Firefox but needs fallbacks elsewhere.
+*/

package/esm/NodeOrderedList.d.ts

@@ -0,0 +1,23 @@
+import { NodeSpec, NodeType } from 'prosemirror-model';
+import { type CoreEditor, Node } from '@kerebron/editor';
+import { type InputRule } from '@kerebron/editor/plugins/input-rules';
+import { type CommandFactories, type CommandShortcuts } from '@kerebron/editor/commands';
+export declare class NodeOrderedList extends Node {
+    name: string;
+    requires: string[];
+    attributes: {
+        type: {
+            default: string;
+            fromDom(element: HTMLElement): any;
+        };
+        start: {
+            default: number;
+            fromDom(element: HTMLElement): number;
+        };
+    };
+    getNodeSpec(): NodeSpec;
+    getInputRules(type: NodeType): InputRule[];
+    getCommandFactories(editor: CoreEditor, type: NodeType): Partial<CommandFactories>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+}
+//# sourceMappingURL=NodeOrderedList.d.ts.map

package/esm/NodeOrderedList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeOrderedList.d.ts","sourceRoot":"","sources":["../src/NodeOrderedList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,KAAK,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAMzD,OAAO,EACL,KAAK,SAAS,EAEf,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACtB,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,eAAgB,SAAQ,IAAI;IAC9B,IAAI,SAAkB;IAC/B,QAAQ,WAAW;IAEV,UAAU;;;6BAGE,WAAW;;;;6BAQX,WAAW;;MAM9B;IAEO,WAAW,IAAI,QAAQ;IAWvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAa1C,mBAAmB,CAC1B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,QAAQ,GACb,OAAO,CAAC,gBAAgB,CAAC;IAMnB,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAK3D"}