@harbour-enterprises/superdoc 0.8.9 → 0.8.11

package/dist/super-editor/chunks/{editor-BChxC9A0.js → editor-H6Apbtdi.js}

@@ -12,9 +12,9 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 var _events, _Attribute_static, getGlobalAttributes_fn, getNodeAndMarksAttributes_fn, _Schema_static, createNodesSchema_fn, createMarksSchema_fn, _ExtensionService_instances, setupExtensions_fn, attachEditorEvents_fn, _commandService, _css, _Editor_instances, init_fn, initRichText_fn, onFocus_fn, checkHeadless_fn, insertNewFileData_fn, registerPluginByNameIfNotExists_fn, createExtensionService_fn, createCommandService_fn, createConverter_fn, initMedia_fn, createSchema_fn, generatePmData_fn, createView_fn, onCollaborationReady_fn, initComments_fn, initPagination_fn, dispatchTransaction_fn, prepareDocumentForImport_fn, prepareDocumentForExport_fn, endCollaboration_fn, _FieldAnnotationView_instances, createAnnotation_fn;
 import * as Y from "yjs";
 import { UndoManager, Item as Item$1, ContentType, Text as Text$1, XmlElement } from "yjs";
-import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, f as Schema$1, g as canSplit, l as liftTarget, h as canJoin, j as joinPoint, r as replaceStep$1, R as ReplaceAroundStep, o as objectIncludes, i as ReplaceStep, k as NodeRange, m as findWrapping, n as TrackDeleteMarkName, q as TrackInsertMarkName, v as v4, s as generateDocxRandomId, t as generateRandom32BitHex, u as TrackFormatMarkName, w as comments_module_events, x as AddMarkStep, y as RemoveMarkStep, z as twipsToLines, B as pixelsToTwips, C as SuperConverter, E as EditorState, G as toKebabCase, H as kebabCase, I as SelectionRange, J as Transform } from "./converter-Bn0H50Ks.js";
+import { P as PluginKey, a as Plugin, M as Mapping, N as NodeSelection, S as Selection, T as TextSelection, b as Slice, D as DOMSerializer, F as Fragment, c as DOMParser$1, d as Mark$1, e as dropPoint, A as AllSelection, p as process$1, f as Schema$1, i as isRegExp, g as canSplit, l as liftTarget, h as canJoin, j as joinPoint, r as replaceStep$1, R as ReplaceAroundStep, o as objectIncludes, k as ReplaceStep, m as NodeRange, n as findWrapping, q as TrackDeleteMarkName, s as TrackInsertMarkName, v as v4, t as generateDocxRandomId, u as generateRandom32BitHex, w as TrackFormatMarkName, x as comments_module_events, y as AddMarkStep, z as RemoveMarkStep, B as twipsToLines, C as pixelsToTwips, E as SuperConverter, G as EditorState, H as toKebabCase, I as kebabCase, J as SelectionRange, K as Transform } from "./converter-CVSaF15S.js";
 import { ref, computed, createElementBlock, openBlock, withModifiers, Fragment as Fragment$1, renderList, normalizeClass, createCommentVNode, toDisplayString, createElementVNode, createApp } from "vue";
