@kerebron/extension-basic-editor 0.0.1

package/esm/NodeImage.d.ts

@@ -0,0 +1,25 @@
+import { type Node as PmNode, type NodeSpec } from 'prosemirror-model';
+import { Node } from '@kerebron/editor';
+import { BlockMarker } from '@kerebron/extension-automerge';
+export declare class NodeImage extends Node {
+    name: string;
+    requires: string[];
+    automerge: {
+        block: string;
+        isEmbed: boolean;
+        attrParsers: {
+            fromAutomerge: (block: BlockMarker) => {
+                src: any;
+                alt: any;
+                title: any;
+            };
+            fromProsemirror: (node: PmNode) => {
+                src: any;
+                alt: any;
+                title: any;
+            };
+        };
+    };
+    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,IAAI,IAAI,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGxC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAE5D,qBAAa,SAAU,SAAQ,IAAI;IACxB,IAAI,SAAW;IACxB,QAAQ,WAAW;IAEnB,SAAS;;;;mCAIkB,WAAW;;;;;oCAKV,MAAM;;;;;;MAMhC;IAEO,WAAW,IAAI,QAAQ;CA4BjC"}

package/esm/NodeImage.js

@@ -0,0 +1,68 @@
+import { Node } from '@kerebron/editor';
+import { next as automerge } from '@automerge/automerge/slim';
+export class NodeImage extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'image'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                block: 'image',
+                isEmbed: true,
+                attrParsers: {
+                    fromAutomerge: (block) => ({
+                        src: block.attrs.src?.toString() || null,
+                        alt: block.attrs.alt,
+                        title: block.attrs.title,
+                    }),
+                    fromProsemirror: (node) => ({
+                        src: new automerge.RawString(node.attrs.src),
+                        alt: node.attrs.alt,
+                        title: node.attrs.title,
+                    }),
+                },
+            }
+        });
+    }
+    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/NodeListItem.d.ts

@@ -0,0 +1,13 @@
+import { type CoreEditor, Node } from '@kerebron/editor';
+import { type Commands, type CommandShortcuts } from '@kerebron/editor/commands';
+export declare class NodeListItem extends Node {
+    name: string;
+    requires: string[];
+    automerge: {
+        block: string;
+    };
+    getNodeSpec(): NodeSpec;
+    getCommands(editor: CoreEditor, type: NodeType): Partial<Commands>;
+    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,EAAE,KAAK,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EAEtB,MAAM,2BAA2B,CAAC;AA8PnC,qBAAa,YAAa,SAAQ,IAAI;IAC3B,IAAI,SAAe;IAC5B,QAAQ,WAAW;IAEnB,SAAS;;MAEP;IAEO,WAAW,IAAI,QAAQ;IAWhC,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAQlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAOlD"}

package/esm/NodeListItem.js

@@ -0,0 +1,217 @@
+import { Node } from '@kerebron/editor';
+/// Build a command that splits a non-empty textblock at the top level
+/// of a list item by also splitting that list item.
+function splitListItem(itemType, itemAttrs) {
+    return 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;
+    };
+}
+/// 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.
+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.
+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 {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'list_item'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                block: 'list_item',
+            }
+        });
+    }
+    getNodeSpec() {
+        return {
+            content: 'paragraph block*',
+            parseDOM: [{ tag: 'li' }],
+            defining: true,
+            toDOM() {
+                return ['li', 0];
+            },
+        };
+    }
+    getCommands(editor, type) {
+        return {
+            'splitListItem': () => splitListItem(type),
+            'liftListItem': () => liftListItem(type),
+            'sinkListItem': () => sinkListItem(type),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            // 'Enter': 'splitListItem',
+            'Mod-[': 'liftListItem',
+            'Mod-]': 'sinkListItem',
+        };
+    }
+}

package/esm/NodeOrderedList.d.ts

@@ -0,0 +1,22 @@
+import { NodeSpec, NodeType } from 'prosemirror-model';
+import { CoreEditor, Node } from '@kerebron/editor';
+import { type InputRule } from '@kerebron/editor/plugins/input-rules';
+import { type Commands, type CommandShortcuts } from '@kerebron/editor/commands';
+export declare class NodeOrderedList extends Node {
+    name: string;
+    requires: string[];
+    attributes: {
+        start: {
+            default: number;
+            fromDom(element: HTMLElement): number;
+        };
+    };
+    getNodeSpec(): NodeSpec;
+    getInputRules(type: NodeType): InputRule[];
+    getCommands(editor: CoreEditor, type: NodeType): Partial<Commands>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+    automerge: {
+        block: string;
+    };
+}
+//# 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,UAAU,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGpD,OAAO,EACL,KAAK,SAAS,EAEf,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EAEtB,MAAM,2BAA2B,CAAC;AAGnC,qBAAa,eAAgB,SAAQ,IAAI;IAC9B,IAAI,SAAkB;IAC/B,QAAQ,WAAW;IAEnB,UAAU;;;6BAGW,WAAW;;MAM9B;IAEO,WAAW,IAAI,QAAQ;IAWvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAa1C,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAM1D,SAAS;;MAEP;CACH"}

package/esm/NodeOrderedList.js

