@kerebron/editor 0.4.27 → 0.4.28

package/esm/commands/createChainableState.d.ts

@@ -0,0 +1,3 @@
+import { EditorState, Transaction } from 'prosemirror-state';
+export declare function createChainableState(transaction: Transaction, state: EditorState): EditorState;
+//# sourceMappingURL=createChainableState.d.ts.map

package/esm/commands/createChainableState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createChainableState.d.ts","sourceRoot":"","sources":["../../src/commands/createChainableState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7D,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,WAAW,EACxB,KAAK,EAAE,WAAW,GACjB,WAAW,CA8Bb"}

package/esm/commands/createChainableState.js

@@ -0,0 +1,29 @@
+export function createChainableState(transaction, state) {
+    let { selection } = transaction;
+    let { doc } = transaction;
+    let { storedMarks } = transaction;
+    return {
+        ...state,
+        apply: state.apply.bind(state),
+        applyTransaction: state.applyTransaction.bind(state),
+        plugins: state.plugins,
+        schema: state.schema,
+        reconfigure: state.reconfigure.bind(state),
+        toJSON: state.toJSON.bind(state),
+        get storedMarks() {
+            return storedMarks;
+        },
+        get selection() {
+            return selection;
+        },
+        get doc() {
+            return doc;
+        },
+        get tr() {
+            selection = transaction.selection;
+            doc = transaction.doc;
+            storedMarks = transaction.storedMarks;
+            return transaction;
+        },
+    };
+}

package/esm/commands/keyCommandFactories.d.ts

@@ -0,0 +1,3 @@
+import { CommandFactory } from './mod.js';
+export declare const keyCommandFactories: Record<string, CommandFactory>;
+//# sourceMappingURL=keyCommandFactories.d.ts.map

package/esm/commands/keyCommandFactories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyCommandFactories.d.ts","sourceRoot":"","sources":["../../src/commands/keyCommandFactories.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAgB,MAAM,UAAU,CAAC;AAqBxD,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAI9D,CAAC"}

package/esm/commands/keyCommandFactories.js

@@ -0,0 +1,10 @@
+import { firstCommand } from './mod.js';
+import { baseCommandFactories } from './baseCommandFactories.js';
+const backspace = firstCommand(baseCommandFactories.undoInputRule(), baseCommandFactories.deleteSelection(), baseCommandFactories.joinBackward(), baseCommandFactories.selectNodeBackward());
+const del = firstCommand(baseCommandFactories.deleteSelection(), baseCommandFactories.joinForward(), baseCommandFactories.selectNodeForward());
+const enter = firstCommand(baseCommandFactories.newlineInCode(), baseCommandFactories.createParagraphNear(), baseCommandFactories.liftEmptyBlock(), baseCommandFactories.splitBlock());
+export const keyCommandFactories = {
+    backspace: () => backspace,
+    del: () => del,
+    enter: () => enter,
+};

package/esm/commands/mod.d.ts

@@ -0,0 +1,7 @@
+import type { Node } from 'prosemirror-model';
+import type { Command } from './types.js';
+export * from './types.js';
+export declare function firstCommand(...commands: readonly Command[]): Command;
+export declare function alternativeCommands(...commands: readonly Command[]): Command;
+export declare function autoJoin(command: Command, isJoinable: ((before: Node, after: Node) => boolean) | readonly string[]): Command;
+//# sourceMappingURL=mod.d.ts.map

package/esm/commands/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/commands/mod.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1C,cAAc,YAAY,CAAC;AAI3B,wBAAgB,YAAY,CAAC,GAAG,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAmBrE;AAED,wBAAgB,mBAAmB,CAAC,GAAG,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAO5E;AAyDD,wBAAgB,QAAQ,CACtB,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,KAAK,OAAO,CAAC,GAAG,SAAS,MAAM,EAAE,GACvE,OAAO,CAMT"}

package/esm/commands/mod.js

