@atlaskit/editor-plugin-text-formatting 0.1.0

package/dist/esm/commands/text-formatting.js

@@ -0,0 +1,134 @@
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { withAnalytics } from '@atlaskit/editor-common/editor-analytics';
+import { applyMarkOnRange } from '@atlaskit/editor-common/mark';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import { hasCode, markActive } from '../utils';
+export var moveRight = function moveRight() {
+  return function (state, dispatch) {
+    var code = state.schema.marks.code;
+    var _ref = state.selection,
+      empty = _ref.empty,
+      $cursor = _ref.$cursor;
+    if (!empty || !$cursor) {
+      return false;
+    }
+    var storedMarks = state.tr.storedMarks;
+    if (code) {
+      var insideCode = markActive(state, code.create());
+      var currentPosHasCode = state.doc.rangeHasMark($cursor.pos, $cursor.pos, code);
+      var nextPosHasCode = state.doc.rangeHasMark($cursor.pos, $cursor.pos + 1, code);
+      var exitingCode = !currentPosHasCode && !nextPosHasCode && (!storedMarks || !!storedMarks.length);
+      var enteringCode = !currentPosHasCode && nextPosHasCode && (!storedMarks || !storedMarks.length);
+
+      // entering code mark (from the left edge): don't move the cursor, just add the mark
+      if (!insideCode && enteringCode) {
+        if (dispatch) {
+          dispatch(state.tr.addStoredMark(code.create()));
+        }
+        return true;
+      }
+
+      // exiting code mark: don't move the cursor, just remove the mark
+      if (insideCode && exitingCode) {
+        if (dispatch) {
+          dispatch(state.tr.removeStoredMark(code));
+        }
+        return true;
+      }
+    }
+    return false;
+  };
+};
+export var moveLeft = function moveLeft() {
+  return function (state, dispatch) {
+    var code = state.schema.marks.code;
+    var _ref2 = state.selection,
+      empty = _ref2.empty,
+      $cursor = _ref2.$cursor;
+    if (!empty || !$cursor) {
+      return false;
+    }
+    var storedMarks = state.tr.storedMarks;
+    if (code) {
+      var insideCode = code && markActive(state, code.create());
+      var currentPosHasCode = hasCode(state, $cursor.pos);
+      var nextPosHasCode = hasCode(state, $cursor.pos - 1);
+      var nextNextPosHasCode = hasCode(state, $cursor.pos - 2);
+      var exitingCode = currentPosHasCode && !nextPosHasCode && Array.isArray(storedMarks);
+      var atLeftEdge = nextPosHasCode && !nextNextPosHasCode && (storedMarks === null || Array.isArray(storedMarks) && !!storedMarks.length);
+      var atRightEdge = (exitingCode && Array.isArray(storedMarks) && !storedMarks.length || !exitingCode && storedMarks === null) && !nextPosHasCode && nextNextPosHasCode;
+      var enteringCode = !currentPosHasCode && nextPosHasCode && Array.isArray(storedMarks) && !storedMarks.length;
+
+      // at the right edge: remove code mark and move the cursor to the left
+      if (!insideCode && atRightEdge) {
+        var tr = state.tr.setSelection(Selection.near(state.doc.resolve($cursor.pos - 1)));
+        if (dispatch) {
+          dispatch(tr.removeStoredMark(code));
+        }
+        return true;
+      }
+
+      // entering code mark (from right edge): don't move the cursor, just add the mark
+      if (!insideCode && enteringCode) {
+        if (dispatch) {
+          dispatch(state.tr.addStoredMark(code.create()));
+        }
+        return true;
+      }
+
+      // at the left edge: add code mark and move the cursor to the left
+      if (insideCode && atLeftEdge) {
+        var _tr = state.tr.setSelection(Selection.near(state.doc.resolve($cursor.pos - 1)));
+        if (dispatch) {
+          dispatch(_tr.addStoredMark(code.create()));
+        }
+        return true;
+      }
+
+      // exiting code mark (or at the beginning of the line): don't move the cursor, just remove the mark
+      var isFirstChild = $cursor.index($cursor.depth - 1) === 0;
+      if (insideCode && (exitingCode || !$cursor.nodeBefore && isFirstChild)) {
+        if (dispatch) {
+          dispatch(state.tr.removeStoredMark(code));
+        }
+        return true;
+      }
+    }
+    return false;
+  };
+};
+var createInlineCodeFromTextInput = function createInlineCodeFromTextInput(from, to, text) {
+  return function (state, dispatch) {
+    if (state.selection.empty) {
+      var _state$doc$resolve = state.doc.resolve(from),
+        before = _state$doc$resolve.nodeBefore;
+      var _state$doc$resolve2 = state.doc.resolve(to),
+        after = _state$doc$resolve2.nodeAfter;
+      var hasTickBefore = before && before.text && before.text.endsWith('`');
+      var hasTickAfter = after && after.text && after.text.startsWith('`');
+      if (hasTickBefore && hasTickAfter) {
+        var tr = state.tr.replaceRangeWith(from - 1, to + 1, state.schema.text(text));
+        if (dispatch) {
+          var codeMark = state.schema.marks.code.create();
+          tr = applyMarkOnRange(tr.mapping.map(from - 1), tr.mapping.map(to + 1), false, codeMark, tr).setStoredMarks([codeMark]);
+          dispatch(tr);
+        }
+        return true;
+      }
+    }
+    return false;
+  };
+};
+export var createInlineCodeFromTextInputWithAnalytics = function createInlineCodeFromTextInputWithAnalytics(editorAnalyticsAPI) {
+  return function (from, to, text) {
+    return withAnalytics(editorAnalyticsAPI, {
+      action: ACTION.FORMATTED,
+      actionSubject: ACTION_SUBJECT.TEXT,
+      eventType: EVENT_TYPE.TRACK,
+      actionSubjectId: ACTION_SUBJECT_ID.FORMAT_CODE,
+      attributes: {
+        inputMethod: INPUT_METHOD.FORMATTING
+      }
+    })(createInlineCodeFromTextInput(from, to, text));
+  };
+};

