@baleada/logic 0.21.1 → 0.22.0

package/lib/index.cjs

@@ -291,16 +291,61 @@ const modifiersByAlias = {
   opt: "alt",
   option: "alt"
 };
-function createExceptAndOnlyEffect(effect, options) {
+function createExceptAndOnlyEffect(type, effect, options) {
   const { except = [], only = [] } = options;
+  if (type === "keydown" || type === "keyup") {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true], api = {
+        is: (keycombo) => eventMatchesKeycombo(event, ensureKeycombo(keycombo))
+      };
+      if (matchesOnly) {
+        effect(event, api);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event, api);
+        return;
+      }
+    };
+  }
+  if (type === "click" || type === "mousedown" || type === "mouseup" || type === "dblclick" || type === "contextmenu") {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true], api = {
+        is: (clickcombo) => eventMatchesClickcombo(event, ensureClickcombo(clickcombo))
+      };
+      if (matchesOnly) {
+        effect(event, api);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event, api);
+        return;
+      }
+    };
+  }
+  if (type === "pointerdown" || type === "pointerup") {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true], api = {
+        is: (pointercombo) => eventMatchesPointercombo(event, ensurePointercombo(pointercombo))
+      };
+      if (matchesOnly) {
+        effect(event, api);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event, api);
+        return;
+      }
+    };
+  }
   return (event) => {
     const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => lazyCollections.some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
     if (matchesOnly) {
-      effect(event);
+      effect(event, {});
       return;
     }
     if (only.length === 0 && !matchesExcept) {
-      effect(event);
+      effect(event, {});
       return;
     }
   };
