@kerebron/extension-codemirror 0.2.0 → 0.2.1

package/esm/editor/src/mod.d.ts

@@ -0,0 +1,6 @@
+export * from './CoreEditor.js';
+export * from './Extension.js';
+export * from './Mark.js';
+export * from './Node.js';
+export * from './nodeToTreeString.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/editor/src/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/editor/src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,uBAAuB,CAAC"}

package/esm/editor/src/mod.js

@@ -0,0 +1,5 @@
+export * from './CoreEditor.js';
+export * from './Extension.js';
+export * from './Mark.js';
+export * from './Node.js';
+export * from './nodeToTreeString.js';

package/esm/editor/src/nodeToTreeString.d.ts

@@ -0,0 +1,4 @@
+import { Node } from 'prosemirror-model';
+export declare function nodeToTreeString(node: Node | Node[] | readonly Node[], level?: number, currentPos?: number): string;
+export declare function debugNode(node: Node | Node[]): void;
+//# sourceMappingURL=nodeToTreeString.d.ts.map

package/esm/editor/src/nodeToTreeString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeToTreeString.d.ts","sourceRoot":"","sources":["../../../src/editor/src/nodeToTreeString.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAYzC,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,SAAS,IAAI,EAAE,EACrC,KAAK,SAAI,EACT,UAAU,SAAI,UA0Df;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,QAE5C"}

package/esm/editor/src/nodeToTreeString.js

@@ -0,0 +1,56 @@
+function trimText(str, maxLen = 20) {
+    str = str.replaceAll('\n', '\\n');
+    if (str.length <= maxLen) {
+        return str;
+    }
+    return str.slice(0, maxLen) + '...';
+}
+export function nodeToTreeString(node, level = 0, currentPos = 0) {
+    let delim = '';
+    for (let i = 0; i < level; i++) {
+        delim += '  ';
+    }
+    let output = '';
+    if (Array.isArray(node)) {
+        for (const child of node) {
+            output += delim +
+                nodeToTreeString(child, level + 1, currentPos).replace(/\s+$/gm, '') +
+                '\n';
+        }
+        return output;
+    }
+    // https://prosemirror.net/docs/guide/#doc.indexing
+    let line = '';
+    // if (node.type) {
+    line += ` - [${node.type.name}] `;
+    // } else {
+    //   line += ` - `;
+    // }
+    line += `pos: ${currentPos}, `;
+    line += `nodeSize: ${node.nodeSize}, `; // isLeaf ? 1 : 2 + this.content.size
+    line += `epos: ${currentPos + node.nodeSize}, `; // isLeaf ? 1 : 2 + this.content.size
+    if (node.content) {
+        line += `fragment.size: ${node.content.size}, `;
+    }
+    output += (delim + line) + '\n';
+    let marksLine = '';
+    if (node.marks) {
+        for (const mark of node.marks) {
+            marksLine += `(${mark.type.name}), `;
+        }
+    }
+    if (marksLine) {
+        output += (delim + '    ' + marksLine) + '\n';
+    }
+    if (node.text) {
+        output += (delim + '    "' + trimText(node.text) + '"') + '\n';
+    }
+    node.forEach((child, offset) => {
+        output +=
+            nodeToTreeString(child, level + 1, currentPos + offset + 1).replace(/\s+$/gm, '') + '\n'; // + (node.isLeaf ? 1 : 2)
+    });
+    return output;
+}
+export function debugNode(node) {
+    console.debug(nodeToTreeString(node));
+}

package/esm/editor/src/plugins/input-rules/InputRulesPlugin.d.ts