@@ -0,0 +1,72 @@
+import { Node } from '@kerebron/editor';
+import { getHtmlAttributes } from '@kerebron/editor/utilities';
+import { wrappingInputRule, } from '@kerebron/editor/plugins/input-rules';
+import { wrapInList, } from '@kerebron/editor/commands';
+import { setHtmlAttributes } from '@kerebron/editor/utilities';
+export class NodeOrderedList extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'ordered_list'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "attributes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                start: {
+                    default: 1,
+                    fromDom(element) {
+                        return element.hasAttribute('start')
+                            ? +element.getAttribute('start')
+                            : 1;
+                    },
+                },
+            }
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                block: 'ordered_list',
+            }
+        });
+    }
+    getNodeSpec() {
+        return {
+            group: 'block',
+            content: 'list_item+',
+            parseDOM: [
+                { tag: 'ol', getAttrs: (element) => setHtmlAttributes(this, element) },
+            ],
+            toDOM: (node) => ['ol', getHtmlAttributes(this, node), 0],
+        };
+    }
+    getInputRules(type) {
+        return [
+            /// Given a list node type, returns an input rule that turns a number
+            /// followed by a dot at the start of a textblock into an ordered list.
+            wrappingInputRule(/^(\d+)\.\s$/, type, (match) => ({ order: +match[1] }), (match, node) => node.childCount + node.attrs.order == +match[1]),
+        ];
+    }
+    getCommands(editor, type) {
+        return {
+            'toggleOrderedList': () => wrapInList(type),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Shift-Ctrl-9': 'toggleOrderedList',
+        };
+    }
+}

package/esm/NodeParagraph.d.ts

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

package/esm/NodeParagraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeParagraph.d.ts","sourceRoot":"","sources":["../src/NodeParagraph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACjE,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,SAAe;IAC5B,QAAQ,WAAW;IAEnB,SAAS;;MAEP;IAEO,WAAW,IAAI,QAAQ;IAWvB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAMlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAK3D"}

package/esm/NodeParagraph.js

@@ -0,0 +1,47 @@
+import { Node } from '@kerebron/editor';
+import { setBlockType, } from '@kerebron/editor/commands';
+export class NodeParagraph extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'paragraph'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+        Object.defineProperty(this, "automerge", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {
+                block: 'paragraph',
+            }
+        });
+    }
+    getNodeSpec() {
+        return {
+            content: 'inline*',
+            group: 'block',
+            parseDOM: [{ tag: 'p' }],
+            toDOM() {
+                return ['p', 0];
+            },
+        };
+    }
+    getCommands(editor, type) {
+        return {
+            'setParagraph': () => setBlockType(type),
+        };
+    }
+    getKeyboardShortcuts() {
+        return {
+            'Shift-Ctrl-0': 'setParagraph',
+        };
+    }
+}

package/esm/NodeText.d.ts

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

package/esm/NodeText.d.ts.map

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

package/esm/NodeText.js

@@ -0,0 +1,23 @@
+import { Node } from '@kerebron/editor';
+export class NodeText extends Node {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'text'
+        });
+        Object.defineProperty(this, "requires", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ['doc']
+        });
+    }
+    getNodeSpec() {
+        return {
+            group: 'inline',
+        };
+    }
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@kerebron/extension-basic-editor",
+  "version": "0.0.1",
+  "license": "MIT",
+  "module": "./esm/ExtensionBasicEditor.js",
+  "exports": {
+    ".": {
+      "import": "./esm/ExtensionBasicEditor.js"
+    },
+    "./ExtensionBaseKeymap": {
+      "import": "./esm/ExtensionBaseKeymap.js"
+    },
+    "./ExtensionHistory": {
+      "import": "./esm/ExtensionHistory.js"
+    },
+    "./ExtensionDropcursor": {
+      "import": "./esm/ExtensionDropcursor.js"
+    },
+    "./ExtensionGapcursor": {
+      "import": "./esm/ExtensionGapcursor.js"
+    },
+    "./NodeDocument": {
+      "import": "./esm/NodeDocument.js"
+    },
+    "./NodeText": {
+      "import": "./esm/NodeText.js"
+    },
+    "./NodeParagraph": {
+      "import": "./esm/NodeParagraph.js"
+    },
+    "./NodeHardBreak": {
+      "import": "./esm/NodeHardBreak.js"
+    },
+    "./NodeHorizontalRule": {
+      "import": "./esm/NodeHorizontalRule.js"
+    },
+    "./NodeOrderedList": {
+      "import": "./esm/NodeOrderedList.js"
+    },
+    "./NodeBulletList": {
+      "import": "./esm/NodeBulletList.js"
+    },
+    "./NodeListItem": {
+      "import": "./esm/NodeListItem.js"
+    },
+    "./NodeImage": {
+      "import": "./esm/NodeImage.js"
+    },
+    "./NodeBlockquote": {
+      "import": "./esm/NodeBlockquote.js"
+    },
+    "./NodeAside": {
+      "import": "./esm/NodeAside.js"
+    },
+    "./NodeHeading": {
+      "import": "./esm/NodeHeading.js"
+    },
+    "./MarkCode": {
+      "import": "./esm/MarkCode.js"
+    },
+    "./MarkLink": {
+      "import": "./esm/MarkLink.js"
+    },
+    "./MarkItalic": {
+      "import": "./esm/MarkItalic.js"
+    },
+    "./MarkStrong": {
+      "import": "./esm/MarkStrong.js"
+    },
+    "./MarkUnderline": {
+      "import": "./esm/MarkUnderline.js"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@dev"
+}