@kerebron/extension-basic-editor 0.0.1

package/esm/MarkStrong.js

@@ -0,0 +1,60 @@
+import { Mark } from '@kerebron/editor';
+import { toggleMark, } from '@kerebron/editor/commands';
+export class MarkStrong extends Mark {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'strong'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                markName: 'strong',
+            }
+        });
+    }
+    getMarkSpec() {
+        return {
+            parseDOM: [
+                { tag: 'strong' },
+                // This works around a Google Docs misbehavior where
+                // pasted content will be inexplicably wrapped in `<b>`
+                // tags with a font-weight normal.
+                {
+                    tag: 'b',
+                    getAttrs: (node) => node.style.fontWeight != 'normal' && null,
+                },
+                { style: 'font-weight=400', clearMark: (m) => m.type.name == 'strong' },
+                {
+                    style: 'font-weight',
+                    getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null,
+                },
+            ],
+            toDOM() {
+                return ['strong', 0];
+            },
+        };
+    }
+    getCommands(editor, type) {
+        return {
+            'toggleStrong': () => toggleMark(type),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Mod-b': 'toggleStrong',
+            'Mod-B': 'toggleStrong',
+        };
+    }
+}

package/esm/MarkUnderline.d.ts

@@ -0,0 +1,13 @@
+import { CoreEditor, Mark } from '@kerebron/editor';
+import { Commands, CommandShortcuts } from '@kerebron/editor/commands';
+export declare class MarkUnderline extends Mark {
+    name: string;
+    requires: string[];
+    automerge: {
+        markName: string;
+    };
+    getMarkSpec(): MarkSpec;
+    getCommands(editor: CoreEditor, type: MarkType): Partial<Commands>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+}
+//# sourceMappingURL=MarkUnderline.d.ts.map

package/esm/MarkUnderline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkUnderline.d.ts","sourceRoot":"","sources":["../src/MarkUnderline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EACL,QAAQ,EACR,gBAAgB,EAEjB,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,aAAc,SAAQ,IAAI;IAC5B,IAAI,SAAe;IAC5B,QAAQ,WAAW;IAEnB,SAAS;;MAEP;IAEF,WAAW,IAAI,QAAQ;IAoBvB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAMlD"}

package/esm/MarkUnderline.js

@@ -0,0 +1,55 @@
+import { Mark } from '@kerebron/editor';
+import { toggleMark, } from '@kerebron/editor/commands';
+export class MarkUnderline extends Mark {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'underline'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                markName: 'u',
+            }
+        });
+    }
+    getMarkSpec() {
+        return {
+            parseDOM: [
+                {
+                    tag: 'u',
+                },
+                {
+                    style: 'text-decoration',
+                    consuming: false,
+                    getAttrs: (style) => (style.includes('underline') ? {} : false),
+                },
+            ],
+            toDOM() {
+                return ['u', 0];
+            },
+        };
+    }
+    getCommands(editor, type) {
+        return {
+            'toggleUnderline': () => toggleMark(type),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Mod-u': 'toggleUnderline',
+            'Mod-U': 'toggleUnderline',
+        };
+    }
+}

package/esm/NodeAside.d.ts

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

package/esm/NodeAside.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeAside.d.ts","sourceRoot":"","sources":["../src/NodeAside.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,qBAAa,SAAU,SAAQ,IAAI;IACxB,IAAI,SAAW;IACxB,QAAQ,WAAW;IAEnB,SAAS;;MAEP;IAEO,WAAW,IAAI,QAAQ;CAWjC"}

package/esm/NodeAside.js

@@ -0,0 +1,37 @@
+import { Node } from '@kerebron/editor';
+export class NodeAside extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'aside'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                block: 'aside',
+            }
+        });
+    }
+    getNodeSpec() {
+        return {
+            content: 'block+',
+            group: 'block',
+            defining: true,
+            parseDOM: [{ tag: 'aside' }],
+            toDOM() {
+                return ['aside', 0];
+            },
+        };
+    }
+}

package/esm/NodeBlockquote.d.ts

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

package/esm/NodeBlockquote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeBlockquote.d.ts","sourceRoot":"","sources":["../src/NodeBlockquote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EAEtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,SAAS,EAEV,MAAM,sCAAsC,CAAC;AAE9C,qBAAa,cAAe,SAAQ,IAAI;IAC7B,IAAI,SAAgB;IAC7B,QAAQ,WAAW;IAEnB,SAAS;;MAEP;IAEO,WAAW,IAAI,QAAQ;IAYvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAQnD,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAKlD"}

package/esm/NodeBlockquote.js

