@xortex/xcode 3.0.1 → 3.0.2

package/ink/useTerminalNotification.ts

@@ -0,0 +1,126 @@
+import { createContext, useCallback, useContext, useMemo } from 'react'
+import { isProgressReportingAvailable, type Progress } from './terminal.js'
+import { BEL } from './termio/ansi.js'
+import { ITERM2, OSC, osc, PROGRESS, wrapForMultiplexer } from './termio/osc.js'
+
+type WriteRaw = (data: string) => void
+
+export const TerminalWriteContext = createContext<WriteRaw | null>(null)
+
+export const TerminalWriteProvider = TerminalWriteContext.Provider
+
+export type TerminalNotification = {
+  notifyITerm2: (opts: { message: string; title?: string }) => void
+  notifyKitty: (opts: { message: string; title: string; id: number }) => void
+  notifyGhostty: (opts: { message: string; title: string }) => void
+  notifyBell: () => void
+  /**
+   * Report progress to the terminal via OSC 9;4 sequences.
+   * Supported terminals: ConEmu, Ghostty 1.2.0+, iTerm2 3.6.6+
+   * Pass state=null to clear progress.
+   */
+  progress: (state: Progress['state'] | null, percentage?: number) => void
+}
+
+export function useTerminalNotification(): TerminalNotification {
+  const writeRaw = useContext(TerminalWriteContext)
+  if (!writeRaw) {
+    throw new Error(
+      'useTerminalNotification must be used within TerminalWriteProvider',
+    )
+  }
+
+  const notifyITerm2 = useCallback(
+    ({ message, title }: { message: string; title?: string }) => {
+      const displayString = title ? `${title}:\n${message}` : message
+      writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, `\n\n${displayString}`)))
+    },
+    [writeRaw],
+  )
+
+  const notifyKitty = useCallback(
+    ({
+      message,
+      title,
+      id,
+    }: {
+      message: string
+      title: string
+      id: number
+    }) => {
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:d=0:p=title`, title)))
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:p=body`, message)))
+      writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:d=1:a=focus`, '')))
+    },
+    [writeRaw],
+  )
+
+  const notifyGhostty = useCallback(
+    ({ message, title }: { message: string; title: string }) => {
+      writeRaw(wrapForMultiplexer(osc(OSC.GHOSTTY, 'notify', title, message)))
+    },
+    [writeRaw],
+  )
+
+  const notifyBell = useCallback(() => {
+    // Raw BEL — inside tmux this triggers tmux's bell-action (window flag).
+    // Wrapping would make it opaque DCS payload and lose that fallback.
+    writeRaw(BEL)
+  }, [writeRaw])
+
+  const progress = useCallback(
+    (state: Progress['state'] | null, percentage?: number) => {
+      if (!isProgressReportingAvailable()) {
+        return
+      }
+      if (!state) {
+        writeRaw(
+          wrapForMultiplexer(
+            osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.CLEAR, ''),
+          ),
+        )
+        return
+      }
+      const pct = Math.max(0, Math.min(100, Math.round(percentage ?? 0)))
+      switch (state) {
+        case 'completed':
+          writeRaw(
+            wrapForMultiplexer(
+              osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.CLEAR, ''),
+            ),
+          )
+          break
+        case 'error':
+          writeRaw(
+            wrapForMultiplexer(
+              osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.ERROR, pct),
+            ),
+          )
+          break
+        case 'indeterminate':
+          writeRaw(
+            wrapForMultiplexer(
+              osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.INDETERMINATE, ''),
+            ),
+          )
+          break
+        case 'running':
+          writeRaw(
+            wrapForMultiplexer(
+              osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.SET, pct),
+            ),
+          )
+          break
+        case null:
+          // Handled by the if guard above
+          break
+      }
+    },
+    [writeRaw],
+  )
+
+  return useMemo(
+    () => ({ notifyITerm2, notifyKitty, notifyGhostty, notifyBell, progress }),
+    [notifyITerm2, notifyKitty, notifyGhostty, notifyBell, progress],
+  )
+}

package/ink/warn.ts

@@ -0,0 +1,9 @@
+import { logForDebugging } from '../utils/debug.js'
+
+export function ifNotInteger(value: number | undefined, name: string): void {
+  if (value === undefined) return
+  if (Number.isInteger(value)) return
+  logForDebugging(`${name} should be an integer, got ${value}`, {
+    level: 'warn',
+  })
+}

package/ink/widest-line.ts

@@ -0,0 +1,19 @@
+import { lineWidth } from './line-width-cache.js'
+
+export function widestLine(string: string): number {
+  let maxWidth = 0
+  let start = 0
+
+  while (start <= string.length) {
+    const end = string.indexOf('\n', start)
+    const line =
+      end === -1 ? string.substring(start) : string.substring(start, end)
+
+    maxWidth = Math.max(maxWidth, lineWidth(line))
+
+    if (end === -1) break
+    start = end + 1
+  }
+
+  return maxWidth
+}

package/ink/wrap-text.ts

@@ -0,0 +1,74 @@
+import sliceAnsi from '../utils/sliceAnsi.js'
+import { stringWidth } from './stringWidth.js'
+import type { Styles } from './styles.js'
+import { wrapAnsi } from './wrapAnsi.js'
+
+const ELLIPSIS = '…'
+
+// sliceAnsi may include a boundary-spanning wide char (e.g. CJK at position
+// end-1 with width 2 overshoots by 1). Retry with a tighter bound once.
+function sliceFit(text: string, start: number, end: number): string {
+  const s = sliceAnsi(text, start, end)
+  return stringWidth(s) > end - start ? sliceAnsi(text, start, end - 1) : s
+}
+
+function truncate(
+  text: string,
+  columns: number,
+  position: 'start' | 'middle' | 'end',
+): string {
+  if (columns < 1) return ''
+  if (columns === 1) return ELLIPSIS
+
+  const length = stringWidth(text)
+  if (length <= columns) return text
+
+  if (position === 'start') {
+    return ELLIPSIS + sliceFit(text, length - columns + 1, length)
+  }
+  if (position === 'middle') {
+    const half = Math.floor(columns / 2)
+    return (
+      sliceFit(text, 0, half) +
+      ELLIPSIS +
+      sliceFit(text, length - (columns - half) + 1, length)
+    )
+  }
+  return sliceFit(text, 0, columns - 1) + ELLIPSIS
+}
+
+export default function wrapText(
+  text: string,
+  maxWidth: number,
+  wrapType: Styles['textWrap'],
+): string {
+  if (wrapType === 'wrap') {
+    return wrapAnsi(text, maxWidth, {
+      trim: false,
+      hard: true,
+    })
+  }
+
+  if (wrapType === 'wrap-trim') {
+    return wrapAnsi(text, maxWidth, {
+      trim: true,
+      hard: true,
+    })
+  }
+
+  if (wrapType!.startsWith('truncate')) {
+    let position: 'end' | 'middle' | 'start' = 'end'
+
+    if (wrapType === 'truncate-middle') {
+      position = 'middle'
+    }
+
+    if (wrapType === 'truncate-start') {
+      position = 'start'
+    }
+
+    return truncate(text, maxWidth, position)
+  }
+
+  return text
+}

package/ink/wrapAnsi.ts

@@ -0,0 +1,20 @@
+import wrapAnsiNpm from 'wrap-ansi'
+
+type WrapAnsiOptions = {
+  hard?: boolean
+  wordWrap?: boolean
+  trim?: boolean
+}
+
+const wrapAnsiBun =
+  typeof Bun !== 'undefined' && typeof Bun.wrapAnsi === 'function'
+    ? Bun.wrapAnsi
+    : null
+
+const wrapAnsi: (
+  input: string,
+  columns: number,
+  options?: WrapAnsiOptions,
+) => string = wrapAnsiBun ?? wrapAnsiNpm
+
+export { wrapAnsi }

package/inspect.js

@@ -0,0 +1,7 @@
+const fs = require('fs');
+const inputPath = 'components/PromptInput/PromptInput.tsx';
+const src = fs.readFileSync(inputPath, 'utf8');
+
+// Extract the prompt rendering logic to understand it
+const match = src.match(/borderLeft=\{messages\.length === 0.*?(?=minHeight=\{messages\.length)/s);
+console.log(match ? match[0] : "Not found");

package/keybindings/KeybindingContext.tsx

@@ -0,0 +1,243 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { createContext, type RefObject, useContext, useLayoutEffect, useMemo } from 'react';
+import type { Key } from '../ink.js';
+import { type ChordResolveResult, getBindingDisplayText, resolveKeyWithChordState } from './resolver.js';
+import type { KeybindingContextName, ParsedBinding, ParsedKeystroke } from './types.js';
+
+/** Handler registration for action callbacks */
+type HandlerRegistration = {
+  action: string;
+  context: KeybindingContextName;
+  handler: () => void;
+};
+type KeybindingContextValue = {
+  /** Resolve a key input to an action name (with chord support) */
+  resolve: (input: string, key: Key, activeContexts: KeybindingContextName[]) => ChordResolveResult;
+
+  /** Update the pending chord state */
+  setPendingChord: (pending: ParsedKeystroke[] | null) => void;
+
+  /** Get display text for an action (e.g., "ctrl+t") */
+  getDisplayText: (action: string, context: KeybindingContextName) => string | undefined;
+
+  /** All parsed bindings (for help display) */
+  bindings: ParsedBinding[];
+
+  /** Current pending chord keystrokes (null if not in a chord) */
+  pendingChord: ParsedKeystroke[] | null;
+
+  /** Currently active keybinding contexts (for priority resolution) */
+  activeContexts: Set<KeybindingContextName>;
+
+  /** Register a context as active (call on mount) */
+  registerActiveContext: (context: KeybindingContextName) => void;
+
+  /** Unregister a context (call on unmount) */
+  unregisterActiveContext: (context: KeybindingContextName) => void;
+
+  /** Register a handler for an action (used by useKeybinding) */
+  registerHandler: (registration: HandlerRegistration) => () => void;
+
+  /** Invoke all handlers for an action (used by ChordInterceptor) */
+  invokeAction: (action: string) => boolean;
+};
+const KeybindingContext = createContext<KeybindingContextValue | null>(null);
+type ProviderProps = {
+  bindings: ParsedBinding[];
+  /** Ref for immediate access to pending chord (avoids React state delay) */
+  pendingChordRef: RefObject<ParsedKeystroke[] | null>;
+  /** State value for re-renders (UI updates) */
+  pendingChord: ParsedKeystroke[] | null;
+  setPendingChord: (pending: ParsedKeystroke[] | null) => void;
+  activeContexts: Set<KeybindingContextName>;
+  registerActiveContext: (context: KeybindingContextName) => void;
+  unregisterActiveContext: (context: KeybindingContextName) => void;
+  /** Ref to handler registry (used by ChordInterceptor) */
+  handlerRegistryRef: RefObject<Map<string, Set<HandlerRegistration>>>;
+  children: React.ReactNode;
+};
+export function KeybindingProvider(t0) {
+  const $ = _c(24);
+  const {
+    bindings,
+    pendingChordRef,
+    pendingChord,
+    setPendingChord,
+    activeContexts,
+    registerActiveContext,
+    unregisterActiveContext,
+    handlerRegistryRef,
+    children
+  } = t0;
+  let t1;
+  if ($[0] !== bindings) {
+    t1 = (action, context) => getBindingDisplayText(action, context, bindings);
+    $[0] = bindings;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const getDisplay = t1;
+  let t2;
+  if ($[2] !== handlerRegistryRef) {
+    t2 = registration => {
+      const registry = handlerRegistryRef.current;
+      if (!registry) {
+        return _temp;
+      }
+      if (!registry.has(registration.action)) {
+        registry.set(registration.action, new Set());
+      }
+      registry.get(registration.action).add(registration);
+      return () => {
+        const handlers = registry.get(registration.action);
+        if (handlers) {
+          handlers.delete(registration);
+          if (handlers.size === 0) {
+            registry.delete(registration.action);
+          }
+        }
+      };
+    };
+    $[2] = handlerRegistryRef;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  const registerHandler = t2;
+  let t3;
+  if ($[4] !== activeContexts || $[5] !== handlerRegistryRef) {
+    t3 = action_0 => {
+      const registry_0 = handlerRegistryRef.current;
+      if (!registry_0) {
+        return false;
+      }
+      const handlers_0 = registry_0.get(action_0);
+      if (!handlers_0 || handlers_0.size === 0) {
+        return false;
+      }
+      for (const registration_0 of handlers_0) {
+        if (activeContexts.has(registration_0.context)) {
+          registration_0.handler();
+          return true;
+        }
+      }
+      return false;
+    };
+    $[4] = activeContexts;
+    $[5] = handlerRegistryRef;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const invokeAction = t3;
+  let t4;
+  if ($[7] !== bindings || $[8] !== pendingChordRef) {
+    t4 = (input, key, contexts) => resolveKeyWithChordState(input, key, contexts, bindings, pendingChordRef.current);
+    $[7] = bindings;
+    $[8] = pendingChordRef;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] !== activeContexts || $[11] !== bindings || $[12] !== getDisplay || $[13] !== invokeAction || $[14] !== pendingChord || $[15] !== registerActiveContext || $[16] !== registerHandler || $[17] !== setPendingChord || $[18] !== t4 || $[19] !== unregisterActiveContext) {
+    t5 = {
+      resolve: t4,
+      setPendingChord,
+      getDisplayText: getDisplay,
+      bindings,
+      pendingChord,
+      activeContexts,
+      registerActiveContext,
+      unregisterActiveContext,
+      registerHandler,
+      invokeAction
+    };
+    $[10] = activeContexts;
+    $[11] = bindings;
+    $[12] = getDisplay;
+    $[13] = invokeAction;
+    $[14] = pendingChord;
+    $[15] = registerActiveContext;
+    $[16] = registerHandler;
+    $[17] = setPendingChord;
+    $[18] = t4;
+    $[19] = unregisterActiveContext;
+    $[20] = t5;
+  } else {
+    t5 = $[20];
+  }
+  const value = t5;
+  let t6;
+  if ($[21] !== children || $[22] !== value) {
+    t6 = <KeybindingContext.Provider value={value}>{children}</KeybindingContext.Provider>;
+    $[21] = children;
+    $[22] = value;
+    $[23] = t6;
+  } else {
+    t6 = $[23];
+  }
+  return t6;
+}
+function _temp() {}
+export function useKeybindingContext() {
+  const ctx = useContext(KeybindingContext);
+  if (!ctx) {
+    throw new Error("useKeybindingContext must be used within KeybindingProvider");
+  }
+  return ctx;
+}
+
+/**
+ * Optional hook that returns undefined outside of KeybindingProvider.
+ * Useful for components that may render before provider is available.
+ */
+export function useOptionalKeybindingContext() {
+  return useContext(KeybindingContext);
+}
+
+/**
+ * Hook to register a keybinding context as active while the component is mounted.
+ *
+ * When a context is registered, its keybindings take precedence over Global bindings.
+ * This allows context-specific bindings (like ThemePicker's ctrl+t) to override
+ * global bindings (like the todo toggle) when the context is active.
+ *
+ * @example
+ * ```tsx
+ * function ThemePicker() {
+ *   useRegisterKeybindingContext('ThemePicker')
+ *   // Now ThemePicker's ctrl+t binding takes precedence over Global
+ * }
+ * ```
+ */
+export function useRegisterKeybindingContext(context, t0) {
+  const $ = _c(5);
+  const isActive = t0 === undefined ? true : t0;
+  const keybindingContext = useOptionalKeybindingContext();
+  let t1;
+  let t2;
+  if ($[0] !== context || $[1] !== isActive || $[2] !== keybindingContext) {
+    t1 = () => {
+      if (!keybindingContext || !isActive) {
+        return;
+      }
+      keybindingContext.registerActiveContext(context);
+      return () => {
+        keybindingContext.unregisterActiveContext(context);
+      };
+    };
+    t2 = [context, keybindingContext, isActive];
+    $[0] = context;
+    $[1] = isActive;
+    $[2] = keybindingContext;
+    $[3] = t1;
+    $[4] = t2;
+  } else {
+    t1 = $[3];
+    t2 = $[4];
+  }
+  useLayoutEffect(t1, t2);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","createContext","RefObject","useContext","useLayoutEffect","useMemo","Key","ChordResolveResult","getBindingDisplayText","resolveKeyWithChordState","KeybindingContextName","ParsedBinding","ParsedKeystroke","HandlerRegistration","action","context","handler","KeybindingContextValue","resolve","input","key","activeContexts","setPendingChord","pending","getDisplayText","bindings","pendingChord","Set","registerActiveContext","unregisterActiveContext","registerHandler","registration","invokeAction","KeybindingContext","ProviderProps","pendingChordRef","handlerRegistryRef","Map","children","ReactNode","KeybindingProvider","t0","$","_c","t1","getDisplay","t2","registry","current","_temp","has","set","get","add","handlers","delete","size","t3","action_0","registry_0","handlers_0","registration_0","t4","contexts","t5","value","t6","useKeybindingContext","ctx","Error","useOptionalKeybindingContext","useRegisterKeybindingContext","isActive","undefined","keybindingContext"],"sources":["KeybindingContext.tsx"],"sourcesContent":["import React, {\n  createContext,\n  type RefObject,\n  useContext,\n  useLayoutEffect,\n  useMemo,\n} from 'react'\nimport type { Key } from '../ink.js'\nimport {\n  type ChordResolveResult,\n  getBindingDisplayText,\n  resolveKeyWithChordState,\n} from './resolver.js'\nimport type {\n  KeybindingContextName,\n  ParsedBinding,\n  ParsedKeystroke,\n} from './types.js'\n\n/** Handler registration for action callbacks */\ntype HandlerRegistration = {\n  action: string\n  context: KeybindingContextName\n  handler: () => void\n}\n\ntype KeybindingContextValue = {\n  /** Resolve a key input to an action name (with chord support) */\n  resolve: (\n    input: string,\n    key: Key,\n    activeContexts: KeybindingContextName[],\n  ) => ChordResolveResult\n\n  /** Update the pending chord state */\n  setPendingChord: (pending: ParsedKeystroke[] | null) => void\n\n  /** Get display text for an action (e.g., \"ctrl+t\") */\n  getDisplayText: (\n    action: string,\n    context: KeybindingContextName,\n  ) => string | undefined\n\n  /** All parsed bindings (for help display) */\n  bindings: ParsedBinding[]\n\n  /** Current pending chord keystrokes (null if not in a chord) */\n  pendingChord: ParsedKeystroke[] | null\n\n  /** Currently active keybinding contexts (for priority resolution) */\n  activeContexts: Set<KeybindingContextName>\n\n  /** Register a context as active (call on mount) */\n  registerActiveContext: (context: KeybindingContextName) => void\n\n  /** Unregister a context (call on unmount) */\n  unregisterActiveContext: (context: KeybindingContextName) => void\n\n  /** Register a handler for an action (used by useKeybinding) */\n  registerHandler: (registration: HandlerRegistration) => () => void\n\n  /** Invoke all handlers for an action (used by ChordInterceptor) */\n  invokeAction: (action: string) => boolean\n}\n\nconst KeybindingContext = createContext<KeybindingContextValue | null>(null)\n\ntype ProviderProps = {\n  bindings: ParsedBinding[]\n  /** Ref for immediate access to pending chord (avoids React state delay) */\n  pendingChordRef: RefObject<ParsedKeystroke[] | null>\n  /** State value for re-renders (UI updates) */\n  pendingChord: ParsedKeystroke[] | null\n  setPendingChord: (pending: ParsedKeystroke[] | null) => void\n  activeContexts: Set<KeybindingContextName>\n  registerActiveContext: (context: KeybindingContextName) => void\n  unregisterActiveContext: (context: KeybindingContextName) => void\n  /** Ref to handler registry (used by ChordInterceptor) */\n  handlerRegistryRef: RefObject<Map<string, Set<HandlerRegistration>>>\n  children: React.ReactNode\n}\n\nexport function KeybindingProvider({\n  bindings,\n  pendingChordRef,\n  pendingChord,\n  setPendingChord,\n  activeContexts,\n  registerActiveContext,\n  unregisterActiveContext,\n  handlerRegistryRef,\n  children,\n}: ProviderProps): React.ReactNode {\n  const value = useMemo<KeybindingContextValue>(() => {\n    const getDisplay = (action: string, context: KeybindingContextName) =>\n      getBindingDisplayText(action, context, bindings)\n\n    // Register a handler for an action\n    const registerHandler = (registration: HandlerRegistration) => {\n      const registry = handlerRegistryRef.current\n      if (!registry) return () => {}\n\n      if (!registry.has(registration.action)) {\n        registry.set(registration.action, new Set())\n      }\n      registry.get(registration.action)!.add(registration)\n\n      // Return unregister function\n      return () => {\n        const handlers = registry.get(registration.action)\n        if (handlers) {\n          handlers.delete(registration)\n          if (handlers.size === 0) {\n            registry.delete(registration.action)\n          }\n        }\n      }\n    }\n\n    // Invoke all handlers for an action\n    const invokeAction = (action: string): boolean => {\n      const registry = handlerRegistryRef.current\n      if (!registry) return false\n\n      const handlers = registry.get(action)\n      if (!handlers || handlers.size === 0) return false\n\n      // Find handlers whose context is active\n      for (const registration of handlers) {\n        if (activeContexts.has(registration.context)) {\n          registration.handler()\n          return true\n        }\n      }\n      return false\n    }\n\n    return {\n      // Use ref for immediate access to pending chord, avoiding React state delay\n      // This is critical for chord sequences where the second key might be pressed\n      // before React re-renders with the updated pendingChord state\n      resolve: (input, key, contexts) =>\n        resolveKeyWithChordState(\n          input,\n          key,\n          contexts,\n          bindings,\n          pendingChordRef.current,\n        ),\n      setPendingChord,\n      getDisplayText: getDisplay,\n      bindings,\n      pendingChord,\n      activeContexts,\n      registerActiveContext,\n      unregisterActiveContext,\n      registerHandler,\n      invokeAction,\n    }\n  }, [\n    bindings,\n    pendingChordRef,\n    pendingChord,\n    setPendingChord,\n    activeContexts,\n    registerActiveContext,\n    unregisterActiveContext,\n    handlerRegistryRef,\n  ])\n\n  return (\n    <KeybindingContext.Provider value={value}>\n      {children}\n    </KeybindingContext.Provider>\n  )\n}\n\nexport function useKeybindingContext(): KeybindingContextValue {\n  const ctx = useContext(KeybindingContext)\n  if (!ctx) {\n    throw new Error(\n      'useKeybindingContext must be used within KeybindingProvider',\n    )\n  }\n  return ctx\n}\n\n/**\n * Optional hook that returns undefined outside of KeybindingProvider.\n * Useful for components that may render before provider is available.\n */\nexport function useOptionalKeybindingContext(): KeybindingContextValue | null {\n  return useContext(KeybindingContext)\n}\n\n/**\n * Hook to register a keybinding context as active while the component is mounted.\n *\n * When a context is registered, its keybindings take precedence over Global bindings.\n * This allows context-specific bindings (like ThemePicker's ctrl+t) to override\n * global bindings (like the todo toggle) when the context is active.\n *\n * @example\n * ```tsx\n * function ThemePicker() {\n *   useRegisterKeybindingContext('ThemePicker')\n *   // Now ThemePicker's ctrl+t binding takes precedence over Global\n * }\n * ```\n */\nexport function useRegisterKeybindingContext(\n  context: KeybindingContextName,\n  isActive: boolean = true,\n): void {\n  const keybindingContext = useOptionalKeybindingContext()\n\n  useLayoutEffect(() => {\n    if (!keybindingContext || !isActive) return\n\n    keybindingContext.registerActiveContext(context)\n    return () => {\n      keybindingContext.unregisterActiveContext(context)\n    }\n  }, [context, keybindingContext, isActive])\n}\n"],"mappings":"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","ignoreList":[]}