@@ -0,0 +1,23 @@
+import { Command, EditorState, Plugin, Transaction } from 'prosemirror-state';
+export declare class InputRule {
+    readonly match: RegExp;
+    handler: (state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null;
+    undoable: boolean;
+    inCode: boolean | 'only';
+    constructor(match: RegExp, handler: string | ((state: EditorState, match: RegExpMatchArray, start: number, end: number) => Transaction | null), options?: {
+        undoable?: boolean;
+        inCode?: boolean | 'only';
+    });
+}
+type PluginState = {
+    transform: Transaction;
+    from: number;
+    to: number;
+    text: string;
+} | null;
+export declare class InputRulesPlugin extends Plugin<PluginState> {
+    constructor(rules: readonly InputRule[]);
+}
+export declare const undoInputRule: Command;
+export {};
+//# sourceMappingURL=InputRulesPlugin.d.ts.map

package/esm/editor/src/plugins/input-rules/InputRulesPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputRulesPlugin.d.ts","sourceRoot":"","sources":["../../../../../src/editor/src/plugins/input-rules/InputRulesPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,WAAW,EACX,MAAM,EAEN,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAO3B,qBAAa,SAAS;IA8BlB,QAAQ,CAAC,KAAK,EAAE,MAAM;IA5BxB,OAAO,EAAE,CACP,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,KACR,WAAW,GAAG,IAAI,CAAC;IAGxB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;gBAmBd,KAAK,EAAE,MAAM,EACtB,OAAO,EACH,MAAM,GACN,CAAC,CACD,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,gBAAgB,EACvB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,KACR,WAAW,GAAG,IAAI,CAAC,EAC1B,OAAO,GAAE;QAIP,QAAQ,CAAC,EAAE,OAAO,CAAC;QAInB,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;KACtB;CAST;AA0BD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,WAAW,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,IAAI,CAAC;AAKT,qBAAa,gBAAiB,SAAQ,MAAM,CAAC,WAAW,CAAC;gBAC3C,KAAK,EAAE,SAAS,SAAS,EAAE;CAgCxC;AAsCD,eAAO,MAAM,aAAa,EAAE,OA4B3B,CAAC"}

package/esm/editor/src/plugins/input-rules/InputRulesPlugin.js

@@ -0,0 +1,163 @@
+import { Plugin, } from 'prosemirror-state';
+/// Input rules are regular expressions describing a piece of text
+/// that, when typed, causes something to happen. This might be
+/// changing two dashes into an emdash, wrapping a paragraph starting
+/// with `"> "` into a blockquote, or something entirely different.
+export class InputRule {
+    // :: (RegExp, union<string, (state: EditorState, match: [string], start: number, end: number) → ?Transaction>)
+    /// Create an input rule. The rule applies when the user typed
+    /// something and the text directly in front of the cursor matches
+    /// `match`, which should end with `$`.
+    ///
+    /// The `handler` can be a string, in which case the matched text, or
+    /// the first matched group in the regexp, is replaced by that
+    /// string.
+    ///
+    /// Or a it can be a function, which will be called with the match
+    /// array produced by
+    /// [`RegExp.exec`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec),
+    /// as well as the start and end of the matched range, and which can
+    /// return a [transaction](#state.Transaction) that describes the
+    /// rule's effect, or null to indicate the input was not handled.
+    constructor(
+    /// @internal
+    match, handler, options = {}) {
+        Object.defineProperty(this, "match", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: match
+        });
+        /// @internal
+        Object.defineProperty(this, "handler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /// @internal
+        Object.defineProperty(this, "undoable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.match = match;
+        this.handler = typeof handler == 'string'
+            ? stringHandler(handler)
+            : handler;
+        this.undoable = options.undoable !== false;
+        this.inCode = options.inCode || false;
+    }
+}
+function stringHandler(string) {
+    return function (state, match, start, end) {
+        let insert = string;
+        if (match[1]) {
+            let offset = match[0].lastIndexOf(match[1]);
+            insert += match[0].slice(offset + match[1].length);
+            start += offset;
+            let cutOff = start - end;
+            if (cutOff > 0) {
+                insert = match[0].slice(offset - cutOff, offset) + insert;
+                start = end;
+            }
+        }
+        return state.tr.insertText(insert, start, end);
+    };
+}
+const MAX_MATCH = 500;
+/// Create an input rules plugin. When enabled, it will cause text
+/// input that matches any of the given rules to trigger the rule's
+/// action.
+export class InputRulesPlugin extends Plugin {
+    constructor(rules) {
+        super({
+            state: {
+                init() {
+                    return null;
+                },
+                apply(tr, prev) {
+                    let stored = tr.getMeta(this);
+                    if (stored)
+                        return stored;
+                    return tr.selectionSet || tr.docChanged ? null : prev;
+                },
+            },
+            props: {
+                handleTextInput(view, from, to, text) {
+                    return run(view, from, to, text, rules, InputRulesPlugin);
+                },
+                handleDOMEvents: {
+                    compositionend: (view) => {
+                        setTimeout(() => {
+                            let { $cursor } = view.state.selection;
+                            if ($cursor) {
+                                run(view, $cursor.pos, $cursor.pos, '', rules, plugin);
+                            }
+                        });
+                    },
+                },
+            },
+            isInputRules: true,
+        });
+    }
+}
+function run(view, from, to, text, rules, plugin) {
+    if (view.composing)
+        return false;
+    let state = view.state, $from = state.doc.resolve(from);
+    let textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, null, '\ufffc') + text;
+    for (let i = 0; i < rules.length; i++) {
+        let rule = rules[i];
+        if ($from.parent.type.spec.code) {
+            if (!rule.inCode)
+                continue;
+        }
+        else if (rule.inCode === 'only') {
+            continue;
+        }
+        let match = rule.match.exec(textBefore);
+        let tr = match &&
+            rule.handler(state, match, from - (match[0].length - text.length), to);
+        if (!tr)
+            continue;
+        if (rule.undoable)
+            tr.setMeta(plugin, { transform: tr, from, to, text });
+        view.dispatch(tr);
+        return true;
+    }
+    return false;
+}
+/// This is a command that will undo an input rule, if applying such a
+/// rule was the last thing that the user did.
+export const undoInputRule = (state, dispatch) => {
+    let plugins = state.plugins;
+    for (let i = 0; i < plugins.length; i++) {
+        let plugin = plugins[i], undoable;
+        if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+            if (dispatch) {
+                let tr = state.tr, toUndo = undoable.transform;
+                for (let j = toUndo.steps.length - 1; j >= 0; j--) {
+                    tr.step(toUndo.steps[j].invert(toUndo.docs[j]));
+                }
+                if (undoable.text) {
+                    let marks = tr.doc.resolve(undoable.from).marks();
+                    tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks));
+                }
+                else {
+                    tr.delete(undoable.from, undoable.to);
+                }
+                dispatch(tr);
+            }
+            return true;
+        }
+    }
+    return false;
+};