@@ -0,0 +1,56 @@
+import { Node } from '@kerebron/editor';
+import { wrapInList, } from '@kerebron/editor/commands';
+import { wrappingInputRule, } from '@kerebron/editor/plugins/input-rules';
+export class NodeBlockquote extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'blockquote'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                block: 'blockquote',
+            }
+        });
+    }
+    getNodeSpec() {
+        return {
+            content: 'block+',
+            group: 'block',
+            defining: true,
+            parseDOM: [{ tag: 'blockquote' }],
+            toDOM() {
+                return ['blockquote', 0];
+            },
+        };
+    }
+    getInputRules(type) {
+        return [
+            /// Given a blockquote node type, returns an input rule that turns `"> "`
+            /// at the start of a textblock into a blockquote.
+            wrappingInputRule(/^\s*>\s$/, type),
+        ];
+    }
+    getCommands(editor, type) {
+        return {
+            'toggleBlockquote': () => wrapInList(type),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Ctrl->': 'toggleBlockquote',
+        };
+    }
+}

package/esm/NodeBulletList.d.ts

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

package/esm/NodeBulletList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeBulletList.d.ts","sourceRoot":"","sources":["../src/NodeBulletList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EAEtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,SAAS,EAEf,MAAM,sCAAsC,CAAC;AAE9C,qBAAa,cAAe,SAAQ,IAAI;IAC7B,IAAI,SAAiB;IAC9B,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;IAWvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IASnD,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAMjD,SAAS;;MAEP;CACH"}

package/esm/NodeBulletList.js

@@ -0,0 +1,56 @@
+import { Node } from '@kerebron/editor';
+import { wrapInList, } from '@kerebron/editor/commands';
+import { wrappingInputRule, } from '@kerebron/editor/plugins/input-rules';
+export class NodeBulletList extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'bullet_list'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                block: 'bullet_list',
+            }
+        });
+    }
+    getNodeSpec() {
+        return {
+            content: 'list_item+',
+            group: 'block',
+            parseDOM: [{ tag: 'ul' }],
+            toDOM() {
+                return ['ul', 0];
+            },
+        };
+    }
+    getInputRules(type) {
+        /// Given a list node type, returns an input rule that turns a bullet
+        /// (dash, plush, or asterisk) at the start of a textblock into a
+        /// bullet list.
+        return [
+            wrappingInputRule(/^\s*([-+*])\s$/, type),
+        ];
+    }
+    getCommands(editor, type) {
+        return {
+            'toggleBulletList': () => wrapInList(type),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Shift-Ctrl-8': 'toggleBulletList',
+        };
+    }
+}

package/esm/NodeDocument.d.ts

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

package/esm/NodeDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeDocument.d.ts","sourceRoot":"","sources":["../src/NodeDocument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAc,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,qBAAa,YAAa,SAAQ,IAAI;IAC3B,IAAI,SAAS;IAEb,WAAW,IAAI,QAAQ;CAcjC"}

package/esm/NodeDocument.js

@@ -0,0 +1,26 @@
+import { Node } from '@kerebron/editor';
+export class NodeDocument extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'doc'
+        });
+    }
+    getNodeSpec() {
+        return {
+            content: 'block+',
+            EMPTY_DOC: {
+                'type': this.name,
+                'content': [
+                    {
+                        'type': 'paragraph',
+                        'content': [],
+                    },
+                ],
+            },
+        };
+    }
+}

package/esm/NodeHardBreak.d.ts

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

package/esm/NodeHardBreak.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeHardBreak.d.ts","sourceRoot":"","sources":["../src/NodeHardBreak.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,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EAEtB,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,aAAc,SAAQ,IAAI;IAC5B,IAAI,SAAQ;IACrB,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;IAkBvB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAoDlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAiB3D"}

package/esm/NodeHardBreak.js

