@tanstack/hotkeys 0.9.0 → 0.10.0

package/dist/_recorder-chord.cjs

@@ -1,44 +0,0 @@
-const require_constants = require('./constants.cjs');
-const require__keyboard_event = require('./_keyboard-event.cjs');
-const require_parse = require('./parse.cjs');
-
-//#region src/_recorder-chord.ts
-/**
-* Converts a keydown to a replayable chord, preserving physical codes by default.
-* Returns null for composition, modifier-only input, or unusable physical input.
-* Key mode retains the produced character; neither mode guesses layout letters.
-*/
-function hotkeyChordFromKeydown(event, platform, recordBy = "code") {
-	const normalized = require__keyboard_event.normalizeKeyboardEvent(event, platform);
-	if (normalized.isComposing || require_parse.isModifierKey(require_constants.normalizeKeyName(event.key)) || event.key === "AltGraph") return null;
-	if (recordBy === "code" && (!/^[A-Za-z][A-Za-z0-9]*$/.test(event.code) || event.code === "Unidentified" || normalized.altGraph)) return null;
-	const parsed = require_parse.parseKeyboardEvent(event, platform);
-	if (recordBy === "code") {
-		const { key: _key, code: _code, ...modifiers } = parsed;
-		return require_parse.normalizeHotkeyFromParsed({
-			...modifiers,
-			code: event.code
-		}, platform);
-	}
-	return parsed.key ? require_parse.normalizeHotkeyFromParsed(parsed, platform) : null;
-}
-/**
-* Explains why a physical chord cannot be recorded before syntax/policy checks.
-* Logical mode deliberately accepts produced characters instead of requiring a code.
-*/
-function chordRejection(event, options) {
-	if (options.recordBy === "key") return void 0;
-	if (require__keyboard_event.normalizeKeyboardEvent(event, options.platform).altGraph) return {
-		reason: "alt-graph",
-		message: "AltGraph character entry cannot be recorded as a physical shortcut. Use key mode for characters."
-	};
-	if (!/^[A-Za-z][A-Za-z0-9]*$/.test(event.code) || event.code === "Unidentified") return {
-		reason: "missing-code",
-		message: "This event has no usable physical key code."
-	};
-}
-
-//#endregion
-exports.chordRejection = chordRejection;
-exports.hotkeyChordFromKeydown = hotkeyChordFromKeydown;
-//# sourceMappingURL=_recorder-chord.cjs.map

package/dist/_recorder-chord.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"_recorder-chord.cjs","names":["normalizeKeyboardEvent","isModifierKey","normalizeKeyName","parseKeyboardEvent","normalizeHotkeyFromParsed"],"sources":["../src/_recorder-chord.ts"],"sourcesContent":["import { normalizeKeyName } from './constants'\nimport { normalizeKeyboardEvent } from './_keyboard-event'\nimport {\n  isModifierKey,\n  normalizeHotkeyFromParsed,\n  parseKeyboardEvent,\n} from './parse'\nimport type {\n  RecorderKeyMode,\n  RecorderOptions,\n  RecorderRejection,\n} from './recorder-options'\nimport type { Hotkey } from './hotkey.types'\n\n/**\n * Converts a keydown to a replayable chord, preserving physical codes by default.\n * Returns null for composition, modifier-only input, or unusable physical input.\n * Key mode retains the produced character; neither mode guesses layout letters.\n */\nexport function hotkeyChordFromKeydown(\n  event: KeyboardEvent,\n  platform: 'mac' | 'windows' | 'linux',\n  recordBy: RecorderKeyMode = 'code',\n): Hotkey | null {\n  const normalized = normalizeKeyboardEvent(event, platform)\n  if (\n    normalized.isComposing ||\n    isModifierKey(normalizeKeyName(event.key)) ||\n    event.key === 'AltGraph'\n  )\n    return null\n  if (\n    recordBy === 'code' &&\n    (!/^[A-Za-z][A-Za-z0-9]*$/.test(event.code) ||\n      event.code === 'Unidentified' ||\n      normalized.altGraph)\n  )\n    return null\n  const parsed = parseKeyboardEvent(event, platform)\n  if (recordBy === 'code') {\n    // Remove logical identity rather than placing a physical code in the key field.\n    const { key: _key, code: _code, ...modifiers } = parsed\n    return normalizeHotkeyFromParsed(\n      { ...modifiers, code: event.code },\n      platform,\n    )\n  }\n  return parsed.key ? normalizeHotkeyFromParsed(parsed, platform) : null\n}\n\n/**\n * Explains why a physical chord cannot be recorded before syntax/policy checks.\n * Logical mode deliberately accepts produced characters instead of requiring a code.\n */\nexport function chordRejection(\n  event: KeyboardEvent,\n  options: RecorderOptions,\n): RecorderRejection | undefined {\n  if (options.recordBy === 'key') return undefined\n  // AltGr is character entry, often reported as synthetic Ctrl+Alt; macOS Option is handled separately.\n  if (normalizeKeyboardEvent(event, options.platform).altGraph)\n    return {\n      reason: 'alt-graph',\n      message:\n        'AltGraph character entry cannot be recorded as a physical shortcut. Use key mode for characters.',\n    }\n  if (\n    !/^[A-Za-z][A-Za-z0-9]*$/.test(event.code) ||\n    event.code === 'Unidentified'\n  )\n    return {\n      reason: 'missing-code',\n      message: 'This event has no usable physical key code.',\n    }\n  return undefined\n}\n"],"mappings":";;;;;;;;;;AAmBA,SAAgB,uBACd,OACA,UACA,WAA4B,QACb;CACf,MAAM,aAAaA,+CAAuB,OAAO,SAAS;AAC1D,KACE,WAAW,eACXC,4BAAcC,mCAAiB,MAAM,IAAI,CAAC,IAC1C,MAAM,QAAQ,WAEd,QAAO;AACT,KACE,aAAa,WACZ,CAAC,yBAAyB,KAAK,MAAM,KAAK,IACzC,MAAM,SAAS,kBACf,WAAW,UAEb,QAAO;CACT,MAAM,SAASC,iCAAmB,OAAO,SAAS;AAClD,KAAI,aAAa,QAAQ;EAEvB,MAAM,EAAE,KAAK,MAAM,MAAM,OAAO,GAAG,cAAc;AACjD,SAAOC,wCACL;GAAE,GAAG;GAAW,MAAM,MAAM;GAAM,EAClC,SACD;;AAEH,QAAO,OAAO,MAAMA,wCAA0B,QAAQ,SAAS,GAAG;;;;;;AAOpE,SAAgB,eACd,OACA,SAC+B;AAC/B,KAAI,QAAQ,aAAa,MAAO,QAAO;AAEvC,KAAIJ,+CAAuB,OAAO,QAAQ,SAAS,CAAC,SAClD,QAAO;EACL,QAAQ;EACR,SACE;EACH;AACH,KACE,CAAC,yBAAyB,KAAK,MAAM,KAAK,IAC1C,MAAM,SAAS,eAEf,QAAO;EACL,QAAQ;EACR,SAAS;EACV"}

