rx-hotkeys 2.6.0 → 3.0.0

package/dist/keys.d.ts

@@ -152,4 +152,10 @@ export declare const Keys: {
  * This ensures type safety when configuring shortcuts.
  */
 export type StandardKey = typeof Keys[keyof typeof Keys];
+/**
+ * A map of common aliases for keys to their standard `StandardKey` value.
+ * Used internally for parsing string-based shortcut definitions.
+ * @internal
+ */
+export declare const KeyAliases: Record<string, StandardKey>;
 //# sourceMappingURL=keys.d.ts.map

package/dist/keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHP,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,IAAI,CAAC,MAAM,OAAO,IAAI,CAAC,CAAC"}
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHP,CAAC;AAEX;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,IAAI,CAAC,MAAM,OAAO,IAAI,CAAC,CAAC;AAEzD;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAelD,CAAC"}

package/dist/keys.js

@@ -115,3 +115,24 @@ export const Keys = {
     Digit0: "0", Digit1: "1", Digit2: "2", Digit3: "3", Digit4: "4",
     Digit5: "5", Digit6: "6", Digit7: "7", Digit8: "8", Digit9: "9",
 };
+/**
+ * A map of common aliases for keys to their standard `StandardKey` value.
+ * Used internally for parsing string-based shortcut definitions.
+ * @internal
+ */
+export const KeyAliases = {
+    'esc': Keys.Escape, 'escape': Keys.Escape,
+    'enter': Keys.Enter, 'return': Keys.Enter,
+    'tab': Keys.Tab,
+    'space': Keys.Space, 'spacebar': Keys.Space,
+    'backspace': Keys.Backspace,
+    'del': Keys.Delete, 'delete': Keys.Delete,
+    'ins': Keys.Insert, 'insert': Keys.Insert,
+    'up': Keys.ArrowUp, 'down': Keys.ArrowDown, 'left': Keys.ArrowLeft, 'right': Keys.ArrowRight,
+    'pageup': Keys.PageUp, 'pagedown': Keys.PageDown,
+    'cmd': Keys.Meta, 'command': Keys.Meta, 'win': Keys.Meta, 'windows': Keys.Meta,
+    'ctrl': Keys.Control, 'control': Keys.Control,
+    'alt': Keys.Alt, 'option': Keys.Alt,
+    'shift': Keys.Shift,
+    // Add any other desired aliases here
+};

package/dist/testutils.d.ts

@@ -6,9 +6,12 @@ export declare function createMockFn(): {
     mockClear(): void;
 };
 /**
- * Dispatches a KeyboardEvent to the document (JSDOM).
- * @param key - The key value, e.g., "a", "Escape", "ArrowUp"
- * @param modifiers - Optional modifier keys
+ * Dispatches a KeyboardEvent to a specified target element (or document).
+ * @param target - The EventTarget to dispatch the event on (e.g., document or an HTMLElement).
+ * @param key - The key value, e.g., "a", "Escape", "ArrowUp".
+ * @param eventType - The type of event to dispatch, 'keydown' or 'keyup'.
+ * @param modifiers - Optional modifier keys for the event.
+ * @returns The dispatched KeyboardEvent.
  */
-export declare function dispatchKeyEvent(key: string, modifiers?: Partial<KeyboardEventInit>): KeyboardEvent;
+export declare function dispatchKeyEvent(target: EventTarget, key: string, eventType?: 'keydown' | 'keyup', modifiers?: Partial<KeyboardEventInit>): KeyboardEvent;
 //# sourceMappingURL=testutils.d.ts.map

package/dist/testutils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testutils.d.ts","sourceRoot":"","sources":["../src/testutils.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY;cACH,GAAG,EAAE;;;;;EAc7B;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC5B,GAAG,EAAE,MAAM,EACX,SAAS,GAAE,OAAO,CAAC,iBAAiB,CAAM,GAC3C,aAAa,CASf"}
+{"version":3,"file":"testutils.d.ts","sourceRoot":"","sources":["../src/testutils.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY;cACH,GAAG,EAAE;;;;;EAc7B;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC5B,MAAM,EAAE,WAAW,EACnB,GAAG,EAAE,MAAM,EACX,SAAS,GAAE,SAAS,GAAG,OAAmB,EAC1C,SAAS,GAAE,OAAO,CAAC,iBAAiB,CAAM,GAC3C,aAAa,CASf"}

package/dist/testutils.js

@@ -15,17 +15,20 @@ export function createMockFn() {
     return fn;
 }
 /**
- * Dispatches a KeyboardEvent to the document (JSDOM).
- * @param key - The key value, e.g., "a", "Escape", "ArrowUp"
- * @param modifiers - Optional modifier keys
+ * Dispatches a KeyboardEvent to a specified target element (or document).
+ * @param target - The EventTarget to dispatch the event on (e.g., document or an HTMLElement).
+ * @param key - The key value, e.g., "a", "Escape", "ArrowUp".
+ * @param eventType - The type of event to dispatch, 'keydown' or 'keyup'.
+ * @param modifiers - Optional modifier keys for the event.
+ * @returns The dispatched KeyboardEvent.
  */
-export function dispatchKeyEvent(key, modifiers = {}) {
-    const event = new KeyboardEvent("keydown", {
+export function dispatchKeyEvent(target, key, eventType = 'keydown', modifiers = {}) {
+    const event = new KeyboardEvent(eventType, {
         key,
         bubbles: true,
         cancelable: true,
         ...modifiers,
     });
-    document.dispatchEvent(event);
+    target.dispatchEvent(event);
     return event;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rx-hotkeys",
-  "version": "2.6.0",
+  "version": "3.0.0",
   "type": "module",
   "scripts": {
     "build": "tsc",

package/dist/tt.d.ts

@@ -1,125 +0,0 @@
-import { Subscription, Observable } from "rxjs";
-import { type StandardKey } from "./keys.js";
-export declare enum ShortcutTypes {
-    Combination = "combination",
-    Sequence = "sequence"
-}
-interface ShortcutConfigBase {
-    id: string;
-    callback: (event: KeyboardEvent) => void;
-    context?: string | null;
-    preventDefault?: boolean;
-    description?: string;
-    /**
-     * **Only applicable if the shortcut has no top-level `context` defined.**
-     * If `true`, this shortcut is **strictly global** and will only fire when the active
-     * hotkey context is `null`.
-     * If `false` or `undefined` (the default), the shortcut can fire in *any* context,
-     * but will be suppressed by an identical shortcut that belongs to the active context.
-     * @default false
-     */
-    strict?: boolean;
-}
-/**
- * Defines a single key trigger, which can be a StandardKey (for simple presses like "Escape")
- * or an object specifying the main key and its modifiers (e.g., { key: Keys.S, ctrlKey: true }).
- */
-type KeyCombinationTrigger = {
-    /**
-     * The main key for the combination.
-     * This MUST be a value from the exported `Keys` object
-     * (e.g., `Keys.A`, `Keys.Enter`, `Keys.Escape`).
-     */
-    key: StandardKey;
-    ctrlKey?: boolean;
-    altKey?: boolean;
-    shiftKey?: boolean;
-    metaKey?: boolean;
-} | StandardKey;
-export interface KeyCombinationConfig extends ShortcutConfigBase {
-    /**
-     * Defines the key or key combination(s) that trigger the shortcut.
-     */
-    keys: KeyCombinationTrigger | KeyCombinationTrigger[];
-}
-export interface KeySequenceConfig extends ShortcutConfigBase {
-    /**
-     * An array of keys that form the sequence.
-     */
-    sequence: StandardKey[];
-    /**
-     * Optional: Timeout in milliseconds between consecutive key presses in the sequence.
-     * @default undefined
-     */
-    sequenceTimeoutMs?: number;
-}
-type ShortcutConfig = KeyCombinationConfig | KeySequenceConfig;
-export interface ActiveShortcut {
-    id: string;
-    config: ShortcutConfig;
-    subscription: Subscription;
-}
-/**
- * Manages keyboard shortcuts for web applications.
- */
-export declare class Hotkeys {
-    private static readonly KEYDOWN_EVENT;
-    private static readonly LOG_PREFIX;
-    private keydown$;
-    private activeContext$;
-    private activeShortcuts;
-    private debugMode;
-    /**
-     * Creates an instance of Hotkeys.
-     * @param initialContext - Optional initial context name.
-     * @param debugMode - Optional. If true, debug messages will be logged to the console.
-     */
-    constructor(initialContext?: string | null, debugMode?: boolean);
-    /**
-     * Sets the active context for shortcuts.
-     * @param contextName - The name of the context (e.g., "editor"). Pass `null` to clear the context.
-     * @returns `true` if the context was changed, `false` otherwise.
-     */
-    setContext(contextName: string | null): boolean;
-    /**
-     * Gets the current active context.
-     */
-    getContext(): string | null;
-    /**
-     * Enables or disables debug logging.
-     */
-    setDebugMode(enable: boolean): void;
-    /**
-     * Checks if a shortcut with the given ID is registered.
-     */
-    hasShortcut(id: string): boolean;
-    /**
-     * An Observable that emits the new context name whenever it changes.
-     */
-    get onContextChange$(): Observable<string | null>;
-    private _areSequencesIdentical;
-    private _shortcutMatchesEvent;
-    private _registerShortcut;
-    private _parseKeyTrigger;
-    addCombination(config: KeyCombinationConfig): string | undefined;
-    addSequence(config: KeySequenceConfig): string | undefined;
-    /**
-     * Removes a registered shortcut by its ID.
-     */
-    remove(id: string): boolean;
-    /**
-     * Retrieves a list of all currently active shortcuts.
-     */
-    getActiveShortcuts(): {
-        id: string;
-        description?: string;
-        context?: string | null;
-        type: ShortcutTypes;
-    }[];
-    /**
-     * Cleans up all active subscriptions.
-     */
-    destroy(): void;
-}
-export {};
-//# sourceMappingURL=tt.d.ts.map

package/dist/tt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tt.d.ts","sourceRoot":"","sources":["../src/tt.ts"],"names":[],"mappings":"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"}

package/dist/tt.js

@@ -1,384 +0,0 @@
-import { fromEvent, BehaviorSubject, EMPTY, filter, map, bufferCount, withLatestFrom, tap, catchError, scan, merge, } from "rxjs";
-// --- Enums, Interfaces and Types ---
-export var ShortcutTypes;
-(function (ShortcutTypes) {
-    ShortcutTypes["Combination"] = "combination";
-    ShortcutTypes["Sequence"] = "sequence";
-})(ShortcutTypes || (ShortcutTypes = {}));
-var EmitStates;
-(function (EmitStates) {
-    EmitStates[EmitStates["Emit"] = 0] = "Emit";
-    EmitStates[EmitStates["Ignore"] = 1] = "Ignore";
-    EmitStates[EmitStates["InProgress"] = 2] = "InProgress";
-})(EmitStates || (EmitStates = {}));
-// --- Helper function to compare keys ---
-/**
- * Compares a browser event's key with a configured key.
- * - For single character keys (e.g., "a", "A", "7"), comparison is case-insensitive.
- * - For multi-character special keys (e.g., "Enter", "ArrowUp"), comparison is case-sensitive.
- */
-function compareKey(eventKey, configuredKey) {
-    if (configuredKey.length === 1 && eventKey.length === 1) {
-        return eventKey.toLowerCase() === configuredKey.toLowerCase();
-    }
-    return eventKey === configuredKey;
-}
-// --- Hotkeys Library ---
-/**
- * Manages keyboard shortcuts for web applications.
- */
-export class Hotkeys {
-    static KEYDOWN_EVENT = "keydown";
-    static LOG_PREFIX = "Hotkeys:";
-    keydown$;
-    activeContext$;
-    activeShortcuts;
-    debugMode;
-    /**
-     * Creates an instance of Hotkeys.
-     * @param initialContext - Optional initial context name.
-     * @param debugMode - Optional. If true, debug messages will be logged to the console.
-     */
-    constructor(initialContext = null, debugMode = false) {
-        this.debugMode = debugMode;
-        if (typeof document === "undefined" || typeof performance === "undefined") {
-            throw new Error(`${Hotkeys.LOG_PREFIX} Hotkeys can only be used in a browser environment with global "document" and "performance" objects.`);
-        }
-        this.keydown$ = fromEvent(document, Hotkeys.KEYDOWN_EVENT);
-        this.activeContext$ = new BehaviorSubject(initialContext);
-        this.activeShortcuts = new Map();
-        if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} Library initialized. Initial context: "${initialContext}". Debug mode: ${debugMode}.`);
-        }
-    }
-    /**
-     * Sets the active context for shortcuts.
-     * @param contextName - The name of the context (e.g., "editor"). Pass `null` to clear the context.
-     * @returns `true` if the context was changed, `false` otherwise.
-     */
-    setContext(contextName) {
-        const currentContext = this.activeContext$.getValue();
-        if (currentContext === contextName) {
-            if (this.debugMode) {
-                console.log(`${Hotkeys.LOG_PREFIX} setContext called with the same context "${contextName}". No change made.`);
-            }
-            return false;
-        }
-        if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} Context changed from "${currentContext}" to "${contextName}".`);
-        }
-        this.activeContext$.next(contextName);
-        return true;
-    }
-    /**
-     * Gets the current active context.
-     */
-    getContext() {
-        return this.activeContext$.getValue();
-    }
-    /**
-     * Enables or disables debug logging.
-     */
-    setDebugMode(enable) {
-        if (this.debugMode === enable)
-            return;
-        this.debugMode = enable;
-        console.log(`${Hotkeys.LOG_PREFIX} Debug mode ${enable ? "enabled" : "disabled"}.`);
-    }
-    /**
-     * Checks if a shortcut with the given ID is registered.
-     */
-    hasShortcut(id) {
-        return this.activeShortcuts.has(id);
-    }
-    /**
-     * An Observable that emits the new context name whenever it changes.
-     */
-    get onContextChange$() {
-        return this.activeContext$.asObservable();
-    }
-    _areSequencesIdentical(seq1, seq2) {
-        if (seq1.length !== seq2.length)
-            return false;
-        for (let i = 0; i < seq1.length; i++) {
-            if (seq1[i] !== seq2[i])
-                return false;
-        }
-        return true;
-    }
-    _shortcutMatchesEvent(shortcutConfig, event) {
-        const keyTriggers = Array.isArray(shortcutConfig.keys) ? shortcutConfig.keys : [shortcutConfig.keys];
-        for (const keyInput of keyTriggers) {
-            let configuredMainKey;
-            let ctrlKeyConfig, altKeyConfig, shiftKeyConfig, metaKeyConfig;
-            if (typeof keyInput === "string") {
-                if (keyInput === "")
-                    continue;
-                configuredMainKey = keyInput;
-                [ctrlKeyConfig, altKeyConfig, shiftKeyConfig, metaKeyConfig] = [false, false, false, false];
-            }
-            else {
-                if (!keyInput.key)
-                    continue;
-                configuredMainKey = keyInput.key;
-                ({ ctrlKey: ctrlKeyConfig, altKey: altKeyConfig, shiftKey: shiftKeyConfig, metaKey: metaKeyConfig } = keyInput);
-            }
-            const keyMatch = compareKey(event.key, configuredMainKey);
-            if (!keyMatch)
-                continue;
-            const ctrlMatch = (ctrlKeyConfig === undefined) ? true : (event.ctrlKey === ctrlKeyConfig);
-            const altMatch = (altKeyConfig === undefined) ? true : (event.altKey === altKeyConfig);
-            const shiftMatch = (shiftKeyConfig === undefined) ? true : (event.shiftKey === shiftKeyConfig);
-            const metaMatch = (metaKeyConfig === undefined) ? true : (event.metaKey === metaKeyConfig);
-            if (ctrlMatch && altMatch && shiftMatch && metaMatch) {
-                return true;
-            }
-        }
-        return false;
-    }
-    _registerShortcut(config, sub, type, log) {
-        const existing = this.activeShortcuts.get(config.id);
-        if (existing) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Shortcut with ID "${config.id}" already exists. It will be overwritten.`);
-            existing.subscription.unsubscribe();
-        }
-        this.activeShortcuts.set(config.id, { id: config.id, config, subscription: sub });
-        if (this.debugMode) {
-            const contextLog = config.context ? `"${config.context}"` : config.strict ? "global (strict)" : "global (default)";
-            console.log(`${Hotkeys.LOG_PREFIX} ${type} shortcut "${config.id}" added. ${log}, Context: ${contextLog}`);
-        }
-        return config.id;
-    }
-    _parseKeyTrigger(keyInput, shortcutId) {
-        if (typeof keyInput === "string") {
-            if (keyInput === "") {
-                console.warn(`${Hotkeys.LOG_PREFIX} Invalid key (shorthand) in shortcut "${shortcutId}". Key must not be empty.`);
-                return null;
-            }
-            return {
-                configuredMainKey: keyInput, ctrlKeyConfig: false, altKeyConfig: false,
-                shiftKeyConfig: false, metaKeyConfig: false,
-                logDetails: `key: "${keyInput}" (no mods)`,
-            };
-        }
-        else {
-            if (!keyInput.key) {
-                console.warn(`${Hotkeys.LOG_PREFIX} Invalid "key" property in shortcut "${shortcutId}". Key must be a non-empty string.`);
-                return null;
-            }
-            const logDetails = `key: "${keyInput.key}"` +
-                (keyInput.ctrlKey !== undefined ? `, ctrl: ${keyInput.ctrlKey}` : "") +
-                (keyInput.altKey !== undefined ? `, alt: ${keyInput.altKey}` : "") +
-                (keyInput.shiftKey !== undefined ? `, shift: ${keyInput.shiftKey}` : "") +
-                (keyInput.metaKey !== undefined ? `, meta: ${keyInput.metaKey}` : "");
-            return {
-                configuredMainKey: keyInput.key, ctrlKeyConfig: keyInput.ctrlKey, altKeyConfig: keyInput.altKey,
-                shiftKeyConfig: keyInput.shiftKey, metaKeyConfig: keyInput.metaKey,
-                logDetails,
-            };
-        }
-    }
-    addCombination(config) {
-        const { keys, callback, context, preventDefault = false, id, strict = false } = config;
-        const keyTriggers = Array.isArray(keys) ? keys : [keys];
-        if (keyTriggers.length === 0) {
-            console.warn(`${Hotkeys.LOG_PREFIX} "keys" array for combination shortcut "${id}" is empty. Shortcut not added.`);
-            return undefined;
-        }
-        if (context != null && strict) {
-            console.warn(`${Hotkeys.LOG_PREFIX} In shortcut "${id}", the "strict" flag is redundant because the shortcut has a top-level context "${context}". Flag will be ignored.`);
-        }
-        const baseStream$ = (context == null && strict)
-            ? this.keydown$.pipe(// Strictly global, only listen when context is null
-            withLatestFrom(this.activeContext$), filter(([, activeCtx]) => activeCtx === null), map(([event]) => event))
-            : this.keydown$; // Default global or context-specific, listen to all keys
-        const observables = [];
-        const logParts = [];
-        for (const keyInput of keyTriggers) {
-            const parsedTrigger = this._parseKeyTrigger(keyInput, id);
-            if (!parsedTrigger)
-                return undefined;
-            const { configuredMainKey, ctrlKeyConfig, altKeyConfig, shiftKeyConfig, metaKeyConfig, logDetails } = parsedTrigger;
-            logParts.push(`{ ${logDetails} }`);
-            const stream = baseStream$.pipe(
-            // Filter by specific context if the shortcut is not strictly global
-            filter(() => {
-                if (context != null) {
-                    return context === this.activeContext$.getValue();
-                }
-                return true;
-            }), 
-            // Match the key and modifiers for this specific trigger
-            filter(event => {
-                const ctrlMatch = (ctrlKeyConfig === undefined) ? true : (event.ctrlKey === ctrlKeyConfig);
-                const altMatch = (altKeyConfig === undefined) ? true : (event.altKey === altKeyConfig);
-                const shiftMatch = (shiftKeyConfig === undefined) ? true : (event.shiftKey === shiftKeyConfig);
-                const metaMatch = (metaKeyConfig === undefined) ? true : (event.metaKey === metaKeyConfig);
-                return ctrlMatch && altMatch && shiftMatch && metaMatch && compareKey(event.key, configuredMainKey);
-            }), 
-            // Priority filter for global shortcuts to prevent them from firing over specific ones
-            filter(event => {
-                if (context != null || strict)
-                    return true;
-                const currentSpecificContext = this.activeContext$.getValue();
-                if (currentSpecificContext == null)
-                    return true;
-                for (const [, otherAS] of this.activeShortcuts) {
-                    if (otherAS.config.id !== config.id && 'keys' in otherAS.config &&
-                        otherAS.config.context === currentSpecificContext && this._shortcutMatchesEvent(otherAS.config, event)) {
-                        if (this.debugMode) {
-                            console.log(`${Hotkeys.LOG_PREFIX} Global shortcut "${config.id}" (key: "${event.key}") suppressed by specific context shortcut "${otherAS.config.id}".`);
-                        }
-                        return false;
-                    }
-                }
-                return true;
-            }));
-            observables.push(stream);
-        }
-        if (observables.length === 0)
-            return undefined;
-        const finalShortcut$ = merge(...observables);
-        const overallLogDetails = `Triggers: [ ${logParts.join(", ")} ]`;
-        const subscription = finalShortcut$.pipe(tap(event => {
-            if (this.debugMode)
-                console.log(`${Hotkeys.LOG_PREFIX} Combination "${id}" triggered by key "${event.key}".`);
-            if (preventDefault)
-                event.preventDefault();
-        }), catchError(err => {
-            console.error(`${Hotkeys.LOG_PREFIX} Error in stream for combination "${id}":`, err);
-            return EMPTY;
-        })).subscribe(event => {
-            try {
-                callback(event);
-            }
-            catch (e) {
-                console.error(`${Hotkeys.LOG_PREFIX} Error in callback for combination "${id}":`, e);
-            }
-        });
-        return this._registerShortcut(config, subscription, ShortcutTypes.Combination, overallLogDetails);
-    }
-    addSequence(config) {
-        const { sequence, callback, context, preventDefault = false, id, sequenceTimeoutMs, strict = false } = config;
-        if (!Array.isArray(sequence) || sequence.length === 0) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Sequence for shortcut "${id}" is empty. Not added.`);
-            return undefined;
-        }
-        if (sequence.some(key => typeof key !== "string" || key === "")) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Invalid key in sequence for shortcut "${id}". Not added.`);
-            return undefined;
-        }
-        if (context != null && strict) {
-            console.warn(`${Hotkeys.LOG_PREFIX} In sequence shortcut "${id}", the "strict" flag is redundant because it has a top-level context "${context}". Flag will be ignored.`);
-        }
-        const sequenceLength = sequence.length;
-        const baseKeydownStream$ = (context == null && strict)
-            ? this.keydown$.pipe(// Strictly global
-            withLatestFrom(this.activeContext$), filter(([, activeCtx]) => activeCtx === null), map(([event]) => event))
-            : this.keydown$.pipe(// Default global or context-specific
-            withLatestFrom(this.activeContext$), filter(([, activeCtx]) => context == null || context === activeCtx), map(([event]) => event));
-        let shortcut$;
-        if (sequenceTimeoutMs && sequenceTimeoutMs > 0) {
-            shortcut$ = baseKeydownStream$.pipe(scan((acc, event) => {
-                let { matchedEvents, lastEventTime } = acc;
-                const currentTime = performance.now();
-                if (acc.emitState === EmitStates.Emit)
-                    matchedEvents = [];
-                if (matchedEvents.length > 0 && (currentTime - lastEventTime > sequenceTimeoutMs)) {
-                    matchedEvents = [];
-                }
-                if (compareKey(event.key, sequence[matchedEvents.length])) {
-                    const newMatched = [...matchedEvents, event];
-                    if (newMatched.length === sequenceLength) {
-                        return { matchedEvents: newMatched, lastEventTime: currentTime, emitState: EmitStates.Emit };
-                    }
-                    return { matchedEvents: newMatched, lastEventTime: currentTime, emitState: EmitStates.InProgress };
-                }
-                const newSequenceStartsWithKey = compareKey(event.key, sequence[0]);
-                if (matchedEvents.length > 0 && this.debugMode && !newSequenceStartsWithKey) {
-                    console.log(`${Hotkeys.LOG_PREFIX} Sequence "${id}" broken by key "${event.key}". Resetting.`);
-                }
-                return { matchedEvents: newSequenceStartsWithKey ? [event] : [], lastEventTime: currentTime, emitState: EmitStates.InProgress };
-            }, { matchedEvents: [], lastEventTime: 0, emitState: EmitStates.Ignore }), filter(state => state.emitState === EmitStates.Emit), map(state => state.matchedEvents));
-        }
-        else {
-            shortcut$ = baseKeydownStream$.pipe(bufferCount(sequenceLength, 1), filter(events => events.every((e, i) => compareKey(e.key, sequence[i]))));
-        }
-        const finalShortcutWithPriority$ = shortcut$.pipe(filter(() => {
-            if (context != null || strict)
-                return true;
-            const currentSpecificContext = this.activeContext$.getValue();
-            if (currentSpecificContext == null)
-                return true;
-            for (const [, otherAS] of this.activeShortcuts) {
-                if (otherAS.config.id !== config.id && "sequence" in otherAS.config &&
-                    otherAS.config.context === currentSpecificContext && this._areSequencesIdentical(config.sequence, otherAS.config.sequence)) {
-                    if (this.debugMode) {
-                        console.log(`${Hotkeys.LOG_PREFIX} Global sequence "${config.id}" suppressed by specific context shortcut "${otherAS.config.id}".`);
-                    }
-                    return false;
-                }
-            }
-            return true;
-        }), tap(events => {
-            if (this.debugMode)
-                console.log(`${Hotkeys.LOG_PREFIX} Sequence "${id}" triggered.`);
-            if (preventDefault && events.length > 0)
-                events[events.length - 1].preventDefault();
-        }), catchError(err => {
-            console.error(`${Hotkeys.LOG_PREFIX} Error in stream for sequence "${id}":`, err);
-            return EMPTY;
-        }));
-        const subscription = finalShortcutWithPriority$.subscribe(events => {
-            try {
-                if (events.length > 0)
-                    callback(events[events.length - 1]);
-            }
-            catch (e) {
-                console.error(`${Hotkeys.LOG_PREFIX} Error in callback for sequence "${id}":`, e);
-            }
-        });
-        const logDetails = `Sequence: ${sequence.join(" -> ")}`;
-        return this._registerShortcut(config, subscription, ShortcutTypes.Sequence, logDetails);
-    }
-    /**
-     * Removes a registered shortcut by its ID.
-     */
-    remove(id) {
-        const shortcut = this.activeShortcuts.get(id);
-        if (shortcut) {
-            shortcut.subscription.unsubscribe();
-            this.activeShortcuts.delete(id);
-            if (this.debugMode)
-                console.log(`${Hotkeys.LOG_PREFIX} Shortcut "${id}" removed.`);
-            return true;
-        }
-        console.warn(`${Hotkeys.LOG_PREFIX} Shortcut with ID "${id}" not found for removal.`);
-        return false;
-    }
-    /**
-     * Retrieves a list of all currently active shortcuts.
-     */
-    getActiveShortcuts() {
-        const shortcuts = [];
-        for (const [id, activeShortcut] of this.activeShortcuts.entries()) {
-            shortcuts.push({
-                id,
-                description: activeShortcut.config.description,
-                context: activeShortcut.config.context,
-                type: "sequence" in activeShortcut.config ? ShortcutTypes.Sequence : ShortcutTypes.Combination
-            });
-        }
-        return shortcuts;
-    }
-    /**
-     * Cleans up all active subscriptions.
-     */
-    destroy() {
-        if (this.debugMode)
-            console.log(`${Hotkeys.LOG_PREFIX} Destroying library instance.`);
-        this.activeShortcuts.forEach(shortcut => shortcut.subscription.unsubscribe());
-        this.activeShortcuts.clear();
-        this.activeContext$.complete();
-    }
-}