@@ -0,0 +1,81 @@
+import { canJoin } from 'prosemirror-transform';
+export * from './types.js';
+/// Combine a number of command functions into a single function (which
+/// calls them one by one until one returns true).
+export function firstCommand(...commands) {
+    const cmd = function (state, dispatch, view) {
+        for (let i = 0; i < commands.length; i++) {
+            if (commands[i](state, dispatch, view)) {
+                const cmd = commands[i];
+                if (cmd.displayName !== 'first') {
+                    console.debug('firstCommand: ', commands[i].displayName || commands[i]);
+                }
+                return true;
+            }
+        }
+        return false;
+    };
+    cmd.displayName = 'first';
+    return cmd;
+}
+export function alternativeCommands(...commands) {
+    return function (state, dispatch, view) {
+        for (let i = 0; i < commands.length; i++) {
+            if (commands[i](state, dispatch, view))
+                return true;
+        }
+        return false;
+    };
+}
+function wrapDispatchForJoin(dispatch, isJoinable) {
+    return (tr) => {
+        if (!tr.isGeneric)
+            return dispatch(tr);
+        let ranges = [];
+        for (let i = 0; i < tr.mapping.maps.length; i++) {
+            let map = tr.mapping.maps[i];
+            for (let j = 0; j < ranges.length; j++) {
+                ranges[j] = map.map(ranges[j]);
+            }
+            map.forEach((_s, _e, from, to) => ranges.push(from, to));
+        }
+        // Figure out which joinable points exist inside those ranges,
+        // by checking all node boundaries in their parent nodes.
+        let joinable = [];
+        for (let i = 0; i < ranges.length; i += 2) {
+            let from = ranges[i], to = ranges[i + 1];
+            let $from = tr.doc.resolve(from), depth = $from.sharedDepth(to), parent = $from.node(depth);
+            for (let index = $from.indexAfter(depth), pos = $from.after(depth + 1); pos <= to; ++index) {
+                let after = parent.maybeChild(index);
+                if (!after)
+                    break;
+                if (index && joinable.indexOf(pos) == -1) {
+                    let before = parent.child(index - 1);
+                    if (before.type == after.type && isJoinable(before, after)) {
+                        joinable.push(pos);
+                    }
+                }
+                pos += after.nodeSize;
+            }
+        }
+        // Join the joinable points
+        joinable.sort((a, b) => a - b);
+        for (let i = joinable.length - 1; i >= 0; i--) {
+            if (canJoin(tr.doc, joinable[i]))
+                tr.join(joinable[i]);
+        }
+        dispatch(tr);
+    };
+}
+/// Wrap a command so that, when it produces a transform that causes
+/// two joinable nodes to end up next to each other, those are joined.
+/// Nodes are considered joinable when they are of the same type and
+/// when the `isJoinable` predicate returns true for them or, if an
+/// array of strings was passed, if their node type name is in that
+/// array.
+export function autoJoin(command, isJoinable) {
+    let canJoin = Array.isArray(isJoinable)
+        ? (node) => isJoinable.indexOf(node.type.name) > -1
+        : isJoinable;
+    return (state, dispatch, view) => command(state, dispatch && wrapDispatchForJoin(dispatch, canJoin), view);
+}

package/esm/commands/replaceCommandFactories.d.ts

@@ -0,0 +1,3 @@
+import type { CommandFactory } from './mod.js';
+export declare const replaceCommandFactories: Record<string, CommandFactory>;
+//# sourceMappingURL=replaceCommandFactories.d.ts.map

package/esm/commands/replaceCommandFactories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replaceCommandFactories.d.ts","sourceRoot":"","sources":["../../src/commands/replaceCommandFactories.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAW,cAAc,EAAE,MAAM,UAAU,CAAC;AAwHxD,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAMlE,CAAC"}

package/esm/commands/replaceCommandFactories.js