package/dist/esm/commands/transform-to-code.js

@@ -0,0 +1,61 @@
+import { filterChildrenBetween } from '@atlaskit/editor-common/mark';
+var SMART_TO_ASCII = {
+  '…': '...',
+  '→': '->',
+  '←': '<-',
+  '–': '--',
+  '“': '"',
+  '”': '"',
+  '‘': "'",
+  '’': "'"
+};
+var FIND_SMART_CHAR = new RegExp("[".concat(Object.keys(SMART_TO_ASCII).join(''), "]"), 'g');
+var replaceMentionOrEmojiForTextContent = function replaceMentionOrEmojiForTextContent(position, nodeSize, textContent, tr) {
+  var currentPos = tr.mapping.map(position);
+  var schema = tr.doc.type.schema;
+  tr.replaceWith(currentPos, currentPos + nodeSize, schema.text(textContent));
+};
+var replaceSmartCharsToAscii = function replaceSmartCharsToAscii(position, textContent, tr) {
+  var schema = tr.doc.type.schema;
+  var match;
+  while (match = FIND_SMART_CHAR.exec(textContent)) {
+    var _match = match,
+      smartChar = _match[0],
+      offset = _match.index;
+    var replacePos = tr.mapping.map(position + offset);
+    var replacementText = schema.text(SMART_TO_ASCII[smartChar]);
+    tr.replaceWith(replacePos, replacePos + smartChar.length, replacementText);
+  }
+};
+var isNodeTextBlock = function isNodeTextBlock(schema) {
+  var _schema$nodes = schema.nodes,
+    mention = _schema$nodes.mention,
+    text = _schema$nodes.text,
+    emoji = _schema$nodes.emoji;
+  return function (node, _, parent) {
+    if (node.type === mention || node.type === emoji || node.type === text) {
+      return parent === null || parent === void 0 ? void 0 : parent.isTextblock;
+    }
+    return;
+  };
+};
+export var transformSmartCharsMentionsAndEmojis = function transformSmartCharsMentionsAndEmojis(from, to, tr) {
+  var schema = tr.doc.type.schema;
+  var _schema$nodes2 = schema.nodes,
+    mention = _schema$nodes2.mention,
+    text = _schema$nodes2.text,
+    emoji = _schema$nodes2.emoji;
+  // Traverse through all the nodes within the range and replace them with their plaintext counterpart
+  var children = filterChildrenBetween(tr.doc, from, to, isNodeTextBlock(schema));
+  children.forEach(function (_ref) {
+    var node = _ref.node,
+      pos = _ref.pos;
+    if (node.type === mention || node.type === emoji) {
+      replaceMentionOrEmojiForTextContent(pos, node.nodeSize, node.attrs.text, tr);
+    } else if (node.type === text && node.text) {
+      var replacePosition = pos > from ? pos : from;
+      var textToReplace = pos > from ? node.text : node.text.substr(from - pos);
+      replaceSmartCharsToAscii(replacePosition, textToReplace, tr);
+    }
+  });
+};