package/esm/editor/src/plugins/input-rules/mod.d.ts

@@ -0,0 +1,3 @@
+export * from './InputRulesPlugin.js';
+export * from './rulebuilders.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/editor/src/plugins/input-rules/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../src/editor/src/plugins/input-rules/mod.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC"}

package/esm/editor/src/plugins/input-rules/mod.js

@@ -0,0 +1,2 @@
+export * from './InputRulesPlugin.js';
+export * from './rulebuilders.js';

package/esm/editor/src/plugins/input-rules/rulebuilders.d.ts

@@ -0,0 +1,5 @@
+import { Attrs, Node, NodeType } from 'prosemirror-model';
+import { InputRule } from './InputRulesPlugin.js';
+export declare function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((matches: RegExpMatchArray) => Attrs | null), joinPredicate?: (match: RegExpMatchArray, node: Node) => boolean): InputRule;
+export declare function textblockTypeInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null)): InputRule;
+//# sourceMappingURL=rulebuilders.d.ts.map

package/esm/editor/src/plugins/input-rules/rulebuilders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rulebuilders.d.ts","sourceRoot":"","sources":["../../../../../src/editor/src/plugins/input-rules/rulebuilders.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE1D,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAiBlD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,QAAQ,GAAE,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,gBAAgB,KAAK,KAAK,GAAG,IAAI,CAAQ,EAC7E,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,aAmBjE;AAQD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,QAAQ,GAAE,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,gBAAgB,KAAK,KAAK,GAAG,IAAI,CAAQ,aAgB5E"}

package/esm/editor/src/plugins/input-rules/rulebuilders.js

