@portabletext/plugin-emoji-picker 1.0.3 → 1.0.5

package/dist/index.cjs

@@ -1,22 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
 var compilerRuntime = require("react/compiler-runtime"), editor = require("@portabletext/editor"), react = require("@xstate/react"), behaviors = require("@portabletext/editor/behaviors"), selectors = require("@portabletext/editor/selectors"), utils = require("@portabletext/editor/utils"), keyboardShortcuts = require("@portabletext/keyboard-shortcuts"), pluginInputRule = require("@portabletext/plugin-input-rule"), xstate = require("xstate");
-function _interopNamespaceCompat(e) {
-  if (e && typeof e == "object" && "default" in e) return e;
-  var n = /* @__PURE__ */ Object.create(null);
-  return e && Object.keys(e).forEach(function(k) {
-    if (k !== "default") {
-      var d = Object.getOwnPropertyDescriptor(e, k);
-      Object.defineProperty(n, k, d.get ? d : {
-        enumerable: !0,
-        get: function() {
-          return e[k];
-        }
-      });
-    }
-  }), n.default = e, Object.freeze(n);
-}
-var selectors__namespace = /* @__PURE__ */ _interopNamespaceCompat(selectors), utils__namespace = /* @__PURE__ */ _interopNamespaceCompat(utils);
 function createMatchEmojis(config) {
   return ({
     keyword
@@ -72,22 +56,111 @@ const arrowUpShortcut = keyboardShortcuts.createKeyboardShortcut({
   default: [{
     key: "Escape"
   }]
-}), triggerRule = pluginInputRule.defineInputRule({
+}), getTriggerState = (snapshot) => {
+  const focusSpan = selectors.getFocusSpan(snapshot), markState = selectors.getMarkState(snapshot);
+  if (!focusSpan || !markState || !snapshot.context.selection)
+    return;
+  const focusSpanTextBefore = focusSpan.node.text.slice(0, snapshot.context.selection.focus.offset), focusSpanTextAfter = focusSpan.node.text.slice(snapshot.context.selection.focus.offset), previousSpan = selectors.getPreviousSpan(snapshot), nextSpan = selectors.getNextSpan(snapshot);
+  return {
+    focusSpan,
+    markState,
+    focusSpanTextBefore,
+    focusSpanTextAfter,
+    previousSpan,
+    nextSpan
+  };
+};
+function createTriggerActions({
+  snapshot,
+  payload,
+  keywordState
+}) {
+  if (payload.markState.state === "unchanged") {
+    const focusSpan2 = {
+      node: {
+        _key: payload.focusSpan.node._key,
+        _type: payload.focusSpan.node._type,
+        text: `${payload.focusSpanTextBefore}${payload.lastMatch.text}${payload.focusSpanTextAfter}`,
+        marks: payload.markState.marks
+      },
+      path: payload.focusSpan.path,
+      textBefore: payload.focusSpanTextBefore,
+      textAfter: payload.focusSpanTextAfter
+    };
+    return keywordState === "complete" ? [behaviors.raise(createKeywordFoundEvent({
+      focusSpan: focusSpan2
+    }))] : [behaviors.raise(createTriggerFoundEvent({
+      focusSpan: focusSpan2
+    }))];
+  }
+  const newSpan = {
+    _key: snapshot.context.keyGenerator(),
+    _type: payload.focusSpan.node._type,
+    text: payload.lastMatch.text,
+    marks: payload.markState.marks
+  };
+  let focusSpan = {
+    node: {
+      _key: newSpan._key,
+      _type: newSpan._type,
+      text: `${newSpan.text}${payload.nextSpan?.node.text ?? payload.focusSpanTextAfter}`,
+      marks: payload.markState.marks
+    },
+    path: [{
+      _key: payload.focusSpan.path[0]._key
+    }, "children", {
+      _key: newSpan._key
+    }],
+    textBefore: "",
+    textAfter: payload.nextSpan?.node.text ?? payload.focusSpanTextAfter
+  };
+  return payload.previousSpan && payload.focusSpanTextBefore.length === 0 && JSON.stringify(payload.previousSpan.node.marks ?? []) === JSON.stringify(payload.markState.marks) && (focusSpan = {
+    node: {
+      _key: payload.previousSpan.node._key,
+      _type: newSpan._type,
+      text: `${payload.previousSpan.node.text}${newSpan.text}`,
+      marks: newSpan.marks
+    },
+    path: payload.previousSpan.path,
+    textBefore: payload.previousSpan.node.text,
+    textAfter: ""
+  }), [behaviors.raise({
+    type: "select",
+    at: payload.lastMatch.targetOffsets
+  }), behaviors.raise({
+    type: "delete",
+    at: payload.lastMatch.targetOffsets
+  }), behaviors.raise({
+    type: "insert.child",
+    child: newSpan
+  }), ...keywordState === "complete" ? [behaviors.raise(createKeywordFoundEvent({
+    focusSpan
+  }))] : [behaviors.raise(createTriggerFoundEvent({
+    focusSpan
+  }))]];
+}
+const triggerRule = pluginInputRule.defineInputRule({
   on: /:/,
   guard: ({
+    snapshot,
     event
   }) => {
     const lastMatch = event.matches.at(-1);
-    return lastMatch === void 0 ? !1 : {
-      keyword: lastMatch.text,
-      keywordAnchor: {
-        point: lastMatch.selection.anchor,
-        blockOffset: lastMatch.targetOffsets.anchor
-      },
-      keywordFocus: lastMatch.targetOffsets.focus
-    };
+    if (lastMatch === void 0)
+      return !1;
+    const triggerState = getTriggerState(snapshot);
+    return triggerState ? {
+      lastMatch,
+      ...triggerState
+    } : !1;
   },
-  actions: [(_, payload) => [behaviors.raise(createTriggerFoundEvent(payload))]]
+  actions: [({
+    snapshot
+  }, payload) => createTriggerActions({
+    snapshot,
+    payload,
+    keywordState: "partial"
+  })]
 });
 function createTriggerFoundEvent(payload) {
   return {
@@ -98,48 +171,47 @@ function createTriggerFoundEvent(payload) {
 const partialKeywordRule = pluginInputRule.defineInputRule({
   on: /:[\S]+/,
   guard: ({
+    snapshot,
     event
   }) => {
     const lastMatch = event.matches.at(-1);
-    if (lastMatch === void 0)
+    if (lastMatch === void 0 || lastMatch.targetOffsets.anchor.offset < event.textBefore.length)
       return !1;
-    const keyword = lastMatch.text, keywordAnchor = {
-      point: lastMatch.selection.anchor,
-      blockOffset: lastMatch.targetOffsets.anchor
-    }, keywordFocus = lastMatch.targetOffsets.focus;
-    return {
-      keyword,
-      keywordAnchor,
-      keywordFocus
-    };
+    const triggerState = getTriggerState(snapshot);
+    return triggerState ? {
+      ...triggerState,
+      lastMatch
+    } : !1;
   },
-  actions: [(_, payload) => [behaviors.raise(createPartialKeywordFoundEvent(payload))]]
-});
-function createPartialKeywordFoundEvent(payload) {
-  return {
-    type: "custom.partial keyword found",
-    ...payload
-  };
-}
-const keywordRule = pluginInputRule.defineInputRule({
+  actions: [({
+    snapshot
+  }, payload) => createTriggerActions({
+    snapshot,
+    payload,
+    keywordState: "partial"
+  })]
+}), keywordRule = pluginInputRule.defineInputRule({
   on: /:[\S]+:/,
   guard: ({
+    snapshot,
     event
   }) => {
     const lastMatch = event.matches.at(-1);
-    if (lastMatch === void 0)
+    if (lastMatch === void 0 || lastMatch.targetOffsets.anchor.offset < event.textBefore.length)
       return !1;
-    const keyword = lastMatch.text, keywordAnchor = {
-      point: lastMatch.selection.anchor,
-      blockOffset: lastMatch.targetOffsets.anchor
-    }, keywordFocus = lastMatch.targetOffsets.focus;
-    return {
-      keyword,
-      keywordAnchor,
-      keywordFocus
-    };
+    const triggerState = getTriggerState(snapshot);
+    return triggerState ? {
+      ...triggerState,
+      lastMatch
+    } : !1;
   },
-  actions: [(_, payload) => [behaviors.raise(createKeywordFoundEvent(payload))]]
+  actions: [({
+    snapshot
+  }, payload) => createTriggerActions({
+    snapshot,
+    payload,
+    keywordState: "complete"
+  })]
 });
 function createKeywordFoundEvent(payload) {
   return {
@@ -164,15 +236,6 @@ const triggerListenerCallback = ({
         sendBack(event);
       })]]
     })
-  }), input.editor.registerBehavior({
-    behavior: behaviors.defineBehavior({
-      on: "custom.partial keyword found",
-      actions: [({
-        event
-      }) => [behaviors.effect(() => {
-        sendBack(event);
-      })]]
-    })
   }), input.editor.registerBehavior({
     behavior: behaviors.defineBehavior({
       on: "custom.trigger found",
@@ -248,10 +311,16 @@ const triggerListenerCallback = ({
         type: "dismiss"
       });
     }), behaviors.raise({
-      type: "delete.text",
+      type: "delete",
       at: {
-        anchor: event.anchor,
-        focus: event.focus
+        anchor: {
+          path: event.focusSpan.path,
+          offset: event.focusSpan.textBefore.length
+        },
+        focus: {
+          path: event.focusSpan.path,
+          offset: event.focusSpan.node.text.length - event.focusSpan.textAfter.length
+        }
       }
     }), behaviors.raise({
       type: "insert.text",
@@ -275,22 +344,19 @@ const triggerListenerCallback = ({
       }) => {
         if (!enterShortcut.guard(event.originEvent) && !tabShortcut.guard(event.originEvent))
           return !1;
-        const anchor = context.keywordAnchor?.blockOffset, focus = context.keywordFocus, match = context.matches[context.selectedIndex];
-        return match && anchor && focus ? {
-          anchor,
-          focus,
+        const focusSpan = context.focusSpan, match = context.matches[context.selectedIndex];
+        return match && focusSpan ? {
+          focusSpan,
           emoji: match.emoji
         } : !1;
       },
       actions: [(_, {
-        anchor,
-        focus,
+        focusSpan,
         emoji
       }) => [behaviors.raise({
         type: "custom.insert emoji",
         emoji,
-        anchor,
-        focus
+        focusSpan
       })]]
     })
   }), input.context.editor.registerBehavior({
@@ -305,19 +371,6 @@ const triggerListenerCallback = ({
         });
       })]]
     })