package/dist/_recorder-chord.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_recorder-chord.js","names":[],"sources":["../src/_recorder-chord.ts"],"sourcesContent":["import { normalizeKeyName } from './constants'\nimport { normalizeKeyboardEvent } from './_keyboard-event'\nimport {\n  isModifierKey,\n  normalizeHotkeyFromParsed,\n  parseKeyboardEvent,\n} from './parse'\nimport type {\n  RecorderKeyMode,\n  RecorderOptions,\n  RecorderRejection,\n} from './recorder-options'\nimport type { Hotkey } from './hotkey.types'\n\n/**\n * Converts a keydown to a replayable chord, preserving physical codes by default.\n * Returns null for composition, modifier-only input, or unusable physical input.\n * Key mode retains the produced character; neither mode guesses layout letters.\n */\nexport function hotkeyChordFromKeydown(\n  event: KeyboardEvent,\n  platform: 'mac' | 'windows' | 'linux',\n  recordBy: RecorderKeyMode = 'code',\n): Hotkey | null {\n  const normalized = normalizeKeyboardEvent(event, platform)\n  if (\n    normalized.isComposing ||\n    isModifierKey(normalizeKeyName(event.key)) ||\n    event.key === 'AltGraph'\n  )\n    return null\n  if (\n    recordBy === 'code' &&\n    (!/^[A-Za-z][A-Za-z0-9]*$/.test(event.code) ||\n      event.code === 'Unidentified' ||\n      normalized.altGraph)\n  )\n    return null\n  const parsed = parseKeyboardEvent(event, platform)\n  if (recordBy === 'code') {\n    // Remove logical identity rather than placing a physical code in the key field.\n    const { key: _key, code: _code, ...modifiers } = parsed\n    return normalizeHotkeyFromParsed(\n      { ...modifiers, code: event.code },\n      platform,\n    )\n  }\n  return parsed.key ? normalizeHotkeyFromParsed(parsed, platform) : null\n}\n\n/**\n * Explains why a physical chord cannot be recorded before syntax/policy checks.\n * Logical mode deliberately accepts produced characters instead of requiring a code.\n */\nexport function chordRejection(\n  event: KeyboardEvent,\n  options: RecorderOptions,\n): RecorderRejection | undefined {\n  if (options.recordBy === 'key') return undefined\n  // AltGr is character entry, often reported as synthetic Ctrl+Alt; macOS Option is handled separately.\n  if (normalizeKeyboardEvent(event, options.platform).altGraph)\n    return {\n      reason: 'alt-graph',\n      message:\n        'AltGraph character entry cannot be recorded as a physical shortcut. Use key mode for characters.',\n    }\n  if (\n    !/^[A-Za-z][A-Za-z0-9]*$/.test(event.code) ||\n    event.code === 'Unidentified'\n  )\n    return {\n      reason: 'missing-code',\n      message: 'This event has no usable physical key code.',\n    }\n  return undefined\n}\n"],"mappings":";;;;;;;;;;AAmBA,SAAgB,uBACd,OACA,UACA,WAA4B,QACb;CACf,MAAM,aAAa,uBAAuB,OAAO,SAAS;AAC1D,KACE,WAAW,eACX,cAAc,iBAAiB,MAAM,IAAI,CAAC,IAC1C,MAAM,QAAQ,WAEd,QAAO;AACT,KACE,aAAa,WACZ,CAAC,yBAAyB,KAAK,MAAM,KAAK,IACzC,MAAM,SAAS,kBACf,WAAW,UAEb,QAAO;CACT,MAAM,SAAS,mBAAmB,OAAO,SAAS;AAClD,KAAI,aAAa,QAAQ;EAEvB,MAAM,EAAE,KAAK,MAAM,MAAM,OAAO,GAAG,cAAc;AACjD,SAAO,0BACL;GAAE,GAAG;GAAW,MAAM,MAAM;GAAM,EAClC,SACD;;AAEH,QAAO,OAAO,MAAM,0BAA0B,QAAQ,SAAS,GAAG;;;;;;AAOpE,SAAgB,eACd,OACA,SAC+B;AAC/B,KAAI,QAAQ,aAAa,MAAO,QAAO;AAEvC,KAAI,uBAAuB,OAAO,QAAQ,SAAS,CAAC,SAClD,QAAO;EACL,QAAQ;EACR,SACE;EACH;AACH,KACE,CAAC,yBAAyB,KAAK,MAAM,KAAK,IAC1C,MAAM,SAAS,eAEf,QAAO;EACL,QAAQ;EACR,SAAS;EACV"}

package/dist/_recording-guard.cjs

@@ -1,59 +0,0 @@
-const require_constants = require('./constants.cjs');
-
-//#region src/_recording-guard.ts
-const sessions = /* @__PURE__ */ new Set();
-const captured = /* @__PURE__ */ new WeakSet();
-const pending = /* @__PURE__ */ new Map();
-let listening = false;
-const identity = (event) => event.code || `key:${event.key}`;
-/** Consumes recorded key releases and removes guards for completed chords. */
-function release(event) {
-	if (pending.delete(identity(event))) captured.add(event);
-	if (require_constants.MODIFIER_KEYS.has(require_constants.normalizeKeyName(event.key))) {
-		for (const [id, key] of pending) if (!require_constants.MODIFIER_KEYS.has(key)) pending.delete(id);
-	}
-	cleanup();
-}
-/** Clears pending releases when focus loss prevents the browser from delivering them. */
-function blur() {
-	pending.clear();
-	cleanup();
-}
-/** Detaches shared listeners once neither active sessions nor pending releases need them. */
-function cleanup() {
-	if (listening && sessions.size === 0 && pending.size === 0) {
-		document.removeEventListener("keyup", release, true);
-		window.removeEventListener("blur", blur);
-		listening = false;
-	}
-}
-/** Pauses application shortcut dispatch and starts tracking releases for this recorder. */
-function beginRecording(owner) {
-	sessions.add(owner);
-	if (!listening && typeof document !== "undefined") {
-		document.addEventListener("keyup", release, true);
-		window.addEventListener("blur", blur);
-		listening = true;
-	}
-}
-/** Ends a session while retaining guards for keys still held after commit or cancellation. */
-function endRecording(owner) {
-	sessions.delete(owner);
-	cleanup();
-}
-/** Marks a consumed keydown and guards subsequent repeats and its release. */
-function captureRecordingEvent(event) {
-	captured.add(event);
-	pending.set(identity(event), require_constants.normalizeKeyName(event.key));
-}
-/** Whether managers should suppress callbacks for this recording session or captured chord. */
-function isRecordingEvent(event) {
-	return sessions.size > 0 || captured.has(event) || pending.has(identity(event));
-}
-
-//#endregion
-exports.beginRecording = beginRecording;
-exports.captureRecordingEvent = captureRecordingEvent;
-exports.endRecording = endRecording;
-exports.isRecordingEvent = isRecordingEvent;
-//# sourceMappingURL=_recording-guard.cjs.map

package/dist/_recording-guard.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"_recording-guard.cjs","names":["MODIFIER_KEYS","normalizeKeyName"],"sources":["../src/_recording-guard.ts"],"sourcesContent":["import { MODIFIER_KEYS, normalizeKeyName } from './constants'\n\n// Shared only by recorders and dispatchers. Does not own bindings or preferences.\n// Multiple recorder instances may be active; dispatch resumes after the last one ends.\nconst sessions = new Set<object>()\n// Remember consumed event objects through the remainder of their DOM dispatch.\nconst captured = new WeakSet<KeyboardEvent>()\n// Captured physical identities stay blocked through repeats and their eventual keyup.\nconst pending = new Map<string, string>()\nlet listening = false\n// Prefer the stable physical identity when modifier release changes event.key.\nconst identity = (event: KeyboardEvent) => event.code || `key:${event.key}`\n\n/** Consumes recorded key releases and removes guards for completed chords. */\nfunction release(event: KeyboardEvent): void {\n  if (pending.delete(identity(event))) captured.add(event)\n  // macOS can swallow the main key's keyup while Command is held.\n  // Releasing a modifier ends that chord, as in KeyStateTracker.\n  if (MODIFIER_KEYS.has(normalizeKeyName(event.key))) {\n    for (const [id, key] of pending) {\n      if (!MODIFIER_KEYS.has(key)) pending.delete(id)\n    }\n  }\n  cleanup()\n}\n/** Clears pending releases when focus loss prevents the browser from delivering them. */\nfunction blur(): void {\n  pending.clear()\n  cleanup()\n}\n/** Detaches shared listeners once neither active sessions nor pending releases need them. */\nfunction cleanup(): void {\n  if (listening && sessions.size === 0 && pending.size === 0) {\n    document.removeEventListener('keyup', release, true)\n    window.removeEventListener('blur', blur)\n    listening = false\n  }\n}\n/** Pauses application shortcut dispatch and starts tracking releases for this recorder. */\nexport function beginRecording(owner: object): void {\n  sessions.add(owner)\n  if (!listening && typeof document !== 'undefined') {\n    document.addEventListener('keyup', release, true)\n    window.addEventListener('blur', blur)\n    listening = true\n  }\n}\n/** Ends a session while retaining guards for keys still held after commit or cancellation. */\nexport function endRecording(owner: object): void {\n  sessions.delete(owner)\n  cleanup()\n}\n/** Marks a consumed keydown and guards subsequent repeats and its release. */\nexport function captureRecordingEvent(event: KeyboardEvent): void {\n  captured.add(event)\n  pending.set(identity(event), normalizeKeyName(event.key))\n}\n/** Whether managers should suppress callbacks for this recording session or captured chord. */\nexport function isRecordingEvent(event: KeyboardEvent): boolean {\n  return (\n    sessions.size > 0 || captured.has(event) || pending.has(identity(event))\n  )\n}\n"],"mappings":";;;AAIA,MAAM,2BAAW,IAAI,KAAa;AAElC,MAAM,2BAAW,IAAI,SAAwB;AAE7C,MAAM,0BAAU,IAAI,KAAqB;AACzC,IAAI,YAAY;AAEhB,MAAM,YAAY,UAAyB,MAAM,QAAQ,OAAO,MAAM;;AAGtE,SAAS,QAAQ,OAA4B;AAC3C,KAAI,QAAQ,OAAO,SAAS,MAAM,CAAC,CAAE,UAAS,IAAI,MAAM;AAGxD,KAAIA,gCAAc,IAAIC,mCAAiB,MAAM,IAAI,CAAC,EAChD;OAAK,MAAM,CAAC,IAAI,QAAQ,QACtB,KAAI,CAACD,gCAAc,IAAI,IAAI,CAAE,SAAQ,OAAO,GAAG;;AAGnD,UAAS;;;AAGX,SAAS,OAAa;AACpB,SAAQ,OAAO;AACf,UAAS;;;AAGX,SAAS,UAAgB;AACvB,KAAI,aAAa,SAAS,SAAS,KAAK,QAAQ,SAAS,GAAG;AAC1D,WAAS,oBAAoB,SAAS,SAAS,KAAK;AACpD,SAAO,oBAAoB,QAAQ,KAAK;AACxC,cAAY;;;;AAIhB,SAAgB,eAAe,OAAqB;AAClD,UAAS,IAAI,MAAM;AACnB,KAAI,CAAC,aAAa,OAAO,aAAa,aAAa;AACjD,WAAS,iBAAiB,SAAS,SAAS,KAAK;AACjD,SAAO,iBAAiB,QAAQ,KAAK;AACrC,cAAY;;;;AAIhB,SAAgB,aAAa,OAAqB;AAChD,UAAS,OAAO,MAAM;AACtB,UAAS;;;AAGX,SAAgB,sBAAsB,OAA4B;AAChE,UAAS,IAAI,MAAM;AACnB,SAAQ,IAAI,SAAS,MAAM,EAAEC,mCAAiB,MAAM,IAAI,CAAC;;;AAG3D,SAAgB,iBAAiB,OAA+B;AAC9D,QACE,SAAS,OAAO,KAAK,SAAS,IAAI,MAAM,IAAI,QAAQ,IAAI,SAAS,MAAM,CAAC"}

package/dist/_recording-guard.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_recording-guard.js","names":[],"sources":["../src/_recording-guard.ts"],"sourcesContent":["import { MODIFIER_KEYS, normalizeKeyName } from './constants'\n\n// Shared only by recorders and dispatchers. Does not own bindings or preferences.\n// Multiple recorder instances may be active; dispatch resumes after the last one ends.\nconst sessions = new Set<object>()\n// Remember consumed event objects through the remainder of their DOM dispatch.\nconst captured = new WeakSet<KeyboardEvent>()\n// Captured physical identities stay blocked through repeats and their eventual keyup.\nconst pending = new Map<string, string>()\nlet listening = false\n// Prefer the stable physical identity when modifier release changes event.key.\nconst identity = (event: KeyboardEvent) => event.code || `key:${event.key}`\n\n/** Consumes recorded key releases and removes guards for completed chords. */\nfunction release(event: KeyboardEvent): void {\n  if (pending.delete(identity(event))) captured.add(event)\n  // macOS can swallow the main key's keyup while Command is held.\n  // Releasing a modifier ends that chord, as in KeyStateTracker.\n  if (MODIFIER_KEYS.has(normalizeKeyName(event.key))) {\n    for (const [id, key] of pending) {\n      if (!MODIFIER_KEYS.has(key)) pending.delete(id)\n    }\n  }\n  cleanup()\n}\n/** Clears pending releases when focus loss prevents the browser from delivering them. */\nfunction blur(): void {\n  pending.clear()\n  cleanup()\n}\n/** Detaches shared listeners once neither active sessions nor pending releases need them. */\nfunction cleanup(): void {\n  if (listening && sessions.size === 0 && pending.size === 0) {\n    document.removeEventListener('keyup', release, true)\n    window.removeEventListener('blur', blur)\n    listening = false\n  }\n}\n/** Pauses application shortcut dispatch and starts tracking releases for this recorder. */\nexport function beginRecording(owner: object): void {\n  sessions.add(owner)\n  if (!listening && typeof document !== 'undefined') {\n    document.addEventListener('keyup', release, true)\n    window.addEventListener('blur', blur)\n    listening = true\n  }\n}\n/** Ends a session while retaining guards for keys still held after commit or cancellation. */\nexport function endRecording(owner: object): void {\n  sessions.delete(owner)\n  cleanup()\n}\n/** Marks a consumed keydown and guards subsequent repeats and its release. */\nexport function captureRecordingEvent(event: KeyboardEvent): void {\n  captured.add(event)\n  pending.set(identity(event), normalizeKeyName(event.key))\n}\n/** Whether managers should suppress callbacks for this recording session or captured chord. */\nexport function isRecordingEvent(event: KeyboardEvent): boolean {\n  return (\n    sessions.size > 0 || captured.has(event) || pending.has(identity(event))\n  )\n}\n"],"mappings":";;;AAIA,MAAM,2BAAW,IAAI,KAAa;AAElC,MAAM,2BAAW,IAAI,SAAwB;AAE7C,MAAM,0BAAU,IAAI,KAAqB;AACzC,IAAI,YAAY;AAEhB,MAAM,YAAY,UAAyB,MAAM,QAAQ,OAAO,MAAM;;AAGtE,SAAS,QAAQ,OAA4B;AAC3C,KAAI,QAAQ,OAAO,SAAS,MAAM,CAAC,CAAE,UAAS,IAAI,MAAM;AAGxD,KAAI,cAAc,IAAI,iBAAiB,MAAM,IAAI,CAAC,EAChD;OAAK,MAAM,CAAC,IAAI,QAAQ,QACtB,KAAI,CAAC,cAAc,IAAI,IAAI,CAAE,SAAQ,OAAO,GAAG;;AAGnD,UAAS;;;AAGX,SAAS,OAAa;AACpB,SAAQ,OAAO;AACf,UAAS;;;AAGX,SAAS,UAAgB;AACvB,KAAI,aAAa,SAAS,SAAS,KAAK,QAAQ,SAAS,GAAG;AAC1D,WAAS,oBAAoB,SAAS,SAAS,KAAK;AACpD,SAAO,oBAAoB,QAAQ,KAAK;AACxC,cAAY;;;;AAIhB,SAAgB,eAAe,OAAqB;AAClD,UAAS,IAAI,MAAM;AACnB,KAAI,CAAC,aAAa,OAAO,aAAa,aAAa;AACjD,WAAS,iBAAiB,SAAS,SAAS,KAAK;AACjD,SAAO,iBAAiB,QAAQ,KAAK;AACrC,cAAY;;;;AAIhB,SAAgB,aAAa,OAAqB;AAChD,UAAS,OAAO,MAAM;AACtB,UAAS;;;AAGX,SAAgB,sBAAsB,OAA4B;AAChE,UAAS,IAAI,MAAM;AACnB,SAAQ,IAAI,SAAS,MAAM,EAAE,iBAAiB,MAAM,IAAI,CAAC;;;AAG3D,SAAgB,iBAAiB,OAA+B;AAC9D,QACE,SAAS,OAAO,KAAK,SAAS,IAAI,MAAM,IAAI,QAAQ,IAAI,SAAS,MAAM,CAAC"}

package/dist/_registration.cjs

@@ -1,54 +0,0 @@
-
-//#region src/_registration.ts
-/**
-* Default options for hotkey/sequence registration.
-* Omitted: platform, target (resolved at registration), requireReset (HotkeyManager only).
-*/
-const defaultHotkeyOptions = {
-	preventDefault: true,
-	stopPropagation: true,
-	eventType: "keydown",
-	enabled: true,
-	ignoreInputs: true,
-	conflictBehavior: "warn"
-};
-/**
-* Computes the default ignoreInputs value based on the hotkey.
-* Ctrl/Meta shortcuts and Escape fire in inputs; single keys and Shift/Alt combos are ignored.
-*/
-function getDefaultIgnoreInputs(parsedHotkey) {
-	if (parsedHotkey.ctrl || parsedHotkey.meta) return false;
-	if (parsedHotkey.key === "Escape" || parsedHotkey.code === "Escape") return false;
-	return true;
-}
-/**
-* Handles conflicts between registrations based on conflict behavior.
-*
-* @param conflictingId - The ID of the conflicting registration
-* @param keyDisplay - Display string for the conflicting key/sequence (for error messages)
-* @param conflictBehavior - How to handle the conflict
-* @param unregister - Function to unregister by ID
-*/
-function handleConflict(conflictingId, keyDisplay, conflictBehavior, unregister) {
-	if (conflictBehavior === "allow") return;
-	if (conflictBehavior === "warn") {
-		console.warn(`'${keyDisplay}' is already registered. Multiple handlers will be triggered. Use conflictBehavior: 'replace' to replace the existing handler, or conflictBehavior: 'allow' to suppress this warning.`);
-		return;
-	}
-	if (conflictBehavior === "error") throw new Error(`'${keyDisplay}' is already registered. Use conflictBehavior: 'replace' to replace the existing handler, or conflictBehavior: 'allow' to allow multiple registrations.`);
-	unregister(conflictingId);
-}
-/** Compare updates without publishing unchanged options, including fresh metadata objects. */
-function optionsEqual(left, right) {
-	const a = left;
-	const b = right;
-	const keys = Object.keys(a);
-	return keys.length === Object.keys(b).length && keys.every((key) => key === "meta" && a[key] && b[key] ? optionsEqual(a[key], b[key]) : Object.is(a[key], b[key]));
-}
-
-//#endregion
-exports.defaultHotkeyOptions = defaultHotkeyOptions;
-exports.getDefaultIgnoreInputs = getDefaultIgnoreInputs;
-exports.handleConflict = handleConflict;
-exports.optionsEqual = optionsEqual;
-//# sourceMappingURL=_registration.cjs.map

package/dist/_registration.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"_registration.cjs","names":[],"sources":["../src/_registration.ts"],"sourcesContent":["import type { ConflictBehavior, ParsedHotkey } from './hotkey.types'\n\n/**\n * Default options for hotkey/sequence registration.\n * Omitted: platform, target (resolved at registration), requireReset (HotkeyManager only).\n */\nexport const defaultHotkeyOptions = {\n  preventDefault: true,\n  stopPropagation: true,\n  eventType: 'keydown' as const,\n  enabled: true,\n  ignoreInputs: true,\n  conflictBehavior: 'warn' as ConflictBehavior,\n}\n\n/**\n * Computes the default ignoreInputs value based on the hotkey.\n * Ctrl/Meta shortcuts and Escape fire in inputs; single keys and Shift/Alt combos are ignored.\n */\nexport function getDefaultIgnoreInputs(parsedHotkey: ParsedHotkey): boolean {\n  if (parsedHotkey.ctrl || parsedHotkey.meta) return false // Mod+S, Ctrl+C, etc.\n  if (parsedHotkey.key === 'Escape' || parsedHotkey.code === 'Escape')\n    return false // Close modal, etc.\n  return true // Single keys, Shift+key, Alt+key\n}\n\n/**\n * Handles conflicts between registrations based on conflict behavior.\n *\n * @param conflictingId - The ID of the conflicting registration\n * @param keyDisplay - Display string for the conflicting key/sequence (for error messages)\n * @param conflictBehavior - How to handle the conflict\n * @param unregister - Function to unregister by ID\n */\nexport function handleConflict(\n  conflictingId: string,\n  keyDisplay: string,\n  conflictBehavior: ConflictBehavior,\n  unregister: (id: string) => void,\n): void {\n  if (conflictBehavior === 'allow') {\n    return\n  }\n\n  if (conflictBehavior === 'warn') {\n    console.warn(\n      `'${keyDisplay}' is already registered. Multiple handlers will be triggered. ` +\n        `Use conflictBehavior: 'replace' to replace the existing handler, ` +\n        `or conflictBehavior: 'allow' to suppress this warning.`,\n    )\n    return\n  }\n\n  if (conflictBehavior === 'error') {\n    throw new Error(\n      `'${keyDisplay}' is already registered. ` +\n        `Use conflictBehavior: 'replace' to replace the existing handler, ` +\n        `or conflictBehavior: 'allow' to allow multiple registrations.`,\n    )\n  }\n\n  // At this point, conflictBehavior must be 'replace'\n  unregister(conflictingId)\n}\n\n/** Compare updates without publishing unchanged options, including fresh metadata objects. */\nexport function optionsEqual(left: object, right: object): boolean {\n  const a = left as Record<string, unknown>\n  const b = right as Record<string, unknown>\n  const keys = Object.keys(a)\n  return (\n    keys.length === Object.keys(b).length &&\n    keys.every((key) =>\n      key === 'meta' && a[key] && b[key]\n        ? optionsEqual(a[key] as object, b[key] as object)\n        : Object.is(a[key], b[key]),\n    )\n  )\n}\n"],"mappings":";;;;;;AAMA,MAAa,uBAAuB;CAClC,gBAAgB;CAChB,iBAAiB;CACjB,WAAW;CACX,SAAS;CACT,cAAc;CACd,kBAAkB;CACnB;;;;;AAMD,SAAgB,uBAAuB,cAAqC;AAC1E,KAAI,aAAa,QAAQ,aAAa,KAAM,QAAO;AACnD,KAAI,aAAa,QAAQ,YAAY,aAAa,SAAS,SACzD,QAAO;AACT,QAAO;;;;;;;;;;AAWT,SAAgB,eACd,eACA,YACA,kBACA,YACM;AACN,KAAI,qBAAqB,QACvB;AAGF,KAAI,qBAAqB,QAAQ;AAC/B,UAAQ,KACN,IAAI,WAAW,uLAGhB;AACD;;AAGF,KAAI,qBAAqB,QACvB,OAAM,IAAI,MACR,IAAI,WAAW,yJAGhB;AAIH,YAAW,cAAc;;;AAI3B,SAAgB,aAAa,MAAc,OAAwB;CACjE,MAAM,IAAI;CACV,MAAM,IAAI;CACV,MAAM,OAAO,OAAO,KAAK,EAAE;AAC3B,QACE,KAAK,WAAW,OAAO,KAAK,EAAE,CAAC,UAC/B,KAAK,OAAO,QACV,QAAQ,UAAU,EAAE,QAAQ,EAAE,OAC1B,aAAa,EAAE,MAAgB,EAAE,KAAe,GAChD,OAAO,GAAG,EAAE,MAAM,EAAE,KAAK,CAC9B"}