@@ -0,0 +1,50 @@
+import { canJoin, findWrapping } from 'prosemirror-transform';
+import { InputRule } from './InputRulesPlugin.js';
+/// Build an input rule for automatically wrapping a textblock when a
+/// given string is typed. The `regexp` argument is
+/// directly passed through to the `InputRule` constructor. You'll
+/// probably want the regexp to start with `^`, so that the pattern can
+/// only occur at the start of a textblock.
+///
+/// `nodeType` is the type of node to wrap in. If it needs attributes,
+/// you can either pass them directly, or pass a function that will
+/// compute them from the regular expression match.
+///
+/// By default, if there's a node with the same type above the newly
+/// wrapped node, the rule will try to [join](#transform.Transform.join) those
+/// two nodes. You can pass a join predicate, which takes a regular
+/// expression match and the node before the wrapped node, and can
+/// return a boolean to indicate whether a join should happen.
+export function wrappingInputRule(regexp, nodeType, getAttrs = null, joinPredicate) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        let attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        let tr = state.tr.delete(start, end);
+        let $start = tr.doc.resolve(start), range = $start.blockRange(), wrapping = range && findWrapping(range, nodeType, attrs);
+        if (!wrapping)
+            return null;
+        tr.wrap(range, wrapping);
+        let before = tr.doc.resolve(start - 1).nodeBefore;
+        if (before && before.type == nodeType && canJoin(tr.doc, start - 1) &&
+            (!joinPredicate || joinPredicate(match, before))) {
+            tr.join(start - 1);
+        }
+        return tr;
+    });
+}
+/// Build an input rule that changes the type of a textblock when the
+/// matched text is typed into it. You'll usually want to start your
+/// regexp with `^` to that it is only matched at the start of a
+/// textblock. The optional `getAttrs` parameter can be used to compute
+/// the new node's attributes, and works the same as in the
+/// `wrappingInputRule` function.
+export function textblockTypeInputRule(regexp, nodeType, getAttrs = null) {
+    return new InputRule(regexp, (state, match, start, end) => {
+        let $start = state.doc.resolve(start);
+        let attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+        if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType))
+            return null;
+        return state.tr
+            .delete(start, end)
+            .setBlockType(start, start, nodeType, attrs);
+    });
+}

package/esm/editor/src/types.d.ts

@@ -0,0 +1,29 @@
+import type { ParseOptions } from 'prosemirror-model';
+import type { Extension } from './Extension.js';
+import type { Mark } from './Mark.js';
+import type { Node } from './Node.js';
+export type AnyExtension = (Extension | Node | Mark) & {
+    requires: Set<AnyExtension | string>;
+};
+export type Extensions = AnyExtension[];
+export type Content = JSONContent | JSONContent[] | null;
+export interface EditorOptions {
+    element: Element;
+    content: Content;
+    parseOptions: ParseOptions;
+    extensions: Extensions;
+    topNode?: string;
+}
+export type JSONContent = {
+    type?: string;
+    attrs?: Record<string, any>;
+    content?: JSONContent[];
+    marks?: {
+        type: string;
+        attrs?: Record<string, any>;
+        [key: string]: any;
+    }[];
+    text?: string;
+    [key: string]: any;
+};
+//# sourceMappingURL=types.d.ts.map

package/esm/editor/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/editor/src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,MAAM,MAAM,YAAY,GAAG,CAAC,SAAS,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG;IACrD,QAAQ,EAAE,GAAG,CAAC,YAAY,GAAG,MAAM,CAAC,CAAC;CACtC,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,YAAY,EAAE,CAAC;AAExC,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,WAAW,EAAE,GAAG,IAAI,CAAC;AAEzD,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,YAAY,CAAC;IAC3B,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5B,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,EAAE,CAAC;IACJ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC"}

package/esm/editor/src/types.js

@@ -0,0 +1 @@
+export {};

package/esm/editor/src/utilities/createNodeFromContent.d.ts

