@tanstack/angular-hotkeys 0.11.0 → 0.12.1

package/dist/injectHotkeySequence.cjs

@@ -1,93 +0,0 @@
-const require_hotkeys_provider = require('./hotkeys-provider.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _angular_core = require("@angular/core");
-
-//#region src/injectHotkeySequence.ts
-/**
-* Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).
-*
-* Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
-* when the full sequence is pressed within a timeout.
-*
-* Each step may include modifiers. You can chain the same modifier across
-* steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
-* Control, Alt, or Meta pressed alone) are ignored while matching—they do not
-* advance the sequence or reset progress.
-*
-* @param sequence - Array of hotkey strings that form the sequence (or getter function)
-* @param callback - Function to call when the sequence is completed
-* @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers
-*   the sequence (visible in devtools); only execution is suppressed.
-*
-* @example
-* ```ts
-* @Component({ ... })
-* export class VimEditorComponent {
-*   lastSequence = signal<string | null>(null)
-*
-*   constructor() {
-*     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))
-*     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))
-*     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })
-*     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
-*   }
-* }
-* ```
-*/
-function injectHotkeySequence(sequence, callback, options = {}) {
-	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
-	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
-	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
-	let handle = null;
-	let lastSequenceKey = null;
-	let lastTarget = null;
-	destroyRef.onDestroy(() => {
-		if (handle?.isActive) {
-			handle.unregister();
-			handle = null;
-		}
-		lastSequenceKey = null;
-		lastTarget = null;
-	});
-	(0, _angular_core.effect)(() => {
-		const resolvedSequence = typeof sequence === "function" ? sequence() : sequence;
-		const resolvedOptions = typeof options === "function" ? options() : options;
-		const { enabled = true, ...sequenceOptions } = {
-			...defaultOptions.hotkeySequence,
-			...resolvedOptions
-		};
-		const resolvedTarget = "target" in sequenceOptions ? sequenceOptions.target ?? null : typeof document !== "undefined" ? document : null;
-		if (resolvedSequence.length === 0 || !resolvedTarget) {
-			if (handle?.isActive) {
-				handle.unregister();
-				handle = null;
-			}
-			lastSequenceKey = null;
-			lastTarget = null;
-			return;
-		}
-		const sequenceKey = (0, _tanstack_hotkeys.formatHotkeySequence)(resolvedSequence);
-		const registerPayload = {
-			...sequenceOptions,
-			enabled,
-			target: resolvedTarget
-		};
-		const { target: _t, ...optionsWithoutTarget } = registerPayload;
-		if (handle?.isActive && lastSequenceKey === sequenceKey && lastTarget === resolvedTarget) {
-			handle.callback = callback;
-			handle.setOptions(optionsWithoutTarget);
-			return;
-		}
-		if (handle?.isActive) {
-			handle.unregister();
-			handle = null;
-		}
-		handle = manager.register(resolvedSequence, callback, registerPayload);
-		lastSequenceKey = sequenceKey;
-		lastTarget = resolvedTarget;
-	});
-}
-
-//#endregion
-exports.injectHotkeySequence = injectHotkeySequence;
-//# sourceMappingURL=injectHotkeySequence.cjs.map

package/dist/injectHotkeySequence.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeySequence.cjs","names":["injectDefaultHotkeysOptions","DestroyRef"],"sources":["../src/injectHotkeySequence.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\ntype SequenceTarget = Document | HTMLElement | Window\n\nexport interface InjectHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled' | 'target'\n> {\n  /** Whether the sequence is enabled. Defaults to true. */\n  enabled?: boolean\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor target, or null.\n   * Defaults to document when omitted.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).\n *\n * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger\n * when the full sequence is pressed within a timeout.\n *\n * Each step may include modifiers. You can chain the same modifier across\n * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,\n * Control, Alt, or Meta pressed alone) are ignored while matching—they do not\n * advance the sequence or reset progress.\n *\n * @param sequence - Array of hotkey strings that form the sequence (or getter function)\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers\n *   the sequence (visible in devtools); only execution is suppressed.\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimEditorComponent {\n *   lastSequence = signal<string | null>(null)\n *\n *   constructor() {\n *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))\n *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))\n *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })\n *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequence(\n  sequence: HotkeySequence | (() => HotkeySequence),\n  callback: HotkeyCallback,\n  options:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n  const destroyRef = inject(DestroyRef)\n\n  let handle: SequenceRegistrationHandle | null = null\n  let lastSequenceKey: string | null = null\n  let lastTarget: SequenceTarget | null = null\n\n  destroyRef.onDestroy(() => {\n    if (handle?.isActive) {\n      handle.unregister()\n      handle = null\n    }\n    lastSequenceKey = null\n    lastTarget = null\n  })\n\n  effect(() => {\n    // Resolve reactive values\n    const resolvedSequence =\n      typeof sequence === 'function' ? sequence() : sequence\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkeySequence,\n      ...resolvedOptions,\n    } as InjectHotkeySequenceOptions\n\n    const { enabled = true, ...sequenceOptions } = mergedOptions\n\n    const resolvedTarget =\n      'target' in sequenceOptions\n        ? (sequenceOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (resolvedSequence.length === 0 || !resolvedTarget) {\n      if (handle?.isActive) {\n        handle.unregister()\n        handle = null\n      }\n      lastSequenceKey = null\n      lastTarget = null\n      return\n    }\n\n    const sequenceKey = formatHotkeySequence(resolvedSequence)\n\n    const registerPayload: SequenceOptions = {\n      ...sequenceOptions,\n      enabled,\n      target: resolvedTarget,\n    }\n    const { target: _t, ...optionsWithoutTarget } = registerPayload\n\n    if (\n      handle?.isActive &&\n      lastSequenceKey === sequenceKey &&\n      lastTarget === resolvedTarget\n    ) {\n      handle.callback = callback\n      handle.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (handle?.isActive) {\n      handle.unregister()\n      handle = null\n    }\n\n    handle = manager.register(resolvedSequence, callback, registerPayload)\n    lastSequenceKey = sequenceKey\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,qDAA8B;CACpC,MAAM,uCAAoBC,yBAAW;CAErC,IAAI,SAA4C;CAChD,IAAI,kBAAiC;CACrC,IAAI,aAAoC;AAExC,YAAW,gBAAgB;AACzB,MAAI,QAAQ,UAAU;AACpB,UAAO,YAAY;AACnB,YAAS;;AAEX,oBAAkB;AAClB,eAAa;GACb;AAEF,iCAAa;EAEX,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAOpE,MAAM,EAAE,UAAU,MAAM,GAAG,oBALL;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAID,MAAM,iBACJ,YAAY,kBACP,gBAAgB,UAAU,OAC3B,OAAO,aAAa,cAClB,WACA;AAER,MAAI,iBAAiB,WAAW,KAAK,CAAC,gBAAgB;AACpD,OAAI,QAAQ,UAAU;AACpB,WAAO,YAAY;AACnB,aAAS;;AAEX,qBAAkB;AAClB,gBAAa;AACb;;EAGF,MAAM,0DAAmC,iBAAiB;EAE1D,MAAM,kBAAmC;GACvC,GAAG;GACH;GACA,QAAQ;GACT;EACD,MAAM,EAAE,QAAQ,IAAI,GAAG,yBAAyB;AAEhD,MACE,QAAQ,YACR,oBAAoB,eACpB,eAAe,gBACf;AACA,UAAO,WAAW;AAClB,UAAO,WAAW,qBAAqB;AACvC;;AAGF,MAAI,QAAQ,UAAU;AACpB,UAAO,YAAY;AACnB,YAAS;;AAGX,WAAS,QAAQ,SAAS,kBAAkB,UAAU,gBAAgB;AACtE,oBAAkB;AAClB,eAAa;GACb"}

package/dist/injectHotkeySequence.d.cts

@@ -1,48 +0,0 @@
-import { HotkeyCallback, HotkeySequence, SequenceOptions } from "@tanstack/hotkeys";
-
-//#region src/injectHotkeySequence.d.ts
-interface InjectHotkeySequenceOptions extends Omit<SequenceOptions, 'enabled' | 'target'> {
-  /** Whether the sequence is enabled. Defaults to true. */
-  enabled?: boolean;
-  /**
-   * The DOM element to attach the event listener to.
-   * Can be a direct DOM element, an accessor target, or null.
-   * Defaults to document when omitted.
-   */
-  target?: HTMLElement | Document | Window | null;
-}
-/**
- * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).
- *
- * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger
- * when the full sequence is pressed within a timeout.
- *
- * Each step may include modifiers. You can chain the same modifier across
- * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,
- * Control, Alt, or Meta pressed alone) are ignored while matching—they do not
- * advance the sequence or reset progress.
- *
- * @param sequence - Array of hotkey strings that form the sequence (or getter function)
- * @param callback - Function to call when the sequence is completed
- * @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers
- *   the sequence (visible in devtools); only execution is suppressed.
- *
- * @example
- * ```ts
- * @Component({ ... })
- * export class VimEditorComponent {
- *   lastSequence = signal<string | null>(null)
- *
- *   constructor() {
- *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))
- *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))
- *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })
- *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))
- *   }
- * }
- * ```
- */
-declare function injectHotkeySequence(sequence: HotkeySequence | (() => HotkeySequence), callback: HotkeyCallback, options?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)): void;
-//#endregion
-export { InjectHotkeySequenceOptions, injectHotkeySequence };
-//# sourceMappingURL=injectHotkeySequence.d.cts.map