@@ -0,0 +1,94 @@
+import { Fragment, Slice } from 'prosemirror-model';
+const replaceRangeText = (range, text) => {
+    return (state, dispatch) => {
+        const tr = state.tr;
+        const from = tr.mapping.map(range.from);
+        const to = tr.mapping.map(range.to);
+        const frag = Fragment.from(state.schema.text(text));
+        const insert = new Slice(frag, 0, 0);
+        tr.replace(from, to, insert);
+        if (dispatch) {
+            dispatch(tr);
+        }
+        return true;
+    };
+};
+const replaceRangeSlice = (range, insert) => {
+    return (state, dispatch) => {
+        const tr = state.tr;
+        const from = tr.mapping.map(range.from);
+        const to = tr.mapping.map(range.to);
+        tr.replace(from, to, insert);
+        if (dispatch) {
+            dispatch(tr);
+        }
+        return true;
+    };
+};
+function getTopMostBlockStartForOffset(state, offset) {
+    const { doc } = state;
+    const $pos = doc.resolve(offset);
+    const blockPos = $pos.before($pos.depth);
+    if ($pos.depth === 1)
+        return blockPos;
+    return $pos.start(1);
+}
+function getTopMostBlockEndForOffset(state, offset) {
+    const { doc } = state;
+    const $pos = doc.resolve(offset);
+    return $pos.end(1);
+}
+function getAdjacentTopBlock(state, offset) {
+    const { doc } = state;
+    if (offset < 0 || offset > doc.content.size) {
+        throw new RangeError('Offset is outside the document');
+    }
+    const $pos = doc.resolve(offset);
+    const atBlockStart = $pos.pos === $pos.start($pos.depth);
+    if (atBlockStart) {
+        return getTopMostBlockStartForOffset(state, offset);
+    }
+    else {
+        return getTopMostBlockEndForOffset(state, offset);
+    }
+}
+const insertBlockBefore = (pos, insert) => {
+    return (state, dispatch) => {
+        const tr = state.tr;
+        const blockPos = getTopMostBlockStartForOffset(state, tr.mapping.map(pos));
+        tr.insert(blockPos, insert);
+        if (dispatch) {
+            dispatch(tr);
+        }
+        return true;
+    };
+};
+const insertBlockAfter = (pos, insert) => {
+    return (state, dispatch) => {
+        const tr = state.tr;
+        const blockPos = getTopMostBlockEndForOffset(state, tr.mapping.map(pos));
+        tr.insert(blockPos, insert);
+        if (dispatch) {
+            dispatch(tr);
+        }
+        return true;
+    };
+};
+const insertBlockSmart = (pos, insert) => {
+    return (state, dispatch) => {
+        const tr = state.tr;
+        const blockPos = getAdjacentTopBlock(state, tr.mapping.map(pos));
+        tr.insert(blockPos, insert);
+        if (dispatch) {
+            dispatch(tr);
+        }
+        return true;
+    };
+};
+export const replaceCommandFactories = {
+    replaceRangeText,
+    replaceRangeSlice,
+    insertBlockBefore,
+    insertBlockAfter,
+    insertBlockSmart,
+};

package/esm/commands/types.d.ts

@@ -0,0 +1,22 @@
+import type { Command as PmCommand } from 'prosemirror-state';
+interface Command extends PmCommand {
+    displayName?: string;
+    description?: string;
+}
+export type { Command };
+export type CommandFactory = (...args: any[]) => Command;
+export interface Commands {
+    [name: string]: Command;
+}
+export interface CommandFactories {
+    [name: string]: CommandFactory;
+}
+export type CommandShortcuts = {
+    [name: string]: string;
+};
+export type ChainedCommands = {
+    [Item in keyof Commands]: (...args: unknown[]) => ChainedCommands;
+} & {
+    run: () => boolean;
+};
+//# sourceMappingURL=types.d.ts.map

package/esm/commands/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/commands/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9D,UAAU,OAAQ,SAAQ,SAAS;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,YAAY,EAAE,OAAO,EAAE,CAAC;AAExB,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC;AAEzD,MAAM,WAAW,QAAQ;IACvB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAC;CAChC;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,eAAe,GACvB;KACC,IAAI,IAAI,MAAM,QAAQ,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,eAAe;CAClE,GACC;IACA,GAAG,EAAE,MAAM,OAAO,CAAC;CACpB,CAAC"}

package/esm/commands/types.js

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

package/esm/mod.d.ts

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

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../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;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,SAAS,CAAC"}

package/esm/mod.js

@@ -0,0 +1,8 @@
+export * from './CoreEditor.js';
+export * from './Extension.js';
+export * from './Mark.js';
+export * from './Node.js';
+export * from './nodeToTreeString.js';
+export * from './types.js';
+export * from './utilities/SmartOutput.js';
+export * from './ui.js';

package/esm/nodeToTreeString.d.ts

@@ -0,0 +1,10 @@
+import type { Node } from 'prosemirror-model';
+import { SmartOutput } from './utilities/SmartOutput.js';
+export interface NodeAndPos {
+    node: Node;
+    pos: number;
+}
+export declare function nodeToTreeStringOutput(output: SmartOutput<NodeAndPos>, node: Node | Node[] | readonly Node[], level?: number, currentPos?: number): SmartOutput<NodeAndPos> | undefined;
+export declare function nodeToTreeString(node: Node | Node[] | readonly Node[]): string;
+export declare function debugNode(node: Node | Node[]): void;
+//# sourceMappingURL=nodeToTreeString.d.ts.map

