@atlaskit/editor-plugin-text-formatting 0.1.0

package/.eslintrc.js

@@ -0,0 +1,7 @@
+module.exports = {
+  rules: {
+    '@typescript-eslint/consistent-type-imports': 'warn',
+    'no-duplicate-imports': 'off',
+    '@typescript-eslint/no-duplicate-imports': 'error',
+  },
+};

package/CHANGELOG.md

@@ -0,0 +1 @@
+# @atlaskit/editor-plugin-text-formatting

package/LICENSE.md

@@ -0,0 +1,13 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,9 @@
+# EditorPluginTextFormatting
+
+Text-formatting plugin for @atlaskit/editor-core
+
+## Usage
+
+`import EditorPluginTextFormatting from '@atlaskit/editor-plugin-text-formatting';`
+
+Detailed docs and example usage can be found [here](https://atlaskit.atlassian.com/packages/editor/editor-plugin-text-formatting).

package/dist/cjs/actions.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toggleUnderlineWithAnalytics = exports.toggleUnderline = exports.toggleSuperscriptWithAnalytics = exports.toggleSuperscript = exports.toggleSubscriptWithAnalytics = exports.toggleSubscript = exports.toggleStrongWithAnalytics = exports.toggleStrong = exports.toggleStrikeWithAnalytics = exports.toggleStrike = exports.toggleEmWithAnalytics = exports.toggleEm = exports.toggleCodeWithAnalytics = exports.toggleCode = void 0;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _editorAnalytics = require("@atlaskit/editor-common/editor-analytics");
+var _mark = require("@atlaskit/editor-common/mark");
+var toggleEm = function toggleEm() {
+  return function (state, dispatch) {
+    var em = state.schema.marks.em;
+    if (em) {
+      return (0, _mark.toggleMark)(em)(state, dispatch);
+    }
+    return false;
+  };
+};
+exports.toggleEm = toggleEm;
+var toggleEmWithAnalytics = function toggleEmWithAnalytics(editorAnalyticsAPI) {
+  return function (_ref) {
+    var inputMethod = _ref.inputMethod;
+    return (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, {
+      action: _analytics.ACTION.FORMATTED,
+      actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_ITALIC,
+      attributes: {
+        inputMethod: inputMethod
+      }
+    })(toggleEm());
+  };
+};
+exports.toggleEmWithAnalytics = toggleEmWithAnalytics;
+var toggleStrike = function toggleStrike() {
+  return function (state, dispatch) {
+    var strike = state.schema.marks.strike;
+    if (strike) {
+      return (0, _mark.toggleMark)(strike)(state, dispatch);
+    }
+    return false;
+  };
+};
+exports.toggleStrike = toggleStrike;
+var toggleStrikeWithAnalytics = function toggleStrikeWithAnalytics(editorAnalyticsAPI) {
+  return function (_ref2) {
+    var inputMethod = _ref2.inputMethod;
+    return (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, {
+      action: _analytics.ACTION.FORMATTED,
+      actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_STRIKE,
+      attributes: {
+        inputMethod: inputMethod
+      }
+    })(toggleStrike());
+  };
+};
+exports.toggleStrikeWithAnalytics = toggleStrikeWithAnalytics;
+var toggleStrong = function toggleStrong() {
+  return function (state, dispatch) {
+    var strong = state.schema.marks.strong;
+    if (strong) {
+      return (0, _mark.toggleMark)(strong)(state, dispatch);
+    }
+    return false;
+  };
+};
+exports.toggleStrong = toggleStrong;
+var toggleStrongWithAnalytics = function toggleStrongWithAnalytics(editorAnalyticsAPI) {
+  return function (_ref3) {
+    var inputMethod = _ref3.inputMethod;
+    return (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, {
+      action: _analytics.ACTION.FORMATTED,
+      actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_STRONG,
+      attributes: {
+        inputMethod: inputMethod
+      }
+    })(toggleStrong());
+  };
+};
+exports.toggleStrongWithAnalytics = toggleStrongWithAnalytics;
+var toggleUnderline = function toggleUnderline() {
+  return function (state, dispatch) {
+    var underline = state.schema.marks.underline;
+    if (underline) {
+      return (0, _mark.toggleMark)(underline)(state, dispatch);
+    }
+    return false;
+  };
+};
+exports.toggleUnderline = toggleUnderline;
+var toggleUnderlineWithAnalytics = function toggleUnderlineWithAnalytics(editorAnalyticsAPI) {
+  return function (_ref4) {
+    var inputMethod = _ref4.inputMethod;
+    return (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, {
+      action: _analytics.ACTION.FORMATTED,
+      actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_UNDERLINE,
+      attributes: {
+        inputMethod: inputMethod
+      }
+    })(toggleUnderline());
+  };
+};
+exports.toggleUnderlineWithAnalytics = toggleUnderlineWithAnalytics;
+var toggleSuperscript = function toggleSuperscript() {
+  return function (state, dispatch) {
+    var subsup = state.schema.marks.subsup;
+    if (subsup) {
+      return (0, _mark.toggleMark)(subsup, {
+        type: 'sup'
+      })(state, dispatch);
+    }
+    return false;
+  };
+};
+exports.toggleSuperscript = toggleSuperscript;
+var toggleSuperscriptWithAnalytics = function toggleSuperscriptWithAnalytics(editorAnalyticsAPI) {
+  return function (_ref5) {
+    var inputMethod = _ref5.inputMethod;
+    return (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, {
+      action: _analytics.ACTION.FORMATTED,
+      actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_SUPER,
+      attributes: {
+        inputMethod: inputMethod
+      }
+    })(toggleSuperscript());
+  };
+};
+exports.toggleSuperscriptWithAnalytics = toggleSuperscriptWithAnalytics;
+var toggleSubscript = function toggleSubscript() {
+  return function (state, dispatch) {
+    var subsup = state.schema.marks.subsup;
+    if (subsup) {
+      return (0, _mark.toggleMark)(subsup, {
+        type: 'sub'
+      })(state, dispatch);
+    }
+    return false;
+  };
+};
+exports.toggleSubscript = toggleSubscript;
+var toggleSubscriptWithAnalytics = function toggleSubscriptWithAnalytics(editorAnalyticsAPI) {
+  return function (_ref6) {
+    var inputMethod = _ref6.inputMethod;
+    return (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, {
+      action: _analytics.ACTION.FORMATTED,
+      actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_SUB,
+      attributes: {
+        inputMethod: inputMethod
+      }
+    })(toggleSubscript());
+  };
+};
+exports.toggleSubscriptWithAnalytics = toggleSubscriptWithAnalytics;
+var toggleCode = function toggleCode() {
+  return function (state, dispatch) {
+    var code = state.schema.marks.code;
+    if (code) {
+      return (0, _mark.toggleMark)(code)(state, dispatch);
+    }
+    return false;
+  };
+};
+exports.toggleCode = toggleCode;
+var toggleCodeWithAnalytics = function toggleCodeWithAnalytics(editorAnalyticsAPI) {
+  return function (_ref7) {
+    var inputMethod = _ref7.inputMethod;
+    return (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, {
+      action: _analytics.ACTION.FORMATTED,
+      actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_CODE,
+      attributes: {
+        inputMethod: inputMethod
+      }
+    })(toggleCode());
+  };
+};
+exports.toggleCodeWithAnalytics = toggleCodeWithAnalytics;

package/dist/cjs/commands/clear-formatting.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FORMATTING_NODE_TYPES = exports.FORMATTING_MARK_TYPES = void 0;
+exports.clearFormatting = clearFormatting;
+exports.clearFormattingWithAnalytics = clearFormattingWithAnalytics;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _cellSelection = require("@atlaskit/editor-tables/cell-selection");
+var _cellSelection2 = require("../utils/cell-selection");
+var FORMATTING_NODE_TYPES = ['heading', 'blockquote'];
+exports.FORMATTING_NODE_TYPES = FORMATTING_NODE_TYPES;
+var FORMATTING_MARK_TYPES = ['em', 'code', 'strike', 'strong', 'underline', 'textColor', 'subsup'];
+exports.FORMATTING_MARK_TYPES = FORMATTING_MARK_TYPES;
+var formatTypes = {
+  em: _analytics.ACTION_SUBJECT_ID.FORMAT_ITALIC,
+  code: _analytics.ACTION_SUBJECT_ID.FORMAT_CODE,
+  strike: _analytics.ACTION_SUBJECT_ID.FORMAT_STRIKE,
+  strong: _analytics.ACTION_SUBJECT_ID.FORMAT_STRONG,
+  underline: _analytics.ACTION_SUBJECT_ID.FORMAT_UNDERLINE,
+  textColor: _analytics.ACTION_SUBJECT_ID.FORMAT_COLOR,
+  subsup: 'subsup'
+};
+function clearFormattingWithAnalytics(inputMethod, editorAnalyticsAPI) {
+  return clearFormatting(inputMethod, editorAnalyticsAPI);
+}
+function clearNodeFormattingOnSelection(state, tr, formattedNodeType, nodeName, formattingCleared) {
+  return function (node, pos) {
+    if (node.type === formattedNodeType) {
+      if (formattedNodeType.isTextblock) {
+        tr.setNodeMarkup(pos, state.schema.nodes.paragraph);
+        formattingCleared.push(nodeName);
+        return false;
+      } else {
+        // In case of panel or blockquote
+        var fromPos = tr.doc.resolve(pos + 1);
+        var toPos = tr.doc.resolve(pos + node.nodeSize - 1);
+        var nodeRange = fromPos.blockRange(toPos);
+        if (nodeRange) {
+          var targetLiftDepth = (0, _transform.liftTarget)(nodeRange);
+          if (targetLiftDepth || targetLiftDepth === 0) {
+            formattingCleared.push(nodeName);
+            tr.lift(nodeRange, targetLiftDepth);
+          }
+        }
+      }
+    }
+    return true;
+  };
+}
+function clearFormatting(inputMethod, editorAnalyticsAPI) {
+  return function (state, dispatch) {
+    var tr = state.tr;
+    var formattingCleared = [];
+    FORMATTING_MARK_TYPES.forEach(function (mark) {
+      var _tr$selection = tr.selection,
+        from = _tr$selection.from,
+        to = _tr$selection.to;
+      var markType = state.schema.marks[mark];
+      if (!markType) {
+        return;
+      }
+      if (tr.selection instanceof _cellSelection.CellSelection) {
+        (0, _cellSelection2.cellSelectionNodesBetween)(tr.selection, tr.doc, function (node, pos) {
+          var isTableCell = node.type === state.schema.nodes.tableCell || node.type === state.schema.nodes.tableHeader;
+          if (!isTableCell) {
+            return true;
+          }
+          if (tr.doc.rangeHasMark(pos, pos + node.nodeSize, markType)) {
+            formattingCleared.push(formatTypes[mark]);
+            tr.removeMark(pos, pos + node.nodeSize, markType);
+          }
+          return false;
+        });
+      } else if (tr.doc.rangeHasMark(from, to, markType)) {
+        formattingCleared.push(formatTypes[mark]);
+        tr.removeMark(from, to, markType);
+      }
+    });
+    FORMATTING_NODE_TYPES.forEach(function (nodeName) {
+      var formattedNodeType = state.schema.nodes[nodeName];
+      var _tr$selection2 = tr.selection,
+        $from = _tr$selection2.$from,
+        $to = _tr$selection2.$to;
+      if (tr.selection instanceof _cellSelection.CellSelection) {
+        (0, _cellSelection2.cellSelectionNodesBetween)(tr.selection, tr.doc, clearNodeFormattingOnSelection(state, tr, formattedNodeType, nodeName, formattingCleared));
+      } else {
+        tr.doc.nodesBetween($from.pos, $to.pos, clearNodeFormattingOnSelection(state, tr, formattedNodeType, nodeName, formattingCleared));
+      }
+    });
+    tr.setStoredMarks([]);
+    if (formattingCleared.length && inputMethod) {
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+        action: _analytics.ACTION.FORMATTED,
+        eventType: _analytics.EVENT_TYPE.TRACK,
+        actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+        actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_CLEAR,
+        attributes: {
+          inputMethod: inputMethod,
+          formattingCleared: formattingCleared
+        }
+      })(tr);
+    }
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveRight = exports.moveLeft = exports.createInlineCodeFromTextInputWithAnalytics = void 0;
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _editorAnalytics = require("@atlaskit/editor-common/editor-analytics");
+var _mark = require("@atlaskit/editor-common/mark");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils = require("../utils");
+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 = (0, _utils.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;
+  };
+};
+exports.moveRight = moveRight;
+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 && (0, _utils.markActive)(state, code.create());
+      var currentPosHasCode = (0, _utils.hasCode)(state, $cursor.pos);
+      var nextPosHasCode = (0, _utils.hasCode)(state, $cursor.pos - 1);
+      var nextNextPosHasCode = (0, _utils.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(_state.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(_state.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;
+  };
+};
+exports.moveLeft = moveLeft;
+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 = (0, _mark.applyMarkOnRange)(tr.mapping.map(from - 1), tr.mapping.map(to + 1), false, codeMark, tr).setStoredMarks([codeMark]);
+          dispatch(tr);
+        }
+        return true;
+      }
+    }
+    return false;
+  };
+};
+var createInlineCodeFromTextInputWithAnalytics = function createInlineCodeFromTextInputWithAnalytics(editorAnalyticsAPI) {
+  return function (from, to, text) {
+    return (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, {
+      action: _analytics.ACTION.FORMATTED,
+      actionSubject: _analytics.ACTION_SUBJECT.TEXT,
+      eventType: _analytics.EVENT_TYPE.TRACK,
+      actionSubjectId: _analytics.ACTION_SUBJECT_ID.FORMAT_CODE,
+      attributes: {
+        inputMethod: _analytics.INPUT_METHOD.FORMATTING
+      }
+    })(createInlineCodeFromTextInput(from, to, text));
+  };
+};
+exports.createInlineCodeFromTextInputWithAnalytics = createInlineCodeFromTextInputWithAnalytics;

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

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformSmartCharsMentionsAndEmojis = void 0;
+var _mark = require("@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;
+  };
+};
+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 = (0, _mark.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);
+    }
+  });
+};
+exports.transformSmartCharsMentionsAndEmojis = transformSmartCharsMentionsAndEmojis;

package/dist/cjs/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "textFormattingPlugin", {
+  enumerable: true,
+  get: function get() {
+    return _plugin.textFormattingPlugin;
+  }
+});
+var _plugin = require("./plugin");