sia-reactor 0.0.48 → 0.0.49

package/dist/adapters/vanilla.js

@@ -3,9 +3,9 @@ import {
   TimeTravelConsole,
   effect,
   withTracker
-} from "../chunk-IYAWNLD2.js";
-import "../chunk-3IIYJ6B4.js";
-import "../chunk-U4SR3CZF.js";
+} from "../chunk-ZTUAHMMN.js";
+import "../chunk-GC754LMW.js";
+import "../chunk-2EAHPVH6.js";
 import "../chunk-YHGYHYEE.js";
 export {
   Autotracker,

package/dist/{chunk-U4SR3CZF.js → chunk-2EAHPVH6.js}

@@ -82,29 +82,29 @@ function cleanKeyCombo(combo, mods = KEYS_MODS) {
   };
   return Array.isArray(combo) ? combo.map(clean) : clean(combo);
 }
-function matchKeys(required, actual, strict = false, clean = true) {
+function matchKeys(required, actual, strict = false, clean = true, allowedMods) {
   if (clean) actual = cleanKeyCombo(actual);
   const match = (req, actual2) => {
     req = cleanKeyCombo(req);
     if (strict) return req === actual2;
     const reqs = req.split("+"), reals = actual2.split("+");
-    for (const mod of KEYS_CMODS) if (reals.includes(mod) && !reqs.includes(mod)) return false;
+    for (const mod of KEYS_CMODS) if (reals.includes(mod) && !reqs.includes(mod) && !allowedMods?.includes(mod)) return false;
     return reqs.every((k) => reals.includes(k));
   };
   return Array.isArray(required) ? required.some((req) => match(req, actual)) : match(required, actual);
 }
 function getTermsForKey(combo, settings) {
-  const terms = { override: false, block: false, whitelisted: false, action: null }, { overrides = [], shortcuts = {}, blocks = [], strictMatch: stm = false, rankedMatch: ram = true, whitelist = [] } = settings || {};
+  const terms = { override: false, block: false, whitelisted: false, action: null }, { overrides = [], shortcuts = {}, blocks = [], strictMatch: stm = false, rankedMatch: ram = true, whitelist = [], moddedlist = [] } = settings || {};
   combo = cleanKeyCombo(combo);
   if (matchKeys(overrides, combo, stm, false)) terms.override = true;
   if (matchKeys(blocks, combo, stm, false)) terms.block = true;
-  if (matchKeys(whitelist, combo, false)) terms.whitelisted = true;
-  if (!ram) return terms.action = Object.keys(shortcuts).find((id) => shortcuts[id] && matchKeys(shortcuts[id], combo, stm, false)) || null, terms;
+  if (whitelist.some((w) => matchKeys(w, combo, false, true, moddedlist.includes(cleanKeyCombo(w)) ? KEYS_CMODS : void 0))) terms.whitelisted = true;
+  if (!ram) return terms.action = Object.keys(shortcuts).find((id) => shortcuts[id] && matchKeys(shortcuts[id], combo, stm, false, moddedlist.includes(id) ? KEYS_CMODS : void 0)) || null, terms;
   let bestA = null, bestE = false, bestL = 0;
   for (const id of Object.keys(shortcuts))
     for (const c of Array.isArray(shortcuts[id]) ? shortcuts[id] : [shortcuts[id]]) {
       const req = c && cleanKeyCombo(c), isE = req === combo, len = req ? req.split("+").length : 0;
-      if (c && matchKeys(req, combo, stm, false) && (!bestA || isE && !bestE || isE === bestE && len > bestL)) bestA = id, bestE = isE, bestL = len;
+      if (c && matchKeys(req, combo, stm, false, moddedlist.includes(id) ? KEYS_CMODS : void 0) && (!bestA || isE && !bestE || isE === bestE && len > bestL)) bestA = id, bestE = isE, bestL = len;
     }
   return terms.action = bestA, terms;
 }
@@ -156,4 +156,4 @@ export {
   formatKeyShortcutsTooltip,
   parseForARIAKS
 };
-//# sourceMappingURL=chunk-U4SR3CZF.js.map
+//# sourceMappingURL=chunk-2EAHPVH6.js.map

package/dist/chunk-2EAHPVH6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/ts/utils/methd.ts","../src/ts/utils/dom.ts","../src/ts/utils/keys.ts"],"sourcesContent":["// \"THE METHODIST\": A mixin method expert often used to manipulate or bind all methods of a class to an instance\n\n/**\n * Walks an instance and its prototype chain, invoking a callback for each callable method.\n * @param owner Instance whose methods are inspected.\n * @param callback Invoked for each method name found.\n * @param skipOwn Skips owner-level methods when traversing own or parent prototypes.\n * @param nested Internal traversal flag, Override to `true` to avoid skipping own methods when `skipOwn` is `true`.\n */\nexport function onAllMethods(owner: any, callback: (method: string, owner: any) => void, skipOwn = true, nested = false): void {\n  let proto = owner;\n  while (proto && proto !== Object.prototype) {\n    for (const method of Object.getOwnPropertyNames(proto)) {\n      if (method === \"constructor\") continue;\n      if (nested && skipOwn && Object.prototype.hasOwnProperty.call(owner, method)) continue;\n      if (\"function\" === typeof Object.getOwnPropertyDescriptor(proto, method)?.value) callback(method, owner);\n    }\n    (proto = Object.getPrototypeOf(proto)), (nested = true);\n  }\n}\n\n/**\n * Binds all discovered methods on an owner to the owner instance.\n * @param owner Instance whose methods should be bound.\n */\nexport function bindAllMethods(owner: any): void {\n  onAllMethods(owner, (method: string, owner: any) => {\n    owner[method] = owner[method].bind(owner);\n  });\n}\n\n/**\n * Wraps all discovered methods in a guard function, optionally binding before wrapping.\n * @param owner Instance whose methods should be wrapped.\n * @param guardFn Wrapper factory used for each method.\n * @param bound Binds methods to owner before wrapping when true.\n */\nexport function guardAllMethods(owner: any, guardFn: (fn: Function) => Function = guardMethod, bound = true): void {\n  onAllMethods(owner, (method: string, owner: any) => {\n    owner[method] = guardFn(bound ? owner[method].bind(owner) : owner[method]);\n  });\n}\n\n/**\n * Wraps a function with try/catch and async rejection handling.\n * @template T Function type to preserve.\n * @param fn Function to wrap.\n * @param onError Error handler for sync throws and async rejections.\n * @returns Guarded function with the same call signature.\n */\nexport function guardMethod<T extends Function>(fn: T, onError: (e: any) => void = (e) => console.error(e)): T {\n  return ((...args: any[]) => {\n    try {\n      const result = fn(...args);\n      return result instanceof Promise ? result.catch((e) => onError(e)) : result;\n    } catch (e) {\n      onError(e);\n    }\n  }) as unknown as T;\n}\n","// Types\ntype Dataset = Record<string, string | number>;\ntype Style = Partial<CSSStyleDeclaration>;\n\n// Element Factory\n\n/**\n * Creates an HTML element with the specified tag and properties.\n * @param tag The tag name of the element to create.\n * @param props Optional properties to set on the element.\n * @param dataset Optional dataset attributes for the element.\n * @param styles Optional CSS styles for the element.\n * @returns The created HTML element.\n */\nexport function createEl<K extends keyof HTMLElementTagNameMap>(tag: K, props?: Partial<HTMLElementTagNameMap[K]>, dataset?: Dataset, styles?: Style): HTMLElementTagNameMap[K];\nexport function createEl(tag: string, props?: Partial<HTMLElement>, dataset?: Dataset, styles?: Style): HTMLElement | null;\nexport function createEl(tag: string, props?: Record<string, unknown>, dataset?: Dataset, styles?: Style, el = tag ? document?.createElement(tag) : null): HTMLElement | null {\n  return assignEl(el, props, dataset, styles);\n}\n\n/**\n * Assigns properties, dataset attributes, and styles to an HTML element.\n * @param el The HTML element to assign properties to.\n * @param props Optional properties to set on the element.\n * @param dataset Optional dataset attributes for the element.\n * @param styles Optional CSS styles for the element.\n * @return The modified HTML element to allow signature swaps with `createEl()`.\n */\nexport function assignEl<El extends HTMLElement>(el?: El | null, props?: Partial<El>, dataset?: Dataset, styles?: Style, nodiff?: boolean): El | null;\nexport function assignEl<El extends HTMLElement>(el?: El | null, props?: Partial<El>, dataset?: Dataset, styles?: Style, nodiff?: boolean): El | null;\nexport function assignEl(el?: HTMLElement | null, props?: Record<string, unknown>, dataset?: Dataset, styles?: Style, nodiff = true): HTMLElement | null {\n  if (!el) return null;\n  if (props) for (const k of Object.keys(props)) if (props[k] !== undefined) if (nodiff || (el as any)[k] !== props[k]) (el as unknown as Record<string, unknown>)[k] = props[k];\n  if (dataset) for (const k of Object.keys(dataset)) if (dataset[k] !== undefined) if (nodiff || (el.dataset as any)[k] !== dataset[k]) (el.dataset as DOMStringMap)[k] = String(dataset[k]);\n  if (styles) for (const k of Object.keys(styles)) if (styles[k as keyof Style] !== undefined) if (nodiff || (el.style as any)[k] !== styles[k as any]) (el.style as unknown as Record<string, unknown>)[k] = styles[k as keyof Style];\n  return el;\n}\n\n/** Get the currently active element, traversing into shadow roots if necessary.\n * @param root Root node to start searching from, defaults to the main document.\n * @param noBody If `true`, will return `null` if the active element is the body element.\n * @returns The active element or null if none found.\n */\nexport function getActiveEl(root?: Document | ShadowRoot | null, noBody = true): Element | null {\n  const activeEl = (root ?? document).activeElement;\n  return !activeEl || (noBody && activeEl === document.body) ? null : activeEl.shadowRoot ? getActiveEl(activeEl.shadowRoot) : activeEl;\n}\n","import { getActiveEl } from \"./dom\";\n\n/** Keyboard matching configuration used by utility helpers. */\nexport interface KeysSettings {\n  /** Disables key handling when true. */\n  disabled?: boolean;\n  /** Combos that should call `preventDefault` when matched. */\n  overrides?: string[];\n  /** Action map from action id to combo or combo list. */\n  shortcuts?: Record<string, string | string[]>;\n  /** Combos that should be rejected immediately. */\n  blocks?: string[];\n  /** Enables exact combo matching instead of subset matching. */\n  strictMatch?: boolean;\n  /** Ranks shortcut matches by exactness before insertion order. Enabled by default. */\n  rankedMatch?: boolean;\n  /** Combos that are allowed as pass-through key actions. */\n  whitelist?: string[];\n  /** Actions permitted to match base keys even when heavy modifiers are held. */\n  moddedlist?: string[];\n}\n\n/** Canonical key-combo structure used by parser and serializer helpers. */\nexport type KeyStruct = Record<\"ctrlKey\" | \"shiftKey\" | \"altKey\" | \"metaKey\", boolean> & { key: string };\n\n/**\n * Global registry of native browser hotkeys and shortcut combinations, pass as `.blocks` in `Settings` config for `keyEventAllowed()` for better UX.\n * Used by the system to prevent default browser behaviors (e.g., zooming, tab switching, refreshing, or opening dev tools) inside the listener context.\n */\n// prettier-ignore\nexport const KEYS_BLOCKS = [\"Ctrl+Tab\", \"Ctrl+Shift+Tab\", \"Ctrl+PageUp\", \"Ctrl+PageDown\", \"Cmd+Option+ArrowRight\", \"Cmd+Option+ArrowLeft\", \"Ctrl+1\", \"Ctrl+2\", \"Ctrl+3\", \"Ctrl+4\", \"Ctrl+5\", \"Ctrl+6\", \"Ctrl+7\", \"Ctrl+8\", \"Ctrl+9\", \"Cmd+1\", \"Cmd+2\", \"Cmd+3\", \"Cmd+4\", \"Cmd+5\", \"Cmd+6\", \"Cmd+7\", \"Cmd+8\", \"Cmd+9\", \"Alt+ArrowLeft\", \"Alt+ArrowRight\", \"Cmd+ArrowLeft\", \"Cmd+ArrowRight\", \"Ctrl+r\", \"Ctrl+Shift+r\", \"F5\", \"Shift+F5\", \"Cmd+r\", \"Cmd+Shift+r\", \"Ctrl+h\", \"Ctrl+j\", \"Ctrl+d\", \"Ctrl+f\", \"Cmd+y\", \"Cmd+Option+b\", \"Cmd+d\", \"Cmd+f\", \"Ctrl+Shift+i\", \"Ctrl+Shift+j\", \"Ctrl+Shift+c\", \"Ctrl+u\", \"F12\", \"Cmd+Option+i\", \"Cmd+Option+j\", \"Cmd+Option+c\", \"Cmd+Option+u\", \"Ctrl+=\", \"Ctrl+-\", \"Ctrl+0\", \"Cmd+=\", \"Cmd+-\", \"Cmd+0\", \"Ctrl+p\", \"Ctrl+s\", \"Ctrl+o\", \"Cmd+p\", \"Cmd+s\", \"Cmd+o\"], // JIT eats loops :)\n  KEYS_MODS = [\"ctrl\", \"shift\", \"alt\", \"meta\"] as const,\n  KEYS_CMODS = [\"ctrl\", \"alt\", \"meta\"] as const,\n  KEYS_ALIAS: Record<string, string> = { cmd: \"meta\", space: \" \" };\n\n/**\n * Parses a combo string into modifier flags + terminal key.\n * @param combo Key combo string (for example: `\"ctrl+shift+z\"`).\n * @returns Parsed key structure with boolean modifier flags.\n * @example\n * parseKeyCombo(\"ctrl+shift+z\")\n * // => { ctrlKey: true, shiftKey: true, altKey: false, metaKey: false, key: \"z\" }\n */\nexport function parseKeyCombo(combo: string): KeyStruct {\n  const parts = cleanKeyCombo(combo).toLowerCase().split(\"+\");\n  return { ctrlKey: parts.includes(\"ctrl\"), shiftKey: parts.includes(\"shift\"), altKey: parts.includes(\"alt\"), metaKey: parts.includes(\"meta\") || parts.includes(\"cmd\"), key: parts.find((p) => !/^(ctrl|shift|alt|meta|cmd)$/.test(p)) || \"\" };\n}\n\n/**\n * Serializes a key structure or keyboard event into canonical combo form.\n * @param e KeyboardEvent-like object or parsed key structure.\n * @returns Canonical combo string (for example: `\"ctrl+shift+z\"`).\n */\nexport function stringifyKeyEvent(e: KeyStruct | KeyboardEvent): string {\n  const parts: string[] = [];\n  e.ctrlKey && parts.push(\"ctrl\"), e.altKey && parts.push(\"alt\"), e.shiftKey && parts.push(\"shift\"), e.metaKey && parts.push(\"meta\"), parts.push(e.key?.toLowerCase() ?? \"\");\n  return parts.join(\"+\");\n}\n\n/**\n * Normalizes combo(s) by:\n * - lowercasing,\n * - aliasing `cmd -> meta`, `space -> \" \"`,\n * - preserving literal space/plus edge cases,\n * - sorting modifiers as `ctrl, alt, shift, meta`.\n * @param combo Raw combo or list of combos.\n * @param mods Optional list of modifier keys to sort and filter by (default: `[\"ctrl\", \"shift\", \"alt\", \"meta\"]`).\n * @returns Canonical combo string or list.\n * @example\n * cleanKeyCombo([\"Shift+Alt+Ctrl+Z\", \"cmd+y\"])\n * // => [\"ctrl+shift+alt+z\", \"meta+y\"]\n */\nexport function cleanKeyCombo(combo: string, mods?: string[]): string;\nexport function cleanKeyCombo(combo: string[], mods?: string[]): string[];\nexport function cleanKeyCombo(combo: string | string[], mods: string[] = KEYS_MODS as any): string | string[] {\n  const clean = (combo: string): string => {\n    if (combo === \" \" || combo === \"+\") return combo;\n    combo = combo.replace(/\\+\\s*\\+$/, \"+plus\");\n    const p = combo\n      .toLowerCase()\n      .split(\"+\")\n      .filter((k) => k !== \"\")\n      .map((k, _, __, tk = k.trim()) => KEYS_ALIAS[tk] || (tk === \"plus\" ? \"+\" : tk || \" \"));\n    return [...p.filter((k) => mods.includes(k)).sort((a, b) => mods.indexOf(a) - mods.indexOf(b)), ...(p.filter((k) => !mods.includes(k)) || \"\")].join(\"+\");\n  };\n  return Array.isArray(combo) ? combo.map(clean) : clean(combo);\n}\n\n/**\n * Determines if actual combo satisfies required combo rule(s).\n * Non-strict mode performs subset matching (required keys must all be present).\n * Strict mode requires exact canonical equality.\n * @param required Required combo or combo list.\n * @param actual Actual combo string.\n * @param strict Whether to require exact match.\n * @param clean Whether to clean the actual combo.\n * @returns `true` when match succeeds.\n */\nexport function matchKeys(required: string | string[], actual: string, strict = false, clean = true, allowedMods?: string[] | readonly string[]): boolean {\n  if (clean) actual = cleanKeyCombo(actual);\n  const match = (req: string, actual: string): boolean => {\n    req = cleanKeyCombo(req);\n    if (strict) return req === actual;\n    const reqs = req.split(\"+\"),\n      reals = actual.split(\"+\");\n    for (const mod of KEYS_CMODS) if (reals.includes(mod) && !reqs.includes(mod) && !allowedMods?.includes(mod)) return false; // no unrequested heavy mods\n    return reqs.every((k) => reals.includes(k));\n  };\n  return Array.isArray(required) ? required.some((req) => match(req, actual)) : match(required, actual);\n}\n\n/**\n * Resolves key-combo terms against settings:\n * - override, block, whitelist, and matched action id.\n * @param combo Canonical combo string.\n * @param settings Matching settings.\n * @returns Match resolution record.\n */\nexport function getTermsForKey(combo: string, settings: KeysSettings): { override: boolean; block: boolean; whitelisted: boolean; action: string | null } {\n  const terms = { override: false, block: false, whitelisted: false, action: null as string | null },\n    { overrides = [], shortcuts = {}, blocks = [], strictMatch: stm = false, rankedMatch: ram = true, whitelist = [], moddedlist = [] } = settings || {};\n  combo = cleanKeyCombo(combo);\n  if (matchKeys(overrides, combo, stm, false)) terms.override = true;\n  if (matchKeys(blocks, combo, stm, false)) terms.block = true;\n  if (whitelist.some((w) => matchKeys(w, combo, false, true, moddedlist.includes(cleanKeyCombo(w)) ? KEYS_CMODS : undefined))) terms.whitelisted = true;\n  if (!ram) return (terms.action = Object.keys(shortcuts).find((id) => shortcuts[id] && matchKeys(shortcuts[id], combo, stm, false, moddedlist.includes(id) ? KEYS_CMODS : undefined)) || null), terms;\n  // prettier-ignore\n  let bestA: string | null = null, bestE = false, bestL = 0;\n  for (const id of Object.keys(shortcuts))\n    for (const c of Array.isArray(shortcuts[id]) ? shortcuts[id] : [shortcuts[id]]) {\n      // prettier-ignore\n      const req = c && cleanKeyCombo(c), isE = req === combo, len = req ? req.split(\"+\").length : 0;\n      if (c && matchKeys(req, combo, stm, false, moddedlist.includes(id) ? KEYS_CMODS : undefined) && (!bestA || (isE && !bestE) || (isE === bestE && len > bestL))) (bestA = id), (bestE = isE), (bestL = len);\n    }\n  return (terms.action = bestA), terms;\n}\n\n/**\n * Evaluates whether a keyboard event is allowed and maps it to an action id.\n * Behavior order:\n * 1. hard gate checks (`disabled`, focused editable, button-space/enter),\n * 2. blocked combos,\n * 3. override combos (`preventDefault`),\n * 4. shortcut action match,\n * 5. whitelist pass-through.\n * @param e Browser keyboard event.\n * @param settings Matching settings.\n * @returns Action id, pass-through key, or `false` when denied.\n */\nexport function keyEventAllowed<const S extends KeysSettings>(e: KeyboardEvent, settings: S): false | (S[\"shortcuts\"] extends object ? keyof S[\"shortcuts\"] : never) | (S[\"whitelist\"] extends readonly string[] ? (string[] extends S[\"whitelist\"] ? never : S[\"whitelist\"][number]) : never) {\n  if (settings.disabled) return false;\n  const activeEl = getActiveEl((e.target as Node)?.ownerDocument); // shadow DOM proof\n  if ((e.key === \" \" || e.key === \"Enter\") && activeEl?.matches(\"button,input[type='button'],input[type='submit']\")) return false;\n  if (e.currentTarget !== activeEl && activeEl?.matches(\"input,textarea,[contenteditable],[role]\") && !(e.key === \"Escape\" && !e.ctrlKey && !e.shiftKey && !e.altKey && !e.metaKey)) return false;\n  const combo = stringifyKeyEvent(e),\n    { override, block, action, whitelisted } = getTermsForKey(combo, settings);\n  if (block) return false;\n  if (override) e.preventDefault();\n  if (action) return action as any;\n  if (whitelisted) return e.key.toLowerCase() as any;\n  return false;\n}\n\n/**\n * Formats one or many combos for human-readable UI labels, prepends \" \" for fluid appending.\n * @param combo Combo or combo list.\n * @param keyFn Function to format each combo.\n * @returns Display label (for example: `\" (ctrl+z) or (meta+z)\"`).\n */\nexport const formatKeyTooltip = (combo: string | string[] = \"\", keyFn = (c = \"\") => cleanKeyCombo(c).replace(\" \", \"space\")): string => {\n  const combined = combo?.length ? (Array.isArray(combo) ? combo.map(keyFn).join(\" or \") : keyFn(combo)) : \"\";\n  return combined ? ` (${combined})` : \"\";\n};\n\n/**\n * Formats an action-shortcuts map for display labels.\n * @param keyShortcuts Action to combo(s) map.\n * @returns Action to display-label map.\n */\nexport function formatKeyShortcutsTooltip(keyShortcuts: Record<string, string | string[]> = {}, formatter = formatKeyTooltip): Record<string, string> {\n  const shortcuts: Record<string, string> = {};\n  for (const action of Object.keys(keyShortcuts)) shortcuts[action] = formatter(keyShortcuts[action]);\n  return shortcuts;\n}\n\n/**\n * Converts combo text into WAI-ARIA `aria-keyshortcuts` format.\n * @param s Combo text or combo list.\n * @param format Whether to format to tooltip first.\n * @returns Normalized aria-keyshortcuts string.\n * @example\n * parseForARIAKS(\" (ctrl+z) or (meta+z)\")\n * // => \"Control+z Meta+z\"\n * @example\n * parseForARIAKS([\"ctrl+z\", \"meta+z\"], false)\n * // => \"Control+z Meta+z\"\n */\nexport function parseForARIAKS(s: string | string[] = \"\", format = true) {\n  const m = { ctrl: \"Control\", cmd: \"Meta\", space: \"Space\", plus: \"+\" };\n  return (!format && !Array.isArray(s) ? s : formatKeyTooltip(s))\n    .toLowerCase()\n    .replace(/[()]/g, \"\") // 1. Remove parens\n    .replace(/\\bor\\b/g, \" \") // 2. Replace \"or\" with the REQUIRED space\n    .replace(/\\w+/g, (k: any) => m[k as keyof typeof m] || k) // 3. Map keys (ctrl -> Control)\n    .replace(/\\s+/g, \" \")\n    .trim(); // 4. Cleanup extra spaces\n} // W3 ARIA Key Shortcut\n"],"mappings":"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","names":["owner","combo","actual"]}

package/dist/{chunk-3IIYJ6B4.js → chunk-GC754LMW.js}

@@ -1,7 +1,7 @@
 import {
   guardAllMethods,
   guardMethod
-} from "./chunk-U4SR3CZF.js";
+} from "./chunk-2EAHPVH6.js";
 import {
   getPath,
   getReactor,
@@ -144,4 +144,4 @@ export {
   BaseReactorModule,
   wpArr
 };
-//# sourceMappingURL=chunk-3IIYJ6B4.js.map
+//# sourceMappingURL=chunk-GC754LMW.js.map

package/dist/{chunk-IYAWNLD2.js → chunk-ZTUAHMMN.js}

@@ -1,13 +1,13 @@
 import {
   wpArr
-} from "./chunk-3IIYJ6B4.js";
+} from "./chunk-GC754LMW.js";
 import {
   KEYS_BLOCKS,
   createEl,
   formatKeyTooltip,
   keyEventAllowed,
   parseForARIAKS
-} from "./chunk-U4SR3CZF.js";
+} from "./chunk-2EAHPVH6.js";
 import {
   CTX,
   NIL,
@@ -287,4 +287,4 @@ export {
   effect,
   TimeTravelConsole
 };
-//# sourceMappingURL=chunk-IYAWNLD2.js.map
+//# sourceMappingURL=chunk-ZTUAHMMN.js.map

package/dist/modules.js

@@ -5,8 +5,8 @@ import {
 } from "./chunk-IZK2TOJP.js";
 import {
   BaseReactorModule
-} from "./chunk-3IIYJ6B4.js";
-import "./chunk-U4SR3CZF.js";
+} from "./chunk-GC754LMW.js";
+import "./chunk-2EAHPVH6.js";
 import {
   CTX,
   NIL,

package/dist/super.d.ts

@@ -1380,6 +1380,8 @@ interface KeysSettings {
     rankedMatch?: boolean;
     /** Combos that are allowed as pass-through key actions. */
     whitelist?: string[];
+    /** Actions permitted to match base keys even when heavy modifiers are held. */
+    moddedlist?: string[];
 }
 /** Canonical key-combo structure used by parser and serializer helpers. */
 type KeyStruct = Record<"ctrlKey" | "shiftKey" | "altKey" | "metaKey", boolean> & {
@@ -1434,7 +1436,7 @@ declare function cleanKeyCombo(combo: string[], mods?: string[]): string[];
  * @param clean Whether to clean the actual combo.
  * @returns `true` when match succeeds.
  */
-declare function matchKeys(required: string | string[], actual: string, strict?: boolean, clean?: boolean): boolean;
+declare function matchKeys(required: string | string[], actual: string, strict?: boolean, clean?: boolean, allowedMods?: string[] | readonly string[]): boolean;
 /**
  * Resolves key-combo terms against settings:
  * - override, block, whitelist, and matched action id.

package/dist/super.global.js

@@ -1291,29 +1291,29 @@ var sia = (() => {
     };
     return Array.isArray(combo) ? combo.map(clean) : clean(combo);
   }
-  function matchKeys(required, actual, strict = false, clean = true) {
+  function matchKeys(required, actual, strict = false, clean = true, allowedMods) {
     if (clean) actual = cleanKeyCombo(actual);
     const match = (req, actual2) => {
       req = cleanKeyCombo(req);
       if (strict) return req === actual2;
       const reqs = req.split("+"), reals = actual2.split("+");
-      for (const mod of KEYS_CMODS) if (reals.includes(mod) && !reqs.includes(mod)) return false;
+      for (const mod of KEYS_CMODS) if (reals.includes(mod) && !reqs.includes(mod) && !allowedMods?.includes(mod)) return false;
       return reqs.every((k) => reals.includes(k));
     };
     return Array.isArray(required) ? required.some((req) => match(req, actual)) : match(required, actual);
   }
   function getTermsForKey(combo, settings) {
-    const terms = { override: false, block: false, whitelisted: false, action: null }, { overrides = [], shortcuts = {}, blocks = [], strictMatch: stm = false, rankedMatch: ram = true, whitelist = [] } = settings || {};
+    const terms = { override: false, block: false, whitelisted: false, action: null }, { overrides = [], shortcuts = {}, blocks = [], strictMatch: stm = false, rankedMatch: ram = true, whitelist = [], moddedlist = [] } = settings || {};
     combo = cleanKeyCombo(combo);
     if (matchKeys(overrides, combo, stm, false)) terms.override = true;
     if (matchKeys(blocks, combo, stm, false)) terms.block = true;
-    if (matchKeys(whitelist, combo, false)) terms.whitelisted = true;
-    if (!ram) return terms.action = Object.keys(shortcuts).find((id) => shortcuts[id] && matchKeys(shortcuts[id], combo, stm, false)) || null, terms;
+    if (whitelist.some((w) => matchKeys(w, combo, false, true, moddedlist.includes(cleanKeyCombo(w)) ? KEYS_CMODS : void 0))) terms.whitelisted = true;
+    if (!ram) return terms.action = Object.keys(shortcuts).find((id) => shortcuts[id] && matchKeys(shortcuts[id], combo, stm, false, moddedlist.includes(id) ? KEYS_CMODS : void 0)) || null, terms;
     let bestA = null, bestE = false, bestL = 0;
     for (const id of Object.keys(shortcuts))
       for (const c of Array.isArray(shortcuts[id]) ? shortcuts[id] : [shortcuts[id]]) {
         const req = c && cleanKeyCombo(c), isE = req === combo, len = req ? req.split("+").length : 0;
-        if (c && matchKeys(req, combo, stm, false) && (!bestA || isE && !bestE || isE === bestE && len > bestL)) bestA = id, bestE = isE, bestL = len;
+        if (c && matchKeys(req, combo, stm, false, moddedlist.includes(id) ? KEYS_CMODS : void 0) && (!bestA || isE && !bestE || isE === bestE && len > bestL)) bestA = id, bestE = isE, bestL = len;
       }
     return terms.action = bestA, terms;
   }