-  }), input.context.editor.registerBehavior({
-    behavior: pluginInputRule.defineInputRuleBehavior({
-      rules: [keywordRule]
-    })
-  }), input.context.editor.registerBehavior({
-    behavior: behaviors.defineBehavior({
-      on: "custom.keyword found",
-      actions: [({
-        event
-      }) => [behaviors.effect(() => {
-        sendBack(event);
-      })]]
-    })
   })];
   return () => {
     for (const unregister of unregisterBehaviors)
@@ -327,79 +380,40 @@ const triggerListenerCallback = ({
   sendBack,
   input
 }) => input.editor.on("selection", () => {
-  const snapshot = input.editor.getSnapshot();
   sendBack({
-    type: "selection changed",
-    snapshot
+    type: "selection changed"
   });
-}).unsubscribe, textChangeListener = ({
+}).unsubscribe, textInsertionListenerCallback = ({
   sendBack,
-  input
+  input,
+  receive
 }) => {
-  const unregisterBehaviors = [input.editor.registerBehavior({
+  let context = input.context;
+  return receive((event) => {
+    context = event.context;
+  }), input.context.editor.registerBehavior({
     behavior: behaviors.defineBehavior({
       on: "insert.text",
       guard: ({
         snapshot
-      }) => snapshot.context.selection ? {
-        focus: snapshot.context.selection.focus
-      } : !1,
-      actions: [({
-        event
-      }, {
-        focus
-      }) => [behaviors.effect(() => {
-        sendBack({
-          ...event,
-          focus
-        });
-      }), behaviors.forward(event)]]
-    })
-  }), input.editor.registerBehavior({
-    behavior: behaviors.defineBehavior({
-      on: "delete.backward",
-      guard: ({
-        snapshot,
-        event
-      }) => event.unit === "character" && snapshot.context.selection ? {
-        focus: snapshot.context.selection.focus
-      } : !1,
-      actions: [({
-        event
-      }, {
-        focus
-      }) => [behaviors.effect(() => {
-        sendBack({
-          type: "delete.backward",
-          focus
-        });
-      }), behaviors.forward(event)]]
-    })
-  }), input.editor.registerBehavior({
-    behavior: behaviors.defineBehavior({
-      on: "delete.forward",
-      guard: ({
-        snapshot,
-        event
-      }) => event.unit === "character" && snapshot.context.selection ? {
-        focus: snapshot.context.selection.focus
-      } : !1,
+      }) => {
+        if (!context.focusSpan || !snapshot.context.selection)
+          return !1;
+        const keywordAnchor = {
+          path: context.focusSpan.path,
+          offset: context.focusSpan.textBefore.length
+        };
+        return utils.isEqualSelectionPoints(snapshot.context.selection.focus, keywordAnchor);
+      },
       actions: [({
         event
-      }, {
-        focus
-      }) => [behaviors.effect(() => {
+      }) => [behaviors.forward(event), behaviors.effect(() => {
         sendBack({
-          type: "delete.forward",
-          focus
+          type: "dismiss"
         });
-      }), behaviors.forward(event)]]
+      })]]
     })
-  })];
-  return () => {
-    for (const unregister of unregisterBehaviors)
-      unregister();
-  };
+  });
 }, emojiPickerMachine = xstate.setup({
   types: {
     context: {},
@@ -413,60 +427,65 @@ const triggerListenerCallback = ({
     "trigger listener": xstate.fromCallback(triggerListenerCallback),
     "escape listener": xstate.fromCallback(escapeListenerCallback),
     "selection listener": xstate.fromCallback(selectionListenerCallback),
-    "text change listener": xstate.fromCallback(textChangeListener)
+    "text insertion listener": xstate.fromCallback(textInsertionListenerCallback)
   },
   actions: {
-    "init keyword": xstate.assign({
-      keyword: ({
-        context,
-        event
-      }) => event.type !== "custom.trigger found" && event.type !== "custom.partial keyword found" && event.type !== "custom.keyword found" ? context.keyword : event.keyword
-    }),
-    "set keyword anchor": xstate.assign({
-      keywordAnchor: ({
-        context,
-        event
-      }) => event.type !== "custom.trigger found" && event.type !== "custom.partial keyword found" && event.type !== "custom.keyword found" ? context.keywordAnchor : event.keywordAnchor
-    }),
-    "set keyword focus": xstate.assign({
-      keywordFocus: ({
-        context,
-        event
-      }) => event.type !== "custom.trigger found" && event.type !== "custom.partial keyword found" && event.type !== "custom.keyword found" ? context.keywordFocus : event.keywordFocus
-    }),
-    "update keyword focus": xstate.assign({
-      keywordFocus: ({
+    "set focus span": xstate.assign({
+      focusSpan: ({
         context,
         event
-      }) => (xstate.assertEvent(event, ["insert.text", "delete.backward", "delete.forward"]), context.keywordFocus ? {
-        path: context.keywordFocus.path,
-        offset: event.type === "insert.text" ? context.keywordFocus.offset + event.text.length : event.type === "delete.backward" || event.type === "delete.forward" ? context.keywordFocus.offset - 1 : event.focus.offset
-      } : context.keywordFocus)
+      }) => event.type !== "custom.trigger found" && event.type !== "custom.keyword found" ? context.focusSpan : event.focusSpan
     }),
-    "update keyword": xstate.assign({
-      keyword: ({
-        context,
-        event
+    "update focus span": xstate.assign({
+      focusSpan: ({
+        context
       }) => {
-        if (xstate.assertEvent(event, "selection changed"), !context.keywordAnchor || !context.keywordFocus)
-          return "";
-        const keywordFocusPoint = utils__namespace.blockOffsetToSpanSelectionPoint({
-          context: event.snapshot.context,
-          blockOffset: context.keywordFocus,
-          direction: "forward"
-        });
-        return keywordFocusPoint ? selectors__namespace.getSelectionText({
-          ...event.snapshot,
+        if (!context.focusSpan)
+          return;
+        const snapshot = context.editor.getSnapshot(), focusSpan = selectors.getFocusSpan(snapshot);
+        if (!snapshot.context.selection || !focusSpan)
+          return;
+        const nextSpan = selectors.getNextSpan({
+          ...snapshot,
           context: {
-            ...event.snapshot.context,
+            ...snapshot.context,
             selection: {
-              anchor: context.keywordAnchor.point,
-              focus: keywordFocusPoint
+              anchor: {
+                path: context.focusSpan.path,
+                offset: 0
+              },
+              focus: {
+                path: context.focusSpan.path,
+                offset: 0
+              }
             }
           }
-        }) : "";
+        });
+        if (JSON.stringify(focusSpan.path) !== JSON.stringify(context.focusSpan.path))
+          return nextSpan && context.focusSpan.textAfter.length === 0 && snapshot.context.selection.focus.offset === 0 && utils.isSelectionCollapsed(snapshot.context.selection) ? context.focusSpan : void 0;
+        if (!focusSpan.node.text.startsWith(context.focusSpan.textBefore) || !focusSpan.node.text.endsWith(context.focusSpan.textAfter))
+          return;
+        const keywordAnchor = {
+          path: focusSpan.path,
+          offset: context.focusSpan.textBefore.length
+        }, keywordFocus = {
+          path: focusSpan.path,
+          offset: focusSpan.node.text.length - context.focusSpan.textAfter.length
+        }, selectionIsBeforeKeyword = selectors.isPointAfterSelection(keywordAnchor)(snapshot), selectionIsAfterKeyword = selectors.isPointBeforeSelection(keywordFocus)(snapshot);
+        if (!(selectionIsBeforeKeyword || selectionIsAfterKeyword))
+          return {
+            node: focusSpan.node,
+            path: focusSpan.path,
+            textBefore: context.focusSpan.textBefore,
+            textAfter: context.focusSpan.textAfter
+          };
       }
     }),
+    "update keyword": xstate.assign({
+      keyword: ({
+        context
+      }) => context.focusSpan ? context.focusSpan.textBefore.length > 0 && context.focusSpan.textAfter.length > 0 ? context.focusSpan.node.text.slice(context.focusSpan.textBefore.length, -context.focusSpan.textAfter.length) : context.focusSpan.textBefore.length > 0 ? context.focusSpan.node.text.slice(context.focusSpan.textBefore.length) : context.focusSpan.textAfter.length > 0 ? context.focusSpan.node.text.slice(0, -context.focusSpan.textAfter.length) : context.focusSpan.node.text : ""
+    }),
     "update matches": xstate.assign({
       matches: ({
         context
@@ -495,99 +514,65 @@ const triggerListenerCallback = ({
         event
       }) => (xstate.assertEvent(event, "navigate to"), event.index)
     }),
-    "update emoji insert listener context": xstate.sendTo("emoji insert listener", ({
+    "update submit listener context": xstate.sendTo("submit listener", ({
       context
     }) => ({
       type: "context changed",
       context
     })),
-    "update submit listener context": xstate.sendTo("submit listener", ({
+    "update text insertion listener context": xstate.sendTo("text insertion listener", ({
       context
     }) => ({
       type: "context changed",
       context
     })),
     "insert selected match": ({
-      context,
-      event
+      context
     }) => {
       const match = context.matches[context.selectedIndex];
-      !match || !context.keywordAnchor || !context.keywordFocus || event.type === "custom.keyword found" && match.type !== "exact" || context.editor.send({
+      !match || !context.focusSpan || context.editor.send({
         type: "custom.insert emoji",
         emoji: match.emoji,
-        anchor: context.keywordAnchor.blockOffset,
-        focus: context.keywordFocus
+        focusSpan: context.focusSpan
       });
     },
     reset: xstate.assign({
-      keywordAnchor: void 0,
-      keywordFocus: void 0,
+      focusSpan: void 0,
       keyword: "",
       matches: [],
       selectedIndex: 0
     })
   },
   guards: {
+    "no focus span": ({
+      context
+    }) => !context.focusSpan,
     "has matches": ({
       context
     }) => context.matches.length > 0,
     "no matches": xstate.not("has matches"),
-    "keyword is wel-formed": ({
+    "keyword is malformed": ({
+      context
+    }) => !context.incompleteKeywordRegex.test(context.keyword),
+    "keyword is direct match": ({
       context
-    }) => context.incompleteKeywordRegex.test(context.keyword),
-    "keyword is malformed": xstate.not("keyword is wel-formed"),
-    "selection is before keyword": ({
-      context,
-      event
-    }) => (xstate.assertEvent(event, "selection changed"), context.keywordAnchor ? selectors__namespace.isPointAfterSelection(context.keywordAnchor.point)(event.snapshot) : !0),
-    "selection is after keyword": ({
-      context,
-      event
-    }) => {
-      if (xstate.assertEvent(event, "selection changed"), context.keywordFocus === void 0)
-        return !0;
-      const keywordFocusPoint = utils__namespace.blockOffsetToSpanSelectionPoint({
-        context: event.snapshot.context,
-        blockOffset: context.keywordFocus,
-        direction: "forward"
-      });
-      return keywordFocusPoint ? selectors__namespace.isPointBeforeSelection(keywordFocusPoint)(event.snapshot) : !0;
-    },
-    "selection is expanded": ({
-      event
-    }) => (xstate.assertEvent(event, "selection changed"), selectors__namespace.isSelectionExpanded(event.snapshot)),
-    "selection moved unexpectedly": xstate.or(["selection is before keyword", "selection is after keyword", "selection is expanded"]),
-    "unexpected text insertion": ({
-      context,
-      event
     }) => {
-      if (event.type !== "insert.text" || !context.keywordAnchor)
+      if (!/^:[\S]+:$/.test(context.keyword))
         return !1;
-      const snapshot = context.editor.getSnapshot();
-      return selectors__namespace.isPointBeforeSelection(event.focus)({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: {
-            anchor: context.keywordAnchor.point,
-            focus: context.keywordAnchor.point
-          }
-        }
-      }) || utils__namespace.isEqualSelectionPoints(event.focus, context.keywordAnchor.point);
+      const match = context.matches.at(context.selectedIndex);
+      return !(!match || match.type !== "exact");
     }
   }
 }).createMachine({
-  /** @xstate-layout N4IgpgJg5mDOIC5RgLYHsBWBLABABywGMBrMAJwDosIAbMAYkLRrQDsctXZyAXSAbQAMAXUSg8aWFh5Y2YkAA9EARmUB2AJwUAzADYNADgCs65YO1q1ygDQgAnojUG1O5c+W7tAJmdfdRgF8A21RMXAIScgpuAEMyQgALTih6Tm4yHgo+BR4hUSQQCSkZOQKlBABaZW0DHSMAFksNQUF6oyNzL1sHBC9vCnrGtS8GtQaNNt0gkPRsfCJSSlj4pNYUiDA6PgoAMzQyAHc4iDz5IulZVnlyr3MKE30LA31DZoNuxD6vAaHdP29vOo1NNwLNwgsostEsl6BstmAKAAjGIkI5kE4iM6SC6lUDlerabT3arDfS3eoaPQfXr9QaWEaNcaTEGhOYRRbRMBxaFrWFYWAofmwU4Fc4lK5lFTqWqDAwUjReeoGbwaNTU1TPCh-QxNNS6XQGHwssHzSJLLkrGHcOiEcU4RIxNYCTGi7Hi66IfxE1oeZX1EbeZXUhUUZSKjxOOV6bTmY1hU0cqGrFLWsC2y72hKOmAnZT5cRuy4ehDVXQUVXDIyWGpmAzveyfLRKwQaVRVwR1ixeONsiHm7nJ+gigvFIuSkvKVuhgwaEwKmMKwbqkaCAaverqVuvKbBUHx9mQi08qAUVhoHAoGI8RJwHCwBJoA4w4eFQu4xSfaoDA3KOmCVSTn06r-i4-hGH0ZiEoI4H1D24JmpyA7JNED5PmsF5XjesD0KwMQAG5YFAV5gDgECPqwL5imOeKIIM9ShsoRh1i2erPB41L6C40GqISUb6n8cEJoeSFrChj7JBh14JHAOH4YRxE4AArnglFvhKNEIGoq4+E0yraPULa6PUHGqhQ3HVDUBL8dogkHv2lqife4noZeUkybhBFEXwOA8Ggqmju+5RGPqFBqP6ujDD4v4tjYDYIMqLjVKo5gdM4TGBLurLwYmR7JmJaFQJJWGpFwvB3psaZ8BARUJP5OLqR+CD1Loq5ymYfyeP4spGOqv70fpv7NBSBKtBlMz7n2iEOSeTkFTVMl1e645eB49wGP+K0UpBbjaMBzQUF4IzBYq7TNa2QS7meGzwAUWVCWQWIBQ15RVJq2ijJoLRtB03jUhUVYUHKtz-gqeoxkYGi2ZN1B0I99XFqobTlh4-5-Ot4H1j0ZirbcENhR4RmKrBmUmnZU3HnDS0aVUjHlh2cqtkqfTBdSSr0RMGieBS7htASUMIUmyFnvNsB3qhySU9RjUVBFdN1ltTPvbowZOGZEWHe9xgTHo-M5SJM3iy5mHSTdI7w+OlnlgY6heJzbgUv4ytxaqtSCBFg1eJFM4XQEQA */
   id: "emoji picker",
   context: ({
     input
   }) => ({
     editor: input.editor,
     keyword: "",
-    keywordAnchor: void 0,
-    keywordFocus: void 0,
+    focusSpan: void 0,
     matchEmojis: input.matchEmojis,
-    incompleteKeywordRegex: /:[\S]*$/,
+    incompleteKeywordRegex: /^:[\S]*$/,
     matches: [],
     selectedIndex: 0
   }),
@@ -615,14 +600,10 @@ const triggerListenerCallback = ({
       on: {
         "custom.trigger found": {
           target: "searching",
-          actions: ["set keyword anchor", "set keyword focus", "init keyword"]
-        },
-        "custom.partial keyword found": {
-          target: "searching",
-          actions: ["set keyword anchor", "set keyword focus", "init keyword"]
+          actions: ["set focus span", "update keyword"]
         },
         "custom.keyword found": {
-          actions: ["set keyword anchor", "set keyword focus", "init keyword", "update matches", "insert selected match"],
+          actions: ["set focus span", "update keyword", "update matches", "insert selected match"],
           target: "idle",
           reenter: !0
         }
@@ -652,42 +633,32 @@ const triggerListenerCallback = ({
           editor: context.editor
         })
       }, {
-        src: "text change listener",
+        src: "text insertion listener",
+        id: "text insertion listener",
         input: ({
           context
         }) => ({
-          editor: context.editor
+          context
         })
       }],
       on: {
-        "custom.keyword found": {
-          actions: ["set keyword anchor", "set keyword focus", "init keyword", "update matches", "insert selected match"]
-        },
-        "insert.text": [{
-          guard: "unexpected text insertion",
-          target: "idle"
-        }, {
-          actions: ["update keyword focus"]
-        }],
-        "delete.forward": {
-          actions: ["update keyword focus"]
-        },
-        "delete.backward": {
-          actions: ["update keyword focus"]
-        },
         dismiss: {
           target: "idle"
         },
         "selection changed": [{
-          guard: "selection moved unexpectedly",
-          target: "idle"
-        }, {
-          actions: ["update keyword", "update matches", "reset selected index", "update submit listener context"]
+          actions: ["update focus span", "update keyword", "update matches", "reset selected index", "update submit listener context", "update text insertion listener context"]
         }]
       },
       always: [{
+        guard: "no focus span",
+        target: "idle"
+      }, {
         guard: "keyword is malformed",
         target: "idle"
+      }, {
+        guard: "keyword is direct match",
+        actions: ["insert selected match"],
+        target: "idle"
       }],
       initial: "no matches showing",
       states: {