package/dist/injectHotkeySequence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeySequence.js","names":[],"sources":["../src/injectHotkeySequence.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceOptions,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\ntype SequenceTarget = Document | HTMLElement | Window\n\nexport interface InjectHotkeySequenceOptions extends Omit<\n  SequenceOptions,\n  'enabled' | 'target'\n> {\n  /** Whether the sequence is enabled. Defaults to true. */\n  enabled?: boolean\n  /**\n   * The DOM element to attach the event listener to.\n   * Can be a direct DOM element, an accessor target, or null.\n   * Defaults to document when omitted.\n   */\n  target?: HTMLElement | Document | Window | null\n}\n\n/**\n * Angular inject-based API for registering a keyboard shortcut sequence (Vim-style).\n *\n * Allows you to register multi-key sequences like 'g g' or 'd d' that trigger\n * when the full sequence is pressed within a timeout.\n *\n * Each step may include modifiers. You can chain the same modifier across\n * steps (e.g. `Shift+R` then `Shift+T`). Modifier-only keydown events (Shift,\n * Control, Alt, or Meta pressed alone) are ignored while matching—they do not\n * advance the sequence or reset progress.\n *\n * @param sequence - Array of hotkey strings that form the sequence (or getter function)\n * @param callback - Function to call when the sequence is completed\n * @param options - Options for the sequence behavior (or getter function). `enabled: false` still registers\n *   the sequence (visible in devtools); only execution is suppressed.\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimEditorComponent {\n *   lastSequence = signal<string | null>(null)\n *\n *   constructor() {\n *     injectHotkeySequence(['G', 'G'], () => this.lastSequence.set('gg → Go to top'))\n *     injectHotkeySequence(['D', 'D'], () => this.lastSequence.set('dd → Delete line'))\n *     injectHotkeySequence(['C', 'I', 'W'], () => this.lastSequence.set('ciw'), { timeout: 500 })\n *     injectHotkeySequence(['Shift+R', 'Shift+T'], () => this.lastSequence.set('⇧R⇧T'))\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequence(\n  sequence: HotkeySequence | (() => HotkeySequence),\n  callback: HotkeyCallback,\n  options:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n  const destroyRef = inject(DestroyRef)\n\n  let handle: SequenceRegistrationHandle | null = null\n  let lastSequenceKey: string | null = null\n  let lastTarget: SequenceTarget | null = null\n\n  destroyRef.onDestroy(() => {\n    if (handle?.isActive) {\n      handle.unregister()\n      handle = null\n    }\n    lastSequenceKey = null\n    lastTarget = null\n  })\n\n  effect(() => {\n    // Resolve reactive values\n    const resolvedSequence =\n      typeof sequence === 'function' ? sequence() : sequence\n    const resolvedOptions = typeof options === 'function' ? options() : options\n\n    const mergedOptions = {\n      ...defaultOptions.hotkeySequence,\n      ...resolvedOptions,\n    } as InjectHotkeySequenceOptions\n\n    const { enabled = true, ...sequenceOptions } = mergedOptions\n\n    const resolvedTarget =\n      'target' in sequenceOptions\n        ? (sequenceOptions.target ?? null)\n        : typeof document !== 'undefined'\n          ? document\n          : null\n\n    if (resolvedSequence.length === 0 || !resolvedTarget) {\n      if (handle?.isActive) {\n        handle.unregister()\n        handle = null\n      }\n      lastSequenceKey = null\n      lastTarget = null\n      return\n    }\n\n    const sequenceKey = formatHotkeySequence(resolvedSequence)\n\n    const registerPayload: SequenceOptions = {\n      ...sequenceOptions,\n      enabled,\n      target: resolvedTarget,\n    }\n    const { target: _t, ...optionsWithoutTarget } = registerPayload\n\n    if (\n      handle?.isActive &&\n      lastSequenceKey === sequenceKey &&\n      lastTarget === resolvedTarget\n    ) {\n      handle.callback = callback\n      handle.setOptions(optionsWithoutTarget)\n      return\n    }\n\n    if (handle?.isActive) {\n      handle.unregister()\n      handle = null\n    }\n\n    handle = manager.register(resolvedSequence, callback, registerPayload)\n    lastSequenceKey = sequenceKey\n    lastTarget = resolvedTarget\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,qBACd,UACA,UACA,UAE0C,EAAE,EACtC;CACN,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,UAAU,oBAAoB;CACpC,MAAM,aAAa,OAAO,WAAW;CAErC,IAAI,SAA4C;CAChD,IAAI,kBAAiC;CACrC,IAAI,aAAoC;AAExC,YAAW,gBAAgB;AACzB,MAAI,QAAQ,UAAU;AACpB,UAAO,YAAY;AACnB,YAAS;;AAEX,oBAAkB;AAClB,eAAa;GACb;AAEF,cAAa;EAEX,MAAM,mBACJ,OAAO,aAAa,aAAa,UAAU,GAAG;EAChD,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EAOpE,MAAM,EAAE,UAAU,MAAM,GAAG,oBALL;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ;EAID,MAAM,iBACJ,YAAY,kBACP,gBAAgB,UAAU,OAC3B,OAAO,aAAa,cAClB,WACA;AAER,MAAI,iBAAiB,WAAW,KAAK,CAAC,gBAAgB;AACpD,OAAI,QAAQ,UAAU;AACpB,WAAO,YAAY;AACnB,aAAS;;AAEX,qBAAkB;AAClB,gBAAa;AACb;;EAGF,MAAM,cAAc,qBAAqB,iBAAiB;EAE1D,MAAM,kBAAmC;GACvC,GAAG;GACH;GACA,QAAQ;GACT;EACD,MAAM,EAAE,QAAQ,IAAI,GAAG,yBAAyB;AAEhD,MACE,QAAQ,YACR,oBAAoB,eACpB,eAAe,gBACf;AACA,UAAO,WAAW;AAClB,UAAO,WAAW,qBAAqB;AACvC;;AAGF,MAAI,QAAQ,UAAU;AACpB,UAAO,YAAY;AACnB,YAAS;;AAGX,WAAS,QAAQ,SAAS,kBAAkB,UAAU,gBAAgB;AACtE,oBAAkB;AAClB,eAAa;GACb"}

package/dist/injectHotkeySequenceRecorder.cjs

@@ -1,58 +0,0 @@
-const require_hotkeys_provider = require('./hotkeys-provider.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _angular_core = require("@angular/core");
-
-//#region src/injectHotkeySequenceRecorder.ts
-/**
-* Angular inject-based API for recording multi-chord sequences.
-*/
-function injectHotkeySequenceRecorder(options) {
-	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
-	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
-	const recorderSignal = (0, _angular_core.computed)(() => (0, _angular_core.untracked)(() => {
-		const resolvedOptions = typeof options === "function" ? options() : options;
-		return new _tanstack_hotkeys.HotkeySequenceRecorder({
-			...defaultOptions.hotkeySequenceRecorder,
-			...resolvedOptions
-		});
-	}));
-	const recorderStore = (0, _angular_core.computed)(() => (0, _angular_core.untracked)(() => recorderSignal().store));
-	const isRecording = injectLazyStore(recorderStore, (state) => state.isRecording);
-	const steps = injectLazyStore(recorderStore, (state) => state.steps);
-	const recordedSequence = injectLazyStore(recorderStore, (state) => state.recordedSequence);
-	(0, _angular_core.effect)(() => {
-		const resolved = typeof options === "function" ? options() : options;
-		recorderSignal().setOptions({
-			...defaultOptions.hotkeySequenceRecorder,
-			...resolved
-		});
-	});
-	destroyRef.onDestroy(() => {
-		recorderSignal().destroy();
-	});
-	return {
-		isRecording,
-		steps,
-		recordedSequence,
-		startRecording: () => recorderSignal().start(),
-		stopRecording: () => recorderSignal().stop(),
-		cancelRecording: () => recorderSignal().cancel(),
-		commitRecording: () => recorderSignal().commit()
-	};
-}
-function injectLazyStore(storeSignal, selector) {
-	const slice = (0, _angular_core.linkedSignal)(() => selector(storeSignal().get()));
-	(0, _angular_core.effect)((onCleanup) => {
-		const currentStore = storeSignal();
-		slice.set(selector(currentStore.get()));
-		const { unsubscribe } = currentStore.subscribe((s) => {
-			slice.set(selector(s));
-		});
-		onCleanup(() => unsubscribe());
-	});
-	return slice.asReadonly();
-}
-
-//#endregion
-exports.injectHotkeySequenceRecorder = injectHotkeySequenceRecorder;
-//# sourceMappingURL=injectHotkeySequenceRecorder.cjs.map