package/esm/nodeToTreeString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeToTreeString.d.ts","sourceRoot":"","sources":["../src/nodeToTreeString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAYzD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,IAAI,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;CACb;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,WAAW,CAAC,UAAU,CAAC,EAC/B,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,SAAS,IAAI,EAAE,EACrC,KAAK,SAAI,EACT,UAAU,SAAI,uCAmEf;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,GAAG,SAAS,IAAI,EAAE,UAIrE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,QAE5C"}

package/esm/nodeToTreeString.js

@@ -0,0 +1,74 @@
+import { SmartOutput } from './utilities/SmartOutput.js';
+function trimText(str, maxLen = 20) {
+    str = str.replaceAll('\n', '\\n');
+    if (str.length <= maxLen) {
+        return str;
+    }
+    return str.slice(0, maxLen) + '...';
+}
+export function nodeToTreeStringOutput(output, node, level = 0, currentPos = 0) {
+    let delim = '';
+    for (let i = 0; i < level; i++) {
+        delim += '  ';
+    }
+    if (Array.isArray(node)) {
+        for (const child of node) {
+            output.log(delim, { node: child, pos: currentPos });
+            nodeToTreeStringOutput(output, child, level + 1, currentPos);
+            // .replace(/\s+$/gm, '') +
+            // '\n'
+        }
+        return;
+    }
+    // https://prosemirror.net/docs/guide/#doc.indexing
+    let line = '';
+    // if (node.type) {
+    if ('type' in node) {
+        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.log((delim + line) + '\n', { node, pos: currentPos });
+        let marksLine = '';
+        if (node.marks) {
+            for (const mark of node.marks) {
+                marksLine += `(${mark.type.name}), `;
+            }
+        }
+        if (marksLine) {
+            output.log((delim + '    ' + marksLine) + '\n', {
+                node,
+                pos: currentPos,
+            });
+        }
+        if (node.text) {
+            output.log((delim + '    "' + trimText(node.text) + '"') + '\n', {
+                node,
+                pos: currentPos,
+            });
+        }
+    }
+    node.forEach((child, offset) => {
+        // output +=
+        nodeToTreeStringOutput(output, child, level + 1, currentPos + offset + 1);
+        //   .replace(
+        //   /\s+$/gm,
+        //   '',
+        // ) + '\n'; // + (node.isLeaf ? 1 : 2)
+    });
+    return output;
+}
+export function nodeToTreeString(node) {
+    const output = new SmartOutput();
+    nodeToTreeStringOutput(output, node);
+    return output.toString();
+}
+export function debugNode(node) {
+    console.debug(nodeToTreeString(node));
+}

package/esm/package.json

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

package/esm/plugins/TrackSelecionPlugin.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'prosemirror-state';
+import type { CoreEditor } from '../mod.js';
+export declare class TrackSelecionPlugin extends Plugin {
+    constructor(editor: CoreEditor);
+}
+//# sourceMappingURL=TrackSelecionPlugin.d.ts.map

package/esm/plugins/TrackSelecionPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrackSelecionPlugin.d.ts","sourceRoot":"","sources":["../../src/plugins/TrackSelecionPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,qBAAa,mBAAoB,SAAQ,MAAM;gBACjC,MAAM,EAAE,UAAU;CAsB/B"}

package/esm/plugins/TrackSelecionPlugin.js

@@ -0,0 +1,24 @@
+import { Plugin } from 'prosemirror-state';
+export class TrackSelecionPlugin extends Plugin {
+    constructor(editor) {
+        super({
+            view(editorView) {
+                return {
+                    update(view, prevState) {
+                        const state = view.state;
+                        const prevSelection = prevState.selection;
+                        const selection = state.selection;
+                        if (!prevSelection.eq(selection)) {
+                            const event = new CustomEvent('selection', {
+                                detail: {
+                                    selection,
+                                },
+                            });
+                            editor.dispatchEvent(event);
+                        }
+                    },
+                };
+            },
+        });
+    }
+}

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