-import { D as DocxZipper } from "./docx-zipper-_duxMt64.js";
+import { D as DocxZipper } from "./docx-zipper-BHwY_rz6.js";
 function getMarksFromSelection(state) {
   const { from: from2, to, empty: empty2 } = state.selection;
   const marks = [];
@@ -7961,6 +7961,357 @@ let Schema = _Schema;
 function getSchemaTypeByName(name, schema) {
   return schema.nodes[name] || schema.marks[name] || null;
 }
+function isExtensionRulesEnabled(extension, enabled) {
+  if (Array.isArray(enabled)) {
+    return enabled.some((enabledExtension) => {
+      const name = typeof enabledExtension === "string" ? enabledExtension : enabledExtension.name;
+      return name === extension.name;
+    });
+  }
+  return enabled;
+}
+function chainableEditorState(transaction, state) {
+  let { selection, doc: doc2, 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 doc2;
+    },
+    get tr() {
+      selection = transaction.selection;
+      doc2 = transaction.doc;
+      storedMarks = transaction.storedMarks;
+      return transaction;
+    }
+  };
+}
+class CommandService {
+  constructor(props) {
+    __publicField(this, "editor");
+    __publicField(this, "rawCommands");
+    this.editor = props.editor;
+    this.rawCommands = this.editor.extensionService.commands;
+  }
+  /**
+   * Static method for creating a service.
+   * @param args Arguments for the constructor.
+   */
+  static create(...args) {
+    return new CommandService(...args);
+  }
+  /**
+   * Get editor state.
+   */
+  get state() {
+    return this.editor.state;
+  }
+  /**
+   * Get all commands with wrapped command method.
+   */
+  get commands() {
+    const { editor, state } = this;
+    const { view } = editor;
+    const { tr } = state;
+    const props = this.createProps(tr);
+    const entries = Object.entries(this.rawCommands).map(([name, command2]) => {
+      const method = (...args) => {
+        const fn2 = command2(...args)(props);
+        if (!tr.getMeta("preventDispatch")) {
+          view.dispatch(tr);
+        }
+        return fn2;
+      };
+      return [name, method];
+    });
+    return Object.fromEntries(entries);
+  }
+  /**
+   * Create a chain of commands to call multiple commands at once.
+   */
+  get chain() {
+    return () => this.createChain();
+  }
+  /**
+   * Check if a command or a chain of commands can be executed. Without executing it.
+   */
+  get can() {
+    return () => this.createCan();
+  }
+  /**
+   * Creates a chain of commands.
+   * @param startTr Start transaction.
+   * @param shouldDispatch Should dispatch or not.
+   */
+  createChain(startTr, shouldDispatch = true) {
+    const { editor, state, rawCommands } = this;
+    const { view } = editor;
+    const callbacks = [];
+    const hasStartTr = !!startTr;
+    const tr = startTr || state.tr;
+    const run2 = () => {
+      if (!hasStartTr && shouldDispatch && !tr.getMeta("preventDispatch")) {
+        view.dispatch(tr);
+      }
+      return callbacks.every((cb) => cb === true);
+    };
+    const entries = Object.entries(rawCommands).map(([name, command2]) => {
+      const chainedCommand = (...args) => {
+        const props = this.createProps(tr, shouldDispatch);
+        const callback = command2(...args)(props);
+        callbacks.push(callback);
+        return chain;
+      };
+      return [name, chainedCommand];
+    });
+    const chain = {
+      ...Object.fromEntries(entries),
+      run: run2
+    };
+    return chain;
+  }
+  /**
+   * Creates a can check for commands.
+   * @param startTr Start transaction.
+   */
+  createCan(startTr) {
+    const { rawCommands, state } = this;
+    const dispatch = false;
+    const tr = startTr || state.tr;
+    const props = this.createProps(tr, dispatch);
+    const commands2 = Object.fromEntries(
+      Object.entries(rawCommands).map(([name, command2]) => {
+        return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
+      })
+    );
+    return {
+      ...commands2,
+      chain: () => this.createChain(tr, dispatch)
+    };
+  }
+  /**
+   * Creates default props for the command method.
+   * @param {*} tr Transaction.
+   * @param {*} shouldDispatch Check if should dispatch.
+   * @returns Object with props.
+   */
+  createProps(tr, shouldDispatch = true) {
+    const { editor, state, rawCommands } = this;
+    const { view } = editor;
+    const props = {
+      tr,
+      editor,
+      view,
+      state: chainableEditorState(tr, state),
+      dispatch: shouldDispatch ? () => void 0 : void 0,
+      chain: () => this.createChain(tr, shouldDispatch),
+      can: () => this.createCan(tr),
+      get commands() {
+        return Object.fromEntries(
+          Object.entries(rawCommands).map(([name, command2]) => {
+            return [name, (...args) => command2(...args)(props)];
+          })
+        );
+      }
+    };
+    return props;
+  }
+}
+function getHTMLFromFragment(fragment, schema) {
+  const documentFragment = DOMSerializer.fromSchema(schema).serializeFragment(fragment);
+  const temporaryDocument = document.implementation.createHTMLDocument();
+  const container = temporaryDocument.createElement("div");
+  container.appendChild(documentFragment);
+  return container.innerHTML;
+}
+const getTextContentFromNodes = ($from, maxMatch = 500) => {
+  let textBefore = "";
+  const sliceEndPos = $from.parentOffset;
+  $from.parent.nodesBetween(
+    Math.max(0, sliceEndPos - maxMatch),
+    sliceEndPos,
+    (node, pos, parent, index2) => {
+      const chunk = node.type.spec.toText?.({
+        node,
+        pos,
+        parent,
+        index: index2
+      }) || node.textContent || "%leaf%";
+      textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos));
+    }
+  );
+  return textBefore;
+};
+class InputRule {
+  constructor(config) {
+    __publicField(this, "match");
+    __publicField(this, "handler");
+    this.match = config.match;
+    this.handler = config.handler;
+  }
+}
+const inputRuleMatcherHandler = (text, match) => {
+  if (isRegExp(match)) {
+    return match.exec(text);
+  }
+  const inputRuleMatch = match(text);
+  if (!inputRuleMatch) {
+    return null;
+  }
+  const result = [inputRuleMatch.text];
+  result.index = inputRuleMatch.index;
+  result.input = text;
+  result.data = inputRuleMatch.data;
+  if (inputRuleMatch.replaceWith) {
+    if (!inputRuleMatch.text.includes(inputRuleMatch.replaceWith)) {
+      console.warn(
+        '[super-editor warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".'
+      );
+    }
+    result.push(inputRuleMatch.replaceWith);
+  }
+  return result;
+};
+const run = (config) => {
+  const {
+    editor,
+    from: from2,
+    to,
+    text,
+    rules,
+    plugin
+  } = config;
+  const { view } = editor;
+  if (view.composing) {
+    return false;
+  }
+  const $from = view.state.doc.resolve(from2);
+  if ($from.parent.type.spec.code || !!($from.nodeBefore || $from.nodeAfter)?.marks.find((mark) => mark.type.spec.code)) {
+    return false;
+  }
+  let matched = false;
+  const textBefore = getTextContentFromNodes($from) + text;
+  rules.forEach((rule) => {
+    if (matched) {
+      return;
+    }
+    const match = inputRuleMatcherHandler(textBefore, rule.match);
+    if (!match) {
+      return;
+    }
+    const tr = view.state.tr;
+    const state = chainableEditorState(tr, view.state);
+    const range = {
+      from: from2 - (match[0].length - text.length),
+      to
+    };
+    const { commands: commands2, chain, can } = new CommandService({
+      editor,
+      state
+    });
+    const handler = rule.handler({
+      state,
+      range,
+      match,
+      commands: commands2,
+      chain,
+      can
+    });
+    if (handler === null || !tr.steps.length) {
+      return;
+    }
+    tr.setMeta(plugin, {
+      transform: tr,
+      from: from2,
+      to,
+      text
+    });
+    view.dispatch(tr);
+    matched = true;
+  });
+  return matched;
+};
+const inputRulesPlugin = ({ editor, rules }) => {
+  const plugin = new Plugin({
+    key: new PluginKey("inputRulesPlugin"),
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr, prev, state) {
+        const stored = tr.getMeta(plugin);
+        if (stored) {
+          return stored;
+        }
+        const simulatedInputMeta = tr.getMeta("applyInputRules");
+        const isSimulatedInput = !!simulatedInputMeta;
+        if (isSimulatedInput) {
+          setTimeout(() => {
+            let { text } = simulatedInputMeta;
+            if (typeof text !== "string") {
+              text = getHTMLFromFragment(Fragment.from(text), state.schema);
+            }
+            const { from: from2 } = simulatedInputMeta;
+            const to = from2 + text.length;
+            run({
+              editor,
+              from: from2,
+              to,
+              text,
+              rules,
+              plugin
+            });
+          });
+        }
+        return tr.selectionSet || tr.docChanged ? null : prev;
+      }
+    },
+    props: {
+      handleTextInput(view, from2, to, text) {
+        return run({
+          editor,
+          from: from2,
+          to,
+          text,
+          rules,
+          plugin
+        });
+      },
+      // add support for input rules to trigger on enter
+      // this is useful for example for code blocks
+      handleKeyDown(view, event) {
+        if (event.key !== "Enter") {
+          return false;
+        }
+        const { $cursor } = view.state.selection;
+        if ($cursor) {
+          return run({
+            editor,
+            from: $cursor.pos,
+            to: $cursor.pos,
+            text: "\n",
+            rules,
+            plugin
+          });
+        }
+        return false;
+      }
+    },
+    isInputRules: true
+  });
+  return plugin;
+};
 const _ExtensionService = class _ExtensionService {
   constructor(extensions, userExtensions, editor) {
     __privateAdd(this, _ExtensionService_instances);
@@ -8045,6 +8396,7 @@ const _ExtensionService = class _ExtensionService {
   get plugins() {
     const editor = this.editor;
     const extensions = _ExtensionService.sortByPriority([...this.extensions].reverse());
+    const inputRules = [];
     const allPlugins = extensions.map((extension) => {
       const context = {
         name: extension.name,
@@ -8063,6 +8415,10 @@ const _ExtensionService = class _ExtensionService {
         bindingsObject = { ...Object.fromEntries(entries) };
       }
       plugins.push(keymap(bindingsObject));
+      const addInputRules = getExtensionConfigField(extension, "addInputRules", context);
+      if (isExtensionRulesEnabled(extension, editor.options.enableInputRules) && addInputRules) {
+        inputRules.push(...addInputRules());
+      }
       const addPmPlugins = getExtensionConfigField(extension, "addPmPlugins", context);
       if (addPmPlugins) {
         const pmPlugins = addPmPlugins();
@@ -8070,7 +8426,13 @@ const _ExtensionService = class _ExtensionService {
       }
       return plugins;
     }).flat();
-    return [...allPlugins];
+    return [
+      inputRulesPlugin({
+        editor,
+        rules: inputRules
+      }),
+      ...allPlugins
+    ];
   }
   /**
    * Get all node views from the extensions.
@@ -8161,164 +8523,6 @@ attachEditorEvents_fn = function(extension) {
   if (onDestroy2) this.editor.on("destroy", onDestroy2);
 };
 let ExtensionService = _ExtensionService;
-function chainableEditorState(transaction, state) {
-  let { selection, doc: doc2, 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 doc2;
-    },
-    get tr() {
-      selection = transaction.selection;
-      doc2 = transaction.doc;
-      storedMarks = transaction.storedMarks;
-      return transaction;
-    }
-  };
-}
-class CommandService {
-  constructor(props) {
-    __publicField(this, "editor");
-    __publicField(this, "rawCommands");
-    this.editor = props.editor;
-    this.rawCommands = this.editor.extensionService.commands;
-  }
-  /**
-   * Static method for creating a service.
-   * @param args Arguments for the constructor.
-   */
-  static create(...args) {
-    return new CommandService(...args);
-  }
-  /**
-   * Get editor state.
-   */
-  get state() {
-    return this.editor.state;
-  }
-  /**
-   * Get all commands with wrapped command method.
-   */
-  get commands() {
-    const { editor, state } = this;
-    const { view } = editor;
-    const { tr } = state;
-    const props = this.createProps(tr);
-    const entries = Object.entries(this.rawCommands).map(([name, command2]) => {
-      const method = (...args) => {
-        const fn2 = command2(...args)(props);
-        if (!tr.getMeta("preventDispatch")) {
-          view.dispatch(tr);
-        }
-        return fn2;
-      };
-      return [name, method];
-    });
-    return Object.fromEntries(entries);
-  }
-  /**
-   * Create a chain of commands to call multiple commands at once.
-   */
-  get chain() {
-    return () => this.createChain();
-  }
-  /**
-   * Check if a command or a chain of commands can be executed. Without executing it.
-   */
-  get can() {
-    return () => this.createCan();
-  }
-  /**
-   * Creates a chain of commands.
-   * @param startTr Start transaction.
-   * @param shouldDispatch Should dispatch or not.
-   */
-  createChain(startTr, shouldDispatch = true) {
-    const { editor, state, rawCommands } = this;
-    const { view } = editor;
-    const callbacks = [];
-    const hasStartTr = !!startTr;
-    const tr = startTr || state.tr;
-    const run = () => {
-      if (!hasStartTr && shouldDispatch && !tr.getMeta("preventDispatch")) {
-        view.dispatch(tr);
-      }
-      return callbacks.every((cb) => cb === true);
-    };
-    const entries = Object.entries(rawCommands).map(([name, command2]) => {
-      const chainedCommand = (...args) => {
-        const props = this.createProps(tr, shouldDispatch);
-        const callback = command2(...args)(props);
-        callbacks.push(callback);
-        return chain;
-      };
-      return [name, chainedCommand];
-    });
-    const chain = {
-      ...Object.fromEntries(entries),
-      run
-    };
-    return chain;
-  }
-  /**
-   * Creates a can check for commands.
-   * @param startTr Start transaction.
-   */
-  createCan(startTr) {
-    const { rawCommands, state } = this;
-    const dispatch = false;
-    const tr = startTr || state.tr;
-    const props = this.createProps(tr, dispatch);
-    const commands2 = Object.fromEntries(
-      Object.entries(rawCommands).map(([name, command2]) => {
-        return [name, (...args) => command2(...args)({ ...props, dispatch: void 0 })];
-      })
-    );
-    return {
-      ...commands2,
-      chain: () => this.createChain(tr, dispatch)
-    };
-  }
-  /**
-   * Creates default props for the command method.
-   * @param {*} tr Transaction.
-   * @param {*} shouldDispatch Check if should dispatch.
-   * @returns Object with props.
-   */
-  createProps(tr, shouldDispatch = true) {
-    const { editor, state, rawCommands } = this;
-    const { view } = editor;
-    const props = {
-      tr,
-      editor,
-      view,
-      state: chainableEditorState(tr, state),
-      dispatch: shouldDispatch ? () => void 0 : void 0,
-      chain: () => this.createChain(tr, shouldDispatch),
-      can: () => this.createCan(tr),
-      get commands() {
-        return Object.fromEntries(
-          Object.entries(rawCommands).map(([name, command2]) => {
-            return [name, (...args) => command2(...args)(props)];
-          })
-        );
-      }
-    };
-    return props;
-  }
-}
 const first = (commands2) => (props) => {
   const items = typeof commands2 === "function" ? commands2(props) : commands2;
   for (let i = 0; i < items.length; i += 1) {
@@ -9355,6 +9559,30 @@ const insertContentAt = (position, value, options) => ({ tr, dispatch, editor })
   }
   return true;
 };
+const undoInputRule = () => ({ state, dispatch }) => {
+  const plugins = state.plugins;
+  for (let i = 0; i < plugins.length; i += 1) {
+    const plugin = plugins[i];
+    let undoable;
+    if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+      if (dispatch) {
+        const tr = state.tr;
+        const toUndo = undoable.transform;
+        for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
+          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);
+        }
+      }
+      return true;
+    }
+  }
+  return false;
+};
 function wrapInList$1(listType, attrs = null) {
   return function(state, dispatch) {
     let { $from, $to } = state.selection;
@@ -9684,6 +9912,7 @@ const commands = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProp
   toggleList,
   toggleMark,
   toggleNode,
+  undoInputRule,
   unsetAllMarks,
   unsetMark,
   updateAttributes,
@@ -9713,6 +9942,7 @@ const Keymap = Extension.create({
       () => commands2.splitBlock()
     ]);
     const handleBackspace = () => this.editor.commands.first(({ commands: commands2, tr }) => [
+      () => commands2.undoInputRule(),
       () => {
         tr.setMeta("inputType", "deleteContentBackward");
         return false;
@@ -11375,6 +11605,7 @@ const _Editor = class _Editor extends EventEmitter {
       editorProps: {},
       parseOptions: {},
       coreExtensionOptions: {},
+      enableInputRules: true,
       isCommentsEnabled: false,
       isNewFile: false,
       scale: 1,
@@ -11813,7 +12044,7 @@ const _Editor = class _Editor extends EventEmitter {
    * @returns {Y.Doc | undefined} Updated Y.Doc if any, otherwise undefined
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "0.8.9");
+    console.debug("[checkVersionMigrations] Current editor version", "0.8.11");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -13206,6 +13437,45 @@ const RunItem = Node.create({
     };
   }
 });
+function wrappingInputRule(config) {
+  return new InputRule({
+    match: config.match,
+    handler: ({
+      state,
+      range,
+      match,
+      chain
+    }) => {
+      const attributes = callOrGet(config.getAttributes, null, match) || {};
+      const tr = state.tr.delete(range.from, range.to);
+      const $start = tr.doc.resolve(range.from);
+      const blockRange = $start.blockRange();
+      const wrapping = blockRange && findWrapping(blockRange, config.type, attributes);
+      if (!wrapping) {
+        return null;
+      }
+      tr.wrap(blockRange, wrapping);
+      if (config.keepMarks && config.editor) {
+        const { selection, storedMarks } = state;
+        const { splittableMarks } = config.editor.extensionService;
+        const marks = storedMarks || selection.$to.parentOffset && selection.$from.marks();
+        if (marks) {
+          const filteredMarks = marks.filter((mark) => splittableMarks.includes(mark.type.name));
+          tr.ensureMarks(filteredMarks);
+        }
+      }
+      if (config.keepAttributes) {
+        const nodeType = config.type.name === "bulletList" || config.type.name === "orderedList" ? "listItem" : config.type.name;
+        chain().updateAttributes(nodeType, attributes).run();
+      }
+      const before = tr.doc.resolve(range.from - 1).nodeBefore;
+      if (before && before.type === config.type && canJoin(tr.doc, range.from - 1) && (!config.joinPredicate || config.joinPredicate(match, before))) {
+        tr.join(range.from - 1);
+      }
+    }
+  });
+}
+const inputRegex$1 = /^\s*([-+*])\s$/;
 const BulletList = Node.create({
   name: "bulletList",
   group: "block list",
@@ -13216,7 +13486,8 @@ const BulletList = Node.create({
     return {
       itemTypeName: "listItem",
       htmlAttributes: {},
-      keepMarks: true
+      keepMarks: true,
+      keepAttributes: false
     };
   },
   parseDOM() {
@@ -13254,8 +13525,29 @@ const BulletList = Node.create({
         return this.editor.commands.toggleBulletList();
       }
     };
-  }
+  },
   // Input rules.
+  addInputRules() {
+    let inputRule = wrappingInputRule({
+      match: inputRegex$1,
+      type: this.type
+    });
+    if (this.options.keepMarks || this.options.keepAttributes) {
+      inputRule = wrappingInputRule({
+        match: inputRegex$1,
+        type: this.type,
+        keepMarks: this.options.keepMarks,
+        keepAttributes: this.options.keepAttributes,
+        getAttributes: () => {
+          return this.editor.getAttributes("textStyle");
+        },
+        editor: this.editor
+      });
+    }
+    return [
+      inputRule
+    ];
+  }
 });
 function orderedListSync(options = {}) {
   return new Plugin({
@@ -13466,6 +13758,7 @@ function buildFirstListItemAttrs({ state, listItems }) {
     listNumberingType
   };
 }
+const inputRegex = /^(\d+)\.\s$/;
 const OrderedList = Node.create({
   name: "orderedList",
   group: "block list",
@@ -13477,6 +13770,7 @@ const OrderedList = Node.create({
       itemTypeName: "listItem",
       htmlAttributes: {},
       keepMarks: true,
+      keepAttributes: false,
       listStyleTypes: ["decimal", "lowerAlpha", "lowerRoman"]
     };
   },
@@ -13634,6 +13928,28 @@ const OrderedList = Node.create({
   },
   addPmPlugins() {
     return [orderedListMarker(), orderedListSync()];
+  },
+  addInputRules() {
+    let inputRule = wrappingInputRule({
+      match: inputRegex,
+      type: this.type,
+      getAttributes: (match) => ({ start: +match[1] }),
+      joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1]
+    });
+    if (this.options.keepMarks || this.options.keepAttributes) {
+      inputRule = wrappingInputRule({
+        match: inputRegex,
+        type: this.type,
+        keepMarks: this.options.keepMarks,
+        keepAttributes: this.options.keepAttributes,
+        getAttributes: (match) => ({ start: +match[1], ...this.editor.getAttributes("textStyle") }),
+        joinPredicate: (match, node) => node.childCount + node.attrs.start === +match[1],
+        editor: this.editor
+      });
+    }
+    return [
+      inputRule
+    ];
   }
 });
 function randomId() {
@@ -22636,6 +22952,7 @@ const onImageLoad = (editor) => {
 const getRichTextExtensions = () => {
   return [
     Bold,
+    BulletList,
     Color,
     Document,
     FontFamily,
@@ -22643,8 +22960,10 @@ const getRichTextExtensions = () => {
     History,
     Heading,
     Italic,
+    ListItem,
     LineHeight,
     Link,
+    OrderedList,
     Paragraph,
     LineBreak,
     HardBreak,
@@ -22749,4 +23068,4 @@ export {
   redoDepth as r,
   undoDepth as u
 };
-//# sourceMappingURL=editor-BChxC9A0.js.map
+//# sourceMappingURL=editor-H6Apbtdi.js.map