package/dist/_registration.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_registration.js","names":[],"sources":["../src/_registration.ts"],"sourcesContent":["import type { ConflictBehavior, ParsedHotkey } from './hotkey.types'\n\n/**\n * Default options for hotkey/sequence registration.\n * Omitted: platform, target (resolved at registration), requireReset (HotkeyManager only).\n */\nexport const defaultHotkeyOptions = {\n  preventDefault: true,\n  stopPropagation: true,\n  eventType: 'keydown' as const,\n  enabled: true,\n  ignoreInputs: true,\n  conflictBehavior: 'warn' as ConflictBehavior,\n}\n\n/**\n * Computes the default ignoreInputs value based on the hotkey.\n * Ctrl/Meta shortcuts and Escape fire in inputs; single keys and Shift/Alt combos are ignored.\n */\nexport function getDefaultIgnoreInputs(parsedHotkey: ParsedHotkey): boolean {\n  if (parsedHotkey.ctrl || parsedHotkey.meta) return false // Mod+S, Ctrl+C, etc.\n  if (parsedHotkey.key === 'Escape' || parsedHotkey.code === 'Escape')\n    return false // Close modal, etc.\n  return true // Single keys, Shift+key, Alt+key\n}\n\n/**\n * Handles conflicts between registrations based on conflict behavior.\n *\n * @param conflictingId - The ID of the conflicting registration\n * @param keyDisplay - Display string for the conflicting key/sequence (for error messages)\n * @param conflictBehavior - How to handle the conflict\n * @param unregister - Function to unregister by ID\n */\nexport function handleConflict(\n  conflictingId: string,\n  keyDisplay: string,\n  conflictBehavior: ConflictBehavior,\n  unregister: (id: string) => void,\n): void {\n  if (conflictBehavior === 'allow') {\n    return\n  }\n\n  if (conflictBehavior === 'warn') {\n    console.warn(\n      `'${keyDisplay}' is already registered. Multiple handlers will be triggered. ` +\n        `Use conflictBehavior: 'replace' to replace the existing handler, ` +\n        `or conflictBehavior: 'allow' to suppress this warning.`,\n    )\n    return\n  }\n\n  if (conflictBehavior === 'error') {\n    throw new Error(\n      `'${keyDisplay}' is already registered. ` +\n        `Use conflictBehavior: 'replace' to replace the existing handler, ` +\n        `or conflictBehavior: 'allow' to allow multiple registrations.`,\n    )\n  }\n\n  // At this point, conflictBehavior must be 'replace'\n  unregister(conflictingId)\n}\n\n/** Compare updates without publishing unchanged options, including fresh metadata objects. */\nexport function optionsEqual(left: object, right: object): boolean {\n  const a = left as Record<string, unknown>\n  const b = right as Record<string, unknown>\n  const keys = Object.keys(a)\n  return (\n    keys.length === Object.keys(b).length &&\n    keys.every((key) =>\n      key === 'meta' && a[key] && b[key]\n        ? optionsEqual(a[key] as object, b[key] as object)\n        : Object.is(a[key], b[key]),\n    )\n  )\n}\n"],"mappings":";;;;;AAMA,MAAa,uBAAuB;CAClC,gBAAgB;CAChB,iBAAiB;CACjB,WAAW;CACX,SAAS;CACT,cAAc;CACd,kBAAkB;CACnB;;;;;AAMD,SAAgB,uBAAuB,cAAqC;AAC1E,KAAI,aAAa,QAAQ,aAAa,KAAM,QAAO;AACnD,KAAI,aAAa,QAAQ,YAAY,aAAa,SAAS,SACzD,QAAO;AACT,QAAO;;;;;;;;;;AAWT,SAAgB,eACd,eACA,YACA,kBACA,YACM;AACN,KAAI,qBAAqB,QACvB;AAGF,KAAI,qBAAqB,QAAQ;AAC/B,UAAQ,KACN,IAAI,WAAW,uLAGhB;AACD;;AAGF,KAAI,qBAAqB,QACvB,OAAM,IAAI,MACR,IAAI,WAAW,yJAGhB;AAIH,YAAW,cAAc;;;AAI3B,SAAgB,aAAa,MAAc,OAAwB;CACjE,MAAM,IAAI;CACV,MAAM,IAAI;CACV,MAAM,OAAO,OAAO,KAAK,EAAE;AAC3B,QACE,KAAK,WAAW,OAAO,KAAK,EAAE,CAAC,UAC/B,KAAK,OAAO,QACV,QAAQ,UAAU,EAAE,QAAQ,EAAE,OAC1B,aAAa,EAAE,MAAgB,EAAE,KAAe,GAChD,OAAO,GAAG,EAAE,MAAM,EAAE,KAAK,CAC9B"}

package/dist/conflicts.cjs

@@ -1,55 +0,0 @@
-const require_platform = require('./platform.cjs');
-const require__keyboard_event = require('./_keyboard-event.cjs');
-const require_parse = require('./parse.cjs');
-const require_match = require('./match.cjs');
-const require_hotkey_manager = require('./hotkey-manager.cjs');
-const require_sequence_manager = require('./sequence-manager.cjs');
-
-//#region src/conflicts.ts
-/** Whether two targets share a document and one contains the other (or is its window). */
-function targetsOverlap(a, b) {
-	if (a === b) return true;
-	const documentOf = (target) => {
-		if ("document" in target) return target.document;
-		if (target.nodeType === 9) return target;
-		return target.ownerDocument;
-	};
-	if (documentOf(a) !== documentOf(b)) return false;
-	if (!("contains" in a) || !("contains" in b)) return true;
-	return a.contains(b) || b.contains(a);
-}
-/**
-* Find equivalent bindings and sequence-prefix conflicts in the live registry.
-* With source events, also checks observed logical/physical overlap. Does not
-* discover unmounted handlers, external listeners, or other keyboard layouts.
-*/
-function findHotkeyConflicts(candidate, options = {}) {
-	const steps = Array.isArray(candidate) ? candidate : [candidate];
-	if (steps.length === 0) return [];
-	const platform = options.platform ?? require_platform.detectPlatform();
-	const parsed = steps.map((step) => require_parse.parseRegisterableHotkey(step, platform));
-	const target = options.target ?? (typeof document === "undefined" ? void 0 : document);
-	const conflicts = [];
-	const matches = (registration, bindings) => {
-		if (!options.includeDisabled && registration.options.enabled === false || (registration.options.eventType ?? "keydown") !== (options.eventType ?? "keydown") || options.excludeIds?.includes(registration.id) || options.exclude?.(registration) || options.scope !== "all" && target && !targetsOverlap(target, registration.target)) return false;
-		return parsed.slice(0, Math.min(parsed.length, bindings.length)).every((a, index) => {
-			const b = require_parse.parseRegisterableHotkey(bindings[index], registration.options.platform);
-			const same = a.ctrl === b.ctrl && a.alt === b.alt && a.shift === b.shift && a.meta === b.meta && (a.code !== void 0 || b.code !== void 0 ? a.code === b.code : require__keyboard_event.keysEqual(a.key, b.key));
-			const event = options.events?.[index];
-			return same || event !== void 0 && require_match.matchesKeyboardEvent(event, a, platform) && require_match.matchesKeyboardEvent(event, b, registration.options.platform);
-		});
-	};
-	for (const registration of require_hotkey_manager.getHotkeyManager().registrations.state.values()) if (matches(registration, [registration.hotkey])) conflicts.push({
-		type: "hotkey",
-		registration: require_hotkey_manager.toHotkeyRegistrationView(registration)
-	});
-	for (const registration of require_sequence_manager.getSequenceManager().registrations.state.values()) if (matches(registration, registration.sequence)) conflicts.push({
-		type: "sequence",
-		registration
-	});
-	return conflicts;
-}
-
-//#endregion
-exports.findHotkeyConflicts = findHotkeyConflicts;
-//# sourceMappingURL=conflicts.cjs.map

package/dist/conflicts.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"conflicts.cjs","names":["detectPlatform","parseRegisterableHotkey","keysEqual","matchesKeyboardEvent","getHotkeyManager","toHotkeyRegistrationView","getSequenceManager"],"sources":["../src/conflicts.ts"],"sourcesContent":["import { detectPlatform } from './platform'\nimport { parseRegisterableHotkey } from './parse'\nimport { keysEqual } from './_keyboard-event'\nimport { matchesKeyboardEvent } from './match'\nimport { getHotkeyManager, toHotkeyRegistrationView } from './hotkey-manager'\nimport { getSequenceManager } from './sequence-manager'\nimport type { HotkeyRegistrationView } from './hotkey-manager'\nimport type { SequenceRegistrationView } from './sequence-manager'\nimport type { RegisterableHotkey } from './hotkey.types'\n\nexport type HotkeyConflict =\n  | { type: 'hotkey'; registration: HotkeyRegistrationView }\n  | { type: 'sequence'; registration: SequenceRegistrationView }\n\nexport interface HotkeyConflictOptions {\n  /** Intended registration target. Defaults to document; disjoint targets are excluded. */\n  target?: HTMLElement | Document | Window\n  /** Check all targets instead of overlapping targets. Default: overlapping. */\n  scope?: 'overlapping' | 'all'\n  /** Intended event type. Default: keydown. */\n  eventType?: 'keydown' | 'keyup'\n  /** Include disabled registrations. Default: false. */\n  includeDisabled?: boolean\n  /** IDs of registrations being edited. */\n  excludeIds?: ReadonlyArray<string>\n  /** Additional app-specific exclusions, such as all instances of one action. */\n  exclude?: (\n    registration: HotkeyRegistrationView | SequenceRegistrationView,\n  ) => boolean\n  /** Platform used to resolve Mod in the candidate. Registrations retain their own platform. */\n  platform?: 'mac' | 'windows' | 'linux'\n  /** Source events allow detecting physical/logical overlap on the recorded layout. */\n  events?: ReadonlyArray<KeyboardEvent>\n}\n\n/** Whether two targets share a document and one contains the other (or is its window). */\nfunction targetsOverlap(\n  a: HTMLElement | Document | Window,\n  b: HTMLElement | Document | Window,\n): boolean {\n  if (a === b) return true\n  // Resolve the owning document without relying on cross-frame instanceof checks.\n  const documentOf = (target: typeof a): Document | null => {\n    if ('document' in target) return target.document\n    if (target.nodeType === 9) return target as Document\n    return target.ownerDocument\n  }\n  if (documentOf(a) !== documentOf(b)) return false\n  if (!('contains' in a) || !('contains' in b)) return true\n  return a.contains(b as Node) || b.contains(a as Node)\n}\n\n/**\n * Find equivalent bindings and sequence-prefix conflicts in the live registry.\n * With source events, also checks observed logical/physical overlap. Does not\n * discover unmounted handlers, external listeners, or other keyboard layouts.\n */\nexport function findHotkeyConflicts(\n  candidate: RegisterableHotkey | ReadonlyArray<RegisterableHotkey>,\n  options: HotkeyConflictOptions = {},\n): Array<HotkeyConflict> {\n  const steps: ReadonlyArray<RegisterableHotkey> = Array.isArray(candidate)\n    ? candidate\n    : [candidate as RegisterableHotkey]\n  if (steps.length === 0) return []\n  const platform = options.platform ?? detectPlatform()\n  const parsed = steps.map((step) => parseRegisterableHotkey(step, platform))\n  const target =\n    options.target ?? (typeof document === 'undefined' ? undefined : document)\n  const conflicts: Array<HotkeyConflict> = []\n  // Apply scope policy before comparing equivalent bindings or observed event overlap.\n  const matches = (\n    registration: HotkeyRegistrationView | SequenceRegistrationView,\n    bindings: ReadonlyArray<RegisterableHotkey>,\n  ) => {\n    if (\n      (!options.includeDisabled && registration.options.enabled === false) ||\n      (registration.options.eventType ?? 'keydown') !==\n        (options.eventType ?? 'keydown') ||\n      options.excludeIds?.includes(registration.id) ||\n      options.exclude?.(registration) ||\n      (options.scope !== 'all' &&\n        target &&\n        !targetsOverlap(target, registration.target))\n    )\n      return false\n    // Compare only the common prefix: a shorter sequence can collide with a longer one.\n    return parsed\n      .slice(0, Math.min(parsed.length, bindings.length))\n      .every((a, index) => {\n        const b = parseRegisterableHotkey(\n          bindings[index]!,\n          registration.options.platform,\n        )\n        const same =\n          a.ctrl === b.ctrl &&\n          a.alt === b.alt &&\n          a.shift === b.shift &&\n          a.meta === b.meta &&\n          (a.code !== undefined || b.code !== undefined\n            ? a.code === b.code\n            : keysEqual(a.key, b.key))\n        // A source event can establish code/key overlap without guessing its layout.\n        const event = options.events?.[index]\n        return (\n          same ||\n          (event !== undefined &&\n            matchesKeyboardEvent(event, a, platform) &&\n            matchesKeyboardEvent(event, b, registration.options.platform))\n        )\n      })\n  }\n  for (const registration of getHotkeyManager().registrations.state.values()) {\n    if (matches(registration, [registration.hotkey]))\n      conflicts.push({\n        type: 'hotkey',\n        registration: toHotkeyRegistrationView(registration),\n      })\n  }\n  for (const registration of getSequenceManager().registrations.state.values()) {\n    if (matches(registration, registration.sequence))\n      conflicts.push({ type: 'sequence', registration })\n  }\n  return conflicts\n}\n"],"mappings":";;;;;;;;;AAoCA,SAAS,eACP,GACA,GACS;AACT,KAAI,MAAM,EAAG,QAAO;CAEpB,MAAM,cAAc,WAAsC;AACxD,MAAI,cAAc,OAAQ,QAAO,OAAO;AACxC,MAAI,OAAO,aAAa,EAAG,QAAO;AAClC,SAAO,OAAO;;AAEhB,KAAI,WAAW,EAAE,KAAK,WAAW,EAAE,CAAE,QAAO;AAC5C,KAAI,EAAE,cAAc,MAAM,EAAE,cAAc,GAAI,QAAO;AACrD,QAAO,EAAE,SAAS,EAAU,IAAI,EAAE,SAAS,EAAU;;;;;;;AAQvD,SAAgB,oBACd,WACA,UAAiC,EAAE,EACZ;CACvB,MAAM,QAA2C,MAAM,QAAQ,UAAU,GACrE,YACA,CAAC,UAAgC;AACrC,KAAI,MAAM,WAAW,EAAG,QAAO,EAAE;CACjC,MAAM,WAAW,QAAQ,YAAYA,iCAAgB;CACrD,MAAM,SAAS,MAAM,KAAK,SAASC,sCAAwB,MAAM,SAAS,CAAC;CAC3E,MAAM,SACJ,QAAQ,WAAW,OAAO,aAAa,cAAc,SAAY;CACnE,MAAM,YAAmC,EAAE;CAE3C,MAAM,WACJ,cACA,aACG;AACH,MACG,CAAC,QAAQ,mBAAmB,aAAa,QAAQ,YAAY,UAC7D,aAAa,QAAQ,aAAa,gBAChC,QAAQ,aAAa,cACxB,QAAQ,YAAY,SAAS,aAAa,GAAG,IAC7C,QAAQ,UAAU,aAAa,IAC9B,QAAQ,UAAU,SACjB,UACA,CAAC,eAAe,QAAQ,aAAa,OAAO,CAE9C,QAAO;AAET,SAAO,OACJ,MAAM,GAAG,KAAK,IAAI,OAAO,QAAQ,SAAS,OAAO,CAAC,CAClD,OAAO,GAAG,UAAU;GACnB,MAAM,IAAIA,sCACR,SAAS,QACT,aAAa,QAAQ,SACtB;GACD,MAAM,OACJ,EAAE,SAAS,EAAE,QACb,EAAE,QAAQ,EAAE,OACZ,EAAE,UAAU,EAAE,SACd,EAAE,SAAS,EAAE,SACZ,EAAE,SAAS,UAAa,EAAE,SAAS,SAChC,EAAE,SAAS,EAAE,OACbC,kCAAU,EAAE,KAAK,EAAE,IAAI;GAE7B,MAAM,QAAQ,QAAQ,SAAS;AAC/B,UACE,QACC,UAAU,UACTC,mCAAqB,OAAO,GAAG,SAAS,IACxCA,mCAAqB,OAAO,GAAG,aAAa,QAAQ,SAAS;IAEjE;;AAEN,MAAK,MAAM,gBAAgBC,yCAAkB,CAAC,cAAc,MAAM,QAAQ,CACxE,KAAI,QAAQ,cAAc,CAAC,aAAa,OAAO,CAAC,CAC9C,WAAU,KAAK;EACb,MAAM;EACN,cAAcC,gDAAyB,aAAa;EACrD,CAAC;AAEN,MAAK,MAAM,gBAAgBC,6CAAoB,CAAC,cAAc,MAAM,QAAQ,CAC1E,KAAI,QAAQ,cAAc,aAAa,SAAS,CAC9C,WAAU,KAAK;EAAE,MAAM;EAAY;EAAc,CAAC;AAEtD,QAAO"}