package/dist/esm/index.js

@@ -0,0 +1 @@
+export { textFormattingPlugin } from './plugin';

package/dist/esm/plugin.js

@@ -0,0 +1,125 @@
+import React from 'react';
+import { code, em, strike, strong, subsup, underline } from '@atlaskit/adf-schema';
+import { WithPluginState } from '@atlaskit/editor-common/with-plugin-state';
+import { toggleCodeWithAnalytics, toggleEmWithAnalytics, toggleStrikeWithAnalytics, toggleStrongWithAnalytics, toggleSubscriptWithAnalytics, toggleSuperscriptWithAnalytics, toggleUnderlineWithAnalytics } from './actions';
+import { plugin as clearFormattingPlugin, pluginKey as clearFormattingPluginKey } from './pm-plugins/clear-formatting';
+import clearFormattingKeymapPlugin from './pm-plugins/clear-formatting-keymap';
+import textFormattingCursorPlugin from './pm-plugins/cursor';
+import textFormattingInputRulePlugin from './pm-plugins/input-rule';
+import keymapPlugin from './pm-plugins/keymap';
+import { plugin as pmPlugin, pluginKey as textFormattingPluginKey } from './pm-plugins/main';
+import textFormattingSmartInputRulePlugin from './pm-plugins/smart-input-rule';
+import Toolbar from './ui/Toolbar';
+export var textFormattingPlugin = function textFormattingPlugin() {
+  var _api$dependencies$ana7, _api$dependencies$ana8, _api$dependencies$ana9, _api$dependencies$ana10, _api$dependencies$ana11, _api$dependencies$ana12, _api$dependencies$ana13;
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var api = arguments.length > 1 ? arguments[1] : undefined;
+  return {
+    name: 'textFormatting',
+    marks: function marks() {
+      return [{
+        name: 'em',
+        mark: em
+      }, {
+        name: 'strong',
+        mark: strong
+      }, {
+        name: 'strike',
+        mark: strike
+      }].concat(options.disableCode ? [] : {
+        name: 'code',
+        mark: code
+      }).concat(options.disableSuperscriptAndSubscript ? [] : {
+        name: 'subsup',
+        mark: subsup
+      }).concat(options.disableUnderline ? [] : {
+        name: 'underline',
+        mark: underline
+      });
+    },
+    pmPlugins: function pmPlugins() {
+      return [{
+        name: 'textFormatting',
+        plugin: function plugin(_ref) {
+          var _api$dependencies$ana;
+          var dispatch = _ref.dispatch;
+          return pmPlugin(dispatch, api === null || api === void 0 ? void 0 : (_api$dependencies$ana = api.dependencies.analytics) === null || _api$dependencies$ana === void 0 ? void 0 : _api$dependencies$ana.actions);
+        }
+      }, {
+        name: 'textFormattingCursor',
+        plugin: function plugin() {
+          return textFormattingCursorPlugin;
+        }
+      }, {
+        name: 'textFormattingInputRule',
+        plugin: function plugin(_ref2) {
+          var _api$dependencies$ana2;
+          var schema = _ref2.schema;
+          return textFormattingInputRulePlugin(schema, api === null || api === void 0 ? void 0 : (_api$dependencies$ana2 = api.dependencies.analytics) === null || _api$dependencies$ana2 === void 0 ? void 0 : _api$dependencies$ana2.actions);
+        }
+      }, {
+        name: 'textFormattingSmartRule',
+        plugin: function plugin() {
+          var _api$dependencies$ana3;
+          return !options.disableSmartTextCompletion ? textFormattingSmartInputRulePlugin(api === null || api === void 0 ? void 0 : (_api$dependencies$ana3 = api.dependencies.analytics) === null || _api$dependencies$ana3 === void 0 ? void 0 : _api$dependencies$ana3.actions) : undefined;
+        }
+      }, {
+        name: 'textFormattingClear',
+        plugin: function plugin(_ref3) {
+          var dispatch = _ref3.dispatch;
+          return clearFormattingPlugin(dispatch);
+        }
+      }, {
+        name: 'textFormattingClearKeymap',
+        plugin: function plugin() {
+          var _api$dependencies$ana4;
+          return clearFormattingKeymapPlugin(api === null || api === void 0 ? void 0 : (_api$dependencies$ana4 = api.dependencies.analytics) === null || _api$dependencies$ana4 === void 0 ? void 0 : _api$dependencies$ana4.actions);
+        }
+      }, {
+        name: 'textFormattingKeymap',
+        plugin: function plugin(_ref4) {
+          var _api$dependencies$ana5;
+          var schema = _ref4.schema;
+          return keymapPlugin(schema, api === null || api === void 0 ? void 0 : (_api$dependencies$ana5 = api.dependencies.analytics) === null || _api$dependencies$ana5 === void 0 ? void 0 : _api$dependencies$ana5.actions);
+        }
+      }];
+    },
+    primaryToolbarComponent: function primaryToolbarComponent(_ref5) {
+      var editorView = _ref5.editorView,
+        popupsMountPoint = _ref5.popupsMountPoint,
+        popupsScrollableElement = _ref5.popupsScrollableElement,
+        isToolbarReducedSpacing = _ref5.isToolbarReducedSpacing,
+        toolbarSize = _ref5.toolbarSize,
+        disabled = _ref5.disabled;
+      return /*#__PURE__*/React.createElement(WithPluginState, {
+        plugins: {
+          textFormattingState: textFormattingPluginKey,
+          clearFormattingPluginState: clearFormattingPluginKey
+        },
+        render: function render() {
+          var _api$dependencies$ana6;
+          return /*#__PURE__*/React.createElement(Toolbar, {
+            editorState: editorView.state,
+            popupsMountPoint: popupsMountPoint,
+            popupsScrollableElement: popupsScrollableElement,
+            toolbarSize: toolbarSize,
+            isReducedSpacing: isToolbarReducedSpacing,
+            editorView: editorView,
+            isToolbarDisabled: disabled,
+            shouldUseResponsiveToolbar: Boolean(options.responsiveToolbarMenu),
+            editorAnalyticsAPI: api === null || api === void 0 ? void 0 : (_api$dependencies$ana6 = api.dependencies.analytics) === null || _api$dependencies$ana6 === void 0 ? void 0 : _api$dependencies$ana6.actions
+          });
+        }
+      });
+    },
+    actions: {
+      toggleSuperscript: toggleSuperscriptWithAnalytics(api === null || api === void 0 ? void 0 : (_api$dependencies$ana7 = api.dependencies.analytics) === null || _api$dependencies$ana7 === void 0 ? void 0 : _api$dependencies$ana7.actions),
+      toggleSubscript: toggleSubscriptWithAnalytics(api === null || api === void 0 ? void 0 : (_api$dependencies$ana8 = api.dependencies.analytics) === null || _api$dependencies$ana8 === void 0 ? void 0 : _api$dependencies$ana8.actions),
+      toggleStrike: toggleStrikeWithAnalytics(api === null || api === void 0 ? void 0 : (_api$dependencies$ana9 = api.dependencies.analytics) === null || _api$dependencies$ana9 === void 0 ? void 0 : _api$dependencies$ana9.actions),
+      toggleCode: toggleCodeWithAnalytics(api === null || api === void 0 ? void 0 : (_api$dependencies$ana10 = api.dependencies.analytics) === null || _api$dependencies$ana10 === void 0 ? void 0 : _api$dependencies$ana10.actions),
+      toggleUnderline: toggleUnderlineWithAnalytics(api === null || api === void 0 ? void 0 : (_api$dependencies$ana11 = api.dependencies.analytics) === null || _api$dependencies$ana11 === void 0 ? void 0 : _api$dependencies$ana11.actions),
+      toggleEm: toggleEmWithAnalytics(api === null || api === void 0 ? void 0 : (_api$dependencies$ana12 = api.dependencies.analytics) === null || _api$dependencies$ana12 === void 0 ? void 0 : _api$dependencies$ana12.actions),
+      toggleStrong: toggleStrongWithAnalytics(api === null || api === void 0 ? void 0 : (_api$dependencies$ana13 = api.dependencies.analytics) === null || _api$dependencies$ana13 === void 0 ? void 0 : _api$dependencies$ana13.actions)
+    }
+  };
+};