package/dist/injectHotkeySequenceRecorder.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeySequenceRecorder.cjs","names":["injectDefaultHotkeysOptions","DestroyRef","HotkeySequenceRecorder"],"sources":["../src/injectHotkeySequenceRecorder.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  effect,\n  inject,\n  linkedSignal,\n  untracked,\n} from '@angular/core'\nimport { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { Atom, ReadonlyAtom } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\nexport interface AngularHotkeySequenceRecorder {\n  readonly isRecording: () => boolean\n  readonly steps: () => HotkeySequence\n  readonly recordedSequence: () => HotkeySequence | null\n  readonly startRecording: () => void\n  readonly stopRecording: () => void\n  readonly cancelRecording: () => void\n  readonly commitRecording: () => void\n}\n\n/**\n * Angular inject-based API for recording multi-chord sequences.\n */\nexport function injectHotkeySequenceRecorder(\n  options:\n    | HotkeySequenceRecorderOptions\n    | (() => HotkeySequenceRecorderOptions),\n): AngularHotkeySequenceRecorder {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const destroyRef = inject(DestroyRef)\n\n  const recorderSignal = computed(() =>\n    untracked(() => {\n      const resolvedOptions =\n        typeof options === 'function' ? options() : options\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequenceRecorder,\n        ...resolvedOptions,\n      } as HotkeySequenceRecorderOptions\n\n      return new HotkeySequenceRecorder(mergedOptions)\n    }),\n  )\n\n  const recorderStore = computed(() => untracked(() => recorderSignal().store))\n  const isRecording = injectLazyStore(\n    recorderStore,\n    (state) => state.isRecording,\n  )\n  const steps = injectLazyStore(recorderStore, (state) => state.steps)\n  const recordedSequence = injectLazyStore(\n    recorderStore,\n    (state) => state.recordedSequence,\n  )\n\n  effect(() => {\n    const resolved = typeof options === 'function' ? options() : options\n    recorderSignal().setOptions({\n      ...defaultOptions.hotkeySequenceRecorder,\n      ...resolved,\n    } as HotkeySequenceRecorderOptions)\n  })\n\n  destroyRef.onDestroy(() => {\n    recorderSignal().destroy()\n  })\n\n  return {\n    isRecording,\n    steps,\n    recordedSequence,\n    startRecording: () => recorderSignal().start(),\n    stopRecording: () => recorderSignal().stop(),\n    cancelRecording: () => recorderSignal().cancel(),\n    commitRecording: () => recorderSignal().commit(),\n  }\n}\n\nfunction injectLazyStore<TState, TSelected = NoInfer<TState>>(\n  storeSignal: Signal<Atom<TState> | ReadonlyAtom<TState>>,\n  selector: (state: NoInfer<TState>) => TSelected,\n): Signal<TSelected> {\n  const slice = linkedSignal(() => selector(storeSignal().get()))\n\n  effect((onCleanup) => {\n    const currentStore = storeSignal()\n    slice.set(selector(currentStore.get()))\n    const { unsubscribe } = currentStore.subscribe((s) => {\n      slice.set(selector(s))\n    })\n    onCleanup(() => unsubscribe())\n  })\n\n  return slice.asReadonly()\n}\n"],"mappings":";;;;;;;;AA8BA,SAAgB,6BACd,SAG+B;CAC/B,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,uCAAoBC,yBAAW;CAErC,MAAM,sFACY;EACd,MAAM,kBACJ,OAAO,YAAY,aAAa,SAAS,GAAG;AAO9C,SAAO,IAAIC,yCALW;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ,CAE+C;GAChD,CACH;CAED,MAAM,qFAA+C,gBAAgB,CAAC,MAAM,CAAC;CAC7E,MAAM,cAAc,gBAClB,gBACC,UAAU,MAAM,YAClB;CACD,MAAM,QAAQ,gBAAgB,gBAAgB,UAAU,MAAM,MAAM;CACpE,MAAM,mBAAmB,gBACvB,gBACC,UAAU,MAAM,iBAClB;AAED,iCAAa;EACX,MAAM,WAAW,OAAO,YAAY,aAAa,SAAS,GAAG;AAC7D,kBAAgB,CAAC,WAAW;GAC1B,GAAG,eAAe;GAClB,GAAG;GACJ,CAAkC;GACnC;AAEF,YAAW,gBAAgB;AACzB,kBAAgB,CAAC,SAAS;GAC1B;AAEF,QAAO;EACL;EACA;EACA;EACA,sBAAsB,gBAAgB,CAAC,OAAO;EAC9C,qBAAqB,gBAAgB,CAAC,MAAM;EAC5C,uBAAuB,gBAAgB,CAAC,QAAQ;EAChD,uBAAuB,gBAAgB,CAAC,QAAQ;EACjD;;AAGH,SAAS,gBACP,aACA,UACmB;CACnB,MAAM,8CAA2B,SAAS,aAAa,CAAC,KAAK,CAAC,CAAC;AAE/D,4BAAQ,cAAc;EACpB,MAAM,eAAe,aAAa;AAClC,QAAM,IAAI,SAAS,aAAa,KAAK,CAAC,CAAC;EACvC,MAAM,EAAE,gBAAgB,aAAa,WAAW,MAAM;AACpD,SAAM,IAAI,SAAS,EAAE,CAAC;IACtB;AACF,kBAAgB,aAAa,CAAC;GAC9B;AAEF,QAAO,MAAM,YAAY"}

package/dist/injectHotkeySequenceRecorder.d.cts

@@ -1,19 +0,0 @@
-import { HotkeySequence, HotkeySequenceRecorderOptions } from "@tanstack/hotkeys";
-
-//#region src/injectHotkeySequenceRecorder.d.ts
-interface AngularHotkeySequenceRecorder {
-  readonly isRecording: () => boolean;
-  readonly steps: () => HotkeySequence;
-  readonly recordedSequence: () => HotkeySequence | null;
-  readonly startRecording: () => void;
-  readonly stopRecording: () => void;
-  readonly cancelRecording: () => void;
-  readonly commitRecording: () => void;
-}
-/**
- * Angular inject-based API for recording multi-chord sequences.
- */
-declare function injectHotkeySequenceRecorder(options: HotkeySequenceRecorderOptions | (() => HotkeySequenceRecorderOptions)): AngularHotkeySequenceRecorder;
-//#endregion
-export { AngularHotkeySequenceRecorder, injectHotkeySequenceRecorder };
-//# sourceMappingURL=injectHotkeySequenceRecorder.d.cts.map