package/dist/conflicts.d.cts

@@ -1,39 +0,0 @@
-import { RegisterableHotkey } from "./hotkey.types.cjs";
-import { HotkeyRegistrationView } from "./hotkey-manager.cjs";
-import { SequenceRegistrationView } from "./sequence-manager.cjs";
-
-//#region src/conflicts.d.ts
-type HotkeyConflict = {
-  type: 'hotkey';
-  registration: HotkeyRegistrationView;
-} | {
-  type: 'sequence';
-  registration: SequenceRegistrationView;
-};
-interface HotkeyConflictOptions {
-  /** Intended registration target. Defaults to document; disjoint targets are excluded. */
-  target?: HTMLElement | Document | Window;
-  /** Check all targets instead of overlapping targets. Default: overlapping. */
-  scope?: 'overlapping' | 'all';
-  /** Intended event type. Default: keydown. */
-  eventType?: 'keydown' | 'keyup';
-  /** Include disabled registrations. Default: false. */
-  includeDisabled?: boolean;
-  /** IDs of registrations being edited. */
-  excludeIds?: ReadonlyArray<string>;
-  /** Additional app-specific exclusions, such as all instances of one action. */
-  exclude?: (registration: HotkeyRegistrationView | SequenceRegistrationView) => boolean;
-  /** Platform used to resolve Mod in the candidate. Registrations retain their own platform. */
-  platform?: 'mac' | 'windows' | 'linux';
-  /** Source events allow detecting physical/logical overlap on the recorded layout. */
-  events?: ReadonlyArray<KeyboardEvent>;
-}
-/**
- * Find equivalent bindings and sequence-prefix conflicts in the live registry.
- * With source events, also checks observed logical/physical overlap. Does not
- * discover unmounted handlers, external listeners, or other keyboard layouts.
- */
-declare function findHotkeyConflicts(candidate: RegisterableHotkey | ReadonlyArray<RegisterableHotkey>, options?: HotkeyConflictOptions): Array<HotkeyConflict>;
-//#endregion
-export { HotkeyConflict, HotkeyConflictOptions, findHotkeyConflicts };
-//# sourceMappingURL=conflicts.d.cts.map

