@atlaskit/prosemirror-input-rules 3.5.0 → 3.6.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @atlaskit/prosemirror-input-rules
 
+## 3.6.0
+
+### Minor Changes
+
+- [`3c501a06f7c8b`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/3c501a06f7c8b) -
+  [ux] [EDITOR-2460] detect and format backticks that close strings on the LHS
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 3.5.0
 
 ### Minor Changes
@@ -110,7 +121,6 @@
 
   These are no longer available via `@atlaskit/prosemirror-input-rules` but are available from
   `@atlaskit/editor-common/types`:
-
   - InputRuleWrapper
   - InputRuleHandler
   - OnHandlerApply
@@ -120,7 +130,6 @@
   need to instantiate a `SafePlugin` (ie. `new SafePlugin(createPlugin( ... ))`).
 
   `SafePlugin` exists in `@atlaskit/editor-common/safe-plugin`.
-
   - createPlugin
   - createInputRulePlugin
 
@@ -368,7 +377,6 @@
 
 - [`c6feed82071`](https://bitbucket.org/atlassian/atlassian-frontend/commits/c6feed82071) -
   ED-11632: Bump prosemirror packages;
-
   - prosmirror-commands 1.1.4 -> 1.1.11,
   - prosemirror-model 1.11.0 -> 1.14.3,
   - prosemirror-state 1.3.3 -> 1.3.4,

package/dist/cjs/constants.js

@@ -3,11 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.leafNodeReplacementCharacter = exports.TEXT_INPUT_RULE_TRANSACTION_KEY = exports.MAX_REGEX_MATCH = void 0;
+exports.leafNodeReplacementCharacter = exports.TYPEAHEAD_TRIGGERS = exports.TEXT_INPUT_RULE_TRANSACTION_KEY = exports.MAX_REGEX_MATCH = void 0;
 // ProseMirror uses the Unicode Character 'OBJECT REPLACEMENT CHARACTER' (U+FFFC) as text representation for
 // leaf nodes, i.e. nodes that don't have any content or text property (e.g. hardBreak, emoji, mention, rule)
 // It was introduced because of https://github.com/ProseMirror/prosemirror/issues/262
 // This can be used in an input rule regex to be able to include or exclude such nodes.
 var leafNodeReplacementCharacter = exports.leafNodeReplacementCharacter = "\uFFFC";
 var TEXT_INPUT_RULE_TRANSACTION_KEY = exports.TEXT_INPUT_RULE_TRANSACTION_KEY = 'input_rule_plugin_transaction';
-var MAX_REGEX_MATCH = exports.MAX_REGEX_MATCH = 500;
+var MAX_REGEX_MATCH = exports.MAX_REGEX_MATCH = 500;
+var TYPEAHEAD_TRIGGERS = exports.TYPEAHEAD_TRIGGERS = [':', '/', '@'];

package/dist/cjs/handler.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createInputEventHandler = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var _constants = require("./constants");
 var _editorCommon = require("./editor-common");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
@@ -39,11 +40,30 @@ var createInputEventHandler = exports.createInputEventHandler = function createI
     var textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - _constants.MAX_REGEX_MATCH), $from.parentOffset, undefined, _constants.leafNodeReplacementCharacter) + text;
     var result = findMatchOnRules({
       rules: rules,
-      textBefore: textBefore,
+      textToMatch: textBefore,
       from: from,
       to: to,
       state: state
     });
+    var isBackwardMatch;
+    if (!result && (0, _expValEquals.expValEquals)('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+      if (_constants.TYPEAHEAD_TRIGGERS.includes(text)) {
+        return false;
+      }
+      var textAfter = text + $from.parent.textBetween($from.parentOffset, Math.min($from.parent.content.size, $from.parentOffset + _constants.MAX_REGEX_MATCH), undefined, _constants.leafNodeReplacementCharacter);
+      isBackwardMatch = true;
+      result = findMatchOnRules({
+        rules: rules,
+        textToMatch: textAfter,
+        from: from,
+        to: to,
+        state: state,
+        isBackwardMatch: isBackwardMatch
+      });
+      if (!result) {
+        return false;
+      }
+    }
     if (!result) {
       return false;
     }