package/dist/injectHotkeySequenceRecorder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeySequenceRecorder.js","names":[],"sources":["../src/injectHotkeySequenceRecorder.ts"],"sourcesContent":["import {\n  DestroyRef,\n  computed,\n  effect,\n  inject,\n  linkedSignal,\n  untracked,\n} from '@angular/core'\nimport { HotkeySequenceRecorder } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { Atom, ReadonlyAtom } from '@tanstack/angular-store'\nimport type { Signal } from '@angular/core'\nimport type {\n  HotkeySequence,\n  HotkeySequenceRecorderOptions,\n} from '@tanstack/hotkeys'\n\nexport interface AngularHotkeySequenceRecorder {\n  readonly isRecording: () => boolean\n  readonly steps: () => HotkeySequence\n  readonly recordedSequence: () => HotkeySequence | null\n  readonly startRecording: () => void\n  readonly stopRecording: () => void\n  readonly cancelRecording: () => void\n  readonly commitRecording: () => void\n}\n\n/**\n * Angular inject-based API for recording multi-chord sequences.\n */\nexport function injectHotkeySequenceRecorder(\n  options:\n    | HotkeySequenceRecorderOptions\n    | (() => HotkeySequenceRecorderOptions),\n): AngularHotkeySequenceRecorder {\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const destroyRef = inject(DestroyRef)\n\n  const recorderSignal = computed(() =>\n    untracked(() => {\n      const resolvedOptions =\n        typeof options === 'function' ? options() : options\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequenceRecorder,\n        ...resolvedOptions,\n      } as HotkeySequenceRecorderOptions\n\n      return new HotkeySequenceRecorder(mergedOptions)\n    }),\n  )\n\n  const recorderStore = computed(() => untracked(() => recorderSignal().store))\n  const isRecording = injectLazyStore(\n    recorderStore,\n    (state) => state.isRecording,\n  )\n  const steps = injectLazyStore(recorderStore, (state) => state.steps)\n  const recordedSequence = injectLazyStore(\n    recorderStore,\n    (state) => state.recordedSequence,\n  )\n\n  effect(() => {\n    const resolved = typeof options === 'function' ? options() : options\n    recorderSignal().setOptions({\n      ...defaultOptions.hotkeySequenceRecorder,\n      ...resolved,\n    } as HotkeySequenceRecorderOptions)\n  })\n\n  destroyRef.onDestroy(() => {\n    recorderSignal().destroy()\n  })\n\n  return {\n    isRecording,\n    steps,\n    recordedSequence,\n    startRecording: () => recorderSignal().start(),\n    stopRecording: () => recorderSignal().stop(),\n    cancelRecording: () => recorderSignal().cancel(),\n    commitRecording: () => recorderSignal().commit(),\n  }\n}\n\nfunction injectLazyStore<TState, TSelected = NoInfer<TState>>(\n  storeSignal: Signal<Atom<TState> | ReadonlyAtom<TState>>,\n  selector: (state: NoInfer<TState>) => TSelected,\n): Signal<TSelected> {\n  const slice = linkedSignal(() => selector(storeSignal().get()))\n\n  effect((onCleanup) => {\n    const currentStore = storeSignal()\n    slice.set(selector(currentStore.get()))\n    const { unsubscribe } = currentStore.subscribe((s) => {\n      slice.set(selector(s))\n    })\n    onCleanup(() => unsubscribe())\n  })\n\n  return slice.asReadonly()\n}\n"],"mappings":";;;;;;;;AA8BA,SAAgB,6BACd,SAG+B;CAC/B,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,aAAa,OAAO,WAAW;CAErC,MAAM,iBAAiB,eACrB,gBAAgB;EACd,MAAM,kBACJ,OAAO,YAAY,aAAa,SAAS,GAAG;AAO9C,SAAO,IAAI,uBALW;GACpB,GAAG,eAAe;GAClB,GAAG;GACJ,CAE+C;GAChD,CACH;CAED,MAAM,gBAAgB,eAAe,gBAAgB,gBAAgB,CAAC,MAAM,CAAC;CAC7E,MAAM,cAAc,gBAClB,gBACC,UAAU,MAAM,YAClB;CACD,MAAM,QAAQ,gBAAgB,gBAAgB,UAAU,MAAM,MAAM;CACpE,MAAM,mBAAmB,gBACvB,gBACC,UAAU,MAAM,iBAClB;AAED,cAAa;EACX,MAAM,WAAW,OAAO,YAAY,aAAa,SAAS,GAAG;AAC7D,kBAAgB,CAAC,WAAW;GAC1B,GAAG,eAAe;GAClB,GAAG;GACJ,CAAkC;GACnC;AAEF,YAAW,gBAAgB;AACzB,kBAAgB,CAAC,SAAS;GAC1B;AAEF,QAAO;EACL;EACA;EACA;EACA,sBAAsB,gBAAgB,CAAC,OAAO;EAC9C,qBAAqB,gBAAgB,CAAC,MAAM;EAC5C,uBAAuB,gBAAgB,CAAC,QAAQ;EAChD,uBAAuB,gBAAgB,CAAC,QAAQ;EACjD;;AAGH,SAAS,gBACP,aACA,UACmB;CACnB,MAAM,QAAQ,mBAAmB,SAAS,aAAa,CAAC,KAAK,CAAC,CAAC;AAE/D,SAAQ,cAAc;EACpB,MAAM,eAAe,aAAa;AAClC,QAAM,IAAI,SAAS,aAAa,KAAK,CAAC,CAAC;EACvC,MAAM,EAAE,gBAAgB,aAAa,WAAW,MAAM;AACpD,SAAM,IAAI,SAAS,EAAE,CAAC;IACtB;AACF,kBAAgB,aAAa,CAAC;GAC9B;AAEF,QAAO,MAAM,YAAY"}

package/dist/injectHotkeySequences.cjs