@@ -0,0 +1,25 @@
+import { EditorState, Plugin, Transaction } from 'prosemirror-state';
+import type { Command, CommandFactory } from '../../commands/types.js';
+type PluginState = {
+    transform: Transaction;
+    from: number;
+    to: number;
+    text: string;
+} | null;
+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';
+    });
+}
+export declare class InputRulesPlugin extends Plugin<PluginState> {
+    constructor(rules: readonly InputRule[]);
+}
+export declare const runInputRules: CommandFactory;
+export declare const undoInputRuleCommand: Command;
+export {};
+//# sourceMappingURL=InputRulesPlugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InputRulesPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/input-rules/InputRulesPlugin.ts"],"names":[],"mappings":"AACA,OAAO,EACL,WAAW,EACX,MAAM,EAEN,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAIvE,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;AAMT,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;AA2BD,qBAAa,gBAAiB,SAAQ,MAAM,CAAC,WAAW,CAAC;gBAC3C,KAAK,EAAE,SAAS,SAAS,EAAE;CA4CxC;AAED,eAAO,MAAM,aAAa,EAAE,cAiD3B,CAAC;AAIF,eAAO,MAAM,oBAAoB,EAAE,OAiClC,CAAC"}

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

@@ -0,0 +1,168 @@
+import { Plugin, } from 'prosemirror-state';
+const MAX_MATCH = 500;
+/// 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 {
+    match;
+    /// @internal
+    handler;
+    /// @internal
+    undoable;
+    inCode;
+    // :: (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 = {}) {
+        this.match = match;
+        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]) {
+            const offset = match[0].lastIndexOf(match[1]);
+            insert += match[0].slice(offset + match[1].length);
+            start += offset;
+            const cutOff = start - end;
+            if (cutOff > 0) {
+                insert = match[0].slice(offset - cutOff, offset) + insert;
+                start = end;
+            }
+        }
+        return state.tr.insertText(insert, start, end);
+    };
+}
+/// 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) {
+                    const stored = tr.getMeta(this);
+                    if (stored) {
+                        return stored;
+                    }
+                    return tr.selectionSet || tr.docChanged ? null : prev;
+                },
+            },
+            props: {
+                handleTextInput(view, from, to, text) {
+                    const cmd = runInputRules(from, to, text, rules);
+                    const dispatch = (tr) => {
+                        view.dispatch(tr);
+                    };
+                    return cmd(view.state, dispatch, view);
+                    // return run(view, from, to, text, rules, this);
+                },
+                handleDOMEvents: {
+                    compositionend: (view) => {
+                        setTimeout(() => {
+                            const { $cursor } = view.state.selection;
+                            if ($cursor) {
+                                const cmd = runInputRules($cursor.pos, $cursor.pos, '', rules);
+                                const dispatch = (tr) => {
+                                    view.dispatch(tr);
+                                };
+                                return cmd(view.state, dispatch, view);
+                                // run(view, $cursor.pos, $cursor.pos, '', rules, this);
+                            }
+                        });
+                    },
+                },
+            },
+            isInputRules: true,
+        });
+    }
+}
+export const runInputRules = (from, to, text, rules) => {
+    const cmd = (state, dispatch, view) => {
+        const plugins = state.plugins;
+        const plugin = plugins.find((plugin) => plugin.spec.isInputRules);
+        if (!plugin) {
+            return false;
+        }
+        if (view?.composing)
+            return false;
+        const $from = state.doc.resolve(from);
+        const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, null, '\ufffc') + text;
+        for (let i = 0; i < rules.length; i++) {
+            const rule = rules[i];
+            if ($from.parent.type.spec.code) {
+                if (!rule.inCode)
+                    continue;
+            }
+            else if (rule.inCode === 'only') {
+                continue;
+            }
+            const match = rule.match.exec(textBefore);
+            const 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;
+    };
+    cmd.displayName = 'runInputRules';
+    return cmd;
+};
+/// 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 undoInputRuleCommand = (state, dispatch) => {
+    const plugins = state.plugins;
+    const plugin = plugins.find((plugin) => plugin.spec.isInputRules);
+    if (!plugin) {
+        return false;
+    }
+    const undoable = plugin.getState(state);
+    if (!undoable) {
+        return false;
+    }
+    if (dispatch) {
+        const tr = state.tr;
+        const 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) {
+            const 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;
+};

package/esm/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/plugins/input-rules/mod.d.ts.map

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

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

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