package/dist/conflicts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"conflicts.js","names":[],"sources":["../src/conflicts.ts"],"sourcesContent":["import { detectPlatform } from './platform'\nimport { parseRegisterableHotkey } from './parse'\nimport { keysEqual } from './_keyboard-event'\nimport { matchesKeyboardEvent } from './match'\nimport { getHotkeyManager, toHotkeyRegistrationView } from './hotkey-manager'\nimport { getSequenceManager } from './sequence-manager'\nimport type { HotkeyRegistrationView } from './hotkey-manager'\nimport type { SequenceRegistrationView } from './sequence-manager'\nimport type { RegisterableHotkey } from './hotkey.types'\n\nexport type HotkeyConflict =\n  | { type: 'hotkey'; registration: HotkeyRegistrationView }\n  | { type: 'sequence'; registration: SequenceRegistrationView }\n\nexport interface HotkeyConflictOptions {\n  /** Intended registration target. Defaults to document; disjoint targets are excluded. */\n  target?: HTMLElement | Document | Window\n  /** Check all targets instead of overlapping targets. Default: overlapping. */\n  scope?: 'overlapping' | 'all'\n  /** Intended event type. Default: keydown. */\n  eventType?: 'keydown' | 'keyup'\n  /** Include disabled registrations. Default: false. */\n  includeDisabled?: boolean\n  /** IDs of registrations being edited. */\n  excludeIds?: ReadonlyArray<string>\n  /** Additional app-specific exclusions, such as all instances of one action. */\n  exclude?: (\n    registration: HotkeyRegistrationView | SequenceRegistrationView,\n  ) => boolean\n  /** Platform used to resolve Mod in the candidate. Registrations retain their own platform. */\n  platform?: 'mac' | 'windows' | 'linux'\n  /** Source events allow detecting physical/logical overlap on the recorded layout. */\n  events?: ReadonlyArray<KeyboardEvent>\n}\n\n/** Whether two targets share a document and one contains the other (or is its window). */\nfunction targetsOverlap(\n  a: HTMLElement | Document | Window,\n  b: HTMLElement | Document | Window,\n): boolean {\n  if (a === b) return true\n  // Resolve the owning document without relying on cross-frame instanceof checks.\n  const documentOf = (target: typeof a): Document | null => {\n    if ('document' in target) return target.document\n    if (target.nodeType === 9) return target as Document\n    return target.ownerDocument\n  }\n  if (documentOf(a) !== documentOf(b)) return false\n  if (!('contains' in a) || !('contains' in b)) return true\n  return a.contains(b as Node) || b.contains(a as Node)\n}\n\n/**\n * Find equivalent bindings and sequence-prefix conflicts in the live registry.\n * With source events, also checks observed logical/physical overlap. Does not\n * discover unmounted handlers, external listeners, or other keyboard layouts.\n */\nexport function findHotkeyConflicts(\n  candidate: RegisterableHotkey | ReadonlyArray<RegisterableHotkey>,\n  options: HotkeyConflictOptions = {},\n): Array<HotkeyConflict> {\n  const steps: ReadonlyArray<RegisterableHotkey> = Array.isArray(candidate)\n    ? candidate\n    : [candidate as RegisterableHotkey]\n  if (steps.length === 0) return []\n  const platform = options.platform ?? detectPlatform()\n  const parsed = steps.map((step) => parseRegisterableHotkey(step, platform))\n  const target =\n    options.target ?? (typeof document === 'undefined' ? undefined : document)\n  const conflicts: Array<HotkeyConflict> = []\n  // Apply scope policy before comparing equivalent bindings or observed event overlap.\n  const matches = (\n    registration: HotkeyRegistrationView | SequenceRegistrationView,\n    bindings: ReadonlyArray<RegisterableHotkey>,\n  ) => {\n    if (\n      (!options.includeDisabled && registration.options.enabled === false) ||\n      (registration.options.eventType ?? 'keydown') !==\n        (options.eventType ?? 'keydown') ||\n      options.excludeIds?.includes(registration.id) ||\n      options.exclude?.(registration) ||\n      (options.scope !== 'all' &&\n        target &&\n        !targetsOverlap(target, registration.target))\n    )\n      return false\n    // Compare only the common prefix: a shorter sequence can collide with a longer one.\n    return parsed\n      .slice(0, Math.min(parsed.length, bindings.length))\n      .every((a, index) => {\n        const b = parseRegisterableHotkey(\n          bindings[index]!,\n          registration.options.platform,\n        )\n        const same =\n          a.ctrl === b.ctrl &&\n          a.alt === b.alt &&\n          a.shift === b.shift &&\n          a.meta === b.meta &&\n          (a.code !== undefined || b.code !== undefined\n            ? a.code === b.code\n            : keysEqual(a.key, b.key))\n        // A source event can establish code/key overlap without guessing its layout.\n        const event = options.events?.[index]\n        return (\n          same ||\n          (event !== undefined &&\n            matchesKeyboardEvent(event, a, platform) &&\n            matchesKeyboardEvent(event, b, registration.options.platform))\n        )\n      })\n  }\n  for (const registration of getHotkeyManager().registrations.state.values()) {\n    if (matches(registration, [registration.hotkey]))\n      conflicts.push({\n        type: 'hotkey',\n        registration: toHotkeyRegistrationView(registration),\n      })\n  }\n  for (const registration of getSequenceManager().registrations.state.values()) {\n    if (matches(registration, registration.sequence))\n      conflicts.push({ type: 'sequence', registration })\n  }\n  return conflicts\n}\n"],"mappings":";;;;;;;;;AAoCA,SAAS,eACP,GACA,GACS;AACT,KAAI,MAAM,EAAG,QAAO;CAEpB,MAAM,cAAc,WAAsC;AACxD,MAAI,cAAc,OAAQ,QAAO,OAAO;AACxC,MAAI,OAAO,aAAa,EAAG,QAAO;AAClC,SAAO,OAAO;;AAEhB,KAAI,WAAW,EAAE,KAAK,WAAW,EAAE,CAAE,QAAO;AAC5C,KAAI,EAAE,cAAc,MAAM,EAAE,cAAc,GAAI,QAAO;AACrD,QAAO,EAAE,SAAS,EAAU,IAAI,EAAE,SAAS,EAAU;;;;;;;AAQvD,SAAgB,oBACd,WACA,UAAiC,EAAE,EACZ;CACvB,MAAM,QAA2C,MAAM,QAAQ,UAAU,GACrE,YACA,CAAC,UAAgC;AACrC,KAAI,MAAM,WAAW,EAAG,QAAO,EAAE;CACjC,MAAM,WAAW,QAAQ,YAAY,gBAAgB;CACrD,MAAM,SAAS,MAAM,KAAK,SAAS,wBAAwB,MAAM,SAAS,CAAC;CAC3E,MAAM,SACJ,QAAQ,WAAW,OAAO,aAAa,cAAc,SAAY;CACnE,MAAM,YAAmC,EAAE;CAE3C,MAAM,WACJ,cACA,aACG;AACH,MACG,CAAC,QAAQ,mBAAmB,aAAa,QAAQ,YAAY,UAC7D,aAAa,QAAQ,aAAa,gBAChC,QAAQ,aAAa,cACxB,QAAQ,YAAY,SAAS,aAAa,GAAG,IAC7C,QAAQ,UAAU,aAAa,IAC9B,QAAQ,UAAU,SACjB,UACA,CAAC,eAAe,QAAQ,aAAa,OAAO,CAE9C,QAAO;AAET,SAAO,OACJ,MAAM,GAAG,KAAK,IAAI,OAAO,QAAQ,SAAS,OAAO,CAAC,CAClD,OAAO,GAAG,UAAU;GACnB,MAAM,IAAI,wBACR,SAAS,QACT,aAAa,QAAQ,SACtB;GACD,MAAM,OACJ,EAAE,SAAS,EAAE,QACb,EAAE,QAAQ,EAAE,OACZ,EAAE,UAAU,EAAE,SACd,EAAE,SAAS,EAAE,SACZ,EAAE,SAAS,UAAa,EAAE,SAAS,SAChC,EAAE,SAAS,EAAE,OACb,UAAU,EAAE,KAAK,EAAE,IAAI;GAE7B,MAAM,QAAQ,QAAQ,SAAS;AAC/B,UACE,QACC,UAAU,UACT,qBAAqB,OAAO,GAAG,SAAS,IACxC,qBAAqB,OAAO,GAAG,aAAa,QAAQ,SAAS;IAEjE;;AAEN,MAAK,MAAM,gBAAgB,kBAAkB,CAAC,cAAc,MAAM,QAAQ,CACxE,KAAI,QAAQ,cAAc,CAAC,aAAa,OAAO,CAAC,CAC9C,WAAU,KAAK;EACb,MAAM;EACN,cAAc,yBAAyB,aAAa;EACrD,CAAC;AAEN,MAAK,MAAM,gBAAgB,oBAAoB,CAAC,cAAc,MAAM,QAAQ,CAC1E,KAAI,QAAQ,cAAc,aAAa,SAAS,CAC9C,WAAU,KAAK;EAAE,MAAM;EAAY;EAAc,CAAC;AAEtD,QAAO"}