package/dist/esm/pm-plugins/clear-formatting-keymap.js

@@ -0,0 +1,10 @@
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import * as keymaps from '@atlaskit/editor-common/keymaps';
+import { keymap } from '@atlaskit/editor-prosemirror/keymap';
+import { clearFormattingWithAnalytics } from '../commands/clear-formatting';
+export function keymapPlugin(editorAnalyticsAPI) {
+  var list = {};
+  keymaps.bindKeymapWithCommand(keymaps.clearFormatting.common, clearFormattingWithAnalytics(INPUT_METHOD.SHORTCUT, editorAnalyticsAPI), list);
+  return keymap(list);
+}
+export default keymapPlugin;

package/dist/esm/pm-plugins/clear-formatting.js

@@ -0,0 +1,28 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+import { checkFormattingIsPresent } from '../utils';
+export var pluginKey = new PluginKey('clearFormattingPlugin');
+export var plugin = function plugin(dispatch) {
+  return new SafePlugin({
+    state: {
+      init: function init(_config, state) {
+        return {
+          formattingIsPresent: checkFormattingIsPresent(state)
+        };
+      },
+      apply: function apply(_tr, pluginState, _oldState, newState) {
+        var formattingIsPresent = checkFormattingIsPresent(newState);
+        if (formattingIsPresent !== pluginState.formattingIsPresent) {
+          dispatch(pluginKey, {
+            formattingIsPresent: formattingIsPresent
+          });
+          return {
+            formattingIsPresent: formattingIsPresent
+          };
+        }
+        return pluginState;
+      }
+    },
+    key: pluginKey
+  });
+};