@@ -0,0 +1,8 @@
+import { Fragment, Node as ProseMirrorNode, Schema } from 'prosemirror-model';
+import type { Content } from '../types.js';
+export type CreateNodeFromContentOptions = {
+    errorOnInvalidContent?: boolean;
+};
+export declare function createNodeFromObject(content: Content | ProseMirrorNode | Fragment, schema: Schema, options?: CreateNodeFromContentOptions): ProseMirrorNode | Fragment;
+export declare function createNodeFromContent(content: Content | ProseMirrorNode | Fragment, schema: Schema, options?: CreateNodeFromContentOptions): ProseMirrorNode | Fragment;
+//# sourceMappingURL=createNodeFromContent.d.ts.map

package/esm/editor/src/utilities/createNodeFromContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNodeFromContent.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/utilities/createNodeFromContent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,IAAI,eAAe,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE9E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,4BAA4B,GAAG;IACzC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,GAAG,eAAe,GAAG,QAAQ,EAC7C,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,eAAe,GAAG,QAAQ,CAiC5B;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,OAAO,GAAG,eAAe,GAAG,QAAQ,EAC7C,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,eAAe,GAAG,QAAQ,CAY5B"}

package/esm/editor/src/utilities/createNodeFromContent.js

@@ -0,0 +1,33 @@
+import { Fragment, Node as ProseMirrorNode } from 'prosemirror-model';
+export function createNodeFromObject(content, schema, options) {
+    try {
+        // if the JSON Content is an array of nodes, create a fragment for each node
+        if (Array.isArray(content) && content.length > 0) {
+            return Fragment.fromArray(content.map((item) => schema.nodeFromJSON(item)));
+        }
+        const node = schema.nodeFromJSON(content);
+        if (options?.errorOnInvalidContent) {
+            node.check();
+        }
+        return node;
+    }
+    catch (error) {
+        if (options?.errorOnInvalidContent) {
+            throw new Error('Invalid JSON content', {
+                cause: error,
+            });
+        }
+        console.warn('Invalid content.', 'Passed value:', content, 'Error:', error);
+        return schema.topNodeType.createAndFill(null, []);
+    }
+}
+export function createNodeFromContent(content, schema, options) {
+    if (content instanceof ProseMirrorNode || content instanceof Fragment) {
+        return content;
+    }
+    const isJSONContent = typeof content === 'object' && content !== null;
+    if (isJSONContent) {
+        createNodeFromObject(content, schema, options);
+    }
+    return schema.topNodeType.createAndFill(null, []);
+}

package/esm/editor/src/utilities/getHtmlAttributes.d.ts

@@ -0,0 +1,4 @@
+export declare function getHtmlAttributes(extension: any, node: any): {};
+export declare function setHtmlAttributes(extension: any, element: any): {};
+export declare function addAttributesToSchema(spec: any, extension: any): void;
+//# sourceMappingURL=getHtmlAttributes.d.ts.map

package/esm/editor/src/utilities/getHtmlAttributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getHtmlAttributes.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/utilities/getHtmlAttributes.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,SAAS,KAAA,EAAE,IAAI,KAAA,MAkBhD;AAED,wBAAgB,iBAAiB,CAAC,SAAS,KAAA,EAAE,OAAO,KAAA,MAcnD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,KAAA,EAAE,SAAS,KAAA,QAcpD"}

package/esm/editor/src/utilities/getHtmlAttributes.js

@@ -0,0 +1,47 @@
+export function getHtmlAttributes(extension, node) {
+    const attrs = {};
+    if (extension.attributes) {
+        for (const [key, value] of Object.entries(extension.attributes)) {
+            if ('undefined' !== typeof node.attrs[key]) {
+                attrs[key] = node.attrs[key];
+            }
+            else {
+                if (value.toDom) {
+                    attrs[key] = value.toDom(node);
+                }
+                else {
+                    attrs[key] = value.default;
+                }
+            }
+        }
+    }
+    return attrs;
+}
+export function setHtmlAttributes(extension, element) {
+    const attrs = {};
+    if (extension.attributes) {
+        for (const [key, value] of Object.entries(extension.attributes)) {
+            if (value.fromDom) {
+                attrs[key] = value.fromDom(element);
+            }
+            else {
+                attrs[key] = value.default;
+            }
+        }
+    }
+    return attrs;
+}
+export function addAttributesToSchema(spec, extension) {
+    const attrs = {};
+    if (extension.attributes) {
+        if (!spec.attrs) {
+            spec.attrs = {};
+        }
+        for (const [key, value] of Object.entries(extension.attributes)) {
+            spec.attrs[key] = value;
+            if (!value.toDom) {
+                value.toDom = (node) => node.attrs[key];
+            }
+        }
+    }
+}