@@ -349,19 +394,13 @@ class Recognizeable {
   maxSequenceLength;
   effects;
   effectApi;
-  toType;
-  constructor(sequence, options = { effectsIncludeCombos: true }) {
+  constructor(sequence, options = {}) {
     const defaultOptions = {
       maxSequenceLength: true,
-      effectsIncludeCombos: true,
       effects: {}
     };
     this.maxSequenceLength = options?.maxSequenceLength || defaultOptions.maxSequenceLength;
-    this.effects = new Map(isFunction(options?.effects) ? options.effects(createDefineEffect()) : Object.entries(options?.effects || defaultOptions.effects));
-    this.toType = createToType({
-      effectsIncludeCombos: options.effectsIncludeCombos,
-      effects: this.effects
-    });
+    this.effects = new Map(Object.entries(options?.effects || defaultOptions.effects));
     this.resetComputedMetadata();
     this.setSequence(sequence);
     this.effectApi = {
@@ -404,14 +443,13 @@ class Recognizeable {
     this.computedSequence = sequence;
     return this;
   }
-  recognize(sequenceItem, { onRecognized } = {}) {
+  recognize(sequenceItem, api, { onRecognized } = {}) {
     this.recognizing();
     const type = this.toType(sequenceItem), excess = isNumber(this.maxSequenceLength) ? Math.max(0, this.sequence.length - this.maxSequenceLength) : 0, newSequence = createConcat(createSlice(excess)(this.sequence), [sequenceItem])([]);
-    this.effectApi.sequenceItem = sequenceItem;
     this.effectApi.getSequence = () => newSequence;
     this.effectApi.onRecognized = onRecognized || (() => {
     });
-    this.effects.get(type)?.(this.effectApi);
+    this.effects.get(type)?.(sequenceItem, { ...api, ...this.effectApi });
     switch (this.status) {
       case "denied":
         this.resetComputedMetadata();
@@ -427,34 +465,7 @@ class Recognizeable {
   recognizing() {
     this.computedStatus = "recognizing";
   }
-}
-function createDefineEffect() {
-  return (type, effect) => {
-    return [type, effect];
-  };
-}
-function createToType({
-  effectsIncludeCombos,
-  effects
-}) {
-  const effectLeftclickcombos = [], effectRightclickcombos = [], effectKeycombos = [];
-  if (effectsIncludeCombos) {
-    for (const [effectKey] of effects) {
-      const implementation = toImplementation(effectKey);
-      switch (implementation) {
-        case "leftclickcombo":
-          effectLeftclickcombos.push(ensureClickcombo(effectKey));
-          break;
-        case "rightclickcombo":
-          effectRightclickcombos.push(ensureClickcombo(effectKey));
-          break;
-        case "keycombo":
-          effectKeycombos.push(ensureKeycombo(effectKey));
-          break;
-      }
-    }
-  }
-  return function toType(sequenceItem) {
+  toType(sequenceItem) {
     if (isArray(sequenceItem)) {
       if (sequenceItem[0] instanceof IntersectionObserverEntry) {
         return "intersect";
@@ -472,38 +483,10 @@ function createToType({
       if ("didTimeout" in sequenceItem) {
         return "idle";
       }
-      if (effectLeftclickcombos?.length > 0) {
-        if (leftclickcomboEventTypes.has(sequenceItem.type)) {
-          for (const clickcombo of effectLeftclickcombos) {
-            if (eventMatchesClickcombo({ event: sequenceItem, clickcombo })) {
-              return toJoinedClickcombo(clickcombo);
-            }
-          }
-        }
-      }
-      if (effectRightclickcombos?.length > 0) {
-        if (rightclickComboEventTypes.has(sequenceItem.type)) {
-          for (const clickcombo of effectRightclickcombos) {
-            if (eventMatchesClickcombo({ event: sequenceItem, clickcombo })) {
-              return toJoinedClickcombo(clickcombo);
-            }
-          }
-        }
-      }
-      if (effectKeycombos?.length > 0) {
-        if (keycomboEventTypes.has(sequenceItem.type)) {
-          for (const keycombo of effectKeycombos) {
-            if (eventMatchesKeycombo({ event: sequenceItem, keycombo })) {
-              return toJoinedKeycombo(keycombo);
-            }
-          }
-        }
-      }
       return sequenceItem.type;
     }
-  };
+  }
 }
-const leftclickcomboEventTypes = /* @__PURE__ */ new Set(["click", "mousedown", "mouseup", "dblclick"]), rightclickComboEventTypes = /* @__PURE__ */ new Set(["contextmenu"]), keycomboEventTypes = /* @__PURE__ */ new Set(["keydown", "keyup"]), toJoinedClickcombo = lazyCollections.join("+"), toJoinedKeycombo = lazyCollections.pipe(lazyCollections.map(({ name }) => name), toJoinedClickcombo);
 
 class Listenable {
   computedRecognizeable;
@@ -511,15 +494,8 @@ class Listenable {
   computedActive;
   constructor(type, options) {
     if (type === "recognizeable") {
-      const recognizeableOptions = {
-        ...options?.recognizeable || {},
-        effects: isFunction(options?.recognizeable?.effects) ? createReduce((effects, [type2, effect]) => {
-          effects[type2] = effect;
-          return effects;
-        }, {})(options.recognizeable.effects(createDefineEffect())) : options?.recognizeable?.effects || {}
-      };
-      this.computedRecognizeable = new Recognizeable([], recognizeableOptions);
-      this.recognizeableEffectsKeys = Object.keys(recognizeableOptions.effects);
+      this.computedRecognizeable = new Recognizeable([], options?.recognizeable || {});
+      this.recognizeableEffectsKeys = Object.keys(options?.recognizeable?.effects || {});
     }
     this.computedActive = /* @__PURE__ */ new Set();
     this.setType(type);
@@ -575,16 +551,6 @@ class Listenable {
       case "documentevent":
         this.documentEventListen(effect, options);
         break;
-      case "keycombo":
-        this.keycomboListen(effect, options);
-        break;
-      case "leftclickcombo":
-      case "rightclickcombo":
-        this.clickcomboListen(effect, options);
-        break;
-      case "pointercombo":
-        this.pointercomboListen(effect, options);
-        break;
       case "event":
         this.eventListen(effect, options);
         break;
@@ -612,18 +578,19 @@ class Listenable {
     if (isFunction(options.instantEffect)) {
       options.instantEffect(target);
     }
-    target.addEventListener("change", effect);
-    this.active.add({ target, id: ["change", effect] });
+    const withApi = (event) => effect(event, {});
+    target.addEventListener("change", withApi);
+    this.active.add({ target, id: ["change", withApi] });
   }
   idleListen(effect, options) {
-    const { requestIdleCallback } = options, id = window.requestIdleCallback(effect, requestIdleCallback);
+    const { requestIdleCallback } = options, id = window.requestIdleCallback((deadline) => effect(deadline, {}), requestIdleCallback);
     this.active.add({ target: window, id });
   }
   recognizeableListen(effect, options) {
-    const guardedEffect = (sequenceItem) => {
-      this.recognizeable.recognize(sequenceItem, { onRecognized: effect });
+    const guardedEffect = (sequenceItem, api) => {
+      this.recognizeable.recognize(sequenceItem, api, { onRecognized: (sequenceItem2) => effect(sequenceItem2, api) });
       if (this.recognizeable.status === "recognized") {
-        effect(sequenceItem);
+        effect(sequenceItem, api);
       }
     };
     for (const type of this.recognizeableEffectsKeys) {
@@ -639,44 +606,8 @@ class Listenable {
     };
     this.eventListen(effect, ensuredOptions);
   }
-  pointercomboListen(effect, options) {
-    const pointercombo = ensurePointercombo(this.type), guardedEffect = (event) => {
-      if (eventMatchesPointercombo({ event, pointercombo })) {
-        effect(event);
-      }
-    };
-    this.eventListen(guardedEffect, options);
-  }
-  clickcomboListen(effect, options) {
-    const clickcombo = ensureClickcombo(this.type), guardedEffect = (event) => {
-      if (eventMatchesClickcombo({ event, clickcombo })) {
-        effect(event);
-      }
-    };
-    this.eventListen(guardedEffect, options);
-  }
-  keycomboListen(effect, options) {
-    const keycombo = ensureKeycombo(this.type), guardedEffect = (event) => {
-      if (eventMatchesKeycombo({ event, keycombo })) {
-        effect(event);
-      }
-    };
-    this.eventListen(guardedEffect, options);
-  }
   eventListen(effect, options) {
-    const type = (() => {
-      switch (this.implementation) {
-        case "keycombo":
-          return `key${options.keyDirection || "down"}`;
-        case "leftclickcombo":
-          return this.type.match(/(\w+)$/)[1];
-        case "rightclickcombo":
-          return "contextmenu";
-        default:
-          return this.type;
-      }
-    })();
-    const { exceptAndOnlyEffect, effectOptions } = toAddEventListenerParams(effect, options), eventListeners = [[type, exceptAndOnlyEffect, ...effectOptions]];
+    const { exceptAndOnlyEffect, effectOptions } = toAddEventListenerParams(this.type, effect, options), eventListeners = [[this.type, exceptAndOnlyEffect, ...effectOptions]];
     this.addEventListeners(eventListeners, options);
   }
   addEventListeners(eventListeners, options) {
@@ -767,22 +698,6 @@ const predicatesByImplementation = /* @__PURE__ */ new Map([
     "documentevent",
     (type) => documentEvents.has(type)
   ],
-  [
-    "keycombo",
-    (type) => implementationREs.keycombo.test(type)
-  ],
-  [
-    "leftclickcombo",
-    (type) => implementationREs.leftclickcombo.test(type)
-  ],
-  [
-    "rightclickcombo",
-    (type) => implementationREs.rightclickcombo.test(type)
-  ],
-  [
-    "pointercombo",
-    (type) => implementationREs.pointercombo.test(type)
-  ],
   [
     "event",
     () => true
@@ -797,17 +712,13 @@ const documentEvents = /* @__PURE__ */ new Set([
   "visibilitychange"
 ]);
 const implementationREs = {
-  mediaquery: /^\(.+\)$/,
-  keycombo: /^((!?([a-zA-Z0-9,<.>/?;:'"[{\]}\\|`~!@#$%^&*()-_=+]|tab|space|arrow|vertical|horizontal|up|right|down|left|enter|backspace|esc|home|end|pagedown|pageup|capslock|f[0-9]{1,2}|camera|delete|cmd|command|meta|shift|ctrl|control|alt|opt|option))\+)*(!?([a-zA-Z0-9,<.>/?;:'"[{\]}\\|`~!@#$%^&*()-_=+]|tab|space|arrow|vertical|horizontal|up|right|down|left|enter|backspace|esc|home|end|pagedown|pageup|capslock|f[0-9]{1,2}|camera|delete|cmd|command|meta|shift|ctrl|control|alt|opt|option))$/,
-  leftclickcombo: /^(!?((cmd|command|meta|shift|ctrl|control|alt|opt|option))\+){0,4}!?(click|mousedown|mouseup|dblclick)$/,
-  rightclickcombo: /^(!?((cmd|command|meta|shift|ctrl|control|alt|opt|option))\+){0,4}!?(rightclick|contextmenu)$/,
-  pointercombo: /^(!?((cmd|command|meta|shift|ctrl|control|alt|opt|option))\+){0,4}!?(pointerdown|pointerup)$/
+  mediaquery: /^\(.+\)$/
 };
-function toAddEventListenerParams(effect, options) {
-  const { addEventListener, useCapture } = options, exceptAndOnlyEffect = createExceptAndOnlyEffect(effect, options), effectOptions = [addEventListener || useCapture];
+function toAddEventListenerParams(type, effect, options) {
+  const { addEventListener, useCapture } = options, exceptAndOnlyEffect = createExceptAndOnlyEffect(type, effect, options), effectOptions = [addEventListener || useCapture];
   return { exceptAndOnlyEffect, effectOptions };
 }
-function eventMatchesKeycombo({ event, keycombo }) {
+function eventMatchesKeycombo(event, keycombo) {
   return lazyCollections.every(({ name, type }, index) => {
     switch (type) {
       case "singleCharacter":
@@ -891,10 +802,10 @@ const predicatesByArrow = /* @__PURE__ */ new Map([
 const arrows = /* @__PURE__ */ new Set(["arrowup", "arrowright", "arrowdown", "arrowleft"]);
 const verticalArrows = /* @__PURE__ */ new Set(["arrowup", "arrowdown"]);
 const horizontalArrows = /* @__PURE__ */ new Set(["arrowright", "arrowleft"]);
-function eventMatchesClickcombo({ event, clickcombo }) {
+function eventMatchesClickcombo(event, clickcombo) {
   return lazyCollections.every((name) => fromComboItemNameToType(name) === "click" || name.startsWith("!") && !isModified({ alias: name.slice(1), event }) || !name.startsWith("!") && isModified({ alias: name, event }))(clickcombo);
 }
-function eventMatchesPointercombo({ event, pointercombo }) {
+function eventMatchesPointercombo(event, pointercombo) {
   return lazyCollections.every((name) => fromComboItemNameToType(name) === "pointer" || name.startsWith("!") && !isModified({ alias: name.slice(1), event }) || !name.startsWith("!") && isModified({ alias: name, event }))(pointercombo);
 }
 const observerAssertionsByType = {
@@ -2704,6 +2615,10 @@ class Navigateable {
 const defaultOptions$1 = {
   initialPicks: []
 };
+const defaultPickOptions = {
+  replace: "none",
+  allowsDuplicates: false
+};
 class Pickable {
   constructor(array, options = {}) {
     this.setArray(array);
@@ -2749,8 +2664,9 @@ class Pickable {
     return this.toItems(this.picks);
   }
   toItems = createMap((index) => this.array[index]);
+  computedMultiple;
   get multiple() {
-    return this.picks.length > 1;
+    return this.computedMultiple;
   }
   toPossiblePicks;
   setArray(array) {
@@ -2762,41 +2678,42 @@ class Pickable {
     return this.pick(indexOrIndices);
   }
   pick(indexOrIndices, options = {}) {
-    const { replace = "none" } = options;
+    const { replace, allowsDuplicates } = { ...defaultPickOptions, ...options };
     this.computedPicks = new Pipeable(indexOrIndices).pipe(ensureIndices, this.toPossiblePicks, (possiblePicks) => {
       if (replace === "all") {
-        return toUnique(possiblePicks);
+        return allowsDuplicates ? possiblePicks : toUnique(possiblePicks);
       }
-      const possibleWithoutDuplicates = createFilter((possiblePick) => typeof lazyCollections.find((pick) => pick === possiblePick)(this.picks || []) !== "number")(possiblePicks);
+      const maybeWithoutDuplicates = allowsDuplicates ? possiblePicks : createFilter((possiblePick) => typeof lazyCollections.find((pick) => pick === possiblePick)(this.picks || []) !== "number")(possiblePicks);
       switch (replace) {
         case "none":
-          return createConcat(this.picks || [], possibleWithoutDuplicates)([]);
+          return createConcat(this.picks || [], maybeWithoutDuplicates)([]);
         case "fifo":
-          if (possibleWithoutDuplicates.length === 0) {
+          if (maybeWithoutDuplicates.length === 0) {
             return this.picks;
           }
-          if (possibleWithoutDuplicates.length === this.picks.length) {
-            return possibleWithoutDuplicates;
+          if (maybeWithoutDuplicates.length === this.picks.length) {
+            return maybeWithoutDuplicates;
           }
-          if (possibleWithoutDuplicates.length > this.picks.length) {
-            return createSlice(possibleWithoutDuplicates.length - this.picks.length)(possibleWithoutDuplicates);
+          if (maybeWithoutDuplicates.length > this.picks.length) {
+            return createSlice(maybeWithoutDuplicates.length - this.picks.length)(maybeWithoutDuplicates);
           }
-          return new Pipeable(this.picks).pipe(createSlice(possibleWithoutDuplicates.length), createConcat(possibleWithoutDuplicates));
+          return new Pipeable(this.picks).pipe(createSlice(maybeWithoutDuplicates.length), createConcat(maybeWithoutDuplicates));
         case "lifo":
-          if (possibleWithoutDuplicates.length === 0) {
+          if (maybeWithoutDuplicates.length === 0) {
             return this.picks;
           }
-          if (possibleWithoutDuplicates.length === this.picks.length) {
-            return possibleWithoutDuplicates;
+          if (maybeWithoutDuplicates.length === this.picks.length) {
+            return maybeWithoutDuplicates;
           }
-          if (possibleWithoutDuplicates.length > this.picks.length) {
-            return createSlice(0, possibleWithoutDuplicates.length - this.picks.length + 1)(possibleWithoutDuplicates);
+          if (maybeWithoutDuplicates.length > this.picks.length) {
+            return createSlice(0, maybeWithoutDuplicates.length - this.picks.length + 1)(maybeWithoutDuplicates);
           }
-          return new Pipeable(this.picks).pipe(createSlice(0, this.picks.length - possibleWithoutDuplicates.length), createConcat(possibleWithoutDuplicates));
+          return new Pipeable(this.picks).pipe(createSlice(0, this.picks.length - maybeWithoutDuplicates.length), createConcat(maybeWithoutDuplicates));
       }
     });
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
+    this.computedMultiple = toUnique(this.picks).length > 1;
     this.picked();
     return this;
   }
@@ -2808,6 +2725,7 @@ class Pickable {
       this.computedPicks = [];
       this.computedFirst = void 0;
       this.computedLast = void 0;
+      this.computedMultiple = false;
       this.omitted();
       return this;
     }
@@ -2815,6 +2733,7 @@ class Pickable {
     this.computedPicks = createFilter((pick, index) => options.reference === "array" ? isUndefined(lazyCollections.find((omit) => pick === omit)(omits)) : isUndefined(lazyCollections.find((omit) => index === omit)(omits)))(this.computedPicks);
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
+    this.computedMultiple = toUnique(this.picks).length > 1;
     this.omitted();
     return this;
   }
@@ -3102,8 +3021,6 @@ exports.easingsNetOutExpo = easingsNetOutExpo;
 exports.easingsNetOutQuad = easingsNetOutQuad;
 exports.easingsNetOutQuint = easingsNetOutQuint;
 exports.easingsNetOutSine = easingsNetOutSine;
-exports.ensureKeycombo = ensureKeycombo;
-exports.eventMatchesKeycombo = eventMatchesKeycombo;
 exports.linear = linear;
 exports.materialAccelerated = materialAccelerated;
 exports.materialDecelerated = materialDecelerated;

package/lib/index.d.ts

@@ -411,23 +411,21 @@ declare class Grantable<DescriptorType extends PermissionDescriptor> {
 
 declare type RecognizeableOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
     maxSequenceLength?: true | number;
-    effectsIncludeCombos?: boolean;
     effects?: {
-        [type in Type]?: (api: RecognizeableEffectApi<Type, Metadata>) => any;
-    } | ((defineEffect: DefineEffect<Type, Metadata>) => [type: Type, effect: (api: RecognizeableEffectApi<Type, Metadata>) => any][]);
+        [type in Type]?: RecognizeableEffect<type, Metadata>;
+    };
 };
-declare type DefineEffect<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = <EffectType extends Type>(type: EffectType, effect: (api: RecognizeableEffectApi<EffectType, Metadata>) => any) => [type: Type, effect: (api: RecognizeableEffectApi<Type, Metadata>) => any];
-declare type RecognizeableStatus = 'recognized' | 'recognizing' | 'denied' | 'ready';
+declare type RecognizeableEffect<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = (sequenceItem: ListenEffectParam<Type>, api: RecognizeableEffectApi<Type, Metadata>) => void;
 declare type RecognizeableEffectApi<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
-    getStatus: () => 'recognized' | 'recognizing' | 'denied' | 'ready';
+    getStatus: () => RecognizeableStatus;
     getMetadata: () => Metadata;
     setMetadata: (metadata: Metadata) => void;
     recognized: () => void;
     denied: () => void;
-    sequenceItem: ListenEffectParam<Type>;
     getSequence: () => ListenEffectParam<Type>[];
     onRecognized: (sequenceItem: ListenEffectParam<Type>) => any;
-};
+} & ListenEffectApi<Type>;
+declare type RecognizeableStatus = 'recognized' | 'recognizing' | 'denied' | 'ready';
 declare type RecognizeOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
     onRecognized?: (sequenceItem: ListenEffectParam<Type>) => any;
 };
@@ -435,7 +433,6 @@ declare class Recognizeable<Type extends ListenableSupportedType, Metadata exten
     private maxSequenceLength;
     private effects;
     private effectApi;
-    private toType;
     constructor(sequence: ListenEffectParam<Type>[], options?: RecognizeableOptions<Type, Metadata>);
     private computedMetadata;
     private resetComputedMetadata;
@@ -449,18 +446,12 @@ declare class Recognizeable<Type extends ListenableSupportedType, Metadata exten
     get metadata(): Metadata;
     private computedSequence;
     setSequence(sequence: ListenEffectParam<Type>[]): this;
-    recognize(sequenceItem: ListenEffectParam<Type>, { onRecognized }?: RecognizeOptions<Type, Metadata>): this;
+    recognize(sequenceItem: ListenEffectParam<Type>, api: ListenEffectApi<Type>, { onRecognized }?: RecognizeOptions<Type, Metadata>): this;
     private recognizing;
+    private toType;
 }
 
-declare type ListenableKeycomboItem = {
-    name: string;
-    type: ListenableComboItemType | 'custom';
-};
-declare function ensureKeycombo(type: string): ListenableKeycomboItem[];
-declare type ListenableComboItemType = 'singleCharacter' | 'arrow' | 'other' | 'modifier' | 'click' | 'pointer';
-
-declare type ListenableSupportedType = 'recognizeable' | 'intersect' | 'mutate' | 'resize' | 'idle' | ListenableMediaQuery | ListenableClickcombo | ListenableLeftClick | ListenableRightClick | ListenablePointercombo | ListenableKeycombo | keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
+declare type ListenableSupportedType = 'recognizeable' | 'intersect' | 'mutate' | 'resize' | 'idle' | ListenableMediaQuery | keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
 declare type ListenableMediaQuery = `(${string})`;
 declare type ListenableClickcombo = `${string}+${ListenableLeftClick | ListenableRightClick}`;
 declare type ListenableLeftClick = 'click' | 'mousedown' | 'mouseup' | 'dblclick';
@@ -468,12 +459,22 @@ declare type ListenableRightClick = 'rightclick' | 'contextmenu';
 declare type ListenablePointercombo = `${string}+${ListenablePointer}`;
 declare type ListenablePointer = 'pointerdown' | 'pointerup';
 declare type ListenableKeycombo = `${string}+${string}`;
-declare type ListenableSupportedEventType = ListenableClickcombo | ListenablePointercombo | ListenableKeycombo | keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
+declare type ListenableSupportedEventType = keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
 declare type ListenableOptions<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> = {
     recognizeable?: RecognizeableOptions<Type, RecognizeableMetadata>;
 };
-declare type ListenEffect<Type extends ListenableSupportedType> = Type extends 'intersect' ? (entries: ListenEffectParam<Type>) => any : Type extends 'mutate' ? (records: ListenEffectParam<Type>) => any : Type extends 'resize' ? (entries: ListenEffectParam<Type>) => any : Type extends 'idle' ? (deadline: ListenEffectParam<Type>) => any : Type extends ListenableMediaQuery ? (event: ListenEffectParam<Type>) => any : Type extends ListenableClickcombo ? (event: ListenEffectParam<Type>) => any : Type extends ListenablePointercombo ? (event: ListenEffectParam<Type>) => any : Type extends ListenableKeycombo ? (event: ListenEffectParam<Type>) => any : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? (event: ListenEffectParam<Type>) => any : Type extends keyof Omit<DocumentEventMap, 'resize'> ? (event: ListenEffectParam<Type>) => any : never;
-declare type ListenEffectParam<Type extends ListenableSupportedType> = Type extends 'intersect' ? IntersectionObserverEntry[] : Type extends 'mutate' ? MutationRecord[] : Type extends 'resize' ? ResizeObserverEntry[] : Type extends 'idle' ? IdleDeadline : Type extends ListenableMediaQuery ? MediaQueryListEvent : Type extends ListenableClickcombo ? MouseEvent : Type extends ListenableLeftClick ? MouseEvent : Type extends ListenableRightClick ? MouseEvent : Type extends ListenablePointercombo ? PointerEvent : Type extends ListenableKeycombo ? KeyboardEvent : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? HTMLElementEventMap[Type] : Type extends keyof Omit<DocumentEventMap, 'resize'> ? DocumentEventMap[Type] : never;
+declare type ListenEffect<Type extends ListenableSupportedType> = Type extends 'intersect' ? (entries: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends 'mutate' ? (records: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends 'resize' ? (entries: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends 'idle' ? (deadline: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends ListenableMediaQuery ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends (ListenableLeftClick | ListenableRightClick) ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends (ListenablePointer) ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends ('keydown' | 'keyup') ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends keyof Omit<DocumentEventMap, 'resize'> ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : never;
+declare type ListenEffectParam<Type extends ListenableSupportedType> = Type extends 'intersect' ? IntersectionObserverEntry[] : Type extends 'mutate' ? MutationRecord[] : Type extends 'resize' ? ResizeObserverEntry[] : Type extends 'idle' ? IdleDeadline : Type extends ListenableMediaQuery ? MediaQueryListEvent : Type extends ListenableRightClick ? MouseEvent : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? HTMLElementEventMap[Type] : Type extends keyof Omit<DocumentEventMap, 'resize'> ? DocumentEventMap[Type] : never;
+declare type ListenEffectApi<Type extends ListenableSupportedType> = Type extends 'intersect' ? Record<never, never> : Type extends 'mutate' ? Record<never, never> : Type extends 'resize' ? Record<never, never> : Type extends 'idle' ? Record<never, never> : Type extends ListenableMediaQuery ? Record<never, never> : Type extends (ListenableLeftClick | ListenableRightClick) ? MouseEventApi : Type extends (ListenablePointer) ? PointerEventApi : Type extends ('keydown' | 'keyup') ? KeyboardEventApi : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? Record<never, never> : Type extends keyof Omit<DocumentEventMap, 'resize'> ? Record<never, never> : never;
+declare type MouseEventApi = {
+    is: (clickcombo: ListenableClickcombo) => boolean;
+};
+declare type PointerEventApi = {
+    is: (pointercombo: ListenablePointercombo) => boolean;
+};
+declare type KeyboardEventApi = {
+    is: (keycombo: ListenableKeycombo) => boolean;
+};
 declare type ListenOptions<Type extends ListenableSupportedType> = Type extends 'intersect' ? {
     observer?: IntersectionObserverInit;
 } & ObservationListenOptions : Type extends 'mutate' ? {
@@ -484,9 +485,7 @@ declare type ListenOptions<Type extends ListenableSupportedType> = Type extends
     requestIdleCallback?: IdleRequestOptions;
 } : Type extends ListenableMediaQuery ? {
     instantEffect?: (list: MediaQueryList) => any;
-} : Type extends ListenableClickcombo ? EventListenOptions : Type extends ListenablePointercombo ? EventListenOptions : Type extends ListenableKeycombo ? {
-    keyDirection?: 'up' | 'down';
-} & EventListenOptions : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? EventListenOptions : Type extends keyof Omit<DocumentEventMap, 'resize'> ? EventListenOptions : never;
+} : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? EventListenOptions : Type extends keyof Omit<DocumentEventMap, 'resize'> ? EventListenOptions : never;
 declare type ObservationListenOptions = {
     target?: Element;
 };
@@ -511,7 +510,7 @@ declare type ListenableActive<Type extends ListenableSupportedType, Recognizeabl
     id: number;
 } : Type extends ListenableMediaQuery ? {
     target: MediaQueryList;
-    id: [type: string, effect: ListenEffect<Type>];
+    id: [type: string, effect: (param: ListenEffectParam<Type>) => void];
 } : Type extends ListenableSupportedEventType ? {
     target: Element | Document;
     id: ListenableActiveEventId<Type>;
@@ -520,7 +519,7 @@ declare type ListenableActive<Type extends ListenableSupportedType, Recognizeabl
 };
 declare type ListenableActiveEventId<Type extends ListenableSupportedEventType> = [
     type: string,
-    exceptAndOnlyEffect: ListenEffect<Type>,
+    exceptAndOnlyEffect: (param: ListenEffectParam<Type>) => void,
     optionsOrUseCapture: AddEventListenerOptions | boolean
 ];
 declare type ListenableStatus = 'ready' | 'listening' | 'stopped';
@@ -547,9 +546,6 @@ declare class Listenable<Type extends ListenableSupportedType, RecognizeableMeta
     private idleListen;
     private recognizeableListen;
     private documentEventListen;
-    private pointercomboListen;
-    private clickcomboListen;
-    private keycomboListen;
     private eventListen;
     private addEventListeners;
     private listening;
@@ -558,10 +554,6 @@ declare class Listenable<Type extends ListenableSupportedType, RecognizeableMeta
     }): this;
     private stopped;
 }
-declare function eventMatchesKeycombo({ event, keycombo }: {
-    event: KeyboardEvent;
-    keycombo: ListenableKeycomboItem[];
-}): boolean;
 
 declare type NavigateableOptions = {
     initialLocation?: number;
@@ -607,6 +599,10 @@ declare type PickableOptions = {
     initialPicks?: number | number[];
 };
 declare type PickableStatus = 'ready' | 'picked' | 'omitted';
+declare type PickOptions = {
+    replace?: 'none' | 'all' | 'fifo' | 'lifo';
+    allowsDuplicates?: boolean;
+};
 declare class Pickable<Item> {
     constructor(array: Item[], options?: PickableOptions);
     private computedStatus;
@@ -626,13 +622,12 @@ declare class Pickable<Item> {
     get status(): PickableStatus;
     get items(): Item[];
     private toItems;
+    computedMultiple: boolean;
     get multiple(): boolean;
     private toPossiblePicks;
     setArray(array: Item[]): this;
     setPicks(indexOrIndices: number | number[]): this;
-    pick(indexOrIndices: number | number[], options?: {
-        replace?: 'none' | 'all' | 'fifo' | 'lifo';
-    }): this;
+    pick(indexOrIndices: number | number[], options?: PickOptions): this;
     private picked;
     omit(indexOrIndices?: number | number[], options?: {
         reference?: 'array' | 'picks';
@@ -753,4 +748,4 @@ declare class Pipeable {
     pipeAsync(...fns: ((...args: any[]) => Promise<any>)[]): Promise<any>;
 }
 
-export { AnimateFrame, AnimateFrameEffect, AnimateOptions, Animateable, AnimateableKeyframe, AnimateableOptions, AnimateableStatus, ArrayFunction, ArrayFunctionAsync, CompleteOptions, Completeable, CompleteableOptions, CompleteableStatus, Copyable, CopyableOptions, CopyableStatus, Delayable, DelayableEffect, DelayableOptions, DelayableStatus, Drawable, DrawableOptions, DrawableState, DrawableStatus, FetchOptions, FetchOptionsApi, Fetchable, FetchableOptions, FetchableStatus, Fullscreenable, FullscreenableGetElement, FullscreenableOptions, FullscreenableStatus, Grantable, GrantableOptions, GrantableStatus, ListenEffect, ListenEffectParam, ListenOptions, Listenable, ListenableActive, ListenableClickcombo, ListenableKeycombo, ListenableKeycomboItem, ListenableOptions, ListenablePointercombo, ListenableStatus, ListenableSupportedEventType, ListenableSupportedType, MapFunction, Navigateable, NavigateableOptions, NavigateableStatus, NumberFunction, ObjectFunction, Pickable, PickableOptions, PickableStatus, Pipeable, RecognizeOptions, Recognizeable, RecognizeableEffectApi, RecognizeableOptions, RecognizeableStatus, Resolveable, ResolveableGetPromise, ResolveableOptions, ResolveableStatus, Sanitizeable, SanitizeableOptions, SanitizeableStatus, Searchable, SearchableOptions, SearchableStatus, Storeable, StoreableOptions, StoreableStatus, StringFunction, createClamp, createClip, createConcat, createDelete, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createReduce, createReduceAsync, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, createUnique, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, ensureKeycombo, eventMatchesKeycombo, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };
+export { AnimateFrame, AnimateFrameEffect, AnimateOptions, Animateable, AnimateableKeyframe, AnimateableOptions, AnimateableStatus, ArrayFunction, ArrayFunctionAsync, CompleteOptions, Completeable, CompleteableOptions, CompleteableStatus, Copyable, CopyableOptions, CopyableStatus, Delayable, DelayableEffect, DelayableOptions, DelayableStatus, Drawable, DrawableOptions, DrawableState, DrawableStatus, FetchOptions, FetchOptionsApi, Fetchable, FetchableOptions, FetchableStatus, Fullscreenable, FullscreenableGetElement, FullscreenableOptions, FullscreenableStatus, Grantable, GrantableOptions, GrantableStatus, ListenEffect, ListenEffectParam, ListenOptions, Listenable, ListenableActive, ListenableClickcombo, ListenableKeycombo, ListenableOptions, ListenablePointercombo, ListenableStatus, ListenableSupportedEventType, ListenableSupportedType, MapFunction, Navigateable, NavigateableOptions, NavigateableStatus, NumberFunction, ObjectFunction, Pickable, PickableOptions, PickableStatus, Pipeable, RecognizeOptions, Recognizeable, RecognizeableEffectApi, RecognizeableOptions, RecognizeableStatus, Resolveable, ResolveableGetPromise, ResolveableOptions, ResolveableStatus, Sanitizeable, SanitizeableOptions, SanitizeableStatus, Searchable, SearchableOptions, SearchableStatus, Storeable, StoreableOptions, StoreableStatus, StringFunction, createClamp, createClip, createConcat, createDelete, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createReduce, createReduceAsync, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, createUnique, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };

package/lib/index.js

@@ -1,4 +1,4 @@
-import { reduce, pipe, filter, toArray, slice, concat, unique, map, find, findIndex, some, join, every } from 'lazy-collections';
+import { reduce, pipe, filter, toArray, slice, concat, unique, map, find, findIndex, some, every, join } from 'lazy-collections';
 import slugify from '@sindresorhus/slugify';
 import BezierEasing from 'bezier-easing';
 import { mix } from '@snigo.dev/color';
@@ -280,16 +280,61 @@ const modifiersByAlias = {
   opt: "alt",
   option: "alt"
 };
-function createExceptAndOnlyEffect(effect, options) {
+function createExceptAndOnlyEffect(type, effect, options) {
   const { except = [], only = [] } = options;
+  if (type === "keydown" || type === "keyup") {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true], api = {
+        is: (keycombo) => eventMatchesKeycombo(event, ensureKeycombo(keycombo))
+      };
+      if (matchesOnly) {
+        effect(event, api);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event, api);
+        return;
+      }
+    };
+  }
+  if (type === "click" || type === "mousedown" || type === "mouseup" || type === "dblclick" || type === "contextmenu") {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true], api = {
+        is: (clickcombo) => eventMatchesClickcombo(event, ensureClickcombo(clickcombo))
+      };
+      if (matchesOnly) {
+        effect(event, api);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event, api);
+        return;
+      }
+    };
+  }
+  if (type === "pointerdown" || type === "pointerup") {
+    return (event) => {
+      const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true], api = {
+        is: (pointercombo) => eventMatchesPointercombo(event, ensurePointercombo(pointercombo))
+      };
+      if (matchesOnly) {
+        effect(event, api);
+        return;
+      }
+      if (only.length === 0 && !matchesExcept) {
+        effect(event, api);
+        return;
+      }
+    };
+  }
   return (event) => {
     const { target } = event, [matchesOnly, matchesExcept] = target instanceof Element ? createMap((selectors) => some((selector) => target.matches(selector))(selectors))([only, except]) : [false, true];
     if (matchesOnly) {
-      effect(event);
+      effect(event, {});
       return;
     }
     if (only.length === 0 && !matchesExcept) {
-      effect(event);
+      effect(event, {});
       return;
     }
   };
@@ -338,19 +383,13 @@ class Recognizeable {
   maxSequenceLength;
   effects;
   effectApi;
-  toType;
-  constructor(sequence, options = { effectsIncludeCombos: true }) {
+  constructor(sequence, options = {}) {
     const defaultOptions = {
       maxSequenceLength: true,
-      effectsIncludeCombos: true,
       effects: {}
     };
     this.maxSequenceLength = options?.maxSequenceLength || defaultOptions.maxSequenceLength;
-    this.effects = new Map(isFunction(options?.effects) ? options.effects(createDefineEffect()) : Object.entries(options?.effects || defaultOptions.effects));
-    this.toType = createToType({
-      effectsIncludeCombos: options.effectsIncludeCombos,
-      effects: this.effects
-    });
+    this.effects = new Map(Object.entries(options?.effects || defaultOptions.effects));
     this.resetComputedMetadata();
     this.setSequence(sequence);
     this.effectApi = {
@@ -393,14 +432,13 @@ class Recognizeable {
     this.computedSequence = sequence;
     return this;
   }
-  recognize(sequenceItem, { onRecognized } = {}) {
+  recognize(sequenceItem, api, { onRecognized } = {}) {
     this.recognizing();
     const type = this.toType(sequenceItem), excess = isNumber(this.maxSequenceLength) ? Math.max(0, this.sequence.length - this.maxSequenceLength) : 0, newSequence = createConcat(createSlice(excess)(this.sequence), [sequenceItem])([]);
-    this.effectApi.sequenceItem = sequenceItem;
     this.effectApi.getSequence = () => newSequence;
     this.effectApi.onRecognized = onRecognized || (() => {
     });
-    this.effects.get(type)?.(this.effectApi);
+    this.effects.get(type)?.(sequenceItem, { ...api, ...this.effectApi });
     switch (this.status) {
       case "denied":
         this.resetComputedMetadata();
@@ -416,34 +454,7 @@ class Recognizeable {
   recognizing() {
     this.computedStatus = "recognizing";
   }
-}
-function createDefineEffect() {
-  return (type, effect) => {
-    return [type, effect];
-  };
-}
-function createToType({
-  effectsIncludeCombos,
-  effects
-}) {
-  const effectLeftclickcombos = [], effectRightclickcombos = [], effectKeycombos = [];
-  if (effectsIncludeCombos) {
-    for (const [effectKey] of effects) {
-      const implementation = toImplementation(effectKey);
-      switch (implementation) {
-        case "leftclickcombo":
-          effectLeftclickcombos.push(ensureClickcombo(effectKey));
-          break;
-        case "rightclickcombo":
-          effectRightclickcombos.push(ensureClickcombo(effectKey));
-          break;
-        case "keycombo":
-          effectKeycombos.push(ensureKeycombo(effectKey));
-          break;
-      }
-    }
-  }
-  return function toType(sequenceItem) {
+  toType(sequenceItem) {
     if (isArray(sequenceItem)) {
       if (sequenceItem[0] instanceof IntersectionObserverEntry) {
         return "intersect";
@@ -461,38 +472,10 @@ function createToType({
       if ("didTimeout" in sequenceItem) {
         return "idle";
       }
-      if (effectLeftclickcombos?.length > 0) {
-        if (leftclickcomboEventTypes.has(sequenceItem.type)) {
-          for (const clickcombo of effectLeftclickcombos) {
-            if (eventMatchesClickcombo({ event: sequenceItem, clickcombo })) {
-              return toJoinedClickcombo(clickcombo);
-            }
-          }
-        }
-      }
-      if (effectRightclickcombos?.length > 0) {
-        if (rightclickComboEventTypes.has(sequenceItem.type)) {
-          for (const clickcombo of effectRightclickcombos) {
-            if (eventMatchesClickcombo({ event: sequenceItem, clickcombo })) {
-              return toJoinedClickcombo(clickcombo);
-            }
-          }
-        }
-      }
-      if (effectKeycombos?.length > 0) {
-        if (keycomboEventTypes.has(sequenceItem.type)) {
-          for (const keycombo of effectKeycombos) {
-            if (eventMatchesKeycombo({ event: sequenceItem, keycombo })) {
-              return toJoinedKeycombo(keycombo);
-            }
-          }
-        }
-      }
       return sequenceItem.type;
     }
-  };
+  }
 }
-const leftclickcomboEventTypes = /* @__PURE__ */ new Set(["click", "mousedown", "mouseup", "dblclick"]), rightclickComboEventTypes = /* @__PURE__ */ new Set(["contextmenu"]), keycomboEventTypes = /* @__PURE__ */ new Set(["keydown", "keyup"]), toJoinedClickcombo = join("+"), toJoinedKeycombo = pipe(map(({ name }) => name), toJoinedClickcombo);
 
 class Listenable {
   computedRecognizeable;
@@ -500,15 +483,8 @@ class Listenable {
   computedActive;
   constructor(type, options) {
     if (type === "recognizeable") {
-      const recognizeableOptions = {
-        ...options?.recognizeable || {},
-        effects: isFunction(options?.recognizeable?.effects) ? createReduce((effects, [type2, effect]) => {
-          effects[type2] = effect;
-          return effects;
-        }, {})(options.recognizeable.effects(createDefineEffect())) : options?.recognizeable?.effects || {}
-      };
-      this.computedRecognizeable = new Recognizeable([], recognizeableOptions);
-      this.recognizeableEffectsKeys = Object.keys(recognizeableOptions.effects);
+      this.computedRecognizeable = new Recognizeable([], options?.recognizeable || {});
+      this.recognizeableEffectsKeys = Object.keys(options?.recognizeable?.effects || {});
     }
     this.computedActive = /* @__PURE__ */ new Set();
     this.setType(type);
@@ -564,16 +540,6 @@ class Listenable {
       case "documentevent":
         this.documentEventListen(effect, options);
         break;
-      case "keycombo":
-        this.keycomboListen(effect, options);
-        break;
-      case "leftclickcombo":
-      case "rightclickcombo":
-        this.clickcomboListen(effect, options);
-        break;
-      case "pointercombo":
-        this.pointercomboListen(effect, options);
-        break;
       case "event":
         this.eventListen(effect, options);
         break;
@@ -601,18 +567,19 @@ class Listenable {
     if (isFunction(options.instantEffect)) {
       options.instantEffect(target);
     }
-    target.addEventListener("change", effect);
-    this.active.add({ target, id: ["change", effect] });
+    const withApi = (event) => effect(event, {});
+    target.addEventListener("change", withApi);
+    this.active.add({ target, id: ["change", withApi] });
   }
   idleListen(effect, options) {
-    const { requestIdleCallback } = options, id = window.requestIdleCallback(effect, requestIdleCallback);
+    const { requestIdleCallback } = options, id = window.requestIdleCallback((deadline) => effect(deadline, {}), requestIdleCallback);
     this.active.add({ target: window, id });
   }
   recognizeableListen(effect, options) {
-    const guardedEffect = (sequenceItem) => {
-      this.recognizeable.recognize(sequenceItem, { onRecognized: effect });
+    const guardedEffect = (sequenceItem, api) => {
+      this.recognizeable.recognize(sequenceItem, api, { onRecognized: (sequenceItem2) => effect(sequenceItem2, api) });
       if (this.recognizeable.status === "recognized") {
-        effect(sequenceItem);
+        effect(sequenceItem, api);
       }
     };
     for (const type of this.recognizeableEffectsKeys) {
@@ -628,44 +595,8 @@ class Listenable {
     };
     this.eventListen(effect, ensuredOptions);
   }
-  pointercomboListen(effect, options) {
-    const pointercombo = ensurePointercombo(this.type), guardedEffect = (event) => {
-      if (eventMatchesPointercombo({ event, pointercombo })) {
-        effect(event);
-      }
-    };
-    this.eventListen(guardedEffect, options);
-  }
-  clickcomboListen(effect, options) {
-    const clickcombo = ensureClickcombo(this.type), guardedEffect = (event) => {
-      if (eventMatchesClickcombo({ event, clickcombo })) {
-        effect(event);
-      }
-    };
-    this.eventListen(guardedEffect, options);
-  }
-  keycomboListen(effect, options) {
-    const keycombo = ensureKeycombo(this.type), guardedEffect = (event) => {
-      if (eventMatchesKeycombo({ event, keycombo })) {
-        effect(event);
-      }
-    };
-    this.eventListen(guardedEffect, options);
-  }
   eventListen(effect, options) {
-    const type = (() => {
-      switch (this.implementation) {
-        case "keycombo":
-          return `key${options.keyDirection || "down"}`;
-        case "leftclickcombo":
-          return this.type.match(/(\w+)$/)[1];
-        case "rightclickcombo":
-          return "contextmenu";
-        default:
-          return this.type;
-      }
-    })();
-    const { exceptAndOnlyEffect, effectOptions } = toAddEventListenerParams(effect, options), eventListeners = [[type, exceptAndOnlyEffect, ...effectOptions]];
+    const { exceptAndOnlyEffect, effectOptions } = toAddEventListenerParams(this.type, effect, options), eventListeners = [[this.type, exceptAndOnlyEffect, ...effectOptions]];
     this.addEventListeners(eventListeners, options);
   }
   addEventListeners(eventListeners, options) {
@@ -756,22 +687,6 @@ const predicatesByImplementation = /* @__PURE__ */ new Map([
     "documentevent",
     (type) => documentEvents.has(type)
   ],
-  [
-    "keycombo",
-    (type) => implementationREs.keycombo.test(type)
-  ],
-  [
-    "leftclickcombo",
-    (type) => implementationREs.leftclickcombo.test(type)
-  ],
-  [
-    "rightclickcombo",
-    (type) => implementationREs.rightclickcombo.test(type)
-  ],
-  [
-    "pointercombo",
-    (type) => implementationREs.pointercombo.test(type)
-  ],
   [
     "event",
     () => true
@@ -786,17 +701,13 @@ const documentEvents = /* @__PURE__ */ new Set([
   "visibilitychange"
 ]);
 const implementationREs = {
-  mediaquery: /^\(.+\)$/,
-  keycombo: /^((!?([a-zA-Z0-9,<.>/?;:'"[{\]}\\|`~!@#$%^&*()-_=+]|tab|space|arrow|vertical|horizontal|up|right|down|left|enter|backspace|esc|home|end|pagedown|pageup|capslock|f[0-9]{1,2}|camera|delete|cmd|command|meta|shift|ctrl|control|alt|opt|option))\+)*(!?([a-zA-Z0-9,<.>/?;:'"[{\]}\\|`~!@#$%^&*()-_=+]|tab|space|arrow|vertical|horizontal|up|right|down|left|enter|backspace|esc|home|end|pagedown|pageup|capslock|f[0-9]{1,2}|camera|delete|cmd|command|meta|shift|ctrl|control|alt|opt|option))$/,
-  leftclickcombo: /^(!?((cmd|command|meta|shift|ctrl|control|alt|opt|option))\+){0,4}!?(click|mousedown|mouseup|dblclick)$/,
-  rightclickcombo: /^(!?((cmd|command|meta|shift|ctrl|control|alt|opt|option))\+){0,4}!?(rightclick|contextmenu)$/,
-  pointercombo: /^(!?((cmd|command|meta|shift|ctrl|control|alt|opt|option))\+){0,4}!?(pointerdown|pointerup)$/
+  mediaquery: /^\(.+\)$/
 };
-function toAddEventListenerParams(effect, options) {
-  const { addEventListener, useCapture } = options, exceptAndOnlyEffect = createExceptAndOnlyEffect(effect, options), effectOptions = [addEventListener || useCapture];
+function toAddEventListenerParams(type, effect, options) {
+  const { addEventListener, useCapture } = options, exceptAndOnlyEffect = createExceptAndOnlyEffect(type, effect, options), effectOptions = [addEventListener || useCapture];
   return { exceptAndOnlyEffect, effectOptions };
 }
-function eventMatchesKeycombo({ event, keycombo }) {
+function eventMatchesKeycombo(event, keycombo) {
   return every(({ name, type }, index) => {
     switch (type) {
       case "singleCharacter":
@@ -880,10 +791,10 @@ const predicatesByArrow = /* @__PURE__ */ new Map([
 const arrows = /* @__PURE__ */ new Set(["arrowup", "arrowright", "arrowdown", "arrowleft"]);
 const verticalArrows = /* @__PURE__ */ new Set(["arrowup", "arrowdown"]);
 const horizontalArrows = /* @__PURE__ */ new Set(["arrowright", "arrowleft"]);
-function eventMatchesClickcombo({ event, clickcombo }) {
+function eventMatchesClickcombo(event, clickcombo) {
   return every((name) => fromComboItemNameToType(name) === "click" || name.startsWith("!") && !isModified({ alias: name.slice(1), event }) || !name.startsWith("!") && isModified({ alias: name, event }))(clickcombo);
 }
-function eventMatchesPointercombo({ event, pointercombo }) {
+function eventMatchesPointercombo(event, pointercombo) {
   return every((name) => fromComboItemNameToType(name) === "pointer" || name.startsWith("!") && !isModified({ alias: name.slice(1), event }) || !name.startsWith("!") && isModified({ alias: name, event }))(pointercombo);
 }
 const observerAssertionsByType = {
@@ -2693,6 +2604,10 @@ class Navigateable {
 const defaultOptions$1 = {
   initialPicks: []
 };
+const defaultPickOptions = {
+  replace: "none",
+  allowsDuplicates: false
+};
 class Pickable {
   constructor(array, options = {}) {
     this.setArray(array);
@@ -2738,8 +2653,9 @@ class Pickable {
     return this.toItems(this.picks);
   }
   toItems = createMap((index) => this.array[index]);
+  computedMultiple;
   get multiple() {
-    return this.picks.length > 1;
+    return this.computedMultiple;
   }
   toPossiblePicks;
   setArray(array) {
@@ -2751,41 +2667,42 @@ class Pickable {
     return this.pick(indexOrIndices);
   }
   pick(indexOrIndices, options = {}) {
-    const { replace = "none" } = options;
+    const { replace, allowsDuplicates } = { ...defaultPickOptions, ...options };
     this.computedPicks = new Pipeable(indexOrIndices).pipe(ensureIndices, this.toPossiblePicks, (possiblePicks) => {
       if (replace === "all") {
-        return toUnique(possiblePicks);
+        return allowsDuplicates ? possiblePicks : toUnique(possiblePicks);
       }
-      const possibleWithoutDuplicates = createFilter((possiblePick) => typeof find((pick) => pick === possiblePick)(this.picks || []) !== "number")(possiblePicks);
+      const maybeWithoutDuplicates = allowsDuplicates ? possiblePicks : createFilter((possiblePick) => typeof find((pick) => pick === possiblePick)(this.picks || []) !== "number")(possiblePicks);
       switch (replace) {
         case "none":
-          return createConcat(this.picks || [], possibleWithoutDuplicates)([]);
+          return createConcat(this.picks || [], maybeWithoutDuplicates)([]);
         case "fifo":
-          if (possibleWithoutDuplicates.length === 0) {
+          if (maybeWithoutDuplicates.length === 0) {
             return this.picks;
           }
-          if (possibleWithoutDuplicates.length === this.picks.length) {
-            return possibleWithoutDuplicates;
+          if (maybeWithoutDuplicates.length === this.picks.length) {
+            return maybeWithoutDuplicates;
           }
-          if (possibleWithoutDuplicates.length > this.picks.length) {
-            return createSlice(possibleWithoutDuplicates.length - this.picks.length)(possibleWithoutDuplicates);
+          if (maybeWithoutDuplicates.length > this.picks.length) {
+            return createSlice(maybeWithoutDuplicates.length - this.picks.length)(maybeWithoutDuplicates);
           }
-          return new Pipeable(this.picks).pipe(createSlice(possibleWithoutDuplicates.length), createConcat(possibleWithoutDuplicates));
+          return new Pipeable(this.picks).pipe(createSlice(maybeWithoutDuplicates.length), createConcat(maybeWithoutDuplicates));
         case "lifo":
-          if (possibleWithoutDuplicates.length === 0) {
+          if (maybeWithoutDuplicates.length === 0) {
             return this.picks;
           }
-          if (possibleWithoutDuplicates.length === this.picks.length) {
-            return possibleWithoutDuplicates;
+          if (maybeWithoutDuplicates.length === this.picks.length) {
+            return maybeWithoutDuplicates;
           }
-          if (possibleWithoutDuplicates.length > this.picks.length) {
-            return createSlice(0, possibleWithoutDuplicates.length - this.picks.length + 1)(possibleWithoutDuplicates);
+          if (maybeWithoutDuplicates.length > this.picks.length) {
+            return createSlice(0, maybeWithoutDuplicates.length - this.picks.length + 1)(maybeWithoutDuplicates);
           }
-          return new Pipeable(this.picks).pipe(createSlice(0, this.picks.length - possibleWithoutDuplicates.length), createConcat(possibleWithoutDuplicates));
+          return new Pipeable(this.picks).pipe(createSlice(0, this.picks.length - maybeWithoutDuplicates.length), createConcat(maybeWithoutDuplicates));
       }
     });
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
+    this.computedMultiple = toUnique(this.picks).length > 1;
     this.picked();
     return this;
   }
@@ -2797,6 +2714,7 @@ class Pickable {
       this.computedPicks = [];
       this.computedFirst = void 0;
       this.computedLast = void 0;
+      this.computedMultiple = false;
       this.omitted();
       return this;
     }
@@ -2804,6 +2722,7 @@ class Pickable {
     this.computedPicks = createFilter((pick, index) => options.reference === "array" ? isUndefined(find((omit) => pick === omit)(omits)) : isUndefined(find((omit) => index === omit)(omits)))(this.computedPicks);
     this.computedFirst = Math.min(...this.picks);
     this.computedLast = Math.max(...this.picks);
+    this.computedMultiple = toUnique(this.picks).length > 1;
     this.omitted();
     return this;
   }
@@ -3029,4 +2948,4 @@ class Storeable {
   }
 }
 
-export { Animateable, Completeable, Copyable, Delayable, Drawable, Fetchable, Fullscreenable, Grantable, Listenable, Navigateable, Pickable, Pipeable, Recognizeable, Resolveable, Sanitizeable, Searchable, Storeable, createClamp, createClip, createConcat, createDelete, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createReduce, createReduceAsync, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, createUnique, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, ensureKeycombo, eventMatchesKeycombo, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };
+export { Animateable, Completeable, Copyable, Delayable, Drawable, Fetchable, Fullscreenable, Grantable, Listenable, Navigateable, Pickable, Pipeable, Recognizeable, Resolveable, Sanitizeable, Searchable, Storeable, createClamp, createClip, createConcat, createDelete, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createReduce, createReduceAsync, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, createUnique, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baleada/logic",
-  "version": "0.21.1",
+  "version": "0.22.0",
   "description": "UI logic for the Baleada toolkit",
   "main": "lib/index.cjs",
   "module": "lib/index.js",