@portabletext/plugin-typeahead-picker 5.0.26 → 6.0.0

package/dist/index.js

@@ -113,9 +113,7 @@ function createTriggerActions({
       text: `${newSpan.text}${payload.nextSpan?.node.text ?? payload.focusSpanTextAfter}`,
       marks: payload.markState.marks
     },
-    path: [{
-      _key: payload.focusSpan.path[0]._key
-    }, "children", {
+    path: [...payload.focusSpan.path.slice(0, -2), "children", {
       _key: newSpan._key
     }],
     textBefore: "",
@@ -626,620 +624,617 @@ const triggerListenerCallback = () => ({
       }), ...selectActions];
     }]
   })
-});
-function createTypeaheadPickerMachine() {
-  return setup({
-    types: {
-      context: {},
-      input: {},
-      events: {}
-    },
-    delays: {
-      DEBOUNCE: ({
-        context
-      }) => context.definition.debounceMs ?? 0
-    },
-    actors: {
-      "trigger listener": fromCallback(triggerListenerCallback()),
-      "escape listener": fromCallback(escapeListenerCallback()),
-      "arrow listener": fromCallback(arrowListenerCallback()),
-      "selection listener": fromCallback(selectionListenerCallback()),
-      "submit listener": fromCallback(submitListenerCallback()),
-      "text insertion listener": fromCallback(textInsertionListenerCallback()),
-      "select match listener": fromCallback(selectMatchListenerCallback()),
-      "dismiss listener": fromCallback(dismissListenerCallback()),
-      "get matches": fromPromise(async ({
-        input
-      }) => {
-        const result = input.getMatches({
-          keyword: input.keyword
-        }), matches = await Promise.resolve(result);
-        return {
-          keyword: input.keyword,
-          matches
-        };
-      })
-    },
-    actions: {
-      "handle trigger found": assign(({
-        context,
-        event
-      }) => {
-        if (event.type !== "custom.typeahead trigger found" && event.type !== "custom.typeahead keyword found")
-          return {};
-        const focusSpan = event.focusSpan, patternText = extractPatternTextFromFocusSpan(focusSpan), keyword = event.extractedKeyword;
-        if (context.definition.mode === "async" || context.definition.debounceMs)
-          return {
-            focusSpan,
-            patternText,
-            keyword,
-            isLoading: !0,
-            selectedIndex: 0
-          };
-        const matches = context.definition.getMatches({
-          keyword
-        });
+}), typeaheadPickerMachine = setup({
+  types: {
+    context: {},
+    input: {},
+    events: {}
+  },
+  delays: {
+    DEBOUNCE: ({
+      context
+    }) => context.definition.debounceMs ?? 0
+  },
+  actors: {
+    "trigger listener": fromCallback(triggerListenerCallback()),
+    "escape listener": fromCallback(escapeListenerCallback()),
+    "arrow listener": fromCallback(arrowListenerCallback()),
+    "selection listener": fromCallback(selectionListenerCallback()),
+    "submit listener": fromCallback(submitListenerCallback()),
+    "text insertion listener": fromCallback(textInsertionListenerCallback()),
+    "select match listener": fromCallback(selectMatchListenerCallback()),
+    "dismiss listener": fromCallback(dismissListenerCallback()),
+    "get matches": fromPromise(async ({
+      input
+    }) => {
+      const result = input.getMatches({
+        keyword: input.keyword
+      }), matches = await Promise.resolve(result);
+      return {
+        keyword: input.keyword,
+        matches
+      };
+    })
+  },
+  actions: {
+    "handle trigger found": assign(({
+      context,
+      event
+    }) => {
+      if (event.type !== "custom.typeahead trigger found" && event.type !== "custom.typeahead keyword found")
+        return {};
+      const focusSpan = event.focusSpan, patternText = extractPatternTextFromFocusSpan(focusSpan), keyword = event.extractedKeyword;
+      if (context.definition.mode === "async" || context.definition.debounceMs)
         return {
           focusSpan,
           patternText,
           keyword,
-          matches,
-          requestedKeyword: keyword,
-          isLoading: !1,
+          isLoading: !0,
           selectedIndex: 0
         };
-      }),
-      "handle selection changed": assign(({
-        context
-      }) => {
-        if (!context.focusSpan)
-          return {
-            focusSpan: void 0
-          };
-        const snapshot = context.editor.getSnapshot(), currentFocusSpan = getFocusSpan(snapshot);
-        if (!snapshot.context.selection || !currentFocusSpan)
-          return {
-            focusSpan: void 0
-          };
-        const nextSpan = getNextSpan({
-          ...snapshot,
-          context: {
-            ...snapshot.context,
-            selection: {
-              anchor: {
-                path: context.focusSpan.path,
-                offset: 0
-              },
-              focus: {
-                path: context.focusSpan.path,
-                offset: 0
-              }
+      const matches = context.definition.getMatches({
+        keyword
+      });
+      return {
+        focusSpan,
+        patternText,
+        keyword,
+        matches,
+        requestedKeyword: keyword,
+        isLoading: !1,
+        selectedIndex: 0
+      };
+    }),
+    "handle selection changed": assign(({
+      context
+    }) => {
+      if (!context.focusSpan)
+        return {
+          focusSpan: void 0
+        };
+      const snapshot = context.editor.getSnapshot(), currentFocusSpan = getFocusSpan(snapshot);
+      if (!snapshot.context.selection || !currentFocusSpan)
+        return {
+          focusSpan: void 0
+        };
+      const nextSpan = getNextSpan({
+        ...snapshot,
+        context: {
+          ...snapshot.context,
+          selection: {
+            anchor: {
+              path: context.focusSpan.path,
+              offset: 0
+            },
+            focus: {
+              path: context.focusSpan.path,
+              offset: 0
             }
           }
-        });
-        if (!isEqualPaths(currentFocusSpan.path, context.focusSpan.path))
-          return nextSpan && context.focusSpan.textAfter.length === 0 && snapshot.context.selection.focus.offset === 0 && isSelectionCollapsed(snapshot) ? {} : {
-            focusSpan: void 0
-          };
-        if (!currentFocusSpan.node.text.startsWith(context.focusSpan.textBefore))
-          return {
-            focusSpan: void 0
-          };
-        if (!currentFocusSpan.node.text.endsWith(context.focusSpan.textAfter))
-          return {
-            focusSpan: void 0
-          };
-        const keywordAnchor = {
-          path: currentFocusSpan.path,
-          offset: context.focusSpan.textBefore.length
-        }, keywordFocus = {
-          path: currentFocusSpan.path,
-          offset: currentFocusSpan.node.text.length - context.focusSpan.textAfter.length
-        }, selectionIsBeforeKeyword = isPointAfterSelection(keywordAnchor)(snapshot), selectionIsAfterKeyword = isPointBeforeSelection(keywordFocus)(snapshot);
-        if (selectionIsBeforeKeyword || selectionIsAfterKeyword)
-          return {
-            focusSpan: void 0
-          };
-        const focusSpan = {
-          node: currentFocusSpan.node,
-          path: currentFocusSpan.path,
-          textBefore: context.focusSpan.textBefore,
-          textAfter: context.focusSpan.textAfter
-        }, patternText = extractPatternTextFromFocusSpan(focusSpan), keyword = extractKeyword(patternText, context.triggerPattern, context.definition.delimiter, context.completePattern);
-        if (context.definition.mode === "async" || context.definition.debounceMs)
-          return {
-            focusSpan,
-            patternText,
-            keyword,
-            selectedIndex: patternText !== context.patternText ? 0 : context.selectedIndex,
-            isLoading: context.isLoading || context.requestedKeyword !== keyword
-          };
-        const matches = context.definition.getMatches({
-          keyword
-        });
+        }
+      });
+      if (!isEqualPaths(currentFocusSpan.path, context.focusSpan.path))
+        return nextSpan && context.focusSpan.textAfter.length === 0 && snapshot.context.selection.focus.offset === 0 && isSelectionCollapsed(snapshot) ? {} : {
+          focusSpan: void 0
+        };
+      if (!currentFocusSpan.node.text.startsWith(context.focusSpan.textBefore))
+        return {
+          focusSpan: void 0
+        };
+      if (!currentFocusSpan.node.text.endsWith(context.focusSpan.textAfter))
+        return {
+          focusSpan: void 0
+        };
+      const keywordAnchor = {
+        path: currentFocusSpan.path,
+        offset: context.focusSpan.textBefore.length
+      }, keywordFocus = {
+        path: currentFocusSpan.path,
+        offset: currentFocusSpan.node.text.length - context.focusSpan.textAfter.length
+      }, selectionIsBeforeKeyword = isPointAfterSelection(keywordAnchor)(snapshot), selectionIsAfterKeyword = isPointBeforeSelection(keywordFocus)(snapshot);
+      if (selectionIsBeforeKeyword || selectionIsAfterKeyword)
+        return {
+          focusSpan: void 0
+        };
+      const focusSpan = {
+        node: currentFocusSpan.node,
+        path: currentFocusSpan.path,
+        textBefore: context.focusSpan.textBefore,
+        textAfter: context.focusSpan.textAfter
+      }, patternText = extractPatternTextFromFocusSpan(focusSpan), keyword = extractKeyword(patternText, context.triggerPattern, context.definition.delimiter, context.completePattern);
+      if (context.definition.mode === "async" || context.definition.debounceMs)
         return {
           focusSpan,
           patternText,
           keyword,
-          matches,
-          requestedKeyword: keyword,
           selectedIndex: patternText !== context.patternText ? 0 : context.selectedIndex,
-          isLoading: !1
-        };
-      }),
-      "handle async load complete": assign(({
-        context,
-        event
-      }) => {
-        const output = event.output;
-        return output.keyword !== context.keyword ? {
-          isLoading: context.keyword !== context.requestedKeyword
-        } : {
-          matches: output.matches,
-          isLoading: context.keyword !== context.requestedKeyword
+          isLoading: context.isLoading || context.requestedKeyword !== keyword
         };
-      }),
-      reset: assign({
-        patternText: "",
-        keyword: "",
-        matches: [],
-        selectedIndex: 0,
-        isLoading: !1,
-        requestedKeyword: "",
-        focusSpan: void 0,
-        error: void 0
-      }),
-      navigate: assign(({
-        context,
-        event
-      }) => context.matches.length === 0 ? {
-        selectedIndex: 0
-      } : event.type === "navigate to" ? {
-        selectedIndex: event.index
-      } : event.type === "navigate up" ? {
-        selectedIndex: (context.selectedIndex - 1 + context.matches.length) % context.matches.length
+      const matches = context.definition.getMatches({
+        keyword
+      });
+      return {
+        focusSpan,
+        patternText,
+        keyword,
+        matches,
+        requestedKeyword: keyword,
+        selectedIndex: patternText !== context.patternText ? 0 : context.selectedIndex,
+        isLoading: !1
+      };
+    }),
+    "handle async load complete": assign(({
+      context,
+      event
+    }) => {
+      const output = event.output;
+      return output.keyword !== context.keyword ? {
+        isLoading: context.keyword !== context.requestedKeyword
       } : {
-        selectedIndex: (context.selectedIndex + 1) % context.matches.length
-      }),
-      "select match": ({
-        context
-      }, params) => {
-        if (!context.focusSpan)
-          return;
-        const match = params.exact ? getFirstExactMatch(context.matches) : context.matches[context.selectedIndex];
-        match && context.editor.send({
-          type: "custom.typeahead select match",
-          match,
-          focusSpan: context.focusSpan,
-          keyword: context.keyword,
-          pickerId: context.definition._id
-        });
-      },
-      "update submit listener context": sendTo("submit listener", ({
-        context
-      }) => ({
-        type: "context changed",
-        context
-      })),
-      "update text insertion listener context": sendTo("text insertion listener", ({
-        context
-      }) => ({
-        type: "context changed",
-        context
-      })),
-      "update escape listener context": sendTo("escape listener", ({
-        context
-      }) => ({
-        type: "context changed",
-        context
-      })),
-      "update request dismiss listener context": sendTo("dismiss listener", ({
-        context
-      }) => ({
-        type: "context changed",
-        context
-      })),
-      "handle error": assign({
-        isLoading: !1,
-        error: ({
-          event
-        }) => event.error
-      })
-    },
-    guards: {
-      "no focus span": ({
-        context
-      }) => !context.focusSpan,
-      "invalid pattern": ({
-        context
-      }) => {
-        if (!context.patternText)
-          return !0;
-        const triggerMatch = context.patternText.match(context.triggerPattern);
-        if (triggerMatch && triggerMatch.index === 0 && triggerMatch[0] === context.patternText)
-          return !1;
-        const partialMatch = context.patternText.match(context.partialPattern);
-        if (partialMatch && partialMatch.index === 0 && partialMatch[0] === context.patternText)
-          return !1;
-        if (context.completePattern) {
-          const completeMatch = context.patternText.match(context.completePattern);
-          if (completeMatch && completeMatch.index === 0 && completeMatch[0] === context.patternText)
-            return !1;
-        }
-        return !0;
-      },
-      "no debounce": ({
-        context
-      }) => !context.definition.debounceMs || context.definition.debounceMs === 0,
-      "is complete keyword": ({
-        context
-      }) => {
-        if (!context.completePattern || !context.focusSpan)
-          return !1;
-        const fullKeywordText = context.focusSpan.node.text.slice(context.focusSpan.textBefore.length, context.focusSpan.textAfter.length > 0 ? -context.focusSpan.textAfter.length : void 0), completeMatch = fullKeywordText.match(context.completePattern);
-        return !completeMatch || completeMatch.index !== 0 || completeMatch[0] !== fullKeywordText ? !1 : hasAtLeastOneExactMatch(context.matches);
-      },
-      "has matches": ({
-        context
-      }) => context.matches.length > 0,
-      "no matches": ({
-        context
-      }) => context.matches.length === 0,
-      "is loading": ({
-        context
-      }) => context.isLoading
-    }
-  }).createMachine({
-    id: "typeahead picker",
-    context: ({
-      input
-    }) => ({
-      editor: input.editor,
-      definition: input.definition,
-      triggerPattern: buildTriggerPattern(input.definition),
-      partialPattern: buildPartialPattern(input.definition),
-      completePattern: buildCompletePattern(input.definition),
-      matches: [],
-      selectedIndex: 0,
-      focusSpan: void 0,
+        matches: output.matches,
+        isLoading: context.keyword !== context.requestedKeyword
+      };
+    }),
+    reset: assign({
       patternText: "",
       keyword: "",
+      matches: [],
+      selectedIndex: 0,
+      isLoading: !1,
       requestedKeyword: "",
-      error: void 0,
-      isLoading: !1
+      focusSpan: void 0,
+      error: void 0
     }),
-    initial: "idle",
-    states: {
-      idle: {
-        entry: ["reset"],
-        invoke: {
-          src: "trigger listener",
-          input: ({
-            context
-          }) => ({
-            editor: context.editor,
-            definition: context.definition
-          })
+    navigate: assign(({
+      context,
+      event
+    }) => context.matches.length === 0 ? {
+      selectedIndex: 0
+    } : event.type === "navigate to" ? {
+      selectedIndex: event.index
+    } : event.type === "navigate up" ? {
+      selectedIndex: (context.selectedIndex - 1 + context.matches.length) % context.matches.length
+    } : {
+      selectedIndex: (context.selectedIndex + 1) % context.matches.length
+    }),
+    "select match": ({
+      context
+    }, params) => {
+      if (!context.focusSpan)
+        return;
+      const match = params.exact ? getFirstExactMatch(context.matches) : context.matches[context.selectedIndex];
+      match && context.editor.send({
+        type: "custom.typeahead select match",
+        match,
+        focusSpan: context.focusSpan,
+        keyword: context.keyword,
+        pickerId: context.definition._id
+      });
+    },
+    "update submit listener context": sendTo("submit listener", ({
+      context
+    }) => ({
+      type: "context changed",
+      context
+    })),
+    "update text insertion listener context": sendTo("text insertion listener", ({
+      context
+    }) => ({
+      type: "context changed",
+      context
+    })),
+    "update escape listener context": sendTo("escape listener", ({
+      context
+    }) => ({
+      type: "context changed",
+      context
+    })),
+    "update request dismiss listener context": sendTo("dismiss listener", ({
+      context
+    }) => ({
+      type: "context changed",
+      context
+    })),
+    "handle error": assign({
+      isLoading: !1,
+      error: ({
+        event
+      }) => event.error
+    })
+  },
+  guards: {
+    "no focus span": ({
+      context
+    }) => !context.focusSpan,
+    "invalid pattern": ({
+      context
+    }) => {
+      if (!context.patternText)
+        return !0;
+      const triggerMatch = context.patternText.match(context.triggerPattern);
+      if (triggerMatch && triggerMatch.index === 0 && triggerMatch[0] === context.patternText)
+        return !1;
+      const partialMatch = context.patternText.match(context.partialPattern);
+      if (partialMatch && partialMatch.index === 0 && partialMatch[0] === context.patternText)
+        return !1;
+      if (context.completePattern) {
+        const completeMatch = context.patternText.match(context.completePattern);
+        if (completeMatch && completeMatch.index === 0 && completeMatch[0] === context.patternText)
+          return !1;
+      }
+      return !0;
+    },
+    "no debounce": ({
+      context
+    }) => !context.definition.debounceMs || context.definition.debounceMs === 0,
+    "is complete keyword": ({
+      context
+    }) => {
+      if (!context.completePattern || !context.focusSpan)
+        return !1;
+      const fullKeywordText = context.focusSpan.node.text.slice(context.focusSpan.textBefore.length, context.focusSpan.textAfter.length > 0 ? -context.focusSpan.textAfter.length : void 0), completeMatch = fullKeywordText.match(context.completePattern);
+      return !completeMatch || completeMatch.index !== 0 || completeMatch[0] !== fullKeywordText ? !1 : hasAtLeastOneExactMatch(context.matches);
+    },
+    "has matches": ({
+      context
+    }) => context.matches.length > 0,
+    "no matches": ({
+      context
+    }) => context.matches.length === 0,
+    "is loading": ({
+      context
+    }) => context.isLoading
+  }
+}).createMachine({
+  id: "typeahead picker",
+  context: ({
+    input
+  }) => ({
+    editor: input.editor,
+    definition: input.definition,
+    triggerPattern: buildTriggerPattern(input.definition),
+    partialPattern: buildPartialPattern(input.definition),
+    completePattern: buildCompletePattern(input.definition),
+    matches: [],
+    selectedIndex: 0,
+    focusSpan: void 0,
+    patternText: "",
+    keyword: "",
+    requestedKeyword: "",
+    error: void 0,
+    isLoading: !1
+  }),
+  initial: "idle",
+  states: {
+    idle: {
+      entry: ["reset"],
+      invoke: {
+        src: "trigger listener",
+        input: ({
+          context
+        }) => ({
+          editor: context.editor,
+          definition: context.definition
+        })
+      },
+      on: {
+        "custom.typeahead trigger found": {
+          target: "active",
+          actions: ["handle trigger found"]
         },
-        on: {
-          "custom.typeahead trigger found": {
-            target: "active",
-            actions: ["handle trigger found"]
-          },
-          "custom.typeahead keyword found": {
-            target: "checking complete",
-            actions: ["handle trigger found"]
-          }
+        "custom.typeahead keyword found": {
+          target: "checking complete",
+          actions: ["handle trigger found"]
         }
-      },
-      "checking complete": {
-        invoke: [{
-          src: "select match listener",
-          input: ({
-            context
-          }) => ({
-            context
-          })
-        }, {
-          src: "get matches",
-          input: ({
-            context
-          }) => ({
-            keyword: context.keyword,
-            getMatches: context.definition.getMatches
-          }),
-          onDone: [{
-            guard: ({
+      }
+    },
+    "checking complete": {
+      invoke: [{
+        src: "select match listener",
+        input: ({
+          context
+        }) => ({
+          context
+        })
+      }, {
+        src: "get matches",
+        input: ({
+          context
+        }) => ({
+          keyword: context.keyword,
+          getMatches: context.definition.getMatches
+        }),
+        onDone: [{
+          guard: ({
+            event
+          }) => hasAtLeastOneExactMatch(event.output.matches),
+          target: "idle",
+          actions: [assign({
+            matches: ({
               event
-            }) => hasAtLeastOneExactMatch(event.output.matches),
-            target: "idle",
-            actions: [assign({
-              matches: ({
-                event
-              }) => event.output.matches
-            }), {
-              type: "select match",
-              params: {
-                exact: !0
-              }
-            }]
-          }, {
-            target: "active",
-            actions: [assign({
-              matches: ({
-                event
-              }) => event.output.matches
-            })]
-          }],
-          onError: {
-            target: "active.no matches",
-            actions: ["handle error"]
-          }
-        }]
-      },
-      active: {
-        invoke: [{
-          src: "select match listener",
-          input: ({
-            context
-          }) => ({
-            context
-          })
-        }, {
-          src: "escape listener",
-          id: "escape listener",
-          input: ({
-            context
-          }) => ({
-            context
-          })
-        }, {
-          src: "selection listener",
-          input: ({
-            context
-          }) => ({
-            editor: context.editor
-          })
-        }, {
-          src: "submit listener",
-          id: "submit listener",
-          input: ({
-            context
-          }) => ({
-            context
-          })
-        }, {
-          src: "text insertion listener",
-          id: "text insertion listener",
-          input: ({
-            context
-          }) => ({
-            context
-          })
-        }, {
-          src: "dismiss listener",
-          id: "dismiss listener",
-          input: ({
-            context
-          }) => ({
-            context
-          })
-        }],
-        on: {
-          close: {
-            target: "idle"
-          },
-          "selection changed": {
-            actions: ["handle selection changed", "update submit listener context", "update text insertion listener context", "update escape listener context", "update request dismiss listener context"]
-          }
-        },
-        always: [{
-          guard: "no focus span",
-          target: "idle"
-        }, {
-          guard: "invalid pattern",
-          target: "idle"
-        }, {
-          guard: "is complete keyword",
-          actions: [{
+            }) => event.output.matches
+          }), {
             type: "select match",
             params: {
-              exact: !1
+              exact: !0
             }
-          }],
+          }]
+        }, {
+          target: "active",
+          actions: [assign({
+            matches: ({
+              event
+            }) => event.output.matches
+          })]
+        }],
+        onError: {
+          target: "active.no matches",
+          actions: ["handle error"]
+        }
+      }]
+    },
+    active: {
+      invoke: [{
+        src: "select match listener",
+        input: ({
+          context
+        }) => ({
+          context
+        })
+      }, {
+        src: "escape listener",
+        id: "escape listener",
+        input: ({
+          context
+        }) => ({
+          context
+        })
+      }, {
+        src: "selection listener",
+        input: ({
+          context
+        }) => ({
+          editor: context.editor
+        })
+      }, {
+        src: "submit listener",
+        id: "submit listener",
+        input: ({
+          context
+        }) => ({
+          context
+        })
+      }, {
+        src: "text insertion listener",
+        id: "text insertion listener",
+        input: ({
+          context
+        }) => ({
+          context
+        })
+      }, {
+        src: "dismiss listener",
+        id: "dismiss listener",
+        input: ({
+          context
+        }) => ({
+          context
+        })
+      }],
+      on: {
+        close: {
           target: "idle"
+        },
+        "selection changed": {
+          actions: ["handle selection changed", "update submit listener context", "update text insertion listener context", "update escape listener context", "update request dismiss listener context"]
+        }
+      },
+      always: [{
+        guard: "no focus span",
+        target: "idle"
+      }, {
+        guard: "invalid pattern",
+        target: "idle"
+      }, {
+        guard: "is complete keyword",
+        actions: [{
+          type: "select match",
+          params: {
+            exact: !1
+          }
         }],
-        initial: "evaluating",
-        states: {
-          evaluating: {
-            always: [{
-              guard: "is loading",
-              target: "loading"
-            }, {
-              guard: "has matches",
-              target: "showing matches"
-            }, {
-              target: "no matches"
-            }]
-          },
-          loading: {
-            entry: [assign({
-              requestedKeyword: ({
-                context
-              }) => context.keyword
-            })],
-            initial: "debouncing",
-            states: {
-              debouncing: {
-                always: [{
-                  guard: "no debounce",
-                  target: "fetching"
-                }],
-                after: {
-                  DEBOUNCE: "fetching"
-                }
-              },
-              fetching: {
-                invoke: {
-                  src: "get matches",
-                  input: ({
-                    context
-                  }) => ({
-                    keyword: context.keyword,
-                    getMatches: context.definition.getMatches
-                  }),
-                  onDone: {
-                    target: "#typeahead picker.active.evaluating",
-                    actions: [assign(({
-                      context,
-                      event
-                    }) => event.output.keyword !== context.keyword ? {
-                      isLoading: context.patternText !== context.requestedKeyword
-                    } : {
-                      matches: event.output.matches,
-                      isLoading: context.keyword !== context.requestedKeyword
-                    })]
-                  },
-                  onError: {
-                    target: "#typeahead picker.active.no matches",
-                    actions: ["handle error"]
-                  }
+        target: "idle"
+      }],
+      initial: "evaluating",
+      states: {
+        evaluating: {
+          always: [{
+            guard: "is loading",
+            target: "loading"
+          }, {
+            guard: "has matches",
+            target: "showing matches"
+          }, {
+            target: "no matches"
+          }]
+        },
+        loading: {
+          entry: [assign({
+            requestedKeyword: ({
+              context
+            }) => context.keyword
+          })],
+          initial: "debouncing",
+          states: {
+            debouncing: {
+              always: [{
+                guard: "no debounce",
+                target: "fetching"
+              }],
+              after: {
+                DEBOUNCE: "fetching"
+              }
+            },
+            fetching: {
+              invoke: {
+                src: "get matches",
+                input: ({
+                  context
+                }) => ({
+                  keyword: context.keyword,
+                  getMatches: context.definition.getMatches
+                }),
+                onDone: {
+                  target: "#typeahead picker.active.evaluating",
+                  actions: [assign(({
+                    context,
+                    event
+                  }) => event.output.keyword !== context.keyword ? {
+                    isLoading: context.patternText !== context.requestedKeyword
+                  } : {
+                    matches: event.output.matches,
+                    isLoading: context.keyword !== context.requestedKeyword
+                  })]
+                },
+                onError: {
+                  target: "#typeahead picker.active.no matches",
+                  actions: ["handle error"]
                 }
               }
             }
-          },
-          "no matches": {
-            entry: [assign({
-              selectedIndex: 0
-            })],
-            always: [{
-              guard: "has matches",
-              target: "showing matches"
-            }],
-            initial: "idle",
-            states: {
-              idle: {
-                always: [{
-                  guard: "is loading",
-                  target: "loading"
-                }]
-              },
-              loading: {
-                entry: [assign({
-                  requestedKeyword: ({
-                    context
-                  }) => context.keyword
-                })],
-                initial: "debouncing",
-                states: {
-                  debouncing: {
-                    always: [{
-                      guard: "no debounce",
-                      target: "fetching"
-                    }],
-                    after: {
-                      DEBOUNCE: "fetching"
-                    }
-                  },
-                  fetching: {
-                    invoke: {
-                      src: "get matches",
-                      input: ({
-                        context
-                      }) => ({
-                        keyword: context.keyword,
-                        getMatches: context.definition.getMatches
-                      }),
-                      onDone: {
-                        target: "#typeahead picker.active.no matches.idle",
-                        actions: ["handle async load complete"]
-                      },
-                      onError: {
-                        target: "#typeahead picker.active.no matches.idle",
-                        actions: ["handle error"]
-                      }
+          }
+        },
+        "no matches": {
+          entry: [assign({
+            selectedIndex: 0
+          })],
+          always: [{
+            guard: "has matches",
+            target: "showing matches"
+          }],
+          initial: "idle",
+          states: {
+            idle: {
+              always: [{
+                guard: "is loading",
+                target: "loading"
+              }]
+            },
+            loading: {
+              entry: [assign({
+                requestedKeyword: ({
+                  context
+                }) => context.keyword
+              })],
+              initial: "debouncing",
+              states: {
+                debouncing: {
+                  always: [{
+                    guard: "no debounce",
+                    target: "fetching"
+                  }],
+                  after: {
+                    DEBOUNCE: "fetching"
+                  }
+                },
+                fetching: {
+                  invoke: {
+                    src: "get matches",
+                    input: ({
+                      context
+                    }) => ({
+                      keyword: context.keyword,
+                      getMatches: context.definition.getMatches
+                    }),
+                    onDone: {
+                      target: "#typeahead picker.active.no matches.idle",
+                      actions: ["handle async load complete"]
+                    },
+                    onError: {
+                      target: "#typeahead picker.active.no matches.idle",
+                      actions: ["handle error"]
                     }
                   }
                 }
               }
             }
+          }
+        },
+        "showing matches": {
+          entry: ["update submit listener context", "update text insertion listener context"],
+          invoke: {
+            src: "arrow listener",
+            input: ({
+              context
+            }) => ({
+              editor: context.editor
+            })
           },
-          "showing matches": {
-            entry: ["update submit listener context", "update text insertion listener context"],
-            invoke: {
-              src: "arrow listener",
-              input: ({
-                context
-              }) => ({
-                editor: context.editor
-              })
+          always: [{
+            guard: "no matches",
+            target: "no matches"
+          }],
+          on: {
+            "navigate down": {
+              actions: ["navigate", "update submit listener context", "update text insertion listener context"]
             },
-            always: [{
-              guard: "no matches",
-              target: "no matches"
-            }],
-            on: {
-              "navigate down": {
-                actions: ["navigate", "update submit listener context", "update text insertion listener context"]
-              },
-              "navigate up": {
-                actions: ["navigate", "update submit listener context", "update text insertion listener context"]
-              },
-              "navigate to": {
-                actions: ["navigate", "update submit listener context", "update text insertion listener context"]
-              },
-              select: {
-                target: "#typeahead picker.idle",
-                actions: [{
-                  type: "select match",
-                  params: {
-                    exact: !1
-                  }
-                }]
-              }
+            "navigate up": {
+              actions: ["navigate", "update submit listener context", "update text insertion listener context"]
             },
-            initial: "idle",
-            states: {
-              idle: {
-                always: [{
-                  guard: "is loading",
-                  target: "loading"
-                }]
-              },
-              loading: {
-                entry: [assign({
-                  requestedKeyword: ({
-                    context
-                  }) => context.keyword
-                })],
-                initial: "debouncing",
-                states: {
-                  debouncing: {
-                    always: [{
-                      guard: "no debounce",
-                      target: "fetching"
-                    }],
-                    after: {
-                      DEBOUNCE: "fetching"
-                    }
-                  },
-                  fetching: {
-                    invoke: {
-                      src: "get matches",
-                      input: ({
-                        context
-                      }) => ({
-                        keyword: context.keyword,
-                        getMatches: context.definition.getMatches
-                      }),
-                      onDone: {
-                        target: "#typeahead picker.active.showing matches.idle",
-                        actions: ["handle async load complete"]
-                      },
-                      onError: {
-                        target: "#typeahead picker.active.showing matches.idle",
-                        actions: ["handle error"]
-                      }
+            "navigate to": {
+              actions: ["navigate", "update submit listener context", "update text insertion listener context"]
+            },
+            select: {
+              target: "#typeahead picker.idle",
+              actions: [{
+                type: "select match",
+                params: {
+                  exact: !1
+                }
+              }]
+            }
+          },
+          initial: "idle",
+          states: {
+            idle: {
+              always: [{
+                guard: "is loading",
+                target: "loading"
+              }]
+            },
+            loading: {
+              entry: [assign({
+                requestedKeyword: ({
+                  context
+                }) => context.keyword
+              })],
+              initial: "debouncing",
+              states: {
+                debouncing: {
+                  always: [{
+                    guard: "no debounce",
+                    target: "fetching"
+                  }],
+                  after: {
+                    DEBOUNCE: "fetching"
+                  }
+                },
+                fetching: {
+                  invoke: {
+                    src: "get matches",
+                    input: ({
+                      context
+                    }) => ({
+                      keyword: context.keyword,
+                      getMatches: context.definition.getMatches
+                    }),
+                    onDone: {
+                      target: "#typeahead picker.active.showing matches.idle",
+                      actions: ["handle async load complete"]
+                    },
+                    onError: {
+                      target: "#typeahead picker.active.showing matches.idle",
+                      actions: ["handle error"]
                     }
                   }
                 }
@@ -1249,8 +1244,8 @@ function createTypeaheadPickerMachine() {
         }
       }
     }
-  });
-}
+  }
+});
 function hasAtLeastOneExactMatch(matches) {
   return matches.some((match) => match?.type === "exact");
 }
@@ -1258,44 +1253,42 @@ function getFirstExactMatch(matches) {
   return matches.find((match) => match?.type === "exact");
 }
 function useTypeaheadPicker(definition) {
-  const $ = c(21), editor = useEditor();
-  let t0;
-  $[0] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel") ? (t0 = createTypeaheadPickerMachine(), $[0] = t0) : t0 = $[0];
+  const $ = c(20), editor = useEditor(), t0 = definition;
   let t1;
-  $[1] !== definition || $[2] !== editor ? (t1 = {
+  $[0] !== editor || $[1] !== t0 ? (t1 = {
     input: {
       editor,
-      definition
+      definition: t0
     }
-  }, $[1] = definition, $[2] = editor, $[3] = t1) : t1 = $[3];
-  const [actorSnapshot, send] = useActor(t0, t1);
+  }, $[0] = editor, $[1] = t0, $[2] = t1) : t1 = $[2];
+  const [actorSnapshot, send] = useActor(typeaheadPickerMachine, t1);
   let t2;
-  $[4] !== actorSnapshot ? (t2 = (state) => actorSnapshot.matches(state), $[4] = actorSnapshot, $[5] = t2) : t2 = $[5];
+  $[3] !== actorSnapshot ? (t2 = (state) => actorSnapshot.matches(state), $[3] = actorSnapshot, $[4] = t2) : t2 = $[4];
   const t3 = actorSnapshot.context.matches;
   let t4;
-  $[6] !== actorSnapshot.context.error || $[7] !== actorSnapshot.context.keyword || $[8] !== actorSnapshot.context.selectedIndex || $[9] !== t3 ? (t4 = {
+  $[5] !== actorSnapshot.context.error || $[6] !== actorSnapshot.context.keyword || $[7] !== actorSnapshot.context.selectedIndex || $[8] !== t3 ? (t4 = {
     keyword: actorSnapshot.context.keyword,
     matches: t3,
     selectedIndex: actorSnapshot.context.selectedIndex,
     error: actorSnapshot.context.error
-  }, $[6] = actorSnapshot.context.error, $[7] = actorSnapshot.context.keyword, $[8] = actorSnapshot.context.selectedIndex, $[9] = t3, $[10] = t4) : t4 = $[10];
+  }, $[5] = actorSnapshot.context.error, $[6] = actorSnapshot.context.keyword, $[7] = actorSnapshot.context.selectedIndex, $[8] = t3, $[9] = t4) : t4 = $[9];
   let t5;
-  $[11] !== t2 || $[12] !== t4 ? (t5 = {
+  $[10] !== t2 || $[11] !== t4 ? (t5 = {
     matches: t2,
     context: t4
-  }, $[11] = t2, $[12] = t4, $[13] = t5) : t5 = $[13];
+  }, $[10] = t2, $[11] = t4, $[12] = t5) : t5 = $[12];
   let t6;
-  $[14] !== definition || $[15] !== editor || $[16] !== send ? (t6 = (event) => {
+  $[13] !== definition || $[14] !== editor || $[15] !== send ? (t6 = (event) => {
     event.type === "dismiss" ? editor.send({
       type: "custom.typeahead dismiss",
       pickerId: definition._id
     }) : send(event);
-  }, $[14] = definition, $[15] = editor, $[16] = send, $[17] = t6) : t6 = $[17];
+  }, $[13] = definition, $[14] = editor, $[15] = send, $[16] = t6) : t6 = $[16];
   let t7;
-  return $[18] !== t5 || $[19] !== t6 ? (t7 = {
+  return $[17] !== t5 || $[18] !== t6 ? (t7 = {
     snapshot: t5,
     send: t6
-  }, $[18] = t5, $[19] = t6, $[20] = t7) : t7 = $[20], t7;
+  }, $[17] = t5, $[18] = t6, $[19] = t7) : t7 = $[19], t7;
 }
 export {
   defineTypeaheadPicker,