package/esm/editor/src/utilities/mod.d.ts

@@ -0,0 +1,3 @@
+export * from './getHtmlAttributes.js';
+export * from './createNodeFromContent.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/editor/src/utilities/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/editor/src/utilities/mod.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC"}

package/esm/editor/src/utilities/mod.js

@@ -0,0 +1,2 @@
+export * from './getHtmlAttributes.js';
+export * from './createNodeFromContent.js';

package/esm/extension-codemirror/src/ExtensionCodeMirror.d.ts

@@ -0,0 +1,5 @@
+export * from './NodeDocumentCode.js';
+export * from './NodeCodeMirror.js';
+export declare class ExtensionCodeMirror {
+}
+//# sourceMappingURL=ExtensionCodeMirror.d.ts.map

package/esm/extension-codemirror/src/ExtensionCodeMirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExtensionCodeMirror.d.ts","sourceRoot":"","sources":["../../../src/extension-codemirror/src/ExtensionCodeMirror.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AAEpC,qBAAa,mBAAmB;CAC/B"}

package/esm/extension-codemirror/src/ExtensionCodeMirror.js

@@ -0,0 +1,4 @@
+export * from './NodeDocumentCode.js';
+export * from './NodeCodeMirror.js';
+export class ExtensionCodeMirror {
+}

package/esm/extension-codemirror/src/NodeCodeMirror.d.ts

@@ -0,0 +1,27 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import type { NodeSpec, NodeType, Schema } from 'prosemirror-model';
+import { Converter, type CoreEditor, Node } from '../../editor/src/mod.js';
+import { type Commands, type CommandShortcuts } from '../../editor/src/commands/mod.js';
+import { type InputRule } from '../../editor/src/plugins/input-rules/mod.js';
+export declare const codeMirrorBlockKey: PluginKey<any>;
+export declare class NodeCodeMirror extends Node {
+    name: string;
+    automerge: {
+        block: string;
+        attrParsers: {
+            fromAutomerge: (block: any) => {
+                lang: any;
+            };
+            fromProsemirror: (node: any) => {
+                lang: any;
+            };
+        };
+    };
+    getConverters(editor: CoreEditor, schema: Schema): Record<string, Converter>;
+    getNodeSpec(): NodeSpec;
+    getInputRules(type: NodeType): InputRule[];
+    getCommands(editor: CoreEditor, type: NodeType): Partial<Commands>;
+    getKeyboardShortcuts(): Partial<CommandShortcuts>;
+    getProseMirrorPlugins(editor: CoreEditor): Plugin[];
+}
+//# sourceMappingURL=NodeCodeMirror.d.ts.map

package/esm/extension-codemirror/src/NodeCodeMirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeCodeMirror.d.ts","sourceRoot":"","sources":["../../../src/extension-codemirror/src/NodeCodeMirror.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,MAAM,EAAE,SAAS,EAAa,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEpE,OAAO,EAAE,SAAS,EAAE,KAAK,UAAU,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,gBAAgB,EAEtB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,KAAK,SAAS,EAEf,MAAM,6CAA6C,CAAC;AAOrD,eAAO,MAAM,kBAAkB,gBAAoC,CAAC;AAyCpE,qBAAa,cAAe,SAAQ,IAAI;IAC7B,IAAI,SAAgB;IAG7B,SAAS;;;;;;;;;;MAMP;IAEO,aAAa,CACpB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC;IAgDnB,WAAW,IAAI,QAAQ;IA0CvB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE;IAQ1C,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAUlE,oBAAoB,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAUjD,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE;CA8B7D"}