@@ -1,105 +0,0 @@
-const require_hotkeys_provider = require('./hotkeys-provider.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _angular_core = require("@angular/core");
-
-//#region src/injectHotkeySequences.ts
-/**
-* Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).
-*
-* Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).
-* Uses `effect()` to track reactive dependencies when definitions or options are getters.
-*
-* Options are merged in this order:
-* provideHotkeys defaults < commonOptions < per-definition options
-*
-* Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)
-* remain registered so they stay visible in devtools; the core manager suppresses execution.
-*
-* @param sequences - Array of sequence definitions, or getter returning them
-* @param commonOptions - Shared options for all sequences, or getter
-*
-* @example
-* ```ts
-* @Component({ ... })
-* export class VimComponent {
-*   constructor() {
-*     injectHotkeySequences([
-*       { sequence: ['G', 'G'], callback: () => this.goTop() },
-*       { sequence: ['D', 'D'], callback: () => this.deleteLine() },
-*     ])
-*   }
-* }
-* ```
-*/
-function injectHotkeySequences(sequences, commonOptions = {}) {
-	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
-	const manager = (0, _tanstack_hotkeys.getSequenceManager)();
-	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
-	const registrations = /* @__PURE__ */ new Map();
-	destroyRef.onDestroy(() => {
-		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
-		registrations.clear();
-	});
-	(0, _angular_core.effect)(() => {
-		const resolvedSequences = typeof sequences === "function" ? sequences() : sequences;
-		const resolvedCommonOptions = typeof commonOptions === "function" ? commonOptions() : commonOptions;
-		const nextKeys = /* @__PURE__ */ new Set();
-		const prepared = [];
-		for (let i = 0; i < resolvedSequences.length; i++) {
-			const def = resolvedSequences[i];
-			const resolvedSequence = typeof def.sequence === "function" ? def.sequence() : def.sequence;
-			const resolvedDefOptions = typeof def.options === "function" ? def.options() : def.options ?? {};
-			const { enabled = true, ...sequenceOpts } = {
-				...defaultOptions.hotkeySequence,
-				...resolvedCommonOptions,
-				...resolvedDefOptions
-			};
-			if (resolvedSequence.length === 0) continue;
-			const resolvedTarget = "target" in sequenceOpts ? sequenceOpts.target ?? null : typeof document !== "undefined" ? document : null;
-			if (!resolvedTarget) continue;
-			const registrationKey = `${i}:${(0, _tanstack_hotkeys.formatHotkeySequence)(resolvedSequence)}`;
-			nextKeys.add(registrationKey);
-			prepared.push({
-				registrationKey,
-				def,
-				resolvedSequence,
-				enabled,
-				sequenceOpts,
-				resolvedTarget
-			});
-		}
-		for (const [key, record] of [...registrations.entries()]) if (!nextKeys.has(key)) {
-			if (record.handle.isActive) record.handle.unregister();
-			registrations.delete(key);
-		}
-		for (const p of prepared) {
-			const existing = registrations.get(p.registrationKey);
-			if (existing?.handle.isActive && existing.target === p.resolvedTarget) {
-				existing.handle.callback = p.def.callback;
-				const { target: _target, ...optionsWithoutTarget } = p.sequenceOpts;
-				existing.handle.setOptions({
-					...optionsWithoutTarget,
-					enabled: p.enabled
-				});
-				continue;
-			}
-			if (existing) {
-				if (existing.handle.isActive) existing.handle.unregister();
-				registrations.delete(p.registrationKey);
-			}
-			const handle = manager.register(p.resolvedSequence, p.def.callback, {
-				...p.sequenceOpts,
-				enabled: p.enabled,
-				target: p.resolvedTarget
-			});
-			registrations.set(p.registrationKey, {
-				handle,
-				target: p.resolvedTarget
-			});
-		}
-	});
-}
-
-//#endregion
-exports.injectHotkeySequences = injectHotkeySequences;
-//# sourceMappingURL=injectHotkeySequences.cjs.map

package/dist/injectHotkeySequences.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeySequences.cjs","names":["injectDefaultHotkeysOptions","DestroyRef"],"sources":["../src/injectHotkeySequences.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { InjectHotkeySequenceOptions } from './injectHotkeySequence'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\n/**\n * A single sequence definition for use with `injectHotkeySequences`.\n */\nexport interface InjectHotkeySequenceDefinition {\n  /** Array of hotkey strings that form the sequence */\n  sequence: HotkeySequence | (() => HotkeySequence)\n  /** The function to call when the sequence is completed */\n  callback: HotkeyCallback\n  /** Per-sequence options (merged on top of commonOptions) */\n  options?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)\n}\n\n/**\n * Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).\n *\n * Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).\n * Uses `effect()` to track reactive dependencies when definitions or options are getters.\n *\n * Options are merged in this order:\n * provideHotkeys defaults < commonOptions < per-definition options\n *\n * Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)\n * remain registered so they stay visible in devtools; the core manager suppresses execution.\n *\n * @param sequences - Array of sequence definitions, or getter returning them\n * @param commonOptions - Shared options for all sequences, or getter\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimComponent {\n *   constructor() {\n *     injectHotkeySequences([\n *       { sequence: ['G', 'G'], callback: () => this.goTop() },\n *       { sequence: ['D', 'D'], callback: () => this.deleteLine() },\n *     ])\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequences(\n  sequences:\n    | Array<InjectHotkeySequenceDefinition>\n    | (() => Array<InjectHotkeySequenceDefinition>),\n  commonOptions:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: SequenceRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n  const destroyRef = inject(DestroyRef)\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  destroyRef.onDestroy(() => {\n    for (const { handle } of registrations.values()) {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    }\n    registrations.clear()\n  })\n\n  effect(() => {\n    const resolvedSequences =\n      typeof sequences === 'function' ? sequences() : sequences\n    const resolvedCommonOptions =\n      typeof commonOptions === 'function' ? commonOptions() : commonOptions\n\n    const nextKeys = new Set<string>()\n    const prepared: Array<{\n      registrationKey: string\n      def: InjectHotkeySequenceDefinition\n      resolvedSequence: HotkeySequence\n      enabled: boolean\n      sequenceOpts: Omit<InjectHotkeySequenceOptions, 'enabled'>\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolvedSequences.length; i++) {\n      const def = resolvedSequences[i]!\n      const resolvedSequence =\n        typeof def.sequence === 'function' ? def.sequence() : def.sequence\n      const resolvedDefOptions =\n        typeof def.options === 'function' ? def.options() : (def.options ?? {})\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequence,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as InjectHotkeySequenceOptions\n\n      const { enabled = true, ...sequenceOpts } = mergedOptions\n\n      if (resolvedSequence.length === 0) {\n        continue\n      }\n\n      const resolvedTarget =\n        'target' in sequenceOpts\n          ? (sequenceOpts.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${formatHotkeySequence(resolvedSequence)}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        resolvedSequence,\n        enabled,\n        sequenceOpts,\n        resolvedTarget,\n      })\n    }\n\n    for (const [key, record] of [...registrations.entries()]) {\n      if (!nextKeys.has(key)) {\n        if (record.handle.isActive) {\n          record.handle.unregister()\n        }\n        registrations.delete(key)\n      }\n    }\n\n    for (const p of prepared) {\n      const existing = registrations.get(p.registrationKey)\n      if (existing?.handle.isActive && existing.target === p.resolvedTarget) {\n        existing.handle.callback = p.def.callback\n        const { target: _target, ...optionsWithoutTarget } = p.sequenceOpts\n        existing.handle.setOptions({\n          ...optionsWithoutTarget,\n          enabled: p.enabled,\n        })\n        continue\n      }\n\n      if (existing) {\n        if (existing.handle.isActive) {\n          existing.handle.unregister()\n        }\n        registrations.delete(p.registrationKey)\n      }\n\n      const handle = manager.register(p.resolvedSequence, p.def.callback, {\n        ...p.sequenceOpts,\n        enabled: p.enabled,\n        target: p.resolvedTarget,\n      })\n      registrations.set(p.registrationKey, {\n        handle,\n        target: p.resolvedTarget,\n      })\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,sBACd,WAGA,gBAE0C,EAAE,EACtC;CAMN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,qDAA8B;CACpC,MAAM,uCAAoBC,yBAAW;CAErC,MAAM,gCAAgB,IAAI,KAAiC;AAE3D,YAAW,gBAAgB;AACzB,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;AAEF,iCAAa;EACX,MAAM,oBACJ,OAAO,cAAc,aAAa,WAAW,GAAG;EAClD,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAOD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,QAAQ,KAAK;GACjD,MAAM,MAAM,kBAAkB;GAC9B,MAAM,mBACJ,OAAO,IAAI,aAAa,aAAa,IAAI,UAAU,GAAG,IAAI;GAC5D,MAAM,qBACJ,OAAO,IAAI,YAAY,aAAa,IAAI,SAAS,GAAI,IAAI,WAAW,EAAE;GAQxE,MAAM,EAAE,UAAU,MAAM,GAAG,iBANL;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;AAID,OAAI,iBAAiB,WAAW,EAC9B;GAGF,MAAM,iBACJ,YAAY,eACP,aAAa,UAAU,OACxB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,+CAAwB,iBAAiB;AACtE,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;IACA;IACA;IACA;IACA;IACA;IACD,CAAC;;AAGJ,OAAK,MAAM,CAAC,KAAK,WAAW,CAAC,GAAG,cAAc,SAAS,CAAC,CACtD,KAAI,CAAC,SAAS,IAAI,IAAI,EAAE;AACtB,OAAI,OAAO,OAAO,SAChB,QAAO,OAAO,YAAY;AAE5B,iBAAc,OAAO,IAAI;;AAI7B,OAAK,MAAM,KAAK,UAAU;GACxB,MAAM,WAAW,cAAc,IAAI,EAAE,gBAAgB;AACrD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,EAAE,gBAAgB;AACrE,aAAS,OAAO,WAAW,EAAE,IAAI;IACjC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;AACvD,aAAS,OAAO,WAAW;KACzB,GAAG;KACH,SAAS,EAAE;KACZ,CAAC;AACF;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,EAAE,gBAAgB;;GAGzC,MAAM,SAAS,QAAQ,SAAS,EAAE,kBAAkB,EAAE,IAAI,UAAU;IAClE,GAAG,EAAE;IACL,SAAS,EAAE;IACX,QAAQ,EAAE;IACX,CAAC;AACF,iBAAc,IAAI,EAAE,iBAAiB;IACnC;IACA,QAAQ,EAAE;IACX,CAAC;;GAEJ"}

package/dist/injectHotkeySequences.d.cts

@@ -1,47 +0,0 @@
-import { InjectHotkeySequenceOptions } from "./injectHotkeySequence.cjs";
-import { HotkeyCallback, HotkeySequence } from "@tanstack/hotkeys";
-
-//#region src/injectHotkeySequences.d.ts
-/**
- * A single sequence definition for use with `injectHotkeySequences`.
- */
-interface InjectHotkeySequenceDefinition {
-  /** Array of hotkey strings that form the sequence */
-  sequence: HotkeySequence | (() => HotkeySequence);
-  /** The function to call when the sequence is completed */
-  callback: HotkeyCallback;
-  /** Per-sequence options (merged on top of commonOptions) */
-  options?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions);
-}
-/**
- * Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).
- *
- * Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).
- * Uses `effect()` to track reactive dependencies when definitions or options are getters.
- *
- * Options are merged in this order:
- * provideHotkeys defaults < commonOptions < per-definition options
- *
- * Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)
- * remain registered so they stay visible in devtools; the core manager suppresses execution.
- *
- * @param sequences - Array of sequence definitions, or getter returning them
- * @param commonOptions - Shared options for all sequences, or getter
- *
- * @example
- * ```ts
- * @Component({ ... })
- * export class VimComponent {
- *   constructor() {
- *     injectHotkeySequences([
- *       { sequence: ['G', 'G'], callback: () => this.goTop() },
- *       { sequence: ['D', 'D'], callback: () => this.deleteLine() },
- *     ])
- *   }
- * }
- * ```
- */
-declare function injectHotkeySequences(sequences: Array<InjectHotkeySequenceDefinition> | (() => Array<InjectHotkeySequenceDefinition>), commonOptions?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)): void;
-//#endregion
-export { InjectHotkeySequenceDefinition, injectHotkeySequences };
-//# sourceMappingURL=injectHotkeySequences.d.cts.map