package/dist/esm/pm-plugins/cursor.js

@@ -0,0 +1,48 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+export default new SafePlugin({
+  props: {
+    handleClick: function handleClick(view, clickPos, event) {
+      // Don't apply in Edge as per ED-4546
+      if (navigator && /Edge\/\d/.test(navigator.userAgent)) {
+        return false;
+      }
+
+      // @see ED-6231
+      if (clickPos > view.state.doc.content.size) {
+        return false;
+      }
+      var code = view.state.schema.marks.code;
+      var paragraph = view.state.schema.nodes.paragraph;
+      var $click = view.state.doc.resolve(clickPos);
+      var clickWasAtEdgeOfATextNode = ($click.nodeBefore ? $click.nodeBefore.isInline : $click.nodeAfter) && ($click.nodeAfter ? $click.nodeAfter.isInline : $click.nodeBefore) && $click.textOffset === 0;
+      var clickWasNearACodeMark = code && ($click.nodeBefore && code.isInSet($click.nodeBefore.marks) || $click.nodeAfter && code.isInSet($click.nodeAfter.marks));
+
+      // Find the starting position of the clicked dom-element
+      // TODO: Remove calls to private API
+      var clickedDOMElementPosition = event.target && event.target instanceof Node && view.posAtDOM(event.target);
+      var clickNode = view.state.doc.nodeAt(clickPos);
+      var clickWasAtTextNode = !!(clickNode && clickNode.isText);
+      var clickWasAtEndOfAParagraphNode = $click.parent.type === paragraph && $click.textOffset === 0 && $click.nodeAfter === null;
+      if (clickWasAtEdgeOfATextNode && clickWasNearACodeMark && clickedDOMElementPosition && (
+      // if click did not occur at a text node or end of paragraph, then
+      // it was at a directly adjacent non-text node, so we skip this manual
+      // text selection logic to preserve that non-text node's selection
+      clickWasAtTextNode || clickWasAtEndOfAParagraphNode)) {
+        var clickWasInsideNodeDOM = event.target.parentNode === view.domAtPos(clickedDOMElementPosition).node && code.isInSet(view.state.doc.resolve(clickedDOMElementPosition).nodeAfter.marks);
+        var nodeNextToClick = $click.nodeBefore && code.isInSet($click.nodeBefore.marks) ? $click.nodeAfter : $click.nodeBefore;
+
+        // Need to set the selection here to allow clicking between [code('text'),{<>},emoji()]
+        var tr = view.state.tr.setSelection(TextSelection.near($click));
+        if (clickWasInsideNodeDOM) {
+          tr.setStoredMarks([code.create()]);
+        } else {
+          tr.setStoredMarks(nodeNextToClick ? nodeNextToClick.marks : []);
+        }
+        view.dispatch(tr);
+        return true;
+      }
+      return false;
+    }
+  }
+});