@@ -0,0 +1,98 @@
+import { Node } from '@kerebron/editor';
+import { exitCode, } from '@kerebron/editor/commands';
+export class NodeHardBreak extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'br'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        // TODO automerge
+    }
+    getNodeSpec() {
+        return {
+            inline: true,
+            group: 'inline',
+            selectable: false,
+            linebreakReplacement: true,
+            parseDOM: [{ tag: 'br' }],
+            toDOM() {
+                return ['br'];
+            },
+        };
+    }
+    /*if (!exitCode(view.state, view.dispatch)) return false
+    view.focus()
+    return true
+  }},*/
+    getCommands(editor, type) {
+        return {
+            // 'first': commands => first(commands),
+            'setHardBreak': () => (state, dispatch) => {
+                if (!exitCode(state, dispatch)) {
+                    return false;
+                }
+                editor.view.focus();
+                if (dispatch) {
+                    dispatch(state.tr.replaceSelectionWith(type.create()).scrollIntoView());
+                }
+                return true;
+            },
+            // const commands = editor.commands;
+            // return commands.first([
+            //     () => commands.exitCode(),
+            //     () => commands.command(() => {
+            //         const { selection, storedMarks } = state
+            //
+            //         if (selection.$from.parent.type.spec.isolating) {
+            //             return false
+            //         }
+            //
+            //         const { keepMarks } = this.options
+            //         const { splittableMarks } = editor.extensionManager
+            //         const marks = storedMarks
+            //             || (selection.$to.parentOffset && selection.$from.marks())
+            //
+            //         return chain()
+            //             .insertContent({ type: this.name })
+            //             .command(({ tr, dispatch }) => {
+            //                 if (dispatch && marks && keepMarks) {
+            //                     const filteredMarks = marks
+            //                         .filter(mark => splittableMarks.includes(mark.type.name))
+            //
+            //                     tr.ensureMarks(filteredMarks)
+            //                 }
+            //
+            //                 return true
+            //             })
+            //             .run()
+            //     }),
+            // ])
+            // chainCommands(exitCode, (state, dispatch) => {
+            //     if (dispatch) dispatch(state.tr.replaceSelectionWith(br.create()).scrollIntoView())
+            //     return true
+            // })
+        };
+    }
+    getKeyboardShortcuts() {
+        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,24 @@
+import { NodeSpec, NodeType } from 'prosemirror-model';
+import { type CoreEditor, Node } from '@kerebron/editor';
+import { type Commands, 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[];
+    automerge: {
+        block: string;
+        attrParsers: {
+            fromAutomerge: (block: any) => {
+                level: any;
+            };
+            fromProsemirror: (node: any) => {
+                level: any;
+            };
+        };
+    };
+    getNodeSpec(): NodeSpec;
+    getInputRules(type: NodeType): InputRule[];
+    getCommands(editor: CoreEditor, type: NodeType): Partial<Commands>;
+    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,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,EAAE,KAAK,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EAEtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,SAAS,EAEf,MAAM,sCAAsC,CAAC;AAI9C,qBAAa,WAAY,SAAQ,IAAI;IAC1B,IAAI,SAAa;IAC1B,QAAQ,WAAW;IAEnB,SAAS;;;;;;;;;;MAMP;IAEO,WAAW,IAAI,QAAQ;IAoBvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAc1C,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAUlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAS3D"}

package/esm/NodeHeading.js

@@ -0,0 +1,75 @@
+import { Node } from '@kerebron/editor';
+import { setBlockType, } from '@kerebron/editor/commands';
+import { textblockTypeInputRule, } from '@kerebron/editor/plugins/input-rules';
+const maxLevel = 6;
+export class NodeHeading extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'heading'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                block: 'heading',
+                attrParsers: {
+                    fromAutomerge: (block) => ({ level: block.attrs.level }),
+                    fromProsemirror: (node) => ({ level: node.attrs.level }),
+                },
+            }
+        });
+    }
+    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 })),
+        ];
+    }
+    getCommands(editor, type) {
+        const commands = {};
+        for (let i = 1; i <= maxLevel; i++) {
+            commands['setHeading' + i] = () => 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 { NodeSpec, NodeType } from 'prosemirror-model';
+import { CoreEditor, Node } from '@kerebron/editor';
+import { Commands, CommandShortcuts } from '@kerebron/editor/commands';
+export declare class NodeHorizontalRule extends Node {
+    name: string;
+    requires: string[];
+    getNodeSpec(): NodeSpec;
+    getCommands(editor: CoreEditor, type: NodeType): Partial<Commands>;
+    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,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAEvE,qBAAa,kBAAmB,SAAQ,IAAI;IACjC,IAAI,SAAQ;IACrB,QAAQ,WAAW;IAEV,WAAW,IAAI,QAAQ;IAUvB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAalE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAO3D"}

package/esm/NodeHorizontalRule.js

@@ -0,0 +1,43 @@
+import { Node } from '@kerebron/editor';
+export class NodeHorizontalRule extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'hr'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        // TODO automerge
+    }
+    getNodeSpec() {
+        return {
+            group: 'block',
+            parseDOM: [{ tag: 'hr' }],
+            toDOM() {
+                return ['hr'];
+            },
+        };
+    }
+    getCommands(editor, type) {
+        return {
+            'setHorizontalRule': () => (state, dispatch) => {
+                if (dispatch) {
+                    dispatch(state.tr.replaceSelectionWith(type.create()).scrollIntoView());
+                }
+                return true;
+            },
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Mod-_': 'setHorizontalRule',
+        };
+    }
+}