@@ -53,7 +73,8 @@ var createInputEventHandler = exports.createInputEventHandler = function createI
       textInserted: text,
       from: result.from,
       to: result.to,
-      matchedRule: result.matchedRule
+      matchedRule: result.matchedRule,
+      isBackwardMatch: isBackwardMatch
     });
     if (onBeforeRegexMatch) {
       onBeforeRegexMatch(tr);
@@ -64,20 +85,42 @@ var createInputEventHandler = exports.createInputEventHandler = function createI
 };
 function findMatchOnRules(_ref3) {
   var rules = _ref3.rules,
-    textBefore = _ref3.textBefore,
+    textToMatch = _ref3.textToMatch,
     from = _ref3.from,
     to = _ref3.to,
-    state = _ref3.state;
+    state = _ref3.state,
+    isBackwardMatch = _ref3.isBackwardMatch;
   for (var i = 0; i < rules.length; i++) {
-    var _textBefore$at;
+    var _textToMatch$at;
     var rule = rules[i];
 
     // Some plugins like Typeahead require a whitespace before a trigger character.
     // We want them to fire inside a gap cursor. Yet, a gap cursor is not considered a whitespace,
-    // and `textBefore` contains the text in the previous block before the gap cursor.
+    // and `textToMatch` contains the text in the previous block before the gap cursor.
     // Here is a workaround: if we inside a gap cursor, match the input rule only against the last typed character
     // (which may be a typeahead trigger) and ignore the rest.
-    var matchString = (0, _editorCommon.isGapCursorSelection)(state.selection) ? (_textBefore$at = textBefore.at(-1)) !== null && _textBefore$at !== void 0 ? _textBefore$at : '' : textBefore;
+    var matchString = (0, _editorCommon.isGapCursorSelection)(state.selection) ? (_textToMatch$at = textToMatch.at(-1)) !== null && _textToMatch$at !== void 0 ? _textToMatch$at : '' : textToMatch;
+
+    // EDITOR-2460
+    // if the user is formatting text to inline code from R to L i.e. backwards
+    if (rule.allowsBackwardMatch && isBackwardMatch && (0, _expValEquals.expValEquals)('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+      var _match = rule.match.exec(matchString);
+      if (!_match) {
+        continue;
+      }
+      var matchEndPos = from + _match[0].length - 1;
+      var _transform = rule.handler(state, _match, from, matchEndPos);
+      if (_transform) {
+        return {
+          from: from,
+          to: matchEndPos,
+          matchedRule: _objectSpread(_objectSpread({}, rule), {}, {
+            result: _match
+          })
+        };
+      }
+      return null;
+    }
     var match = rule.match.exec(matchString);
     if (!match) {
       continue;

package/dist/cjs/plugin.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createInputRulePlugin = createInputRulePlugin;
 var _state = require("@atlaskit/editor-prosemirror/state");
+var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
 var _constants = require("./constants");
 var _handler = require("./handler");
 function createInputRulePlugin(pluginName, rules) {
@@ -44,7 +45,8 @@ function createInputRulePlugin(pluginName, rules) {
       }
       var matchedRule = pluginState.matchedRule,
         from = pluginState.from,
-        to = pluginState.to;
+        to = pluginState.to,
+        isBackwardMatch = pluginState.isBackwardMatch;
       var result = matchedRule.result;
       var mappedTo = transactionWithInputRuleMeta.mapping.map(to);
       var tr = matchedRule.handler(newState, result, from, mappedTo);
@@ -55,6 +57,13 @@ function createInputRulePlugin(pluginName, rules) {
       if (matchedRule.onHandlerApply) {
         matchedRule.onHandlerApply(newState, tr, matchedRule.result);
       }
+
+      // after inserting inline code, we need to reset the selection back
+      // else, we set the selection at the end of the inline code which doesn't make sense if we are closing the inline code from R to L
+      if (isBackwardMatch && (0, _expValEquals.expValEquals)('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+        var prevSelection = oldState.selection.map(tr.doc, tr.mapping);
+        tr.setSelection(prevSelection);
+      }
       return tr;
     },
     props: {

package/dist/es2019/constants.js

@@ -4,4 +4,5 @@
 // This can be used in an input rule regex to be able to include or exclude such nodes.
 export const leafNodeReplacementCharacter = '\ufffc';
 export const TEXT_INPUT_RULE_TRANSACTION_KEY = 'input_rule_plugin_transaction';
-export const MAX_REGEX_MATCH = 500;
+export const MAX_REGEX_MATCH = 500;
+export const TYPEAHEAD_TRIGGERS = [':', '/', '@'];

package/dist/es2019/handler.js

@@ -1,4 +1,5 @@
-import { leafNodeReplacementCharacter, MAX_REGEX_MATCH, TEXT_INPUT_RULE_TRANSACTION_KEY } from './constants';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { leafNodeReplacementCharacter, MAX_REGEX_MATCH, TEXT_INPUT_RULE_TRANSACTION_KEY, TYPEAHEAD_TRIGGERS } from './constants';
 import { isGapCursorSelection } from './editor-common';
 export const createInputEventHandler = ({
   rules,
@@ -28,13 +29,32 @@ export const createInputEventHandler = ({
     return false;
   }
   const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_REGEX_MATCH), $from.parentOffset, undefined, leafNodeReplacementCharacter) + text;
-  const result = findMatchOnRules({
+  let result = findMatchOnRules({
     rules,
-    textBefore,
+    textToMatch: textBefore,
     from,
     to,
     state
   });
+  let isBackwardMatch;
+  if (!result && expValEquals('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+    if (TYPEAHEAD_TRIGGERS.includes(text)) {
+      return false;
+    }
+    const textAfter = text + $from.parent.textBetween($from.parentOffset, Math.min($from.parent.content.size, $from.parentOffset + MAX_REGEX_MATCH), undefined, leafNodeReplacementCharacter);
+    isBackwardMatch = true;
+    result = findMatchOnRules({
+      rules,
+      textToMatch: textAfter,
+      from,
+      to,
+      state,
+      isBackwardMatch
+    });
+    if (!result) {
+      return false;
+    }
+  }
   if (!result) {
     return false;
   }
@@ -44,7 +64,8 @@ export const createInputEventHandler = ({
     textInserted: text,
     from: result.from,
     to: result.to,
-    matchedRule: result.matchedRule
+    matchedRule: result.matchedRule,
+    isBackwardMatch: isBackwardMatch
   });
   if (onBeforeRegexMatch) {
     onBeforeRegexMatch(tr);
@@ -54,21 +75,44 @@ export const createInputEventHandler = ({
 };
 function findMatchOnRules({
   rules,
-  textBefore,
+  textToMatch,
   from,
   to,
-  state
+  state,
+  isBackwardMatch
 }) {
   for (let i = 0; i < rules.length; i++) {
-    var _textBefore$at;
+    var _textToMatch$at;
     const rule = rules[i];
 
     // Some plugins like Typeahead require a whitespace before a trigger character.
     // We want them to fire inside a gap cursor. Yet, a gap cursor is not considered a whitespace,
-    // and `textBefore` contains the text in the previous block before the gap cursor.
+    // and `textToMatch` contains the text in the previous block before the gap cursor.
     // Here is a workaround: if we inside a gap cursor, match the input rule only against the last typed character
     // (which may be a typeahead trigger) and ignore the rest.
-    const matchString = isGapCursorSelection(state.selection) ? (_textBefore$at = textBefore.at(-1)) !== null && _textBefore$at !== void 0 ? _textBefore$at : '' : textBefore;
+    const matchString = isGapCursorSelection(state.selection) ? (_textToMatch$at = textToMatch.at(-1)) !== null && _textToMatch$at !== void 0 ? _textToMatch$at : '' : textToMatch;
+
+    // EDITOR-2460
+    // if the user is formatting text to inline code from R to L i.e. backwards
+    if (rule.allowsBackwardMatch && isBackwardMatch && expValEquals('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+      const match = rule.match.exec(matchString);
+      if (!match) {
+        continue;
+      }
+      const matchEndPos = from + match[0].length - 1;
+      const transform = rule.handler(state, match, from, matchEndPos);
+      if (transform) {
+        return {
+          from: from,
+          to: matchEndPos,
+          matchedRule: {
+            ...rule,
+            result: match
+          }
+        };
+      }
+      return null;
+    }
     const match = rule.match.exec(matchString);
     if (!match) {
       continue;

package/dist/es2019/plugin.js

@@ -1,4 +1,5 @@
 import { PluginKey, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { TEXT_INPUT_RULE_TRANSACTION_KEY } from './constants';
 import { createInputEventHandler } from './handler';
 export function createInputRulePlugin(pluginName, rules, options = {}) {
@@ -36,7 +37,8 @@ export function createInputRulePlugin(pluginName, rules, options = {}) {
       const {
         matchedRule,
         from,
-        to
+        to,
+        isBackwardMatch
       } = pluginState;
       const {
         result
@@ -50,6 +52,13 @@ export function createInputRulePlugin(pluginName, rules, options = {}) {
       if (matchedRule.onHandlerApply) {
         matchedRule.onHandlerApply(newState, tr, matchedRule.result);
       }
+
+      // after inserting inline code, we need to reset the selection back
+      // else, we set the selection at the end of the inline code which doesn't make sense if we are closing the inline code from R to L
+      if (isBackwardMatch && expValEquals('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+        const prevSelection = oldState.selection.map(tr.doc, tr.mapping);
+        tr.setSelection(prevSelection);
+      }
       return tr;
     },
     props: {

package/dist/esm/constants.js

@@ -4,4 +4,5 @@
 // This can be used in an input rule regex to be able to include or exclude such nodes.
 export var leafNodeReplacementCharacter = "\uFFFC";
 export var TEXT_INPUT_RULE_TRANSACTION_KEY = 'input_rule_plugin_transaction';
-export var MAX_REGEX_MATCH = 500;
+export var MAX_REGEX_MATCH = 500;
+export var TYPEAHEAD_TRIGGERS = [':', '/', '@'];

package/dist/esm/handler.js

@@ -1,7 +1,8 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-import { leafNodeReplacementCharacter, MAX_REGEX_MATCH, TEXT_INPUT_RULE_TRANSACTION_KEY } from './constants';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { leafNodeReplacementCharacter, MAX_REGEX_MATCH, TEXT_INPUT_RULE_TRANSACTION_KEY, TYPEAHEAD_TRIGGERS } from './constants';
 import { isGapCursorSelection } from './editor-common';
 export var createInputEventHandler = function createInputEventHandler(_ref) {
   var rules = _ref.rules,
@@ -32,11 +33,30 @@ export var createInputEventHandler = function createInputEventHandler(_ref) {
     var textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_REGEX_MATCH), $from.parentOffset, undefined, leafNodeReplacementCharacter) + text;
     var result = findMatchOnRules({
       rules: rules,
-      textBefore: textBefore,
+      textToMatch: textBefore,
       from: from,
       to: to,
       state: state
     });
+    var isBackwardMatch;
+    if (!result && expValEquals('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+      if (TYPEAHEAD_TRIGGERS.includes(text)) {
+        return false;
+      }
+      var textAfter = text + $from.parent.textBetween($from.parentOffset, Math.min($from.parent.content.size, $from.parentOffset + MAX_REGEX_MATCH), undefined, leafNodeReplacementCharacter);
+      isBackwardMatch = true;
+      result = findMatchOnRules({
+        rules: rules,
+        textToMatch: textAfter,
+        from: from,
+        to: to,
+        state: state,
+        isBackwardMatch: isBackwardMatch
+      });
+      if (!result) {
+        return false;
+      }
+    }
     if (!result) {
       return false;
     }
@@ -46,7 +66,8 @@ export var createInputEventHandler = function createInputEventHandler(_ref) {
       textInserted: text,
       from: result.from,
       to: result.to,
-      matchedRule: result.matchedRule
+      matchedRule: result.matchedRule,
+      isBackwardMatch: isBackwardMatch
     });
     if (onBeforeRegexMatch) {
       onBeforeRegexMatch(tr);
@@ -57,20 +78,42 @@ export var createInputEventHandler = function createInputEventHandler(_ref) {
 };
 function findMatchOnRules(_ref3) {
   var rules = _ref3.rules,
-    textBefore = _ref3.textBefore,
+    textToMatch = _ref3.textToMatch,
     from = _ref3.from,
     to = _ref3.to,
-    state = _ref3.state;
+    state = _ref3.state,
+    isBackwardMatch = _ref3.isBackwardMatch;
   for (var i = 0; i < rules.length; i++) {
-    var _textBefore$at;
+    var _textToMatch$at;
     var rule = rules[i];
 
     // Some plugins like Typeahead require a whitespace before a trigger character.
     // We want them to fire inside a gap cursor. Yet, a gap cursor is not considered a whitespace,
-    // and `textBefore` contains the text in the previous block before the gap cursor.
+    // and `textToMatch` contains the text in the previous block before the gap cursor.
     // Here is a workaround: if we inside a gap cursor, match the input rule only against the last typed character
     // (which may be a typeahead trigger) and ignore the rest.
-    var matchString = isGapCursorSelection(state.selection) ? (_textBefore$at = textBefore.at(-1)) !== null && _textBefore$at !== void 0 ? _textBefore$at : '' : textBefore;
+    var matchString = isGapCursorSelection(state.selection) ? (_textToMatch$at = textToMatch.at(-1)) !== null && _textToMatch$at !== void 0 ? _textToMatch$at : '' : textToMatch;
+
+    // EDITOR-2460
+    // if the user is formatting text to inline code from R to L i.e. backwards
+    if (rule.allowsBackwardMatch && isBackwardMatch && expValEquals('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+      var _match = rule.match.exec(matchString);
+      if (!_match) {
+        continue;
+      }
+      var matchEndPos = from + _match[0].length - 1;
+      var _transform = rule.handler(state, _match, from, matchEndPos);
+      if (_transform) {
+        return {
+          from: from,
+          to: matchEndPos,
+          matchedRule: _objectSpread(_objectSpread({}, rule), {}, {
+            result: _match
+          })
+        };
+      }
+      return null;
+    }
     var match = rule.match.exec(matchString);
     if (!match) {
       continue;

package/dist/esm/plugin.js

@@ -1,4 +1,5 @@
 import { PluginKey, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { TEXT_INPUT_RULE_TRANSACTION_KEY } from './constants';
 import { createInputEventHandler } from './handler';
 export function createInputRulePlugin(pluginName, rules) {
@@ -38,7 +39,8 @@ export function createInputRulePlugin(pluginName, rules) {
       }
       var matchedRule = pluginState.matchedRule,
         from = pluginState.from,
-        to = pluginState.to;
+        to = pluginState.to,
+        isBackwardMatch = pluginState.isBackwardMatch;
       var result = matchedRule.result;
       var mappedTo = transactionWithInputRuleMeta.mapping.map(to);
       var tr = matchedRule.handler(newState, result, from, mappedTo);
@@ -49,6 +51,13 @@ export function createInputRulePlugin(pluginName, rules) {
       if (matchedRule.onHandlerApply) {
         matchedRule.onHandlerApply(newState, tr, matchedRule.result);
       }
+
+      // after inserting inline code, we need to reset the selection back
+      // else, we set the selection at the end of the inline code which doesn't make sense if we are closing the inline code from R to L
+      if (isBackwardMatch && expValEquals('platform_editor_lovability_inline_code', 'isEnabled', true)) {
+        var prevSelection = oldState.selection.map(tr.doc, tr.mapping);
+        tr.setSelection(prevSelection);
+      }
       return tr;
     },
     props: {

package/dist/types/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const leafNodeReplacementCharacter = "\uFFFC";
 export declare const TEXT_INPUT_RULE_TRANSACTION_KEY = "input_rule_plugin_transaction";
 export declare const MAX_REGEX_MATCH = 500;
+export declare const TYPEAHEAD_TRIGGERS: string[];

package/dist/types/editor-common.d.ts

@@ -8,6 +8,7 @@ import type { EditorState, Selection, Transaction } from '@atlaskit/editor-prose
 export type InputRuleHandler = (state: EditorState, matchResult: RegExpExecArray, start: number, end: number) => Transaction | null;
 export type OnHandlerApply = (state: EditorState, tr: Transaction, matchResult: RegExpExecArray) => void;
 export interface InputRuleWrapper {
+    allowsBackwardMatch?: boolean;
     handler: InputRuleHandler;
     match: RegExp;
     onHandlerApply?: OnHandlerApply;

package/dist/types/types.d.ts

@@ -9,6 +9,7 @@ export type HandleInputEvent = (props: {
 }) => boolean;
 export type InputRulePluginState = {
     from: number;
+    isBackwardMatch?: boolean;
     matchedRule: MatchedRule;
     textInserted: string;
     to: number;

package/dist/types-ts4.5/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const leafNodeReplacementCharacter = "\uFFFC";
 export declare const TEXT_INPUT_RULE_TRANSACTION_KEY = "input_rule_plugin_transaction";
 export declare const MAX_REGEX_MATCH = 500;
+export declare const TYPEAHEAD_TRIGGERS: string[];

package/dist/types-ts4.5/editor-common.d.ts

@@ -8,6 +8,7 @@ import type { EditorState, Selection, Transaction } from '@atlaskit/editor-prose
 export type InputRuleHandler = (state: EditorState, matchResult: RegExpExecArray, start: number, end: number) => Transaction | null;
 export type OnHandlerApply = (state: EditorState, tr: Transaction, matchResult: RegExpExecArray) => void;
 export interface InputRuleWrapper {
+    allowsBackwardMatch?: boolean;
     handler: InputRuleHandler;
     match: RegExp;
     onHandlerApply?: OnHandlerApply;

package/dist/types-ts4.5/types.d.ts

@@ -9,6 +9,7 @@ export type HandleInputEvent = (props: {
 }) => boolean;
 export type InputRulePluginState = {
     from: number;
+    isBackwardMatch?: boolean;
     matchedRule: MatchedRule;
     textInserted: string;
     to: number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/prosemirror-input-rules",
-	"version": "3.5.0",
+	"version": "3.6.0",
 	"description": "A package that contains helpers to create autoformatting rules for ProseMirror",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -29,10 +29,11 @@
 	"dependencies": {
 		"@atlaskit/editor-prosemirror": "7.0.0",
 		"@atlaskit/prosemirror-history": "^0.2.0",
+		"@atlaskit/tmp-editor-statsig": "^13.27.0",
 		"@babel/runtime": "^7.0.0"
 	},
 	"devDependencies": {
-		"@atlaskit/editor-common": "^110.10.0"
+		"@atlaskit/editor-common": "^110.22.0"
 	},
 	"techstack": {
 		"@atlassian/frontend": {