rx-hotkeys 4.2.0 → 5.0.0

package/dist/core/hotkeys.js

@@ -1,17 +1,16 @@
-import { fromEvent, BehaviorSubject, EMPTY, filter, map, bufferCount, withLatestFrom, tap, catchError, scan, merge, Subject, takeUntil, share, distinctUntilChanged, combineLatest, } from "rxjs";
+var _a;
+import { fromEvent, BehaviorSubject, EMPTY, Observable, filter, map, bufferCount, withLatestFrom, tap, catchError, scan, merge, Subject, takeUntil, share, distinctUntilChanged, combineLatest, } from "rxjs";
 import { Keys, KeyAliases } from "./keys.js";
 // --- 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 = {}));
+export const ShortcutTypes = Object.freeze({
+    Combination: "combination",
+    Sequence: "sequence",
+});
+const EmitStates = Object.freeze({
+    Emit: "Emit",
+    Ignore: "Ignore",
+    InProgress: "InProgress",
+});
 // --- Helper function to compare keys ---
 /**
  * Compares a browser event's key with a configured key.
@@ -50,30 +49,31 @@ function normalizeKey(key) {
     return finalKey || null;
 }
 // --- Hotkeys Library ---
+const NO_OVERRIDE = Symbol("No Hotkey Override");
 /**
  * Manages keyboard shortcuts for web applications.
  * Allows registration of single key combinations (e.g., Ctrl+S) and key sequences (e.g., g -> i).
  * Supports contexts to enable/disable shortcuts based on application state.
  */
 export class Hotkeys {
-    static KEYDOWN_EVENT = "keydown";
-    static KEYUP_EVENT = "keyup";
-    static LOG_PREFIX = "Hotkeys:";
+    static #KEYDOWN_EVENT = "keydown";
+    static #KEYUP_EVENT = "keyup";
+    static #LOG_PREFIX = "Hotkeys:";
     // --- Sentinel value for no override ---
-    static NO_OVERRIDE = Symbol("No Hotkey Override");
+    static #NO_OVERRIDE = NO_OVERRIDE;
     // NEW: A unified stream cache that handles different listener options.
-    eventStreams;
-    activeShortcuts;
-    debugMode;
+    #eventStreams;
+    #activeShortcuts;
+    #debugMode;
     // --- Separate states for stack and override ---
-    contextStack$;
-    overrideContext$;
+    #contextStack$;
+    #overrideContext$;
     /**
      * An Observable that emits the new active context name (or null) whenever it changes.
      * The active context is the override context if one is set, otherwise it's the context
      * from the top of the stack.
      */
-    activeContext$;
+    #activeContext$;
     /**
      * Creates an instance of Hotkeys.
      * @param initialContext - Optional initial context name. This forms the base of the context stack.
@@ -81,47 +81,47 @@ export class Hotkeys {
      * @throws Error if not in a browser environment (i.e., `document` or `performance` is undefined).
      */
     constructor(initialContext = null, debugMode = false) {
-        this.debugMode = debugMode;
+        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.`);
+            throw new Error(`${_a.#LOG_PREFIX} Hotkeys can only be used in a browser environment.`);
         }
-        this.eventStreams = new WeakMap(); // Initialize the new unified cache
-        this.activeShortcuts = new Map();
+        this.#eventStreams = new WeakMap(); // Initialize the new unified cache
+        this.#activeShortcuts = new Map();
         // The context stack is the source of truth for the active context.
-        this.contextStack$ = new BehaviorSubject([initialContext]);
-        this.overrideContext$ = new BehaviorSubject(Hotkeys.NO_OVERRIDE);
+        this.#contextStack$ = new BehaviorSubject([initialContext]);
+        this.#overrideContext$ = new BehaviorSubject(_a.#NO_OVERRIDE);
         // The public activeContext$ now correctly handles the sentinel value.
-        this.activeContext$ = combineLatest([
-            this.overrideContext$,
-            this.contextStack$.pipe(map(stack => stack.length > 0 ? stack[stack.length - 1] : null))
-        ]).pipe(map(([overrideCtx, stackCtx]) => this._resolveActiveContext(overrideCtx, stackCtx)), distinctUntilChanged());
-        if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} Library initialized. Initial context: "${initialContext}". Debug mode: ${debugMode}.`);
+        this.#activeContext$ = combineLatest([
+            this.#overrideContext$,
+            this.#contextStack$.pipe(map(stack => stack.length > 0 ? stack[stack.length - 1] : null))
+        ]).pipe(map(([overrideCtx, stackCtx]) => this.#resolveActiveContext(overrideCtx, stackCtx)), distinctUntilChanged());
+        if (this.#debugMode) {
+            console.log(`${_a.#LOG_PREFIX} Library initialized. Initial context: "${initialContext}". Debug mode: ${debugMode}.`);
             // Optional: Log context changes for debugging
-            this.activeContext$.subscribe(newContext => {
-                console.log(`${Hotkeys.LOG_PREFIX} Active context changed to: ${newContext}`);
+            this.#activeContext$.subscribe(newContext => {
+                console.log(`${_a.#LOG_PREFIX} Active context changed to: ${newContext}`);
             });
         }
     }
     /**
      * Helper method to determine the active context based on override and stack.
      */