package/dist/injectHotkeySequences.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeySequences.js","names":[],"sources":["../src/injectHotkeySequences.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport { formatHotkeySequence, getSequenceManager } from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { InjectHotkeySequenceOptions } from './injectHotkeySequence'\nimport type {\n  HotkeyCallback,\n  HotkeySequence,\n  SequenceRegistrationHandle,\n} from '@tanstack/hotkeys'\n\n/**\n * A single sequence definition for use with `injectHotkeySequences`.\n */\nexport interface InjectHotkeySequenceDefinition {\n  /** Array of hotkey strings that form the sequence */\n  sequence: HotkeySequence | (() => HotkeySequence)\n  /** The function to call when the sequence is completed */\n  callback: HotkeyCallback\n  /** Per-sequence options (merged on top of commonOptions) */\n  options?: InjectHotkeySequenceOptions | (() => InjectHotkeySequenceOptions)\n}\n\n/**\n * Angular inject-based API for registering multiple keyboard shortcut sequences at once (Vim-style).\n *\n * Uses the singleton SequenceManager. Call in an injection context (e.g. constructor).\n * Uses `effect()` to track reactive dependencies when definitions or options are getters.\n *\n * Options are merged in this order:\n * provideHotkeys defaults < commonOptions < per-definition options\n *\n * Definitions with an empty `sequence` are skipped. Disabled sequences (`enabled: false`)\n * remain registered so they stay visible in devtools; the core manager suppresses execution.\n *\n * @param sequences - Array of sequence definitions, or getter returning them\n * @param commonOptions - Shared options for all sequences, or getter\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class VimComponent {\n *   constructor() {\n *     injectHotkeySequences([\n *       { sequence: ['G', 'G'], callback: () => this.goTop() },\n *       { sequence: ['D', 'D'], callback: () => this.deleteLine() },\n *     ])\n *   }\n * }\n * ```\n */\nexport function injectHotkeySequences(\n  sequences:\n    | Array<InjectHotkeySequenceDefinition>\n    | (() => Array<InjectHotkeySequenceDefinition>),\n  commonOptions:\n    | InjectHotkeySequenceOptions\n    | (() => InjectHotkeySequenceOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: SequenceRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getSequenceManager()\n  const destroyRef = inject(DestroyRef)\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  destroyRef.onDestroy(() => {\n    for (const { handle } of registrations.values()) {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    }\n    registrations.clear()\n  })\n\n  effect(() => {\n    const resolvedSequences =\n      typeof sequences === 'function' ? sequences() : sequences\n    const resolvedCommonOptions =\n      typeof commonOptions === 'function' ? commonOptions() : commonOptions\n\n    const nextKeys = new Set<string>()\n    const prepared: Array<{\n      registrationKey: string\n      def: InjectHotkeySequenceDefinition\n      resolvedSequence: HotkeySequence\n      enabled: boolean\n      sequenceOpts: Omit<InjectHotkeySequenceOptions, 'enabled'>\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolvedSequences.length; i++) {\n      const def = resolvedSequences[i]!\n      const resolvedSequence =\n        typeof def.sequence === 'function' ? def.sequence() : def.sequence\n      const resolvedDefOptions =\n        typeof def.options === 'function' ? def.options() : (def.options ?? {})\n\n      const mergedOptions = {\n        ...defaultOptions.hotkeySequence,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as InjectHotkeySequenceOptions\n\n      const { enabled = true, ...sequenceOpts } = mergedOptions\n\n      if (resolvedSequence.length === 0) {\n        continue\n      }\n\n      const resolvedTarget =\n        'target' in sequenceOpts\n          ? (sequenceOpts.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${formatHotkeySequence(resolvedSequence)}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        resolvedSequence,\n        enabled,\n        sequenceOpts,\n        resolvedTarget,\n      })\n    }\n\n    for (const [key, record] of [...registrations.entries()]) {\n      if (!nextKeys.has(key)) {\n        if (record.handle.isActive) {\n          record.handle.unregister()\n        }\n        registrations.delete(key)\n      }\n    }\n\n    for (const p of prepared) {\n      const existing = registrations.get(p.registrationKey)\n      if (existing?.handle.isActive && existing.target === p.resolvedTarget) {\n        existing.handle.callback = p.def.callback\n        const { target: _target, ...optionsWithoutTarget } = p.sequenceOpts\n        existing.handle.setOptions({\n          ...optionsWithoutTarget,\n          enabled: p.enabled,\n        })\n        continue\n      }\n\n      if (existing) {\n        if (existing.handle.isActive) {\n          existing.handle.unregister()\n        }\n        registrations.delete(p.registrationKey)\n      }\n\n      const handle = manager.register(p.resolvedSequence, p.def.callback, {\n        ...p.sequenceOpts,\n        enabled: p.enabled,\n        target: p.resolvedTarget,\n      })\n      registrations.set(p.registrationKey, {\n        handle,\n        target: p.resolvedTarget,\n      })\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,sBACd,WAGA,gBAE0C,EAAE,EACtC;CAMN,MAAM,iBAAiB,6BAA6B;CACpD,MAAM,UAAU,oBAAoB;CACpC,MAAM,aAAa,OAAO,WAAW;CAErC,MAAM,gCAAgB,IAAI,KAAiC;AAE3D,YAAW,gBAAgB;AACzB,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;AAEF,cAAa;EACX,MAAM,oBACJ,OAAO,cAAc,aAAa,WAAW,GAAG;EAClD,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAOD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,QAAQ,KAAK;GACjD,MAAM,MAAM,kBAAkB;GAC9B,MAAM,mBACJ,OAAO,IAAI,aAAa,aAAa,IAAI,UAAU,GAAG,IAAI;GAC5D,MAAM,qBACJ,OAAO,IAAI,YAAY,aAAa,IAAI,SAAS,GAAI,IAAI,WAAW,EAAE;GAQxE,MAAM,EAAE,UAAU,MAAM,GAAG,iBANL;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;AAID,OAAI,iBAAiB,WAAW,EAC9B;GAGF,MAAM,iBACJ,YAAY,eACP,aAAa,UAAU,OACxB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG,qBAAqB,iBAAiB;AACtE,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;IACA;IACA;IACA;IACA;IACA;IACD,CAAC;;AAGJ,OAAK,MAAM,CAAC,KAAK,WAAW,CAAC,GAAG,cAAc,SAAS,CAAC,CACtD,KAAI,CAAC,SAAS,IAAI,IAAI,EAAE;AACtB,OAAI,OAAO,OAAO,SAChB,QAAO,OAAO,YAAY;AAE5B,iBAAc,OAAO,IAAI;;AAI7B,OAAK,MAAM,KAAK,UAAU;GACxB,MAAM,WAAW,cAAc,IAAI,EAAE,gBAAgB;AACrD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,EAAE,gBAAgB;AACrE,aAAS,OAAO,WAAW,EAAE,IAAI;IACjC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;AACvD,aAAS,OAAO,WAAW;KACzB,GAAG;KACH,SAAS,EAAE;KACZ,CAAC;AACF;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,EAAE,gBAAgB;;GAGzC,MAAM,SAAS,QAAQ,SAAS,EAAE,kBAAkB,EAAE,IAAI,UAAU;IAClE,GAAG,EAAE;IACL,SAAS,EAAE;IACX,QAAQ,EAAE;IACX,CAAC;AACF,iBAAc,IAAI,EAAE,iBAAiB;IACnC;IACA,QAAQ,EAAE;IACX,CAAC;;GAEJ"}

package/dist/injectHotkeys.cjs

@@ -1,120 +0,0 @@
-const require_hotkeys_provider = require('./hotkeys-provider.cjs');
-let _tanstack_hotkeys = require("@tanstack/hotkeys");
-let _angular_core = require("@angular/core");
-
-//#region src/injectHotkeys.ts
-/**
-* Angular inject-based API for registering multiple keyboard hotkeys at once.
-*
-* Uses the singleton HotkeyManager for efficient event handling.
-* Accepts a dynamic array of hotkey definitions.
-*
-* Call in an injection context (e.g. constructor or field initializer).
-* Uses effect() to track reactive dependencies and update registrations
-* when options or the callback change.
-*
-* Options are merged in this order:
-* provideHotkeys defaults < commonOptions < per-definition options
-*
-* @param hotkeys - Array of hotkey definitions, or getter returning them
-* @param commonOptions - Shared options for all hotkeys, or getter
-*
-* @example
-* ```ts
-* @Component({ ... })
-* export class EditorComponent {
-*   constructor() {
-*     injectHotkeys([
-*       { hotkey: 'Mod+S', callback: () => this.save() },
-*       { hotkey: 'Mod+Z', callback: () => this.undo() },
-*       { hotkey: 'Escape', callback: () => this.close() },
-*     ])
-*   }
-* }
-* ```
-*
-* @example
-* ```ts
-* @Component({ ... })
-* export class DynamicShortcuts {
-*   shortcuts = signal([...])
-*
-*   constructor() {
-*     injectHotkeys(
-*       () => this.shortcuts().map((s) => ({
-*         hotkey: s.key,
-*         callback: s.action,
-*       })),
-*     )
-*   }
-* }
-* ```
-*/
-function injectHotkeys(hotkeys, commonOptions = {}) {
-	const defaultOptions = require_hotkeys_provider.injectDefaultHotkeysOptions();
-	const manager = (0, _tanstack_hotkeys.getHotkeyManager)();
-	const destroyRef = (0, _angular_core.inject)(_angular_core.DestroyRef);
-	const registrations = /* @__PURE__ */ new Map();
-	destroyRef.onDestroy(() => {
-		for (const { handle } of registrations.values()) if (handle.isActive) handle.unregister();
-		registrations.clear();
-	});
-	(0, _angular_core.effect)(() => {
-		const resolvedHotkeys = typeof hotkeys === "function" ? hotkeys() : hotkeys;
-		const resolvedCommonOptions = typeof commonOptions === "function" ? commonOptions() : commonOptions;
-		const nextKeys = /* @__PURE__ */ new Set();
-		const prepared = [];
-		for (let i = 0; i < resolvedHotkeys.length; i++) {
-			const def = resolvedHotkeys[i];
-			const resolvedHotkey = typeof def.hotkey === "function" ? def.hotkey() : def.hotkey;
-			const resolvedDefOptions = typeof def.options === "function" ? def.options() : def.options ?? {};
-			const mergedOptions = {
-				...defaultOptions.hotkey,
-				...resolvedCommonOptions,
-				...resolvedDefOptions
-			};
-			const hotkeyString = (0, _tanstack_hotkeys.normalizeRegisterableHotkey)(resolvedHotkey, mergedOptions.platform ?? (0, _tanstack_hotkeys.detectPlatform)());
-			const resolvedTarget = "target" in mergedOptions ? mergedOptions.target ?? null : typeof document !== "undefined" ? document : null;
-			if (!resolvedTarget) continue;
-			const registrationKey = `${i}:${hotkeyString}`;
-			nextKeys.add(registrationKey);
-			prepared.push({
-				registrationKey,
-				def,
-				mergedOptions,
-				hotkeyString,
-				resolvedTarget
-			});
-		}
-		for (const [key, record] of [...registrations.entries()]) if (!nextKeys.has(key)) {
-			if (record.handle.isActive) record.handle.unregister();
-			registrations.delete(key);
-		}
-		for (const p of prepared) {
-			const existing = registrations.get(p.registrationKey);
-			if (existing?.handle.isActive && existing.target === p.resolvedTarget) {
-				existing.handle.callback = p.def.callback;
-				const { target: _target, ...optionsWithoutTarget } = p.mergedOptions;
-				existing.handle.setOptions(optionsWithoutTarget);
-				continue;
-			}
-			if (existing) {
-				if (existing.handle.isActive) existing.handle.unregister();
-				registrations.delete(p.registrationKey);
-			}
-			const { target: _target, ...optionsWithoutTarget } = p.mergedOptions;
-			const handle = manager.register(p.hotkeyString, p.def.callback, {
-				...optionsWithoutTarget,
-				target: p.resolvedTarget
-			});
-			registrations.set(p.registrationKey, {
-				handle,
-				target: p.resolvedTarget
-			});
-		}
-	});
-}
-
-//#endregion
-exports.injectHotkeys = injectHotkeys;
-//# sourceMappingURL=injectHotkeys.cjs.map

package/dist/injectHotkeys.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"injectHotkeys.cjs","names":["injectDefaultHotkeysOptions","DestroyRef"],"sources":["../src/injectHotkeys.ts"],"sourcesContent":["import { DestroyRef, effect, inject } from '@angular/core'\nimport {\n  detectPlatform,\n  getHotkeyManager,\n  normalizeRegisterableHotkey,\n} from '@tanstack/hotkeys'\nimport { injectDefaultHotkeysOptions } from './hotkeys-provider'\nimport type { InjectHotkeyOptions } from './injectHotkey'\nimport type {\n  Hotkey,\n  HotkeyCallback,\n  HotkeyRegistrationHandle,\n  RegisterableHotkey,\n} from '@tanstack/hotkeys'\n\n/**\n * A single hotkey definition for use with `injectHotkeys`.\n */\nexport interface InjectHotkeyDefinition {\n  /** The hotkey string (e.g., 'Mod+S', 'Escape') or RawHotkey object */\n  hotkey: RegisterableHotkey | (() => RegisterableHotkey)\n  /** The function to call when the hotkey is pressed */\n  callback: HotkeyCallback\n  /** Per-hotkey options (merged on top of commonOptions) */\n  options?: InjectHotkeyOptions | (() => InjectHotkeyOptions)\n}\n\n/**\n * Angular inject-based API for registering multiple keyboard hotkeys at once.\n *\n * Uses the singleton HotkeyManager for efficient event handling.\n * Accepts a dynamic array of hotkey definitions.\n *\n * Call in an injection context (e.g. constructor or field initializer).\n * Uses effect() to track reactive dependencies and update registrations\n * when options or the callback change.\n *\n * Options are merged in this order:\n * provideHotkeys defaults < commonOptions < per-definition options\n *\n * @param hotkeys - Array of hotkey definitions, or getter returning them\n * @param commonOptions - Shared options for all hotkeys, or getter\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class EditorComponent {\n *   constructor() {\n *     injectHotkeys([\n *       { hotkey: 'Mod+S', callback: () => this.save() },\n *       { hotkey: 'Mod+Z', callback: () => this.undo() },\n *       { hotkey: 'Escape', callback: () => this.close() },\n *     ])\n *   }\n * }\n * ```\n *\n * @example\n * ```ts\n * @Component({ ... })\n * export class DynamicShortcuts {\n *   shortcuts = signal([...])\n *\n *   constructor() {\n *     injectHotkeys(\n *       () => this.shortcuts().map((s) => ({\n *         hotkey: s.key,\n *         callback: s.action,\n *       })),\n *     )\n *   }\n * }\n * ```\n */\nexport function injectHotkeys(\n  hotkeys:\n    | Array<InjectHotkeyDefinition>\n    | (() => Array<InjectHotkeyDefinition>),\n  commonOptions: InjectHotkeyOptions | (() => InjectHotkeyOptions) = {},\n): void {\n  type RegistrationRecord = {\n    handle: HotkeyRegistrationHandle\n    target: Document | HTMLElement | Window\n  }\n\n  const defaultOptions = injectDefaultHotkeysOptions()\n  const manager = getHotkeyManager()\n  const destroyRef = inject(DestroyRef)\n\n  const registrations = new Map<string, RegistrationRecord>()\n\n  destroyRef.onDestroy(() => {\n    for (const { handle } of registrations.values()) {\n      if (handle.isActive) {\n        handle.unregister()\n      }\n    }\n    registrations.clear()\n  })\n\n  effect(() => {\n    const resolvedHotkeys = typeof hotkeys === 'function' ? hotkeys() : hotkeys\n    const resolvedCommonOptions =\n      typeof commonOptions === 'function' ? commonOptions() : commonOptions\n\n    const nextKeys = new Set<string>()\n    const prepared: Array<{\n      registrationKey: string\n      def: InjectHotkeyDefinition\n      mergedOptions: InjectHotkeyOptions\n      hotkeyString: Hotkey\n      resolvedTarget: Document | HTMLElement | Window\n    }> = []\n\n    for (let i = 0; i < resolvedHotkeys.length; i++) {\n      const def = resolvedHotkeys[i]!\n      const resolvedHotkey =\n        typeof def.hotkey === 'function' ? def.hotkey() : def.hotkey\n      const resolvedDefOptions =\n        typeof def.options === 'function' ? def.options() : (def.options ?? {})\n\n      const mergedOptions = {\n        ...defaultOptions.hotkey,\n        ...resolvedCommonOptions,\n        ...resolvedDefOptions,\n      } as InjectHotkeyOptions\n\n      const platform = mergedOptions.platform ?? detectPlatform()\n      const hotkeyString = normalizeRegisterableHotkey(resolvedHotkey, platform)\n\n      const resolvedTarget =\n        'target' in mergedOptions\n          ? (mergedOptions.target ?? null)\n          : typeof document !== 'undefined'\n            ? document\n            : null\n\n      if (!resolvedTarget) {\n        continue\n      }\n\n      const registrationKey = `${i}:${hotkeyString}`\n      nextKeys.add(registrationKey)\n      prepared.push({\n        registrationKey,\n        def,\n        mergedOptions,\n        hotkeyString,\n        resolvedTarget,\n      })\n    }\n\n    for (const [key, record] of [...registrations.entries()]) {\n      if (!nextKeys.has(key)) {\n        if (record.handle.isActive) {\n          record.handle.unregister()\n        }\n        registrations.delete(key)\n      }\n    }\n\n    for (const p of prepared) {\n      const existing = registrations.get(p.registrationKey)\n      if (existing?.handle.isActive && existing.target === p.resolvedTarget) {\n        existing.handle.callback = p.def.callback\n        const { target: _target, ...optionsWithoutTarget } = p.mergedOptions\n        existing.handle.setOptions(optionsWithoutTarget)\n        continue\n      }\n\n      if (existing) {\n        if (existing.handle.isActive) {\n          existing.handle.unregister()\n        }\n        registrations.delete(p.registrationKey)\n      }\n\n      const { target: _target, ...optionsWithoutTarget } = p.mergedOptions\n      const handle = manager.register(p.hotkeyString, p.def.callback, {\n        ...optionsWithoutTarget,\n        target: p.resolvedTarget,\n      })\n      registrations.set(p.registrationKey, {\n        handle,\n        target: p.resolvedTarget,\n      })\n    }\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,SAAgB,cACd,SAGA,gBAAmE,EAAE,EAC/D;CAMN,MAAM,iBAAiBA,sDAA6B;CACpD,MAAM,mDAA4B;CAClC,MAAM,uCAAoBC,yBAAW;CAErC,MAAM,gCAAgB,IAAI,KAAiC;AAE3D,YAAW,gBAAgB;AACzB,OAAK,MAAM,EAAE,YAAY,cAAc,QAAQ,CAC7C,KAAI,OAAO,SACT,QAAO,YAAY;AAGvB,gBAAc,OAAO;GACrB;AAEF,iCAAa;EACX,MAAM,kBAAkB,OAAO,YAAY,aAAa,SAAS,GAAG;EACpE,MAAM,wBACJ,OAAO,kBAAkB,aAAa,eAAe,GAAG;EAE1D,MAAM,2BAAW,IAAI,KAAa;EAClC,MAAM,WAMD,EAAE;AAEP,OAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK;GAC/C,MAAM,MAAM,gBAAgB;GAC5B,MAAM,iBACJ,OAAO,IAAI,WAAW,aAAa,IAAI,QAAQ,GAAG,IAAI;GACxD,MAAM,qBACJ,OAAO,IAAI,YAAY,aAAa,IAAI,SAAS,GAAI,IAAI,WAAW,EAAE;GAExE,MAAM,gBAAgB;IACpB,GAAG,eAAe;IAClB,GAAG;IACH,GAAG;IACJ;GAGD,MAAM,kEAA2C,gBADhC,cAAc,mDAA4B,CACe;GAE1E,MAAM,iBACJ,YAAY,gBACP,cAAc,UAAU,OACzB,OAAO,aAAa,cAClB,WACA;AAER,OAAI,CAAC,eACH;GAGF,MAAM,kBAAkB,GAAG,EAAE,GAAG;AAChC,YAAS,IAAI,gBAAgB;AAC7B,YAAS,KAAK;IACZ;IACA;IACA;IACA;IACA;IACD,CAAC;;AAGJ,OAAK,MAAM,CAAC,KAAK,WAAW,CAAC,GAAG,cAAc,SAAS,CAAC,CACtD,KAAI,CAAC,SAAS,IAAI,IAAI,EAAE;AACtB,OAAI,OAAO,OAAO,SAChB,QAAO,OAAO,YAAY;AAE5B,iBAAc,OAAO,IAAI;;AAI7B,OAAK,MAAM,KAAK,UAAU;GACxB,MAAM,WAAW,cAAc,IAAI,EAAE,gBAAgB;AACrD,OAAI,UAAU,OAAO,YAAY,SAAS,WAAW,EAAE,gBAAgB;AACrE,aAAS,OAAO,WAAW,EAAE,IAAI;IACjC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;AACvD,aAAS,OAAO,WAAW,qBAAqB;AAChD;;AAGF,OAAI,UAAU;AACZ,QAAI,SAAS,OAAO,SAClB,UAAS,OAAO,YAAY;AAE9B,kBAAc,OAAO,EAAE,gBAAgB;;GAGzC,MAAM,EAAE,QAAQ,SAAS,GAAG,yBAAyB,EAAE;GACvD,MAAM,SAAS,QAAQ,SAAS,EAAE,cAAc,EAAE,IAAI,UAAU;IAC9D,GAAG;IACH,QAAQ,EAAE;IACX,CAAC;AACF,iBAAc,IAAI,EAAE,iBAAiB;IACnC;IACA,QAAQ,EAAE;IACX,CAAC;;GAEJ"}