package/dist/esm/pm-plugins/input-rule.js

@@ -0,0 +1,257 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _get from "@babel/runtime/helpers/get";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _ValidCombinations;
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { transformSmartCharsMentionsAndEmojis } from '@atlaskit/editor-common/mark';
+import { inputRuleWithAnalytics } from '@atlaskit/editor-common/utils';
+import { createPlugin, createRule, leafNodeReplacementCharacter } from '@atlaskit/prosemirror-input-rules';
+var ValidAutoformatChars = /*#__PURE__*/function (ValidAutoformatChars) {
+  ValidAutoformatChars["STRONG"] = "__";
+  ValidAutoformatChars["STRIKE"] = "~~";
+  ValidAutoformatChars["STRONG_MARKDOWN"] = "**";
+  ValidAutoformatChars["ITALIC_MARKDOWN"] = "*";
+  ValidAutoformatChars["ITALIC"] = "_";
+  ValidAutoformatChars["CODE"] = "`";
+  return ValidAutoformatChars;
+}(ValidAutoformatChars || {});
+export var ValidCombinations = (_ValidCombinations = {}, _defineProperty(_ValidCombinations, ValidAutoformatChars.STRIKE, [
+// e.g: _~~lol~~_
+ValidAutoformatChars.ITALIC,
+// e.g: __~~lol~~__
+ValidAutoformatChars.STRONG,
+// e.g: **~~lol~~**
+ValidAutoformatChars.STRONG_MARKDOWN,
+// e.g: *~~lol~~*
+ValidAutoformatChars.ITALIC_MARKDOWN]), _defineProperty(_ValidCombinations, ValidAutoformatChars.STRONG, [
+// e.g: ~~__lol__~~
+ValidAutoformatChars.STRIKE,
+// e.g: *__lol__*
+ValidAutoformatChars.ITALIC_MARKDOWN]), _defineProperty(_ValidCombinations, ValidAutoformatChars.STRONG_MARKDOWN, [
+// e.g: _**lol**_
+ValidAutoformatChars.ITALIC,
+// e.g: ~~**lol**~~
+ValidAutoformatChars.STRIKE]), _defineProperty(_ValidCombinations, ValidAutoformatChars.ITALIC_MARKDOWN, [
+// e.g: ~~*lol*~~
+ValidAutoformatChars.STRIKE,
+// e.g: __*lol*__
+ValidAutoformatChars.STRONG]), _defineProperty(_ValidCombinations, ValidAutoformatChars.ITALIC, [
+// e.g: ~~_lol_~~
+ValidAutoformatChars.STRIKE,
+// e.g: **_lol_**
+ValidAutoformatChars.STRONG_MARKDOWN]), _defineProperty(_ValidCombinations, ValidAutoformatChars.CODE, [
+// e.g: loko (`some code`
+'( ']), _ValidCombinations);
+function addMark(markType, schema, char) {
+  return function (state, match, start, end) {
+    var _schema$marks, _schema$marks$code;
+    var doc = state.doc,
+      schema = state.schema,
+      tr = state.tr;
+    var textPrefix = state.doc.textBetween(start, start + char.length);
+
+    // fixes the following case: my `*name` is *
+    // expected result: should ignore special characters inside "code"
+    if (textPrefix !== char || schema !== null && schema !== void 0 && (_schema$marks = schema.marks) !== null && _schema$marks !== void 0 && (_schema$marks$code = _schema$marks.code) !== null && _schema$marks$code !== void 0 && _schema$marks$code.isInSet(doc.resolve(start + 1).marks())) {
+      return null;
+    }
+
+    // Prevent autoformatting across hardbreaks
+    var containsHardBreak;
+    doc.nodesBetween(start, end, function (node) {
+      if (node.type === schema.nodes.hardBreak) {
+        containsHardBreak = true;
+        return false;
+      }
+      return !containsHardBreak;
+    });
+    if (containsHardBreak) {
+      return null;
+    }
+
+    // fixes autoformatting in heading nodes: # Heading *bold*
+    // expected result: should not autoformat *bold*; <h1>Heading *bold*</h1>
+    var startPosResolved = doc.resolve(start);
+    var endPosResolved = doc.resolve(end);
+    if (startPosResolved.sameParent(endPosResolved) && !startPosResolved.parent.type.allowsMarkType(markType)) {
+      return null;
+    }
+    if (markType.name === 'code') {
+      transformSmartCharsMentionsAndEmojis(tr.mapping.map(start), tr.mapping.map(end), tr);
+    }
+    var mappedStart = tr.mapping.map(start);
+    var mappedEnd = tr.mapping.map(end);
+    tr.addMark(mappedStart, mappedEnd, markType.create());
+    var textSuffix = tr.doc.textBetween(mappedEnd - char.length, mappedEnd);
+    if (textSuffix === char) {
+      tr.delete(mappedEnd - char.length, mappedEnd);
+    }
+    if (textPrefix === char) {
+      tr.delete(mappedStart, mappedStart + char.length);
+    }
+    return tr.removeStoredMark(markType);
+  };
+}
+var ReverseRegexExp = /*#__PURE__*/function (_RegExp) {
+  _inherits(ReverseRegexExp, _RegExp);
+  var _super = _createSuper(ReverseRegexExp);
+  function ReverseRegexExp() {
+    _classCallCheck(this, ReverseRegexExp);
+    return _super.apply(this, arguments);
+  }
+  _createClass(ReverseRegexExp, [{
+    key: "exec",
+    value: function exec(str) {
+      if (!str) {
+        return null;
+      }
+      var reverseStr = _toConsumableArray(str).reverse().join('');
+      var result = _get(_getPrototypeOf(ReverseRegexExp.prototype), "exec", this).call(this, reverseStr);
+      if (!result) {
+        return null;
+      }
+      for (var i = 0; i < result.length; i++) {
+        if (result[i] && typeof result[i] === 'string') {
+          result[i] = _toConsumableArray(result[i]).reverse().join('');
+        }
+      }
+      if (result.input && typeof result.input === 'string') {
+        result.input = _toConsumableArray(result.input).reverse().join('');
+      }
+      if (result.input && result[0]) {
+        result.index = result.input.length - result[0].length;
+      }
+      return result;
+    }
+  }]);
+  return ReverseRegexExp;
+}( /*#__PURE__*/_wrapNativeSuper(RegExp));
+var buildRegex = function buildRegex(char) {
+  var escapedChar = char.replace(/(\W)/g, '\\$1');
+  var combinations = ValidCombinations[char].map(function (c) {
+    return c.replace(/(\W)/g, '\\$1');
+  }).join('|');
+
+  // Single X - https://regex101.com/r/McT3yq/14/
+  // Double X - https://regex101.com/r/pQUgjx/1/
+  var baseRegex = '^X(?=[^X\\s]).*?[^\\sX]X(?=[\\sOBJECT_REPLACEMENT_CHARACTER]COMBINATIONS|$)'.replace('OBJECT_REPLACEMENT_CHARACTER', leafNodeReplacementCharacter).replace('COMBINATIONS', combinations ? "|".concat(combinations) : '');
+  var replacedRegex = String.prototype.hasOwnProperty('replaceAll') ? baseRegex.replaceAll('X', escapedChar) : baseRegex.replace(/X/g, escapedChar);
+  return new ReverseRegexExp(replacedRegex);
+};
+export var strongRegex1 = buildRegex(ValidAutoformatChars.STRONG);
+export var strongRegex2 = buildRegex(ValidAutoformatChars.STRONG_MARKDOWN);
+export var italicRegex1 = buildRegex(ValidAutoformatChars.ITALIC);
+export var italicRegex2 = buildRegex(ValidAutoformatChars.ITALIC_MARKDOWN);
+export var strikeRegex = buildRegex(ValidAutoformatChars.STRIKE);
+export var codeRegex = buildRegex(ValidAutoformatChars.CODE);
+
+/**
+ * Create input rules for strong mark
+ *
+ * @param {Schema} schema
+ * @returns {InputRuleWrapper[]}
+ */
+function getStrongInputRules(schema, editorAnalyticsAPI) {
+  var ruleWithStrongAnalytics = inputRuleWithAnalytics({
+    action: ACTION.FORMATTED,
+    actionSubject: ACTION_SUBJECT.TEXT,
+    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_STRONG,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.FORMATTING
+    }
+  }, editorAnalyticsAPI);
+  // **string** or __strong__ should bold the text
+  var doubleUnderscoreRule = createRule(strongRegex1, addMark(schema.marks.strong, schema, ValidAutoformatChars.STRONG));
+  var doubleAsterixRule = createRule(strongRegex2, addMark(schema.marks.strong, schema, ValidAutoformatChars.STRONG_MARKDOWN));
+  return [ruleWithStrongAnalytics(doubleUnderscoreRule), ruleWithStrongAnalytics(doubleAsterixRule)];
+}
+
+/**
+ * Create input rules for em mark
+ *
+ * @param {Schema} schema
+ * @returns {InputRuleWrapper[]}
+ */
+function getItalicInputRules(schema, editorAnalyticsAPI) {
+  var ruleWithItalicAnalytics = inputRuleWithAnalytics({
+    action: ACTION.FORMATTED,
+    actionSubject: ACTION_SUBJECT.TEXT,
+    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_ITALIC,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.FORMATTING
+    }
+  }, editorAnalyticsAPI);
+  var underscoreRule = createRule(italicRegex1, addMark(schema.marks.em, schema, ValidAutoformatChars.ITALIC));
+  var asterixRule = createRule(italicRegex2, addMark(schema.marks.em, schema, ValidAutoformatChars.ITALIC_MARKDOWN));
+  return [ruleWithItalicAnalytics(underscoreRule), ruleWithItalicAnalytics(asterixRule)];
+}
+
+/**
+ * Create input rules for strike mark
+ *
+ * @param {Schema} schema
+ * @returns {InputRuleWrapper[]}
+ */
+function getStrikeInputRules(schema, editorAnalyticsAPI) {
+  var ruleWithStrikeAnalytics = inputRuleWithAnalytics({
+    action: ACTION.FORMATTED,
+    actionSubject: ACTION_SUBJECT.TEXT,
+    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_STRIKE,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.FORMATTING
+    }
+  }, editorAnalyticsAPI);
+  var doubleTildeRule = createRule(strikeRegex, addMark(schema.marks.strike, schema, ValidAutoformatChars.STRIKE));
+  return [ruleWithStrikeAnalytics(doubleTildeRule)];
+}
+
+/**
+ * Create input rules for code mark
+ *
+ * @param {Schema} schema
+ * @returns {InputRuleWrapper[]}
+ */
+function getCodeInputRules(schema, editorAnalyticsAPI) {
+  var ruleWithCodeAnalytics = inputRuleWithAnalytics({
+    action: ACTION.FORMATTED,
+    actionSubject: ACTION_SUBJECT.TEXT,
+    actionSubjectId: ACTION_SUBJECT_ID.FORMAT_CODE,
+    eventType: EVENT_TYPE.TRACK,
+    attributes: {
+      inputMethod: INPUT_METHOD.FORMATTING
+    }
+  }, editorAnalyticsAPI);
+  var backTickRule = createRule(codeRegex, addMark(schema.marks.code, schema, ValidAutoformatChars.CODE));
+  return [ruleWithCodeAnalytics(backTickRule)];
+}
+export function inputRulePlugin(schema, editorAnalyticsAPI) {
+  var rules = [];
+  if (schema.marks.strong) {
+    rules.push.apply(rules, _toConsumableArray(getStrongInputRules(schema, editorAnalyticsAPI)));
+  }
+  if (schema.marks.em) {
+    rules.push.apply(rules, _toConsumableArray(getItalicInputRules(schema, editorAnalyticsAPI)));
+  }
+  if (schema.marks.strike) {
+    rules.push.apply(rules, _toConsumableArray(getStrikeInputRules(schema, editorAnalyticsAPI)));
+  }
+  if (schema.marks.code) {
+    rules.push.apply(rules, _toConsumableArray(getCodeInputRules(schema, editorAnalyticsAPI)));
+  }
+  if (rules.length !== 0) {
+    return createPlugin('text-formatting', rules);
+  }
+  return;
+}
+export default inputRulePlugin;