-    _resolveActiveContext(overrideCtx, stackCtx) {
-        return overrideCtx !== Hotkeys.NO_OVERRIDE ? overrideCtx : stackCtx;
+    #resolveActiveContext(overrideCtx, stackCtx) {
+        return overrideCtx !== _a.#NO_OVERRIDE ? overrideCtx : stackCtx;
     }
-    _normalizeAndParseTriggers(keys, shortcutId) {
+    #normalizeAndParseTriggers(keys, shortcutId) {
         const keyInputs = Array.isArray(keys) ? keys : [keys];
         const parsedTriggers = [];
         for (const input of keyInputs) {
             let triggersToParse = [];
             if (typeof input === "string" && input.length > 1 && input.includes("+")) {
-                triggersToParse.push(...this._parseCombinationString(input));
+                triggersToParse.push(...this.#parseCombinationString(input));
             }
             else {
                 triggersToParse.push(input);
             }
             for (const trigger of triggersToParse) {
-                const parsed = this._parseKeyTrigger(trigger, shortcutId);
+                const parsed = this.#parseKeyTrigger(trigger, shortcutId);
                 if (parsed) {
                     parsedTriggers.push({
                         key: parsed.configuredMainKey,
@@ -135,7 +135,7 @@ export class Hotkeys {
         }
         return parsedTriggers;
     }
-    _normalizeSequence(sequence, shortcutId) {
+    #normalizeSequence(sequence, shortcutId) {
         const keyInputs = typeof sequence === "string" ? sequence.split("->") : sequence;
         const results = [];
         for (const keyStr of keyInputs) {
@@ -144,7 +144,7 @@ export class Hotkeys {
                 results.push(finalKey);
             }
             else {
-                console.warn(`${Hotkeys.LOG_PREFIX} Could not parse key: "${keyStr}" in sequence for shortcut "${shortcutId}".`);
+                console.warn(`${_a.#LOG_PREFIX} Could not parse key: "${keyStr}" in sequence for shortcut "${shortcutId}".`);
                 return null; // Fail fast if any key is invalid
             }
         }
@@ -153,7 +153,7 @@ export class Hotkeys {
     /**
      * [PRIVATE] Generates a unique key for the stream cache based on event type and options.
      */
-    _getStreamCacheKey(eventType, options) {
+    #getStreamCacheKey(eventType, options) {
         if (!options) {
             return eventType;
         }
@@ -170,19 +170,19 @@ export class Hotkeys {
      * @param options The AddEventListenerOptions.
      * @returns A shared Observable for the specified event.
      */
-    _getEventStream(eventType, target, options) {
-        if (!this.eventStreams.has(target)) {
-            this.eventStreams.set(target, new Map());
+    #getEventStream(eventType, target, options) {
+        if (!this.#eventStreams.has(target)) {
+            this.#eventStreams.set(target, new Map());
         }
-        const targetCache = this.eventStreams.get(target);
-        const cacheKey = this._getStreamCacheKey(eventType, options);
+        const targetCache = this.#eventStreams.get(target);
+        const cacheKey = this.#getStreamCacheKey(eventType, options);
         if (!targetCache.has(cacheKey)) {
             // Create the new stream with the specified options
             const newStream = fromEvent(target, eventType, options).pipe(share());
             targetCache.set(cacheKey, newStream);
-            if (this.debugMode) {
+            if (this.#debugMode) {
                 const targetName = target === document ? "document" : `element "${target.id || target.tagName}"`;
-                console.log(`${Hotkeys.LOG_PREFIX} Created new shared listener for "${cacheKey}" on ${targetName}.`);
+                console.log(`${_a.#LOG_PREFIX} Created new shared listener for "${cacheKey}" on ${targetName}.`);
             }
         }
         return targetCache.get(cacheKey);
@@ -193,18 +193,18 @@ export class Hotkeys {
      * @returns A `restore` function that, when called, clears the override context, reverting to the stack.
      */
     setContext(contextName) {
-        if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} Setting override context to: "${contextName}".`);
+        if (this.#debugMode) {
+            console.log(`${_a.#LOG_PREFIX} Setting override context to: "${contextName}".`);
         }
-        this.overrideContext$.next(contextName);
+        this.#overrideContext$.next(contextName);
         const restore = () => {
             // Only clear the override if it's still the one we set.
-            if (this.overrideContext$.getValue() === contextName) {
-                if (this.debugMode) {
-                    console.log(`${Hotkeys.LOG_PREFIX} Restoring/clearing override context from: "${contextName}".`);
+            if (this.#overrideContext$.getValue() === contextName) {
+                if (this.#debugMode) {
+                    console.log(`${_a.#LOG_PREFIX} Restoring/clearing override context from: "${contextName}".`);
                 }
                 // Restore now sets the special "NO_OVERRIDE" value.
-                this.overrideContext$.next(Hotkeys.NO_OVERRIDE);
+                this.#overrideContext$.next(_a.#NO_OVERRIDE);
             }
         };
         return restore;
@@ -215,7 +215,7 @@ export class Hotkeys {
      * @returns The current context name as a string, or `null` if no context is set.
      */
     getContext() {
-        console.warn(`${Hotkeys.LOG_PREFIX} "getContext" is deprecated. Use "getActiveContext()" or subscribe to "onContextChange$" instead.`);
+        console.warn(`${_a.#LOG_PREFIX} "getContext" is deprecated. Use "getActiveContext()" or subscribe to "onContextChange$" instead.`);
         return this.getActiveContext();
     }
     /**
@@ -223,42 +223,42 @@ export class Hotkeys {
      * @returns The current context name as a string, or `null` if no context is set.
      */
     getActiveContext() {
-        const overrideCtx = this.overrideContext$.getValue();
-        const stack = this.contextStack$.getValue();
+        const overrideCtx = this.#overrideContext$.getValue();
+        const stack = this.#contextStack$.getValue();
         const stackCtx = stack.length > 0 ? stack[stack.length - 1] : null;
         // Also uses the abstracted helper method.
-        return this._resolveActiveContext(overrideCtx, stackCtx);
+        return this.#resolveActiveContext(overrideCtx, stackCtx);
     }
     /**
      * Pushes a new context onto the context stack. It will become active if no override context is set.
      * @param contextName The name of the context to enter (e.g., "modal", "editor").
      */
     enterContext(contextName) {
-        const currentStack = this.contextStack$.getValue();
+        const currentStack = this.#contextStack$.getValue();
         const newStack = [...currentStack, contextName];
-        if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} Entering context: "${contextName}". New stack: [${newStack.join(", ")}]`);
+        if (this.#debugMode) {
+            console.log(`${_a.#LOG_PREFIX} Entering context: "${contextName}". New stack: [${newStack.join(", ")}]`);
         }
-        this.contextStack$.next(newStack);
+        this.#contextStack$.next(newStack);
     }
     /**
      * Pops the current context from the stack.
      * @returns The context that was just left from the stack, or `undefined` if at the base.
      */
     leaveContext() {
-        const currentStack = this.contextStack$.getValue();
+        const currentStack = this.#contextStack$.getValue();
         if (currentStack.length <= 1) {
-            if (this.debugMode) {
-                console.log(`${Hotkeys.LOG_PREFIX} Attempted to leave the base stack context. No change made.`);
+            if (this.#debugMode) {
+                console.log(`${_a.#LOG_PREFIX} Attempted to leave the base stack context. No change made.`);
             }
             return undefined; // Nothing was left
         }
         const leavingContext = currentStack[currentStack.length - 1];
         const newStack = currentStack.slice(0, -1);
-        if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} Leaving context: "${leavingContext}". New stack: [${newStack.join(", ")}]`);
+        if (this.#debugMode) {
+            console.log(`${_a.#LOG_PREFIX} Leaving context: "${leavingContext}". New stack: [${newStack.join(", ")}]`);
         }
-        this.contextStack$.next(newStack);
+        this.#contextStack$.next(newStack);
         return leavingContext;
     }
     /**
@@ -267,15 +267,15 @@ export class Hotkeys {
      * @param enable - True to enable debug logs, false to disable.
      */
     setDebugMode(enable) {
-        if (this.debugMode === enable) {
+        if (this.#debugMode === enable) {
             return;
         }
-        this.debugMode = enable;
+        this.#debugMode = enable;
         if (enable) {
-            console.log(`${Hotkeys.LOG_PREFIX} Debug mode enabled.`);
+            console.log(`${_a.#LOG_PREFIX} Debug mode enabled.`);
         }
         else {
-            console.log(`${Hotkeys.LOG_PREFIX} Debug mode disabled.`);
+            console.log(`${_a.#LOG_PREFIX} Debug mode disabled.`);
         }
     }
     /**
@@ -284,7 +284,7 @@ export class Hotkeys {
      * @returns True if a shortcut with the specified ID exists, false otherwise.
      */
     hasShortcut(id) {
-        return this.activeShortcuts.has(id);
+        return this.#activeShortcuts.has(id);
     }
     /**
      * An Observable that emits the new context name (or null) whenever the active context changes.
@@ -301,7 +301,7 @@ export class Hotkeys {
      * ```
      */
     get onContextChange$() {
-        return this.activeContext$;
+        return this.#activeContext$;
     }
     /**
      * Compares two sequences of StandardKey arrays to see if they are identical.
@@ -309,7 +309,7 @@ export class Hotkeys {
      * @param seq2 - The second sequence array.
      * @returns True if the sequences are identical, false otherwise.
      */
-    _areSequencesIdentical(seq1, seq2) {
+    #areSequencesIdentical(seq1, seq2) {
         if (seq1.length !== seq2.length) {
             return false;
         }
@@ -327,7 +327,7 @@ export class Hotkeys {
      * @param event The KeyboardEvent to match against.
      * @returns True if the shortcutConfig matches the event, false otherwise.
      */
-    _shortcutMatchesEvent(parsedTriggers, event) {
+    #shortcutMatchesEvent(parsedTriggers, event) {
         // It no longer does any parsing. It just compares against the pre-parsed triggers.
         for (const trigger of parsedTriggers) {
             const keyMatch = compareKey(event.key, trigger.key);
@@ -342,8 +342,8 @@ export class Hotkeys {
         }
         return false;
     }
-    filterByContext(source$, context, strict) {
-        return source$.pipe(withLatestFrom(this.activeContext$), filter(([/* event */ , activeCtx]) => {
+    #filterByContext(source$, context, strict) {
+        return source$.pipe(withLatestFrom(this.#activeContext$), filter(([/* event */ , activeCtx]) => {
             if (context == null) {
                 if (strict) {
                     return activeCtx == null;
@@ -357,16 +357,101 @@ export class Hotkeys {
             }
         }), map(([event, /* _activeCtx */]) => event));
     }
-    _registerShortcut(config, terminator$, type, detailsForLog, parsedTriggers) {
-        const existingShortcut = this.activeShortcuts.get(config.id);
+    #checkIsContentEditable(element) {
+        if (typeof element.isContentEditable === "boolean") {
+            return element.isContentEditable;
+        }
+        const closest = element.closest?.("[contenteditable]");
+        if (closest) {
+            const val = closest.getAttribute("contenteditable")?.toLowerCase();
+            return val !== "false";
+        }
+        return false;
+    }
+    #shouldHandleKeyEvent(event, config) {
+        // 1. IME composition check
+        const ignoreComposing = config.ignoreComposing ?? true;
+        if (ignoreComposing) {
+            // @ts-ignore
+            if (event.isComposing || event.keyCode === 229 || event.which === 229 || event.key === "Dead") {
+                if (this.#debugMode) {
+                    console.log(`${_a.#LOG_PREFIX} Shortcut "${config.id}" suppressed during IME composition.`);
+                }
+                return false;
+            }
+        }
+        // 2. Custom filter predicate
+        if (config.filter && !config.filter(event)) {
+            if (this.#debugMode) {
+                console.log(`${_a.#LOG_PREFIX} Shortcut "${config.id}" suppressed by custom filter.`);
+            }
+            return false;
+        }
+        // 3. Resolve target element (supporting Shadow DOM)
+        let targetElement = null;
+        const rawTarget = (typeof event.composedPath === "function" ? event.composedPath()[0] : event.target);
+        if (rawTarget) {
+            if (rawTarget instanceof HTMLElement) {
+                targetElement = rawTarget;
+            }
+            else if (rawTarget.parentElement instanceof HTMLElement) {
+                targetElement = rawTarget.parentElement;
+            }
+        }
+        if (!targetElement) {
+            return true;
+        }
+        // 4. Target exemption: if explicitly attached to this target element, allow it
+        if (config.target && config.target === targetElement) {
+            return true;
+        }
+        const tagName = targetElement.tagName ? targetElement.tagName.toLowerCase() : "";
+        // 5. Form tags (<input>, <textarea>, <select>)
+        const isFormTag = tagName === "input" || tagName === "textarea" || tagName === "select";
+        if (isFormTag) {
+            const { enableOnFormTags = false } = config;
+            if (enableOnFormTags === false) {
+                if (this.#debugMode) {
+                    console.log(`${_a.#LOG_PREFIX} Shortcut "${config.id}" suppressed in <${tagName}> form element.`);
+                }
+                return false;
+            }
+            if (Array.isArray(enableOnFormTags)) {
+                const allowed = enableOnFormTags.map(t => t.toLowerCase());
+                if (!allowed.includes(tagName)) {
+                    if (this.#debugMode) {
+                        console.log(`${_a.#LOG_PREFIX} Shortcut "${config.id}" suppressed in <${tagName}> (allowed: [${allowed.join(", ")}]).`);
+                    }
+                    return false;
+                }
+            }
+        }
+        // 6. Rich-text editor (contentEditable)
+        const isContentEditable = this.#checkIsContentEditable(targetElement);
+        if (isContentEditable) {
+            const { enableOnContentEditable = false } = config;
+            if (!enableOnContentEditable) {
+                if (this.#debugMode) {
+                    console.log(`${_a.#LOG_PREFIX} Shortcut "${config.id}" suppressed in contentEditable element.`);
+                }
+                return false;
+            }
+        }
+        return true;
+    }
+    #filterEvent(source$, config) {
+        return this.#filterByContext(source$, config.context, config.strict ?? false).pipe(filter(event => this.#shouldHandleKeyEvent(event, config)));
+    }
+    #registerShortcut(config, terminator$, type, detailsForLog, parsedTriggers) {
+        const existingShortcut = this.#activeShortcuts.get(config.id);
         if (existingShortcut) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Shortcut with ID "${config.id}" already exists. The old instance will be terminated and overwritten.`);
+            console.warn(`${_a.#LOG_PREFIX} Shortcut with ID "${config.id}" already exists. The old instance will be terminated and overwritten.`);
             existingShortcut.terminator$.next();
             existingShortcut.terminator$.complete();
         }
-        this.activeShortcuts.set(config.id, { id: config.id, config, terminator$, parsedTriggers });
-        if (this.debugMode) {
-            console.log(`${Hotkeys.LOG_PREFIX} ${type} shortcut "${config.id}" added. ${detailsForLog}, Context: ${config.context ?? "any"}`);
+        this.#activeShortcuts.set(config.id, { id: config.id, config, terminator$, parsedTriggers });
+        if (this.#debugMode) {
+            console.log(`${_a.#LOG_PREFIX} ${type} shortcut "${config.id}" added. ${detailsForLog}, Context: ${config.context ?? "any"}`);
         }
     }
     /**
@@ -376,11 +461,11 @@ export class Hotkeys {
      * @param shortcutId - The ID of the shortcut this key trigger belongs to (for logging).
      * @returns An object containing configuredMainKey and modifier states, or null if parsing fails.
      */
-    _parseKeyTrigger(keyInput, shortcutId) {
+    #parseKeyTrigger(keyInput, shortcutId) {
         if (typeof keyInput === "string") {
             const finalKey = normalizeKey(keyInput);
             if (!finalKey) {
-                console.warn(`${Hotkeys.LOG_PREFIX} Could not parse key: "${keyInput}" in shortcut "${shortcutId}".`);
+                console.warn(`${_a.#LOG_PREFIX} Could not parse key: "${keyInput}" in shortcut "${shortcutId}".`);
                 return null;
             }
             return {
@@ -393,7 +478,7 @@ export class Hotkeys {
         }
         else {
             if (!keyInput.key || typeof keyInput.key !== "string" || keyInput.key === "") {
-                console.warn(`${Hotkeys.LOG_PREFIX} Invalid "key" property in shortcut "${shortcutId}". Key must be a non-empty string value from Keys.`);
+                console.warn(`${_a.#LOG_PREFIX} Invalid "key" property in shortcut "${shortcutId}". Key must be a non-empty string value from Keys.`);
                 return null;
             }
             return {
@@ -405,11 +490,11 @@ export class Hotkeys {
             };
         }
     }
-    _parseCombinationString(shortcut) {
+    #parseCombinationString(shortcut) {
         const parts = shortcut.toLowerCase().split("+").map(p => p.trim());
         const mainKeyStr = parts.pop();
         if (!mainKeyStr) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Invalid shortcut string: "${shortcut}". No main key found.`);
+            console.warn(`${_a.#LOG_PREFIX} Invalid shortcut string: "${shortcut}". No main key found.`);
             return [];
         }
         const trigger = {
@@ -418,7 +503,7 @@ export class Hotkeys {
         };
         const finalKey = normalizeKey(mainKeyStr);
         if (!finalKey) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Could not parse key: "${mainKeyStr}" in shortcut string "${shortcut}".`);
+            console.warn(`${_a.#LOG_PREFIX} Could not parse key: "${mainKeyStr}" in shortcut string "${shortcut}".`);
             return [];
         }
         trigger.key = finalKey;
@@ -432,11 +517,11 @@ export class Hotkeys {
             else if (part === "meta" || part === "cmd" || part === "command" || part === "win")
                 trigger.metaKey = true;
             else
-                console.warn(`${Hotkeys.LOG_PREFIX} Unknown modifier: "${part}" in shortcut string "${shortcut}".`);
+                console.warn(`${_a.#LOG_PREFIX} Unknown modifier: "${part}" in shortcut string "${shortcut}".`);
         }
         return [trigger];
     }
-    _parseSequenceString(sequence) {
+    #parseSequenceString(sequence) {
         const keyStrings = sequence.split("->").map(k => k.trim());
         const results = [];
         for (const keyStr of keyStrings) {
@@ -445,7 +530,7 @@ export class Hotkeys {
                 results.push(finalKey);
             }
             else {
-                console.warn(`${Hotkeys.LOG_PREFIX} Could not parse key: "${keyStr}" in sequence string "${sequence}".`);
+                console.warn(`${_a.#LOG_PREFIX} Could not parse key: "${keyStr}" in sequence string "${sequence}".`);
                 return []; // Fail fast
             }
         }
@@ -490,24 +575,25 @@ export class Hotkeys {
     addCombination(config) {
         const { keys, context, preventDefault = false, id, strict = false, target = document, event: eventType = "keydown", options } = config;
         if (context != null && strict) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Shortcut "${id}" has both a context(${context}) and the "strict" flag. The "strict" flag will be ignored.`);
+            console.warn(`${_a.#LOG_PREFIX} Shortcut "${id}" has both a context(${context}) and the "strict" flag. The "strict" flag will be ignored.`);
         }
-        const parsedTriggers = this._normalizeAndParseTriggers(keys, id);
+        const parsedTriggers = this.#normalizeAndParseTriggers(keys, id);
         if (parsedTriggers.length === 0) {
-            console.error(`${Hotkeys.LOG_PREFIX} "keys" definition for combination shortcut "${id}" is empty or invalid. Shortcut not added.`);
+            console.error(`${_a.#LOG_PREFIX} "keys" definition for combination shortcut "${id}" is empty or invalid. Shortcut not added.`);
             return EMPTY;
         }
-        const sourceStream$ = this._getEventStream(eventType, target, options);
+        const sourceStream$ = this.#getEventStream(eventType, target, options);
+        const baseStream$ = this.#filterEvent(sourceStream$, config);
         const observables = [];
         for (const trigger of parsedTriggers) {
-            const stream = this.filterByContext(sourceStream$, context, strict).pipe(filter(event => {
+            const stream = baseStream$.pipe(filter(event => {
                 return event.ctrlKey === trigger.ctrlKey &&
                     event.altKey === trigger.altKey &&
                     event.shiftKey === trigger.shiftKey &&
                     event.metaKey === trigger.metaKey;
             }), filter(event => compareKey(event.key, trigger.key)), 
             // New filter for priority: Specific context > Global context
-            withLatestFrom(this.activeContext$), filter(([event, activeCtx]) => {
+            withLatestFrom(this.#activeContext$), filter(([event, activeCtx]) => {
                 if (context != null || strict) { // This shortcut is NOT global or strict
                     return true;
                 }
@@ -515,13 +601,13 @@ export class Hotkeys {
                 if (activeCtx == null) { // No specific context active
                     return true;
                 }
-                for (const [, otherAS] of this.activeShortcuts) {
+                for (const [, otherAS] of this.#activeShortcuts) {
                     if (otherAS.config.id !== id &&
                         "keys" in otherAS.config &&
                         otherAS.config.context === activeCtx &&
-                        this._shortcutMatchesEvent(otherAS.parsedTriggers ?? [], event)) {
-                        if (this.debugMode) {
-                            console.log(`${Hotkeys.LOG_PREFIX} Global shortcut "${id}" (key: "${event.key}") suppressed by specific context shortcut "${otherAS.config.id}".`);
+                        this.#shortcutMatchesEvent(otherAS.parsedTriggers ?? [], event)) {
+                        if (this.#debugMode) {
+                            console.log(`${_a.#LOG_PREFIX} Global shortcut "${id}" (key: "${event.key}") suppressed by specific context shortcut "${otherAS.config.id}".`);
                         }
                         return false; // Suppress global
                     }
@@ -532,7 +618,7 @@ export class Hotkeys {
         }
         if (observables.length === 0) {
             // This path should now be much harder to hit, but remains a safeguard.
-            console.warn(`${Hotkeys.LOG_PREFIX} No valid key triggers for combination shortcut "${id}". Shortcut not added.`);
+            console.warn(`${_a.#LOG_PREFIX} No valid key triggers for combination shortcut "${id}". Shortcut not added.`);
             return EMPTY;
         }
         const terminator$ = new Subject();
@@ -554,16 +640,16 @@ export class Hotkeys {
             return `{ ${parts.join(", ")} }`;
         });
         const logDetails = `Triggers: [ ${logParts.join(", ")} ]`;
-        this._registerShortcut(config, terminator$, ShortcutTypes.Combination, logDetails, parsedTriggers);
+        this.#registerShortcut(config, terminator$, ShortcutTypes.Combination, logDetails, parsedTriggers);
         return finalShortcut$.pipe(tap(event => {
-            if (this.debugMode) {
+            if (this.#debugMode) {
                 const preventAction = preventDefault ? ", preventing default" : "";
-                console.log(`${Hotkeys.LOG_PREFIX} Combination "${id}" triggered by key "${event.key}" ${preventAction}.`);
+                console.log(`${_a.#LOG_PREFIX} Combination "${id}" triggered by key "${event.key}" ${preventAction}.`);
             }
             if (preventDefault)
                 event.preventDefault();
         }), catchError(err => {
-            console.error(`${Hotkeys.LOG_PREFIX} Error in combination stream for shortcut "${id}":`, err);
+            console.error(`${_a.#LOG_PREFIX} Error in combination stream for shortcut "${id}":`, err);
             return EMPTY;
         }), takeUntil(terminator$));
     }
@@ -600,18 +686,18 @@ export class Hotkeys {
      */
     addSequence(config) {
         const { sequence, context, preventDefault = false, id, sequenceTimeoutMs, strict = false, target = document, event: eventType = "keydown", options } = config;
-        const configuredSequence = this._normalizeSequence(sequence, id);
+        const configuredSequence = this.#normalizeSequence(sequence, id);
         if (!configuredSequence || configuredSequence.length === 0) {
-            console.error(`${Hotkeys.LOG_PREFIX} Sequence for shortcut "${id}" is empty or invalid. Shortcut not added.`);
+            console.error(`${_a.#LOG_PREFIX} Sequence for shortcut "${id}" is empty or invalid. Shortcut not added.`);
             return EMPTY;
         }
         if (context && strict) {
-            console.warn(`${Hotkeys.LOG_PREFIX} Shortcut "${id}" has both a context and the "strict" flag. The "strict" flag will be ignored.`);
+            console.warn(`${_a.#LOG_PREFIX} Shortcut "${id}" has both a context and the "strict" flag. The "strict" flag will be ignored.`);
         }
         const sequenceLength = configuredSequence.length;
         let shortcut$;
-        const sourceStream$ = this._getEventStream(eventType, target, options);
-        const baseKeydownStream$ = this.filterByContext(sourceStream$, context, strict);
+        const sourceStream$ = this.#getEventStream(eventType, target, options);
+        const baseKeydownStream$ = this.#filterEvent(sourceStream$, config);
         if (sequenceTimeoutMs && sequenceTimeoutMs > 0) {
             shortcut$ = baseKeydownStream$.pipe(scan((acc, event) => {
                 let { matchedEvents, lastEventTime } = acc;
@@ -621,8 +707,8 @@ export class Hotkeys {
                     lastEventTime = 0;
                 }
                 if (matchedEvents.length > 0 && (currentTime - lastEventTime > sequenceTimeoutMs)) {
-                    if (this.debugMode) {
-                        console.log(`${Hotkeys.LOG_PREFIX} Sequence "${id}" (timeout: ${sequenceTimeoutMs}ms) attempt timed out. Matched: ${matchedEvents.map(e => e.key).join(",")}. Resetting.`);
+                    if (this.#debugMode) {
+                        console.log(`${_a.#LOG_PREFIX} Sequence "${id}" (timeout: ${sequenceTimeoutMs}ms) attempt timed out. Matched: ${matchedEvents.map(e => e.key).join(",")}. Resetting.`);
                     }
                     matchedEvents = [];
                 }
@@ -638,8 +724,8 @@ export class Hotkeys {
                 if (compareKey(event.key, configuredSequence[nextExpectedKeyIndex])) {
                     const newMatchedEvents = [...matchedEvents, event];
                     if (newMatchedEvents.length === sequenceLength) {
-                        if (this.debugMode && acc.emitState !== EmitStates.Emit)
-                            console.log(`${Hotkeys.LOG_PREFIX} Sequence "${id}" (timeout: ${sequenceTimeoutMs}ms) matched.`);
+                        if (this.#debugMode && acc.emitState !== EmitStates.Emit)
+                            console.log(`${_a.#LOG_PREFIX} Sequence "${id}" (timeout: ${sequenceTimeoutMs}ms) matched.`);
                         return { matchedEvents: newMatchedEvents, lastEventTime: currentTime, emitState: EmitStates.Emit };
                     }
                     else {
@@ -648,8 +734,8 @@ export class Hotkeys {
                 }
                 else {
                     // If current key breaks sequence, check if it starts a new sequence
-                    if (matchedEvents.length > 0 && this.debugMode) {
-                        console.log(`${Hotkeys.LOG_PREFIX} Sequence "${id}" (timeout: ${sequenceTimeoutMs}ms) broken by key "${event.key}". Matched: ${matchedEvents.map(e => e.key).join(",")}. Resetting.`);
+                    if (matchedEvents.length > 0 && this.#debugMode) {
+                        console.log(`${_a.#LOG_PREFIX} Sequence "${id}" (timeout: ${sequenceTimeoutMs}ms) broken by key "${event.key}". Matched: ${matchedEvents.map(e => e.key).join(",")}. Resetting.`);
                     }
                     if (sequenceLength > 0 && compareKey(event.key, configuredSequence[0])) {
                         return { matchedEvents: [event], lastEventTime: currentTime, emitState: EmitStates.InProgress };
@@ -669,7 +755,7 @@ export class Hotkeys {
             }));
         }
         const terminator$ = new Subject();
-        const finalShortcutWithPriority$ = shortcut$.pipe(withLatestFrom(this.activeContext$), filter(([_completedEvents, activeCtx]) => {
+        const finalShortcutWithPriority$ = shortcut$.pipe(withLatestFrom(this.#activeContext$), filter(([_completedEvents, activeCtx]) => {
             if (context != null || strict) { // This sequence is NOT global or strict
                 return true;
             }
@@ -677,33 +763,33 @@ export class Hotkeys {
             if (activeCtx == null) { // No specific context active
                 return true;
             }
-            for (const [, otherAS] of this.activeShortcuts) {
+            for (const [, otherAS] of this.#activeShortcuts) {
                 if (otherAS.config.id !== id &&
                     "sequence" in otherAS.config &&
                     otherAS.config.context === activeCtx &&
-                    this._areSequencesIdentical(configuredSequence, typeof otherAS.config.sequence === "string" ? this._parseSequenceString(otherAS.config.sequence) : otherAS.config.sequence)) {
-                    if (this.debugMode) {
-                        console.log(`${Hotkeys.LOG_PREFIX} Global sequence shortcut "${id}" suppressed by identical specific-context shortcut "${otherAS.config.id}".`);
+                    this.#areSequencesIdentical(configuredSequence, typeof otherAS.config.sequence === "string" ? this.#parseSequenceString(otherAS.config.sequence) : otherAS.config.sequence)) {
+                    if (this.#debugMode) {
+                        console.log(`${_a.#LOG_PREFIX} Global sequence shortcut "${id}" suppressed by identical specific-context shortcut "${otherAS.config.id}".`);
                     }
                     return false; // Suppress global
                 }
             }
             return true; // Global sequence can proceed
         }), map(([events]) => events), tap((events) => {
-            if (this.debugMode) {
+            if (this.#debugMode) {
                 const timeoutInfo = (sequenceTimeoutMs && sequenceTimeoutMs > 0) ? ` (with timeout logic)` : ` (no timeout logic)`;
                 const preventAction = preventDefault ? ", preventing default for last event" : "";
-                console.log(`${Hotkeys.LOG_PREFIX} Sequence "${id}" triggered${timeoutInfo}${preventAction}.`);
+                console.log(`${_a.#LOG_PREFIX} Sequence "${id}" triggered${timeoutInfo}${preventAction}.`);
             }
             if (preventDefault && events.length > 0) {
                 events[events.length - 1].preventDefault();
             }
         }), catchError(err => {
-            console.error(`${Hotkeys.LOG_PREFIX} Error in sequence stream for shortcut "${id}":`, err);
+            console.error(`${_a.#LOG_PREFIX} Error in sequence stream for shortcut "${id}":`, err);
             return EMPTY;
         }));
         const logDetails = `Sequence: ${configuredSequence.join(" -> ")}${sequenceTimeoutMs && sequenceTimeoutMs > 0 ? ` (timeout: ${sequenceTimeoutMs}ms)` : ""}`;
-        this._registerShortcut(config, terminator$, ShortcutTypes.Sequence, logDetails);
+        this.#registerShortcut(config, terminator$, ShortcutTypes.Sequence, logDetails);
         return finalShortcutWithPriority$.pipe(map((events) => events[events.length - 1]), takeUntil(terminator$));
     }
     /**
@@ -714,16 +800,16 @@ export class Hotkeys {
      * A warning is logged to the console if no shortcut with the given ID is found.
      */
     remove(id) {
-        const shortcut = this.activeShortcuts.get(id);
+        const shortcut = this.#activeShortcuts.get(id);
         if (shortcut) {
             shortcut.terminator$.next();
             shortcut.terminator$.complete();
-            this.activeShortcuts.delete(id);
-            if (this.debugMode)
-                console.log(`${Hotkeys.LOG_PREFIX} Shortcut "${id}" removed.`);
+            this.#activeShortcuts.delete(id);
+            if (this.#debugMode)
+                console.log(`${_a.#LOG_PREFIX} Shortcut "${id}" removed.`);
             return true;
         }
-        console.warn(`${Hotkeys.LOG_PREFIX} Shortcut with ID "${id}" not found for removal.`);
+        console.warn(`${_a.#LOG_PREFIX} Shortcut with ID "${id}" not found for removal.`);
         return false;
     }
     /**
@@ -735,7 +821,7 @@ export class Hotkeys {
      */
     getActiveShortcuts() {
         const shortcuts = [];
-        for (const [id, activeShortcut] of this.activeShortcuts.entries()) {
+        for (const [id, activeShortcut] of this.#activeShortcuts.entries()) {
             shortcuts.push({
                 id,
                 description: activeShortcut.config.description,
@@ -752,16 +838,17 @@ export class Hotkeys {
      * After calling `destroy()`, the instance should not be used further.
      */
     destroy() {
-        if (this.debugMode)
-            console.log(`${Hotkeys.LOG_PREFIX} Destroying library instance and terminating all shortcut streams.`);
-        this.activeShortcuts.forEach(shortcut => {
+        if (this.#debugMode)
+            console.log(`${_a.#LOG_PREFIX} Destroying library instance and terminating all shortcut streams.`);
+        this.#activeShortcuts.forEach(shortcut => {
             shortcut.terminator$.next();
             shortcut.terminator$.complete();
         });
-        this.activeShortcuts.clear();
-        this.contextStack$.complete();
-        if (this.debugMode)
-            console.log(`${Hotkeys.LOG_PREFIX} Library destroyed.`);
+        this.#activeShortcuts.clear();
+        this.#contextStack$.complete();
+        if (this.#debugMode)
+            console.log(`${_a.#LOG_PREFIX} Library destroyed.`);
     }
 }
+_a = Hotkeys;
 //# sourceMappingURL=hotkeys.js.map