@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/hooks/useVoiceIntegration.js

@@ -0,0 +1,631 @@
+import { feature } from '../recovery/bunBundleShim.js';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useNotifications } from '../context/notifications.js';
+import { useIsModalOverlayActive } from '../context/overlayContext.js';
+import { useGetVoiceState, useSetVoiceState, useVoiceState } from '../context/voice.js';
+import { KeyboardEvent } from '../ink/events/keyboard-event.js';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- backward-compat bridge until REPL wires handleKeyDown to <Box onKeyDown>
+import { useInput } from '../ink.js';
+import { useOptionalKeybindingContext } from '../keybindings/KeybindingContext.js';
+import { keystrokesEqual } from '../keybindings/resolver.js';
+import { normalizeFullWidthSpace } from '../utils/stringUtils.js';
+import { useVoiceEnabled } from './useVoiceEnabled.js';
+// Dead code elimination: conditional import for voice input hook.
+/* eslint-disable @typescript-eslint/no-require-imports */
+// Capture the module namespace, not the function: spyOn() mutates the module
+// object, so `voiceNs.useVoice(...)` resolves to the spy even if this module
+// was loaded before the spy was installed (test ordering independence).
+const voiceNs = feature('VOICE_MODE') ? require('./useVoice.js') : {
+    useVoice: ({ enabled: _e }) => ({
+        state: 'idle',
+        handleKeyEvent: (_fallbackMs) => { }
+    })
+};
+/* eslint-enable @typescript-eslint/no-require-imports */
+// Maximum gap (ms) between key presses to count as held (auto-repeat).
+// Terminal auto-repeat fires every 30-80ms; 120ms covers jitter while
+// excluding normal typing speed (100-300ms between keystrokes).
+const RAPID_KEY_GAP_MS = 120;
+// Fallback (ms) for modifier-combo first-press activation. Must match
+// FIRST_PRESS_FALLBACK_MS in useVoice.ts. Covers the max OS initial
+// key-repeat delay (~2s on macOS with slider at "Long") so holding a
+// modifier combo doesn't fragment into two sessions when the first
+// auto-repeat arrives after the default 600ms REPEAT_FALLBACK_MS.
+const MODIFIER_FIRST_PRESS_FALLBACK_MS = 2000;
+// Number of rapid consecutive key events required to activate voice.
+// Only applies to bare-char bindings (space, v, etc.) where a single press
+// could be normal typing. Modifier combos activate on the first press.
+const HOLD_THRESHOLD = 5;
+// Number of rapid key events to start showing warmup feedback.
+const WARMUP_THRESHOLD = 2;
+// Match a KeyboardEvent against a ParsedKeystroke. Replaces the legacy
+// matchesKeystroke(input, Key, ...) path which assumed useInput's raw
+// `input` arg — KeyboardEvent.key holds normalized names (e.g. 'space',
+// 'f9') that getKeyName() didn't handle, so modifier combos and f-keys
+// silently failed to match after the onKeyDown migration (#23524).
+function matchesKeyboardEvent(e, target) {
+    // KeyboardEvent stores key names; ParsedKeystroke stores ' ' for space
+    // and 'enter' for return (see parser.ts case 'space'/'return').
+    const key = e.key === 'space' ? ' ' : e.key === 'return' ? 'enter' : e.key.toLowerCase();
+    if (key !== target.key)
+        return false;
+    if (e.ctrl !== target.ctrl)
+        return false;
+    if (e.shift !== target.shift)
+        return false;
+    // KeyboardEvent.meta folds alt|option (terminal limitation — esc-prefix);
+    // ParsedKeystroke has both alt and meta as aliases for the same thing.
+    if (e.meta !== (target.alt || target.meta))
+        return false;
+    if (e.superKey !== target.super)
+        return false;
+    return true;
+}
+// Hardcoded default for when there's no KeybindingProvider at all (e.g.
+// headless/test contexts). NOT used when the provider exists and the
+// lookup returns null — that means the user null-unbound or reassigned
+// space, and falling back to space would pick a dead or conflicting key.
+const DEFAULT_VOICE_KEYSTROKE = {
+    key: ' ',
+    ctrl: false,
+    alt: false,
+    shift: false,
+    meta: false,
+    super: false
+};
+export function useVoiceIntegration({ setInputValueRaw, inputValueRef, insertTextRef }) {
+    const { addNotification } = useNotifications();
+    // Tracks the input content before/after the cursor when voice starts,
+    // so interim transcripts can be inserted at the cursor position without
+    // clobbering surrounding user text.
+    const voicePrefixRef = useRef(null);
+    const voiceSuffixRef = useRef('');
+    // Tracks the last input value this hook wrote (via anchor, interim effect,
+    // or handleVoiceTranscript). If inputValueRef.current diverges, the user
+    // submitted or edited — both write paths bail to avoid clobbering. This is
+    // the only guard that correctly handles empty-prefix-empty-suffix: a
+    // startsWith('')/endsWith('') check vacuously passes, and a length check
+    // can't distinguish a cleared input from a never-set one.
+    const lastSetInputRef = useRef(null);
+    // Strip trailing hold-key chars (and optionally capture the voice
+    // anchor). Called during warmup (to clean up chars that leaked past
+    // stopImmediatePropagation — listener order is not guaranteed) and
+    // on activation (with anchor=true to capture the prefix/suffix around
+    // the cursor for interim transcript placement). The caller passes the
+    // exact count it expects to strip so pre-existing chars at the
+    // boundary are preserved (e.g. the "v" in "hav" when hold-key is "v").
+    // The floor option sets a minimum trailing count to leave behind
+    // (during warmup this is the count we intentionally let through, so
+    // defensive cleanup only removes leaks). Returns the number of
+    // trailing chars remaining after stripping. When nothing changes, no
+    // state update is performed.
+    const stripTrailing = useCallback((maxStrip, { char = ' ', anchor = false, floor = 0 } = {}) => {
+        const prev = inputValueRef.current;
+        const offset = insertTextRef.current?.cursorOffset ?? prev.length;
+        const beforeCursor = prev.slice(0, offset);
+        const afterCursor = prev.slice(offset);
+        // When the hold key is space, also count full-width spaces (U+3000)
+        // that a CJK IME may have inserted for the same physical key.
+        // U+3000 is BMP single-code-unit so indices align with beforeCursor.
+        const scan = char === ' ' ? normalizeFullWidthSpace(beforeCursor) : beforeCursor;
+        let trailing = 0;
+        while (trailing < scan.length && scan[scan.length - 1 - trailing] === char) {
+            trailing++;
+        }
+        const stripCount = Math.max(0, Math.min(trailing - floor, maxStrip));
+        const remaining = trailing - stripCount;
+        const stripped = beforeCursor.slice(0, beforeCursor.length - stripCount);
+        // When anchoring with a non-space suffix, insert a gap space so the
+        // waveform cursor sits on the gap instead of covering the first
+        // suffix letter. The interim transcript effect maintains this same
+        // structure (prefix + leading + interim + trailing + suffix), so
+        // the gap is seamless once transcript text arrives.
+        // Always overwrite on anchor — if a prior activation failed to start
+        // voice (voiceState stayed 'idle'), the cleanup effect didn't fire and
+        // the old anchor is stale. anchor=true is only passed on the single
+        // activation call, never during recording, so overwrite is safe.
+        let gap = '';
+        if (anchor) {
+            voicePrefixRef.current = stripped;
+            voiceSuffixRef.current = afterCursor;
+            if (afterCursor.length > 0 && !/^\s/.test(afterCursor)) {
+                gap = ' ';
+            }
+        }
+        const newValue = stripped + gap + afterCursor;
+        if (anchor)
+            lastSetInputRef.current = newValue;
+        if (newValue === prev && stripCount === 0)
+            return remaining;
+        if (insertTextRef.current) {
+            insertTextRef.current.setInputWithCursor(newValue, stripped.length);
+        }
+        else {
+            setInputValueRaw(newValue);
+        }
+        return remaining;
+    }, [setInputValueRaw, inputValueRef, insertTextRef]);
+    // Undo the gap space inserted by stripTrailing(..., {anchor:true}) and
+    // reset the voice prefix/suffix refs. Called when voice activation fails
+    // (voiceState stays 'idle' after voiceHandleKeyEvent), so the cleanup
+    // effect (voiceState useEffect below) — which only fires on voiceState transitions — can't
+    // reach the stale anchor. Without this, the gap space and stale refs
+    // persist in the input.
+    const resetAnchor = useCallback(() => {
+        const prefix = voicePrefixRef.current;
+        if (prefix === null)
+            return;
+        const suffix = voiceSuffixRef.current;
+        voicePrefixRef.current = null;
+        voiceSuffixRef.current = '';
+        const restored = prefix + suffix;
+        if (insertTextRef.current) {
+            insertTextRef.current.setInputWithCursor(restored, prefix.length);
+        }
+        else {
+            setInputValueRaw(restored);
+        }
+    }, [setInputValueRaw, insertTextRef]);
+    // Voice state selectors. useVoiceEnabled = user intent (settings) +
+    // auth + GB kill-switch, with the auth half memoized on authVersion so
+    // render loops never hit a cold keychain spawn.
+    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+    const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false;
+    const voiceState = feature('VOICE_MODE') ?
+        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+        useVoiceState(s => s.voiceState) : 'idle';
+    const voiceInterimTranscript = feature('VOICE_MODE') ?
+        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+        useVoiceState(s_0 => s_0.voiceInterimTranscript) : '';
+    // Set the voice anchor for focus mode (where recording starts via terminal
+    // focus, not key hold). Key-hold sets the anchor in stripTrailing.
+    useEffect(() => {
+        if (!feature('VOICE_MODE'))
+            return;
+        if (voiceState === 'recording' && voicePrefixRef.current === null) {
+            const input = inputValueRef.current;
+            const offset_0 = insertTextRef.current?.cursorOffset ?? input.length;
+            voicePrefixRef.current = input.slice(0, offset_0);
+            voiceSuffixRef.current = input.slice(offset_0);
+            lastSetInputRef.current = input;
+        }
+        if (voiceState === 'idle') {
+            voicePrefixRef.current = null;
+            voiceSuffixRef.current = '';
+            lastSetInputRef.current = null;
+        }
+    }, [voiceState, inputValueRef, insertTextRef]);
+    // Live-update the prompt input with the interim transcript as voice
+    // transcribes speech. The prefix (user-typed text before the cursor) is
+    // preserved and the transcript is inserted between prefix and suffix.
+    useEffect(() => {
+        if (!feature('VOICE_MODE'))
+            return;
+        if (voicePrefixRef.current === null)
+            return;
+        const prefix_0 = voicePrefixRef.current;
+        const suffix_0 = voiceSuffixRef.current;
+        // Submit race: if the input isn't what this hook last set it to, the
+        // user submitted (clearing it) or edited it. voicePrefixRef is only
+        // cleared on voiceState→idle, so it's still set during the 'processing'
+        // window between CloseStream and WS close — this catches refined
+        // TranscriptText arriving then and re-filling a cleared input.
+        if (inputValueRef.current !== lastSetInputRef.current)
+            return;
+        const needsSpace = prefix_0.length > 0 && !/\s$/.test(prefix_0) && voiceInterimTranscript.length > 0;
+        // Don't gate on voiceInterimTranscript.length -- when interim clears to ''
+        // after handleVoiceTranscript sets the final text, the trailing space
+        // between prefix and suffix must still be preserved.
+        const needsTrailingSpace = suffix_0.length > 0 && !/^\s/.test(suffix_0);
+        const leadingSpace = needsSpace ? ' ' : '';
+        const trailingSpace = needsTrailingSpace ? ' ' : '';
+        const newValue_0 = prefix_0 + leadingSpace + voiceInterimTranscript + trailingSpace + suffix_0;
+        // Position cursor after the transcribed text (before suffix)
+        const cursorPos = prefix_0.length + leadingSpace.length + voiceInterimTranscript.length;
+        if (insertTextRef.current) {
+            insertTextRef.current.setInputWithCursor(newValue_0, cursorPos);
+        }
+        else {
+            setInputValueRaw(newValue_0);
+        }
+        lastSetInputRef.current = newValue_0;
+    }, [voiceInterimTranscript, setInputValueRaw, inputValueRef, insertTextRef]);
+    const handleVoiceTranscript = useCallback((text) => {
+        if (!feature('VOICE_MODE'))
+            return;
+        const prefix_1 = voicePrefixRef.current;
+        // No voice anchor — voice was reset (or never started). Nothing to do.
+        if (prefix_1 === null)
+            return;
+        const suffix_1 = voiceSuffixRef.current;
+        // Submit race: finishRecording() → user presses Enter (input cleared)
+        // → WebSocket close → this callback fires with stale prefix/suffix.
+        // If the input isn't what this hook last set (via the interim effect
+        // or anchor), the user submitted or edited — don't re-fill. Comparing
+        // against `text.length` would false-positive when the final is longer
+        // than the interim (ASR routinely adds punctuation/corrections).
+        if (inputValueRef.current !== lastSetInputRef.current)
+            return;
+        const needsSpace_0 = prefix_1.length > 0 && !/\s$/.test(prefix_1) && text.length > 0;
+        const needsTrailingSpace_0 = suffix_1.length > 0 && !/^\s/.test(suffix_1) && text.length > 0;
+        const leadingSpace_0 = needsSpace_0 ? ' ' : '';
+        const trailingSpace_0 = needsTrailingSpace_0 ? ' ' : '';
+        const newInput = prefix_1 + leadingSpace_0 + text + trailingSpace_0 + suffix_1;
+        // Position cursor after the transcribed text (before suffix)
+        const cursorPos_0 = prefix_1.length + leadingSpace_0.length + text.length;
+        if (insertTextRef.current) {
+            insertTextRef.current.setInputWithCursor(newInput, cursorPos_0);
+        }
+        else {
+            setInputValueRaw(newInput);
+        }
+        lastSetInputRef.current = newInput;
+        // Update the prefix to include this chunk so focus mode can continue
+        // appending subsequent transcripts after it.
+        voicePrefixRef.current = prefix_1 + leadingSpace_0 + text;
+    }, [setInputValueRaw, inputValueRef, insertTextRef]);
+    const voice = voiceNs.useVoice({
+        onTranscript: handleVoiceTranscript,
+        onError: (message) => {
+            addNotification({
+                key: 'voice-error',
+                text: message,
+                color: 'error',
+                priority: 'immediate',
+                timeoutMs: 10_000
+            });
+        },
+        enabled: voiceEnabled,
+        focusMode: false
+    });
+    // Compute the character range of interim (not-yet-finalized) transcript
+    // text in the input value, so the UI can dim it.
+    const interimRange = useMemo(() => {
+        if (!feature('VOICE_MODE'))
+            return null;
+        if (voicePrefixRef.current === null)
+            return null;
+        if (voiceInterimTranscript.length === 0)
+            return null;
+        const prefix_2 = voicePrefixRef.current;
+        const needsSpace_1 = prefix_2.length > 0 && !/\s$/.test(prefix_2) && voiceInterimTranscript.length > 0;
+        const start = prefix_2.length + (needsSpace_1 ? 1 : 0);
+        const end = start + voiceInterimTranscript.length;
+        return {
+            start,
+            end
+        };
+    }, [voiceInterimTranscript]);
+    return {
+        stripTrailing,
+        resetAnchor,
+        handleKeyEvent: voice.handleKeyEvent,
+        interimRange
+    };
+}
+/**
+ * Component that handles hold-to-talk voice activation.
+ *
+ * The activation key is configurable via keybindings (voice:pushToTalk,
+ * default: space). Hold detection depends on OS auto-repeat delivering a
+ * stream of events at 30-80ms intervals. Two binding types work:
+ *
+ * **Modifier + letter (meta+k, ctrl+x, alt+v):** Cleanest. Activates on
+ * the first press — a modifier combo is unambiguous intent (can't be
+ * typed accidentally), so no hold threshold applies. The letter part
+ * auto-repeats while held, feeding release detection in useVoice.ts.
+ * No flow-through, no stripping.
+ *
+ * **Bare chars (space, v, x):** Require HOLD_THRESHOLD rapid presses to
+ * activate (a single space could be normal typing). The first
+ * WARMUP_THRESHOLD presses flow into the input so a single press types
+ * normally. Past that, rapid presses are swallowed; on activation the
+ * flow-through chars are stripped. Binding "v" doesn't make "v"
+ * untypable — normal typing (>120ms between keystrokes) flows through;
+ * only rapid auto-repeat from a held key triggers activation.
+ *
+ * Known broken: modifier+space (NUL → parsed as ctrl+backtick), chords
+ * (discrete sequences, no hold). Validation warns on these.
+ */
+export function useVoiceKeybindingHandler({ voiceHandleKeyEvent, stripTrailing, resetAnchor, isActive }) {
+    const getVoiceState = useGetVoiceState();
+    const setVoiceState = useSetVoiceState();
+    const keybindingContext = useOptionalKeybindingContext();
+    const isModalOverlayActive = useIsModalOverlayActive();
+    // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+    const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false;
+    const voiceState = feature('VOICE_MODE') ?
+        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+        useVoiceState(s => s.voiceState) : 'idle';
+    // Find the configured key for voice:pushToTalk from keybinding context.
+    // Forward iteration with last-wins (matching the resolver): if a later
+    // Chat binding overrides the same chord with null or a different
+    // action, the voice binding is discarded and null is returned — the
+    // user explicitly disabled hold-to-talk via binding override, so
+    // don't second-guess them with a fallback. The DEFAULT is only used
+    // when there's no provider at all. Context filter is required — space
+    // is also bound in Settings/Confirmation/Plugin (select:accept etc.);
+    // without the filter those would null out the default.
+    const voiceKeystroke = useMemo(() => {
+        if (!keybindingContext)
+            return DEFAULT_VOICE_KEYSTROKE;
+        let result = null;
+        for (const binding of keybindingContext.bindings) {
+            if (binding.context !== 'Chat')
+                continue;
+            if (binding.chord.length !== 1)
+                continue;
+            const ks = binding.chord[0];
+            if (!ks)
+                continue;
+            if (binding.action === 'voice:pushToTalk') {
+                result = ks;
+            }
+            else if (result !== null && keystrokesEqual(ks, result)) {
+                // A later binding overrides this chord (null unbind or reassignment)
+                result = null;
+            }
+        }
+        return result;
+    }, [keybindingContext]);
+    // If the binding is a bare (unmodified) single printable char, terminal
+    // auto-repeat may batch N keystrokes into one input event (e.g. "vvv"),
+    // and the char flows into the text input — we need flow-through + strip.
+    // Modifier combos (meta+k, ctrl+x) also auto-repeat (the letter part
+    // repeats) but don't insert text, so they're swallowed from the first
+    // press with no stripping needed. matchesKeyboardEvent handles those.
+    const bareChar = voiceKeystroke !== null && voiceKeystroke.key.length === 1 && !voiceKeystroke.ctrl && !voiceKeystroke.alt && !voiceKeystroke.shift && !voiceKeystroke.meta && !voiceKeystroke.super ? voiceKeystroke.key : null;
+    const rapidCountRef = useRef(0);
+    // How many rapid chars we intentionally let through to the text
+    // input (the first WARMUP_THRESHOLD). The activation strip removes
+    // up to this many + the activation event's potential leak. For the
+    // default (space) this is precise — pre-existing trailing spaces are
+    // rare. For letter bindings (validation warns) this may over-strip
+    // one pre-existing char if the input already ended in the bound
+    // letter (e.g. "hav" + hold "v" → "ha"). We don't track that
+    // boundary — it's best-effort and the warning says so.
+    const charsInInputRef = useRef(0);
+    // Trailing-char count remaining after the activation strip — these
+    // belong to the user's anchored prefix and must be preserved during
+    // recording's defensive leak cleanup.
+    const recordingFloorRef = useRef(0);
+    // True when the current recording was started by key-hold (not focus).
+    // Used to avoid swallowing keypresses during focus-mode recording.
+    const isHoldActiveRef = useRef(false);
+    const resetTimerRef = useRef(null);
+    // Reset hold state as soon as we leave 'recording'. The physical hold
+    // ends when key-repeat stops (state → 'processing'); keeping the ref
+    // set through 'processing' swallows new space presses the user types
+    // while the transcript finalizes.
+    useEffect(() => {
+        if (voiceState !== 'recording') {
+            isHoldActiveRef.current = false;
+            rapidCountRef.current = 0;
+            charsInInputRef.current = 0;
+            recordingFloorRef.current = 0;
+            setVoiceState(prev => {
+                if (!prev.voiceWarmingUp)
+                    return prev;
+                return {
+                    ...prev,
+                    voiceWarmingUp: false
+                };
+            });
+        }
+    }, [voiceState, setVoiceState]);
+    const handleKeyDown = (e) => {
+        if (!voiceEnabled)
+            return;
+        // PromptInput is not a valid transcript target — let the hold key
+        // flow through instead of swallowing it into stale refs (#33556).
+        // Two distinct unmount/unfocus paths (both needed):
+        //   - !isActive: local-jsx command hid PromptInput (shouldHidePromptInput)
+        //     without registering an overlay — e.g. /install-github-app,
+        //     /plugin. Mirrors CommandKeybindingHandlers' isActive gate.
+        //   - isModalOverlayActive: overlay (permission dialog, Select with
+        //     onCancel) has focus; PromptInput is mounted but focus=false.
+        if (!isActive || isModalOverlayActive)
+            return;
+        // null means the user overrode the default (null-unbind/reassign) —
+        // hold-to-talk is disabled via binding. To toggle the feature
+        // itself, use /voice.
+        if (voiceKeystroke === null)
+            return;
+        // Match the configured key. Bare chars match by content (handles
+        // batched auto-repeat like "vvv") with a modifier reject so e.g.
+        // ctrl+v doesn't trip a "v" binding. Modifier combos go through
+        // matchesKeyboardEvent (one event per repeat, no batching).
+        let repeatCount;
+        if (bareChar !== null) {
+            if (e.ctrl || e.meta || e.shift)
+                return;
+            // When bound to space, also accept U+3000 (full-width space) —
+            // CJK IMEs emit it for the same physical key.
+            const normalized = bareChar === ' ' ? normalizeFullWidthSpace(e.key) : e.key;
+            // Fast-path: normal typing (any char that isn't the bound one)
+            // bails here without allocating. The repeat() check only matters
+            // for batched auto-repeat (input.length > 1) which is rare.
+            if (normalized[0] !== bareChar)
+                return;
+            if (normalized.length > 1 && normalized !== bareChar.repeat(normalized.length))
+                return;
+            repeatCount = normalized.length;
+        }
+        else {
+            if (!matchesKeyboardEvent(e, voiceKeystroke))
+                return;
+            repeatCount = 1;
+        }
+        // Guard: only swallow keypresses when recording was triggered by
+        // key-hold. Focus-mode recording also sets voiceState to 'recording',
+        // but keypresses should flow through normally (voiceHandleKeyEvent
+        // returns early for focus-triggered sessions). We also check voiceState
+        // from the store so that if voiceHandleKeyEvent() fails to transition
+        // state (module not loaded, stream unavailable) we don't permanently
+        // swallow keypresses.
+        const currentVoiceState = getVoiceState().voiceState;
+        if (isHoldActiveRef.current && currentVoiceState !== 'idle') {
+            // Already recording — swallow continued keypresses and forward
+            // to voice for release detection. For bare chars, defensively
+            // strip in case the text input handler fired before this one
+            // (listener order is not guaranteed). Modifier combos don't
+            // insert text, so nothing to strip.
+            e.stopImmediatePropagation();
+            if (bareChar !== null) {
+                stripTrailing(repeatCount, {
+                    char: bareChar,
+                    floor: recordingFloorRef.current
+                });
+            }
+            voiceHandleKeyEvent();
+            return;
+        }
+        // Non-hold recording (focus-mode) or processing is active.
+        // Modifier combos must not re-activate: stripTrailing(0,{anchor:true})
+        // would overwrite voicePrefixRef with interim text and duplicate the
+        // transcript on the next interim update. Pre-#22144, a single tap
+        // hit the warmup else-branch (swallow only). Bare chars flow through
+        // unconditionally — user may be typing during focus-recording.
+        if (currentVoiceState !== 'idle') {
+            if (bareChar === null)
+                e.stopImmediatePropagation();
+            return;
+        }
+        const countBefore = rapidCountRef.current;
+        rapidCountRef.current += repeatCount;
+        // ── Activation ────────────────────────────────────────────
+        // Handled first so the warmup branch below does NOT also run
+        // on this event — two strip calls in the same tick would both
+        // read the stale inputValueRef and the second would under-strip.
+        // Modifier combos activate on the first press — they can't be
+        // typed accidentally, so the hold threshold (which exists to
+        // distinguish typing a space from holding space) doesn't apply.
+        if (bareChar === null || rapidCountRef.current >= HOLD_THRESHOLD) {
+            e.stopImmediatePropagation();
+            if (resetTimerRef.current) {
+                clearTimeout(resetTimerRef.current);
+                resetTimerRef.current = null;
+            }
+            rapidCountRef.current = 0;
+            isHoldActiveRef.current = true;
+            setVoiceState(prev_0 => {
+                if (!prev_0.voiceWarmingUp)
+                    return prev_0;
+                return {
+                    ...prev_0,
+                    voiceWarmingUp: false
+                };
+            });
+            if (bareChar !== null) {
+                // Strip the intentional warmup chars plus this event's leak
+                // (if text input fired first). Cap covers both; min(trailing)
+                // handles the no-leak case. Anchor the voice prefix here.
+                // The return value (remaining) becomes the floor for
+                // recording-time leak cleanup.
+                recordingFloorRef.current = stripTrailing(charsInInputRef.current + repeatCount, {
+                    char: bareChar,
+                    anchor: true
+                });
+                charsInInputRef.current = 0;
+                voiceHandleKeyEvent();
+            }
+            else {
+                // Modifier combo: nothing inserted, nothing to strip. Just
+                // anchor the voice prefix at the current cursor position.
+                // Longer fallback: this call is at t=0 (before auto-repeat),
+                // so the gap to the next keypress is the OS initial repeat
+                // *delay* (up to ~2s), not the repeat *rate* (~30-80ms).
+                stripTrailing(0, {
+                    anchor: true
+                });
+                voiceHandleKeyEvent(MODIFIER_FIRST_PRESS_FALLBACK_MS);
+            }
+            // If voice failed to transition (module not loaded, stream
+            // unavailable, stale enabled), clear the ref so a later
+            // focus-mode recording doesn't inherit stale hold state
+            // and swallow keypresses. Store is synchronous — the check is
+            // immediate. The anchor set by stripTrailing above will
+            // be overwritten on retry (anchor always overwrites now).
+            if (getVoiceState().voiceState === 'idle') {
+                isHoldActiveRef.current = false;
+                resetAnchor();
+            }
+            return;
+        }
+        // ── Warmup (bare-char only; modifier combos activated above) ──
+        // First WARMUP_THRESHOLD chars flow to the text input so normal
+        // typing has zero latency (a single press types normally).
+        // Subsequent rapid chars are swallowed so the input stays aligned
+        // with the warmup UI. Strip defensively (listener order is not
+        // guaranteed — text input may have already added the char). The
+        // floor preserves the intentional warmup chars; the strip is a
+        // no-op when nothing leaked. Check countBefore so the event that
+        // crosses the threshold still flows through (terminal batching).
+        if (countBefore >= WARMUP_THRESHOLD) {
+            e.stopImmediatePropagation();
+            stripTrailing(repeatCount, {
+                char: bareChar,
+                floor: charsInInputRef.current
+            });
+        }
+        else {
+            charsInInputRef.current += repeatCount;
+        }
+        // Show warmup feedback once we detect a hold pattern
+        if (rapidCountRef.current >= WARMUP_THRESHOLD) {
+            setVoiceState(prev_1 => {
+                if (prev_1.voiceWarmingUp)
+                    return prev_1;
+                return {
+                    ...prev_1,
+                    voiceWarmingUp: true
+                };
+            });
+        }
+        if (resetTimerRef.current) {
+            clearTimeout(resetTimerRef.current);
+        }
+        resetTimerRef.current = setTimeout((resetTimerRef_0, rapidCountRef_0, charsInInputRef_0, setVoiceState_0) => {
+            resetTimerRef_0.current = null;
+            rapidCountRef_0.current = 0;
+            charsInInputRef_0.current = 0;
+            setVoiceState_0(prev_2 => {
+                if (!prev_2.voiceWarmingUp)
+                    return prev_2;
+                return {
+                    ...prev_2,
+                    voiceWarmingUp: false
+                };
+            });
+        }, RAPID_KEY_GAP_MS, resetTimerRef, rapidCountRef, charsInInputRef, setVoiceState);
+    };
+    // Backward-compat bridge: REPL.tsx doesn't yet wire handleKeyDown to
+    // <Box onKeyDown>. Subscribe via useInput and adapt InputEvent →
+    // KeyboardEvent until the consumer is migrated (separate PR).
+    // TODO(onKeyDown-migration): remove once REPL passes handleKeyDown.
+    useInput((_input, _key, event) => {
+        const kbEvent = new KeyboardEvent(event.keypress);
+        handleKeyDown(kbEvent);
+        // handleKeyDown stopped the adapter event, not the InputEvent the
+        // emitter actually checks — forward it so the text input's useInput
+        // listener is skipped and held spaces don't leak into the prompt.
+        if (kbEvent.didStopImmediatePropagation()) {
+            event.stopImmediatePropagation();
+        }
+    }, {
+        isActive
+    });
+    return {
+        handleKeyDown
+    };
+}
+// TODO(onKeyDown-migration): temporary shim so existing JSX callers
+// (<VoiceKeybindingHandler .../>) keep compiling. Remove once REPL.tsx
+// wires handleKeyDown directly.
+export function VoiceKeybindingHandler(props) {
+    useVoiceKeybindingHandler(props);
+    return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","React","useCallback","useEffect","useMemo","useRef","useNotifications","useIsModalOverlayActive","useGetVoiceState","useSetVoiceState","useVoiceState","KeyboardEvent","useInput","useOptionalKeybindingContext","keystrokesEqual","ParsedKeystroke","normalizeFullWidthSpace","useVoiceEnabled","voiceNs","useVoice","require","enabled","_e","onTranscript","t","state","const","handleKeyEvent","_fallbackMs","RAPID_KEY_GAP_MS","MODIFIER_FIRST_PRESS_FALLBACK_MS","HOLD_THRESHOLD","WARMUP_THRESHOLD","matchesKeyboardEvent","e","target","key","toLowerCase","ctrl","shift","meta","alt","superKey","super","DEFAULT_VOICE_KEYSTROKE","InsertTextHandle","insert","text","setInputWithCursor","value","cursor","cursorOffset","UseVoiceIntegrationArgs","setInputValueRaw","Dispatch","SetStateAction","inputValueRef","RefObject","insertTextRef","InterimRange","start","end","StripOpts","char","anchor","floor","UseVoiceIntegrationResult","stripTrailing","maxStrip","opts","resetAnchor","fallbackMs","interimRange","useVoiceIntegration","addNotification","voicePrefixRef","voiceSuffixRef","lastSetInputRef","prev","current","offset","length","beforeCursor","slice","afterCursor","scan","trailing","stripCount","Math","max","min","remaining","stripped","gap","test","newValue","prefix","suffix","restored","voiceEnabled","voiceState","s","voiceInterimTranscript","input","needsSpace","needsTrailingSpace","leadingSpace","trailingSpace","cursorPos","handleVoiceTranscript","newInput","voice","onError","message","color","priority","timeoutMs","focusMode","useVoiceKeybindingHandler","voiceHandleKeyEvent","isActive","handleKeyDown","getVoiceState","setVoiceState","keybindingContext","isModalOverlayActive","voiceKeystroke","result","binding","bindings","context","chord","ks","action","bareChar","rapidCountRef","charsInInputRef","recordingFloorRef","isHoldActiveRef","resetTimerRef","ReturnType","setTimeout","voiceWarmingUp","repeatCount","normalized","repeat","currentVoiceState","stopImmediatePropagation","countBefore","clearTimeout","_input","_key","event","kbEvent","keypress","didStopImmediatePropagation","VoiceKeybindingHandler","props"],"sources":["useVoiceIntegration.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport * as React from 'react'\nimport { useCallback, useEffect, useMemo, useRef } from 'react'\nimport { useNotifications } from '../context/notifications.js'\nimport { useIsModalOverlayActive } from '../context/overlayContext.js'\nimport {\n  useGetVoiceState,\n  useSetVoiceState,\n  useVoiceState,\n} from '../context/voice.js'\nimport { KeyboardEvent } from '../ink/events/keyboard-event.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- backward-compat bridge until REPL wires handleKeyDown to <Box onKeyDown>\nimport { useInput } from '../ink.js'\nimport { useOptionalKeybindingContext } from '../keybindings/KeybindingContext.js'\nimport { keystrokesEqual } from '../keybindings/resolver.js'\nimport type { ParsedKeystroke } from '../keybindings/types.js'\nimport { normalizeFullWidthSpace } from '../utils/stringUtils.js'\nimport { useVoiceEnabled } from './useVoiceEnabled.js'\n\n// Dead code elimination: conditional import for voice input hook.\n/* eslint-disable @typescript-eslint/no-require-imports */\n// Capture the module namespace, not the function: spyOn() mutates the module\n// object, so `voiceNs.useVoice(...)` resolves to the spy even if this module\n// was loaded before the spy was installed (test ordering independence).\nconst voiceNs: { useVoice: typeof import('./useVoice.js').useVoice } = feature(\n  'VOICE_MODE',\n)\n  ? require('./useVoice.js')\n  : {\n      useVoice: ({\n        enabled: _e,\n      }: {\n        onTranscript: (t: string) => void\n        enabled: boolean\n      }) => ({\n        state: 'idle' as const,\n        handleKeyEvent: (_fallbackMs?: number) => {},\n      }),\n    }\n/* eslint-enable @typescript-eslint/no-require-imports */\n\n// Maximum gap (ms) between key presses to count as held (auto-repeat).\n// Terminal auto-repeat fires every 30-80ms; 120ms covers jitter while\n// excluding normal typing speed (100-300ms between keystrokes).\nconst RAPID_KEY_GAP_MS = 120\n\n// Fallback (ms) for modifier-combo first-press activation. Must match\n// FIRST_PRESS_FALLBACK_MS in useVoice.ts. Covers the max OS initial\n// key-repeat delay (~2s on macOS with slider at \"Long\") so holding a\n// modifier combo doesn't fragment into two sessions when the first\n// auto-repeat arrives after the default 600ms REPEAT_FALLBACK_MS.\nconst MODIFIER_FIRST_PRESS_FALLBACK_MS = 2000\n\n// Number of rapid consecutive key events required to activate voice.\n// Only applies to bare-char bindings (space, v, etc.) where a single press\n// could be normal typing. Modifier combos activate on the first press.\nconst HOLD_THRESHOLD = 5\n\n// Number of rapid key events to start showing warmup feedback.\nconst WARMUP_THRESHOLD = 2\n\n// Match a KeyboardEvent against a ParsedKeystroke. Replaces the legacy\n// matchesKeystroke(input, Key, ...) path which assumed useInput's raw\n// `input` arg — KeyboardEvent.key holds normalized names (e.g. 'space',\n// 'f9') that getKeyName() didn't handle, so modifier combos and f-keys\n// silently failed to match after the onKeyDown migration (#23524).\nfunction matchesKeyboardEvent(\n  e: KeyboardEvent,\n  target: ParsedKeystroke,\n): boolean {\n  // KeyboardEvent stores key names; ParsedKeystroke stores ' ' for space\n  // and 'enter' for return (see parser.ts case 'space'/'return').\n  const key =\n    e.key === 'space' ? ' ' : e.key === 'return' ? 'enter' : e.key.toLowerCase()\n  if (key !== target.key) return false\n  if (e.ctrl !== target.ctrl) return false\n  if (e.shift !== target.shift) return false\n  // KeyboardEvent.meta folds alt|option (terminal limitation — esc-prefix);\n  // ParsedKeystroke has both alt and meta as aliases for the same thing.\n  if (e.meta !== (target.alt || target.meta)) return false\n  if (e.superKey !== target.super) return false\n  return true\n}\n\n// Hardcoded default for when there's no KeybindingProvider at all (e.g.\n// headless/test contexts). NOT used when the provider exists and the\n// lookup returns null — that means the user null-unbound or reassigned\n// space, and falling back to space would pick a dead or conflicting key.\nconst DEFAULT_VOICE_KEYSTROKE: ParsedKeystroke = {\n  key: ' ',\n  ctrl: false,\n  alt: false,\n  shift: false,\n  meta: false,\n  super: false,\n}\n\ntype InsertTextHandle = {\n  insert: (text: string) => void\n  setInputWithCursor: (value: string, cursor: number) => void\n  cursorOffset: number\n}\n\ntype UseVoiceIntegrationArgs = {\n  setInputValueRaw: React.Dispatch<React.SetStateAction<string>>\n  inputValueRef: React.RefObject<string>\n  insertTextRef: React.RefObject<InsertTextHandle | null>\n}\n\ntype InterimRange = { start: number; end: number }\n\ntype StripOpts = {\n  // Which char to strip (the configured hold key). Defaults to space.\n  char?: string\n  // Capture the voice prefix/suffix anchor at the stripped position.\n  anchor?: boolean\n  // Minimum trailing count to leave behind — prevents stripping the\n  // intentional warmup chars when defensively cleaning up leaks.\n  floor?: number\n}\n\ntype UseVoiceIntegrationResult = {\n  // Returns the number of trailing chars remaining after stripping.\n  stripTrailing: (maxStrip: number, opts?: StripOpts) => number\n  // Undo the gap space and reset anchor refs after a failed voice activation.\n  resetAnchor: () => void\n  handleKeyEvent: (fallbackMs?: number) => void\n  interimRange: InterimRange | null\n}\n\nexport function useVoiceIntegration({\n  setInputValueRaw,\n  inputValueRef,\n  insertTextRef,\n}: UseVoiceIntegrationArgs): UseVoiceIntegrationResult {\n  const { addNotification } = useNotifications()\n\n  // Tracks the input content before/after the cursor when voice starts,\n  // so interim transcripts can be inserted at the cursor position without\n  // clobbering surrounding user text.\n  const voicePrefixRef = useRef<string | null>(null)\n  const voiceSuffixRef = useRef<string>('')\n  // Tracks the last input value this hook wrote (via anchor, interim effect,\n  // or handleVoiceTranscript). If inputValueRef.current diverges, the user\n  // submitted or edited — both write paths bail to avoid clobbering. This is\n  // the only guard that correctly handles empty-prefix-empty-suffix: a\n  // startsWith('')/endsWith('') check vacuously passes, and a length check\n  // can't distinguish a cleared input from a never-set one.\n  const lastSetInputRef = useRef<string | null>(null)\n\n  // Strip trailing hold-key chars (and optionally capture the voice\n  // anchor). Called during warmup (to clean up chars that leaked past\n  // stopImmediatePropagation — listener order is not guaranteed) and\n  // on activation (with anchor=true to capture the prefix/suffix around\n  // the cursor for interim transcript placement). The caller passes the\n  // exact count it expects to strip so pre-existing chars at the\n  // boundary are preserved (e.g. the \"v\" in \"hav\" when hold-key is \"v\").\n  // The floor option sets a minimum trailing count to leave behind\n  // (during warmup this is the count we intentionally let through, so\n  // defensive cleanup only removes leaks). Returns the number of\n  // trailing chars remaining after stripping. When nothing changes, no\n  // state update is performed.\n  const stripTrailing = useCallback(\n    (\n      maxStrip: number,\n      { char = ' ', anchor = false, floor = 0 }: StripOpts = {},\n    ) => {\n      const prev = inputValueRef.current\n      const offset = insertTextRef.current?.cursorOffset ?? prev.length\n      const beforeCursor = prev.slice(0, offset)\n      const afterCursor = prev.slice(offset)\n      // When the hold key is space, also count full-width spaces (U+3000)\n      // that a CJK IME may have inserted for the same physical key.\n      // U+3000 is BMP single-code-unit so indices align with beforeCursor.\n      const scan =\n        char === ' ' ? normalizeFullWidthSpace(beforeCursor) : beforeCursor\n      let trailing = 0\n      while (\n        trailing < scan.length &&\n        scan[scan.length - 1 - trailing] === char\n      ) {\n        trailing++\n      }\n      const stripCount = Math.max(0, Math.min(trailing - floor, maxStrip))\n      const remaining = trailing - stripCount\n      const stripped = beforeCursor.slice(0, beforeCursor.length - stripCount)\n      // When anchoring with a non-space suffix, insert a gap space so the\n      // waveform cursor sits on the gap instead of covering the first\n      // suffix letter. The interim transcript effect maintains this same\n      // structure (prefix + leading + interim + trailing + suffix), so\n      // the gap is seamless once transcript text arrives.\n      // Always overwrite on anchor — if a prior activation failed to start\n      // voice (voiceState stayed 'idle'), the cleanup effect didn't fire and\n      // the old anchor is stale. anchor=true is only passed on the single\n      // activation call, never during recording, so overwrite is safe.\n      let gap = ''\n      if (anchor) {\n        voicePrefixRef.current = stripped\n        voiceSuffixRef.current = afterCursor\n        if (afterCursor.length > 0 && !/^\\s/.test(afterCursor)) {\n          gap = ' '\n        }\n      }\n      const newValue = stripped + gap + afterCursor\n      if (anchor) lastSetInputRef.current = newValue\n      if (newValue === prev && stripCount === 0) return remaining\n      if (insertTextRef.current) {\n        insertTextRef.current.setInputWithCursor(newValue, stripped.length)\n      } else {\n        setInputValueRaw(newValue)\n      }\n      return remaining\n    },\n    [setInputValueRaw, inputValueRef, insertTextRef],\n  )\n\n  // Undo the gap space inserted by stripTrailing(..., {anchor:true}) and\n  // reset the voice prefix/suffix refs. Called when voice activation fails\n  // (voiceState stays 'idle' after voiceHandleKeyEvent), so the cleanup\n  // effect (voiceState useEffect below) — which only fires on voiceState transitions — can't\n  // reach the stale anchor. Without this, the gap space and stale refs\n  // persist in the input.\n  const resetAnchor = useCallback(() => {\n    const prefix = voicePrefixRef.current\n    if (prefix === null) return\n    const suffix = voiceSuffixRef.current\n    voicePrefixRef.current = null\n    voiceSuffixRef.current = ''\n    const restored = prefix + suffix\n    if (insertTextRef.current) {\n      insertTextRef.current.setInputWithCursor(restored, prefix.length)\n    } else {\n      setInputValueRaw(restored)\n    }\n  }, [setInputValueRaw, insertTextRef])\n\n  // Voice state selectors. useVoiceEnabled = user intent (settings) +\n  // auth + GB kill-switch, with the auth half memoized on authVersion so\n  // render loops never hit a cold keychain spawn.\n  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n  const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false\n  const voiceState = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceState)\n    : ('idle' as const)\n  const voiceInterimTranscript = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceInterimTranscript)\n    : ''\n\n  // Set the voice anchor for focus mode (where recording starts via terminal\n  // focus, not key hold). Key-hold sets the anchor in stripTrailing.\n  useEffect(() => {\n    if (!feature('VOICE_MODE')) return\n    if (voiceState === 'recording' && voicePrefixRef.current === null) {\n      const input = inputValueRef.current\n      const offset = insertTextRef.current?.cursorOffset ?? input.length\n      voicePrefixRef.current = input.slice(0, offset)\n      voiceSuffixRef.current = input.slice(offset)\n      lastSetInputRef.current = input\n    }\n    if (voiceState === 'idle') {\n      voicePrefixRef.current = null\n      voiceSuffixRef.current = ''\n      lastSetInputRef.current = null\n    }\n  }, [voiceState, inputValueRef, insertTextRef])\n\n  // Live-update the prompt input with the interim transcript as voice\n  // transcribes speech. The prefix (user-typed text before the cursor) is\n  // preserved and the transcript is inserted between prefix and suffix.\n  useEffect(() => {\n    if (!feature('VOICE_MODE')) return\n    if (voicePrefixRef.current === null) return\n    const prefix = voicePrefixRef.current\n    const suffix = voiceSuffixRef.current\n    // Submit race: if the input isn't what this hook last set it to, the\n    // user submitted (clearing it) or edited it. voicePrefixRef is only\n    // cleared on voiceState→idle, so it's still set during the 'processing'\n    // window between CloseStream and WS close — this catches refined\n    // TranscriptText arriving then and re-filling a cleared input.\n    if (inputValueRef.current !== lastSetInputRef.current) return\n    const needsSpace =\n      prefix.length > 0 &&\n      !/\\s$/.test(prefix) &&\n      voiceInterimTranscript.length > 0\n    // Don't gate on voiceInterimTranscript.length -- when interim clears to ''\n    // after handleVoiceTranscript sets the final text, the trailing space\n    // between prefix and suffix must still be preserved.\n    const needsTrailingSpace = suffix.length > 0 && !/^\\s/.test(suffix)\n    const leadingSpace = needsSpace ? ' ' : ''\n    const trailingSpace = needsTrailingSpace ? ' ' : ''\n    const newValue =\n      prefix + leadingSpace + voiceInterimTranscript + trailingSpace + suffix\n    // Position cursor after the transcribed text (before suffix)\n    const cursorPos =\n      prefix.length + leadingSpace.length + voiceInterimTranscript.length\n    if (insertTextRef.current) {\n      insertTextRef.current.setInputWithCursor(newValue, cursorPos)\n    } else {\n      setInputValueRaw(newValue)\n    }\n    lastSetInputRef.current = newValue\n  }, [voiceInterimTranscript, setInputValueRaw, inputValueRef, insertTextRef])\n\n  const handleVoiceTranscript = useCallback(\n    (text: string) => {\n      if (!feature('VOICE_MODE')) return\n      const prefix = voicePrefixRef.current\n      // No voice anchor — voice was reset (or never started). Nothing to do.\n      if (prefix === null) return\n      const suffix = voiceSuffixRef.current\n      // Submit race: finishRecording() → user presses Enter (input cleared)\n      // → WebSocket close → this callback fires with stale prefix/suffix.\n      // If the input isn't what this hook last set (via the interim effect\n      // or anchor), the user submitted or edited — don't re-fill. Comparing\n      // against `text.length` would false-positive when the final is longer\n      // than the interim (ASR routinely adds punctuation/corrections).\n      if (inputValueRef.current !== lastSetInputRef.current) return\n      const needsSpace =\n        prefix.length > 0 && !/\\s$/.test(prefix) && text.length > 0\n      const needsTrailingSpace =\n        suffix.length > 0 && !/^\\s/.test(suffix) && text.length > 0\n      const leadingSpace = needsSpace ? ' ' : ''\n      const trailingSpace = needsTrailingSpace ? ' ' : ''\n      const newInput = prefix + leadingSpace + text + trailingSpace + suffix\n      // Position cursor after the transcribed text (before suffix)\n      const cursorPos = prefix.length + leadingSpace.length + text.length\n      if (insertTextRef.current) {\n        insertTextRef.current.setInputWithCursor(newInput, cursorPos)\n      } else {\n        setInputValueRaw(newInput)\n      }\n      lastSetInputRef.current = newInput\n      // Update the prefix to include this chunk so focus mode can continue\n      // appending subsequent transcripts after it.\n      voicePrefixRef.current = prefix + leadingSpace + text\n    },\n    [setInputValueRaw, inputValueRef, insertTextRef],\n  )\n\n  const voice = voiceNs.useVoice({\n    onTranscript: handleVoiceTranscript,\n    onError: (message: string) => {\n      addNotification({\n        key: 'voice-error',\n        text: message,\n        color: 'error',\n        priority: 'immediate',\n        timeoutMs: 10_000,\n      })\n    },\n    enabled: voiceEnabled,\n    focusMode: false,\n  })\n\n  // Compute the character range of interim (not-yet-finalized) transcript\n  // text in the input value, so the UI can dim it.\n  const interimRange = useMemo((): InterimRange | null => {\n    if (!feature('VOICE_MODE')) return null\n    if (voicePrefixRef.current === null) return null\n    if (voiceInterimTranscript.length === 0) return null\n    const prefix = voicePrefixRef.current\n    const needsSpace =\n      prefix.length > 0 &&\n      !/\\s$/.test(prefix) &&\n      voiceInterimTranscript.length > 0\n    const start = prefix.length + (needsSpace ? 1 : 0)\n    const end = start + voiceInterimTranscript.length\n    return { start, end }\n  }, [voiceInterimTranscript])\n\n  return {\n    stripTrailing,\n    resetAnchor,\n    handleKeyEvent: voice.handleKeyEvent,\n    interimRange,\n  }\n}\n\n/**\n * Component that handles hold-to-talk voice activation.\n *\n * The activation key is configurable via keybindings (voice:pushToTalk,\n * default: space). Hold detection depends on OS auto-repeat delivering a\n * stream of events at 30-80ms intervals. Two binding types work:\n *\n * **Modifier + letter (meta+k, ctrl+x, alt+v):** Cleanest. Activates on\n * the first press — a modifier combo is unambiguous intent (can't be\n * typed accidentally), so no hold threshold applies. The letter part\n * auto-repeats while held, feeding release detection in useVoice.ts.\n * No flow-through, no stripping.\n *\n * **Bare chars (space, v, x):** Require HOLD_THRESHOLD rapid presses to\n * activate (a single space could be normal typing). The first\n * WARMUP_THRESHOLD presses flow into the input so a single press types\n * normally. Past that, rapid presses are swallowed; on activation the\n * flow-through chars are stripped. Binding \"v\" doesn't make \"v\"\n * untypable — normal typing (>120ms between keystrokes) flows through;\n * only rapid auto-repeat from a held key triggers activation.\n *\n * Known broken: modifier+space (NUL → parsed as ctrl+backtick), chords\n * (discrete sequences, no hold). Validation warns on these.\n */\nexport function useVoiceKeybindingHandler({\n  voiceHandleKeyEvent,\n  stripTrailing,\n  resetAnchor,\n  isActive,\n}: {\n  voiceHandleKeyEvent: (fallbackMs?: number) => void\n  stripTrailing: (maxStrip: number, opts?: StripOpts) => number\n  resetAnchor: () => void\n  isActive: boolean\n}): { handleKeyDown: (e: KeyboardEvent) => void } {\n  const getVoiceState = useGetVoiceState()\n  const setVoiceState = useSetVoiceState()\n  const keybindingContext = useOptionalKeybindingContext()\n  const isModalOverlayActive = useIsModalOverlayActive()\n  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n  const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false\n  const voiceState = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceState)\n    : 'idle'\n\n  // Find the configured key for voice:pushToTalk from keybinding context.\n  // Forward iteration with last-wins (matching the resolver): if a later\n  // Chat binding overrides the same chord with null or a different\n  // action, the voice binding is discarded and null is returned — the\n  // user explicitly disabled hold-to-talk via binding override, so\n  // don't second-guess them with a fallback. The DEFAULT is only used\n  // when there's no provider at all. Context filter is required — space\n  // is also bound in Settings/Confirmation/Plugin (select:accept etc.);\n  // without the filter those would null out the default.\n  const voiceKeystroke = useMemo((): ParsedKeystroke | null => {\n    if (!keybindingContext) return DEFAULT_VOICE_KEYSTROKE\n    let result: ParsedKeystroke | null = null\n    for (const binding of keybindingContext.bindings) {\n      if (binding.context !== 'Chat') continue\n      if (binding.chord.length !== 1) continue\n      const ks = binding.chord[0]\n      if (!ks) continue\n      if (binding.action === 'voice:pushToTalk') {\n        result = ks\n      } else if (result !== null && keystrokesEqual(ks, result)) {\n        // A later binding overrides this chord (null unbind or reassignment)\n        result = null\n      }\n    }\n    return result\n  }, [keybindingContext])\n\n  // If the binding is a bare (unmodified) single printable char, terminal\n  // auto-repeat may batch N keystrokes into one input event (e.g. \"vvv\"),\n  // and the char flows into the text input — we need flow-through + strip.\n  // Modifier combos (meta+k, ctrl+x) also auto-repeat (the letter part\n  // repeats) but don't insert text, so they're swallowed from the first\n  // press with no stripping needed. matchesKeyboardEvent handles those.\n  const bareChar =\n    voiceKeystroke !== null &&\n    voiceKeystroke.key.length === 1 &&\n    !voiceKeystroke.ctrl &&\n    !voiceKeystroke.alt &&\n    !voiceKeystroke.shift &&\n    !voiceKeystroke.meta &&\n    !voiceKeystroke.super\n      ? voiceKeystroke.key\n      : null\n\n  const rapidCountRef = useRef(0)\n  // How many rapid chars we intentionally let through to the text\n  // input (the first WARMUP_THRESHOLD). The activation strip removes\n  // up to this many + the activation event's potential leak. For the\n  // default (space) this is precise — pre-existing trailing spaces are\n  // rare. For letter bindings (validation warns) this may over-strip\n  // one pre-existing char if the input already ended in the bound\n  // letter (e.g. \"hav\" + hold \"v\" → \"ha\"). We don't track that\n  // boundary — it's best-effort and the warning says so.\n  const charsInInputRef = useRef(0)\n  // Trailing-char count remaining after the activation strip — these\n  // belong to the user's anchored prefix and must be preserved during\n  // recording's defensive leak cleanup.\n  const recordingFloorRef = useRef(0)\n  // True when the current recording was started by key-hold (not focus).\n  // Used to avoid swallowing keypresses during focus-mode recording.\n  const isHoldActiveRef = useRef(false)\n  const resetTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)\n\n  // Reset hold state as soon as we leave 'recording'. The physical hold\n  // ends when key-repeat stops (state → 'processing'); keeping the ref\n  // set through 'processing' swallows new space presses the user types\n  // while the transcript finalizes.\n  useEffect(() => {\n    if (voiceState !== 'recording') {\n      isHoldActiveRef.current = false\n      rapidCountRef.current = 0\n      charsInInputRef.current = 0\n      recordingFloorRef.current = 0\n      setVoiceState(prev => {\n        if (!prev.voiceWarmingUp) return prev\n        return { ...prev, voiceWarmingUp: false }\n      })\n    }\n  }, [voiceState, setVoiceState])\n\n  const handleKeyDown = (e: KeyboardEvent): void => {\n    if (!voiceEnabled) return\n\n    // PromptInput is not a valid transcript target — let the hold key\n    // flow through instead of swallowing it into stale refs (#33556).\n    // Two distinct unmount/unfocus paths (both needed):\n    //   - !isActive: local-jsx command hid PromptInput (shouldHidePromptInput)\n    //     without registering an overlay — e.g. /install-github-app,\n    //     /plugin. Mirrors CommandKeybindingHandlers' isActive gate.\n    //   - isModalOverlayActive: overlay (permission dialog, Select with\n    //     onCancel) has focus; PromptInput is mounted but focus=false.\n    if (!isActive || isModalOverlayActive) return\n\n    // null means the user overrode the default (null-unbind/reassign) —\n    // hold-to-talk is disabled via binding. To toggle the feature\n    // itself, use /voice.\n    if (voiceKeystroke === null) return\n\n    // Match the configured key. Bare chars match by content (handles\n    // batched auto-repeat like \"vvv\") with a modifier reject so e.g.\n    // ctrl+v doesn't trip a \"v\" binding. Modifier combos go through\n    // matchesKeyboardEvent (one event per repeat, no batching).\n    let repeatCount: number\n    if (bareChar !== null) {\n      if (e.ctrl || e.meta || e.shift) return\n      // When bound to space, also accept U+3000 (full-width space) —\n      // CJK IMEs emit it for the same physical key.\n      const normalized =\n        bareChar === ' ' ? normalizeFullWidthSpace(e.key) : e.key\n      // Fast-path: normal typing (any char that isn't the bound one)\n      // bails here without allocating. The repeat() check only matters\n      // for batched auto-repeat (input.length > 1) which is rare.\n      if (normalized[0] !== bareChar) return\n      if (\n        normalized.length > 1 &&\n        normalized !== bareChar.repeat(normalized.length)\n      )\n        return\n      repeatCount = normalized.length\n    } else {\n      if (!matchesKeyboardEvent(e, voiceKeystroke)) return\n      repeatCount = 1\n    }\n\n    // Guard: only swallow keypresses when recording was triggered by\n    // key-hold. Focus-mode recording also sets voiceState to 'recording',\n    // but keypresses should flow through normally (voiceHandleKeyEvent\n    // returns early for focus-triggered sessions). We also check voiceState\n    // from the store so that if voiceHandleKeyEvent() fails to transition\n    // state (module not loaded, stream unavailable) we don't permanently\n    // swallow keypresses.\n    const currentVoiceState = getVoiceState().voiceState\n    if (isHoldActiveRef.current && currentVoiceState !== 'idle') {\n      // Already recording — swallow continued keypresses and forward\n      // to voice for release detection. For bare chars, defensively\n      // strip in case the text input handler fired before this one\n      // (listener order is not guaranteed). Modifier combos don't\n      // insert text, so nothing to strip.\n      e.stopImmediatePropagation()\n      if (bareChar !== null) {\n        stripTrailing(repeatCount, {\n          char: bareChar,\n          floor: recordingFloorRef.current,\n        })\n      }\n      voiceHandleKeyEvent()\n      return\n    }\n\n    // Non-hold recording (focus-mode) or processing is active.\n    // Modifier combos must not re-activate: stripTrailing(0,{anchor:true})\n    // would overwrite voicePrefixRef with interim text and duplicate the\n    // transcript on the next interim update. Pre-#22144, a single tap\n    // hit the warmup else-branch (swallow only). Bare chars flow through\n    // unconditionally — user may be typing during focus-recording.\n    if (currentVoiceState !== 'idle') {\n      if (bareChar === null) e.stopImmediatePropagation()\n      return\n    }\n\n    const countBefore = rapidCountRef.current\n    rapidCountRef.current += repeatCount\n\n    // ── Activation ────────────────────────────────────────────\n    // Handled first so the warmup branch below does NOT also run\n    // on this event — two strip calls in the same tick would both\n    // read the stale inputValueRef and the second would under-strip.\n    // Modifier combos activate on the first press — they can't be\n    // typed accidentally, so the hold threshold (which exists to\n    // distinguish typing a space from holding space) doesn't apply.\n    if (bareChar === null || rapidCountRef.current >= HOLD_THRESHOLD) {\n      e.stopImmediatePropagation()\n      if (resetTimerRef.current) {\n        clearTimeout(resetTimerRef.current)\n        resetTimerRef.current = null\n      }\n      rapidCountRef.current = 0\n      isHoldActiveRef.current = true\n      setVoiceState(prev => {\n        if (!prev.voiceWarmingUp) return prev\n        return { ...prev, voiceWarmingUp: false }\n      })\n      if (bareChar !== null) {\n        // Strip the intentional warmup chars plus this event's leak\n        // (if text input fired first). Cap covers both; min(trailing)\n        // handles the no-leak case. Anchor the voice prefix here.\n        // The return value (remaining) becomes the floor for\n        // recording-time leak cleanup.\n        recordingFloorRef.current = stripTrailing(\n          charsInInputRef.current + repeatCount,\n          { char: bareChar, anchor: true },\n        )\n        charsInInputRef.current = 0\n        voiceHandleKeyEvent()\n      } else {\n        // Modifier combo: nothing inserted, nothing to strip. Just\n        // anchor the voice prefix at the current cursor position.\n        // Longer fallback: this call is at t=0 (before auto-repeat),\n        // so the gap to the next keypress is the OS initial repeat\n        // *delay* (up to ~2s), not the repeat *rate* (~30-80ms).\n        stripTrailing(0, { anchor: true })\n        voiceHandleKeyEvent(MODIFIER_FIRST_PRESS_FALLBACK_MS)\n      }\n      // If voice failed to transition (module not loaded, stream\n      // unavailable, stale enabled), clear the ref so a later\n      // focus-mode recording doesn't inherit stale hold state\n      // and swallow keypresses. Store is synchronous — the check is\n      // immediate. The anchor set by stripTrailing above will\n      // be overwritten on retry (anchor always overwrites now).\n      if (getVoiceState().voiceState === 'idle') {\n        isHoldActiveRef.current = false\n        resetAnchor()\n      }\n      return\n    }\n\n    // ── Warmup (bare-char only; modifier combos activated above) ──\n    // First WARMUP_THRESHOLD chars flow to the text input so normal\n    // typing has zero latency (a single press types normally).\n    // Subsequent rapid chars are swallowed so the input stays aligned\n    // with the warmup UI. Strip defensively (listener order is not\n    // guaranteed — text input may have already added the char). The\n    // floor preserves the intentional warmup chars; the strip is a\n    // no-op when nothing leaked. Check countBefore so the event that\n    // crosses the threshold still flows through (terminal batching).\n    if (countBefore >= WARMUP_THRESHOLD) {\n      e.stopImmediatePropagation()\n      stripTrailing(repeatCount, {\n        char: bareChar,\n        floor: charsInInputRef.current,\n      })\n    } else {\n      charsInInputRef.current += repeatCount\n    }\n\n    // Show warmup feedback once we detect a hold pattern\n    if (rapidCountRef.current >= WARMUP_THRESHOLD) {\n      setVoiceState(prev => {\n        if (prev.voiceWarmingUp) return prev\n        return { ...prev, voiceWarmingUp: true }\n      })\n    }\n\n    if (resetTimerRef.current) {\n      clearTimeout(resetTimerRef.current)\n    }\n    resetTimerRef.current = setTimeout(\n      (resetTimerRef, rapidCountRef, charsInInputRef, setVoiceState) => {\n        resetTimerRef.current = null\n        rapidCountRef.current = 0\n        charsInInputRef.current = 0\n        setVoiceState(prev => {\n          if (!prev.voiceWarmingUp) return prev\n          return { ...prev, voiceWarmingUp: false }\n        })\n      },\n      RAPID_KEY_GAP_MS,\n      resetTimerRef,\n      rapidCountRef,\n      charsInInputRef,\n      setVoiceState,\n    )\n  }\n\n  // Backward-compat bridge: REPL.tsx doesn't yet wire handleKeyDown to\n  // <Box onKeyDown>. Subscribe via useInput and adapt InputEvent →\n  // KeyboardEvent until the consumer is migrated (separate PR).\n  // TODO(onKeyDown-migration): remove once REPL passes handleKeyDown.\n  useInput(\n    (_input, _key, event) => {\n      const kbEvent = new KeyboardEvent(event.keypress)\n      handleKeyDown(kbEvent)\n      // handleKeyDown stopped the adapter event, not the InputEvent the\n      // emitter actually checks — forward it so the text input's useInput\n      // listener is skipped and held spaces don't leak into the prompt.\n      if (kbEvent.didStopImmediatePropagation()) {\n        event.stopImmediatePropagation()\n      }\n    },\n    { isActive },\n  )\n\n  return { handleKeyDown }\n}\n\n// TODO(onKeyDown-migration): temporary shim so existing JSX callers\n// (<VoiceKeybindingHandler .../>) keep compiling. Remove once REPL.tsx\n// wires handleKeyDown directly.\nexport function VoiceKeybindingHandler(props: {\n  voiceHandleKeyEvent: (fallbackMs?: number) => void\n  stripTrailing: (maxStrip: number, opts?: StripOpts) => number\n  resetAnchor: () => void\n  isActive: boolean\n}): null {\n  useVoiceKeybindingHandler(props)\n  return null\n}\n"],"mappings":"AAAA,SAASA,OAAO,QAAQ,YAAY;AACpC,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,SAASC,WAAW,EAAEC,SAAS,EAAEC,OAAO,EAAEC,MAAM,QAAQ,OAAO;AAC/D,SAASC,gBAAgB,QAAQ,6BAA6B;AAC9D,SAASC,uBAAuB,QAAQ,8BAA8B;AACtE,SACEC,gBAAgB,EAChBC,gBAAgB,EAChBC,aAAa,QACR,qBAAqB;AAC5B,SAASC,aAAa,QAAQ,iCAAiC;AAC/D;AACA,SAASC,QAAQ,QAAQ,WAAW;AACpC,SAASC,4BAA4B,QAAQ,qCAAqC;AAClF,SAASC,eAAe,QAAQ,4BAA4B;AAC5D,cAAcC,eAAe,QAAQ,yBAAyB;AAC9D,SAASC,uBAAuB,QAAQ,yBAAyB;AACjE,SAASC,eAAe,QAAQ,sBAAsB;;AAEtD;AACA;AACA;AACA;AACA;AACA,MAAMC,OAAO,EAAE;EAAEC,QAAQ,EAAE,OAAO,OAAO,eAAe,EAAEA,QAAQ;AAAC,CAAC,GAAGnB,OAAO,CAC5E,YACF,CAAC,GACGoB,OAAO,CAAC,eAAe,CAAC,GACxB;EACED,QAAQ,EAAEA,CAAC;IACTE,OAAO,EAAEC;EAIX,CAHC,EAAE;IACDC,YAAY,EAAE,CAACC,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;IACjCH,OAAO,EAAE,OAAO;EAClB,CAAC,MAAM;IACLI,KAAK,EAAE,MAAM,IAAIC,KAAK;IACtBC,cAAc,EAAEA,CAACC,WAAoB,CAAR,EAAE,MAAM,KAAK,CAAC;EAC7C,CAAC;AACH,CAAC;AACL;;AAEA;AACA;AACA;AACA,MAAMC,gBAAgB,GAAG,GAAG;;AAE5B;AACA;AACA;AACA;AACA;AACA,MAAMC,gCAAgC,GAAG,IAAI;;AAE7C;AACA;AACA;AACA,MAAMC,cAAc,GAAG,CAAC;;AAExB;AACA,MAAMC,gBAAgB,GAAG,CAAC;;AAE1B;AACA;AACA;AACA;AACA;AACA,SAASC,oBAAoBA,CAC3BC,CAAC,EAAEvB,aAAa,EAChBwB,MAAM,EAAEpB,eAAe,CACxB,EAAE,OAAO,CAAC;EACT;EACA;EACA,MAAMqB,GAAG,GACPF,CAAC,CAACE,GAAG,KAAK,OAAO,GAAG,GAAG,GAAGF,CAAC,CAACE,GAAG,KAAK,QAAQ,GAAG,OAAO,GAAGF,CAAC,CAACE,GAAG,CAACC,WAAW,CAAC,CAAC;EAC9E,IAAID,GAAG,KAAKD,MAAM,CAACC,GAAG,EAAE,OAAO,KAAK;EACpC,IAAIF,CAAC,CAACI,IAAI,KAAKH,MAAM,CAACG,IAAI,EAAE,OAAO,KAAK;EACxC,IAAIJ,CAAC,CAACK,KAAK,KAAKJ,MAAM,CAACI,KAAK,EAAE,OAAO,KAAK;EAC1C;EACA;EACA,IAAIL,CAAC,CAACM,IAAI,MAAML,MAAM,CAACM,GAAG,IAAIN,MAAM,CAACK,IAAI,CAAC,EAAE,OAAO,KAAK;EACxD,IAAIN,CAAC,CAACQ,QAAQ,KAAKP,MAAM,CAACQ,KAAK,EAAE,OAAO,KAAK;EAC7C,OAAO,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA,MAAMC,uBAAuB,EAAE7B,eAAe,GAAG;EAC/CqB,GAAG,EAAE,GAAG;EACRE,IAAI,EAAE,KAAK;EACXG,GAAG,EAAE,KAAK;EACVF,KAAK,EAAE,KAAK;EACZC,IAAI,EAAE,KAAK;EACXG,KAAK,EAAE;AACT,CAAC;AAED,KAAKE,gBAAgB,GAAG;EACtBC,MAAM,EAAE,CAACC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI;EAC9BC,kBAAkB,EAAE,CAACC,KAAK,EAAE,MAAM,EAAEC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;EAC3DC,YAAY,EAAE,MAAM;AACtB,CAAC;AAED,KAAKC,uBAAuB,GAAG;EAC7BC,gBAAgB,EAAEpD,KAAK,CAACqD,QAAQ,CAACrD,KAAK,CAACsD,cAAc,CAAC,MAAM,CAAC,CAAC;EAC9DC,aAAa,EAAEvD,KAAK,CAACwD,SAAS,CAAC,MAAM,CAAC;EACtCC,aAAa,EAAEzD,KAAK,CAACwD,SAAS,CAACZ,gBAAgB,GAAG,IAAI,CAAC;AACzD,CAAC;AAED,KAAKc,YAAY,GAAG;EAAEC,KAAK,EAAE,MAAM;EAAEC,GAAG,EAAE,MAAM;AAAC,CAAC;AAElD,KAAKC,SAAS,GAAG;EACf;EACAC,IAAI,CAAC,EAAE,MAAM;EACb;EACAC,MAAM,CAAC,EAAE,OAAO;EAChB;EACA;EACAC,KAAK,CAAC,EAAE,MAAM;AAChB,CAAC;AAED,KAAKC,yBAAyB,GAAG;EAC/B;EACAC,aAAa,EAAE,CAACC,QAAQ,EAAE,MAAM,EAAEC,IAAgB,CAAX,EAAEP,SAAS,EAAE,GAAG,MAAM;EAC7D;EACAQ,WAAW,EAAE,GAAG,GAAG,IAAI;EACvB3C,cAAc,EAAE,CAAC4C,UAAmB,CAAR,EAAE,MAAM,EAAE,GAAG,IAAI;EAC7CC,YAAY,EAAEb,YAAY,GAAG,IAAI;AACnC,CAAC;AAED,OAAO,SAASc,mBAAmBA,CAAC;EAClCpB,gBAAgB;EAChBG,aAAa;EACbE;AACuB,CAAxB,EAAEN,uBAAuB,CAAC,EAAEc,yBAAyB,CAAC;EACrD,MAAM;IAAEQ;EAAgB,CAAC,GAAGpE,gBAAgB,CAAC,CAAC;;EAE9C;EACA;EACA;EACA,MAAMqE,cAAc,GAAGtE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC;EAClD,MAAMuE,cAAc,GAAGvE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;EACzC;EACA;EACA;EACA;EACA;EACA;EACA,MAAMwE,eAAe,GAAGxE,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC;;EAEnD;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAM8D,aAAa,GAAGjE,WAAW,CAC/B,CACEkE,QAAQ,EAAE,MAAM,EAChB;IAAEL,IAAI,GAAG,GAAG;IAAEC,MAAM,GAAG,KAAK;IAAEC,KAAK,GAAG;EAAa,CAAV,EAAEH,SAAS,GAAG,CAAC,CAAC,KACtD;IACH,MAAMgB,IAAI,GAAGtB,aAAa,CAACuB,OAAO;IAClC,MAAMC,MAAM,GAAGtB,aAAa,CAACqB,OAAO,EAAE5B,YAAY,IAAI2B,IAAI,CAACG,MAAM;IACjE,MAAMC,YAAY,GAAGJ,IAAI,CAACK,KAAK,CAAC,CAAC,EAAEH,MAAM,CAAC;IAC1C,MAAMI,WAAW,GAAGN,IAAI,CAACK,KAAK,CAACH,MAAM,CAAC;IACtC;IACA;IACA;IACA,MAAMK,IAAI,GACRtB,IAAI,KAAK,GAAG,GAAG/C,uBAAuB,CAACkE,YAAY,CAAC,GAAGA,YAAY;IACrE,IAAII,QAAQ,GAAG,CAAC;IAChB,OACEA,QAAQ,GAAGD,IAAI,CAACJ,MAAM,IACtBI,IAAI,CAACA,IAAI,CAACJ,MAAM,GAAG,CAAC,GAAGK,QAAQ,CAAC,KAAKvB,IAAI,EACzC;MACAuB,QAAQ,EAAE;IACZ;IACA,MAAMC,UAAU,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACE,GAAG,CAACJ,QAAQ,GAAGrB,KAAK,EAAEG,QAAQ,CAAC,CAAC;IACpE,MAAMuB,SAAS,GAAGL,QAAQ,GAAGC,UAAU;IACvC,MAAMK,QAAQ,GAAGV,YAAY,CAACC,KAAK,CAAC,CAAC,EAAED,YAAY,CAACD,MAAM,GAAGM,UAAU,CAAC;IACxE;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAIM,GAAG,GAAG,EAAE;IACZ,IAAI7B,MAAM,EAAE;MACVW,cAAc,CAACI,OAAO,GAAGa,QAAQ;MACjChB,cAAc,CAACG,OAAO,GAAGK,WAAW;MACpC,IAAIA,WAAW,CAACH,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAACa,IAAI,CAACV,WAAW,CAAC,EAAE;QACtDS,GAAG,GAAG,GAAG;MACX;IACF;IACA,MAAME,QAAQ,GAAGH,QAAQ,GAAGC,GAAG,GAAGT,WAAW;IAC7C,IAAIpB,MAAM,EAAEa,eAAe,CAACE,OAAO,GAAGgB,QAAQ;IAC9C,IAAIA,QAAQ,KAAKjB,IAAI,IAAIS,UAAU,KAAK,CAAC,EAAE,OAAOI,SAAS;IAC3D,IAAIjC,aAAa,CAACqB,OAAO,EAAE;MACzBrB,aAAa,CAACqB,OAAO,CAAC/B,kBAAkB,CAAC+C,QAAQ,EAAEH,QAAQ,CAACX,MAAM,CAAC;IACrE,CAAC,MAAM;MACL5B,gBAAgB,CAAC0C,QAAQ,CAAC;IAC5B;IACA,OAAOJ,SAAS;EAClB,CAAC,EACD,CAACtC,gBAAgB,EAAEG,aAAa,EAAEE,aAAa,CACjD,CAAC;;EAED;EACA;EACA;EACA;EACA;EACA;EACA,MAAMY,WAAW,GAAGpE,WAAW,CAAC,MAAM;IACpC,MAAM8F,MAAM,GAAGrB,cAAc,CAACI,OAAO;IACrC,IAAIiB,MAAM,KAAK,IAAI,EAAE;IACrB,MAAMC,MAAM,GAAGrB,cAAc,CAACG,OAAO;IACrCJ,cAAc,CAACI,OAAO,GAAG,IAAI;IAC7BH,cAAc,CAACG,OAAO,GAAG,EAAE;IAC3B,MAAMmB,QAAQ,GAAGF,MAAM,GAAGC,MAAM;IAChC,IAAIvC,aAAa,CAACqB,OAAO,EAAE;MACzBrB,aAAa,CAACqB,OAAO,CAAC/B,kBAAkB,CAACkD,QAAQ,EAAEF,MAAM,CAACf,MAAM,CAAC;IACnE,CAAC,MAAM;MACL5B,gBAAgB,CAAC6C,QAAQ,CAAC;IAC5B;EACF,CAAC,EAAE,CAAC7C,gBAAgB,EAAEK,aAAa,CAAC,CAAC;;EAErC;EACA;EACA;EACA;EACA,MAAMyC,YAAY,GAAGnG,OAAO,CAAC,YAAY,CAAC,GAAGiB,eAAe,CAAC,CAAC,GAAG,KAAK;EACtE,MAAMmF,UAAU,GAAGpG,OAAO,CAAC,YAAY,CAAC;EACpC;EACAU,aAAa,CAAC2F,CAAC,IAAIA,CAAC,CAACD,UAAU,CAAC,GAC/B,MAAM,IAAI1E,KAAM;EACrB,MAAM4E,sBAAsB,GAAGtG,OAAO,CAAC,YAAY,CAAC;EAChD;EACAU,aAAa,CAAC2F,GAAC,IAAIA,GAAC,CAACC,sBAAsB,CAAC,GAC5C,EAAE;;EAEN;EACA;EACAnG,SAAS,CAAC,MAAM;IACd,IAAI,CAACH,OAAO,CAAC,YAAY,CAAC,EAAE;IAC5B,IAAIoG,UAAU,KAAK,WAAW,IAAIzB,cAAc,CAACI,OAAO,KAAK,IAAI,EAAE;MACjE,MAAMwB,KAAK,GAAG/C,aAAa,CAACuB,OAAO;MACnC,MAAMC,QAAM,GAAGtB,aAAa,CAACqB,OAAO,EAAE5B,YAAY,IAAIoD,KAAK,CAACtB,MAAM;MAClEN,cAAc,CAACI,OAAO,GAAGwB,KAAK,CAACpB,KAAK,CAAC,CAAC,EAAEH,QAAM,CAAC;MAC/CJ,cAAc,CAACG,OAAO,GAAGwB,KAAK,CAACpB,KAAK,CAACH,QAAM,CAAC;MAC5CH,eAAe,CAACE,OAAO,GAAGwB,KAAK;IACjC;IACA,IAAIH,UAAU,KAAK,MAAM,EAAE;MACzBzB,cAAc,CAACI,OAAO,GAAG,IAAI;MAC7BH,cAAc,CAACG,OAAO,GAAG,EAAE;MAC3BF,eAAe,CAACE,OAAO,GAAG,IAAI;IAChC;EACF,CAAC,EAAE,CAACqB,UAAU,EAAE5C,aAAa,EAAEE,aAAa,CAAC,CAAC;;EAE9C;EACA;EACA;EACAvD,SAAS,CAAC,MAAM;IACd,IAAI,CAACH,OAAO,CAAC,YAAY,CAAC,EAAE;IAC5B,IAAI2E,cAAc,CAACI,OAAO,KAAK,IAAI,EAAE;IACrC,MAAMiB,QAAM,GAAGrB,cAAc,CAACI,OAAO;IACrC,MAAMkB,QAAM,GAAGrB,cAAc,CAACG,OAAO;IACrC;IACA;IACA;IACA;IACA;IACA,IAAIvB,aAAa,CAACuB,OAAO,KAAKF,eAAe,CAACE,OAAO,EAAE;IACvD,MAAMyB,UAAU,GACdR,QAAM,CAACf,MAAM,GAAG,CAAC,IACjB,CAAC,KAAK,CAACa,IAAI,CAACE,QAAM,CAAC,IACnBM,sBAAsB,CAACrB,MAAM,GAAG,CAAC;IACnC;IACA;IACA;IACA,MAAMwB,kBAAkB,GAAGR,QAAM,CAAChB,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAACa,IAAI,CAACG,QAAM,CAAC;IACnE,MAAMS,YAAY,GAAGF,UAAU,GAAG,GAAG,GAAG,EAAE;IAC1C,MAAMG,aAAa,GAAGF,kBAAkB,GAAG,GAAG,GAAG,EAAE;IACnD,MAAMV,UAAQ,GACZC,QAAM,GAAGU,YAAY,GAAGJ,sBAAsB,GAAGK,aAAa,GAAGV,QAAM;IACzE;IACA,MAAMW,SAAS,GACbZ,QAAM,CAACf,MAAM,GAAGyB,YAAY,CAACzB,MAAM,GAAGqB,sBAAsB,CAACrB,MAAM;IACrE,IAAIvB,aAAa,CAACqB,OAAO,EAAE;MACzBrB,aAAa,CAACqB,OAAO,CAAC/B,kBAAkB,CAAC+C,UAAQ,EAAEa,SAAS,CAAC;IAC/D,CAAC,MAAM;MACLvD,gBAAgB,CAAC0C,UAAQ,CAAC;IAC5B;IACAlB,eAAe,CAACE,OAAO,GAAGgB,UAAQ;EACpC,CAAC,EAAE,CAACO,sBAAsB,EAAEjD,gBAAgB,EAAEG,aAAa,EAAEE,aAAa,CAAC,CAAC;EAE5E,MAAMmD,qBAAqB,GAAG3G,WAAW,CACvC,CAAC6C,IAAI,EAAE,MAAM,KAAK;IAChB,IAAI,CAAC/C,OAAO,CAAC,YAAY,CAAC,EAAE;IAC5B,MAAMgG,QAAM,GAAGrB,cAAc,CAACI,OAAO;IACrC;IACA,IAAIiB,QAAM,KAAK,IAAI,EAAE;IACrB,MAAMC,QAAM,GAAGrB,cAAc,CAACG,OAAO;IACrC;IACA;IACA;IACA;IACA;IACA;IACA,IAAIvB,aAAa,CAACuB,OAAO,KAAKF,eAAe,CAACE,OAAO,EAAE;IACvD,MAAMyB,YAAU,GACdR,QAAM,CAACf,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAACa,IAAI,CAACE,QAAM,CAAC,IAAIjD,IAAI,CAACkC,MAAM,GAAG,CAAC;IAC7D,MAAMwB,oBAAkB,GACtBR,QAAM,CAAChB,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAACa,IAAI,CAACG,QAAM,CAAC,IAAIlD,IAAI,CAACkC,MAAM,GAAG,CAAC;IAC7D,MAAMyB,cAAY,GAAGF,YAAU,GAAG,GAAG,GAAG,EAAE;IAC1C,MAAMG,eAAa,GAAGF,oBAAkB,GAAG,GAAG,GAAG,EAAE;IACnD,MAAMK,QAAQ,GAAGd,QAAM,GAAGU,cAAY,GAAG3D,IAAI,GAAG4D,eAAa,GAAGV,QAAM;IACtE;IACA,MAAMW,WAAS,GAAGZ,QAAM,CAACf,MAAM,GAAGyB,cAAY,CAACzB,MAAM,GAAGlC,IAAI,CAACkC,MAAM;IACnE,IAAIvB,aAAa,CAACqB,OAAO,EAAE;MACzBrB,aAAa,CAACqB,OAAO,CAAC/B,kBAAkB,CAAC8D,QAAQ,EAAEF,WAAS,CAAC;IAC/D,CAAC,MAAM;MACLvD,gBAAgB,CAACyD,QAAQ,CAAC;IAC5B;IACAjC,eAAe,CAACE,OAAO,GAAG+B,QAAQ;IAClC;IACA;IACAnC,cAAc,CAACI,OAAO,GAAGiB,QAAM,GAAGU,cAAY,GAAG3D,IAAI;EACvD,CAAC,EACD,CAACM,gBAAgB,EAAEG,aAAa,EAAEE,aAAa,CACjD,CAAC;EAED,MAAMqD,KAAK,GAAG7F,OAAO,CAACC,QAAQ,CAAC;IAC7BI,YAAY,EAAEsF,qBAAqB;IACnCG,OAAO,EAAEA,CAACC,OAAO,EAAE,MAAM,KAAK;MAC5BvC,eAAe,CAAC;QACdtC,GAAG,EAAE,aAAa;QAClBW,IAAI,EAAEkE,OAAO;QACbC,KAAK,EAAE,OAAO;QACdC,QAAQ,EAAE,WAAW;QACrBC,SAAS,EAAE;MACb,CAAC,CAAC;IACJ,CAAC;IACD/F,OAAO,EAAE8E,YAAY;IACrBkB,SAAS,EAAE;EACb,CAAC,CAAC;;EAEF;EACA;EACA,MAAM7C,YAAY,GAAGpE,OAAO,CAAC,EAAE,EAAEuD,YAAY,GAAG,IAAI,IAAI;IACtD,IAAI,CAAC3D,OAAO,CAAC,YAAY,CAAC,EAAE,OAAO,IAAI;IACvC,IAAI2E,cAAc,CAACI,OAAO,KAAK,IAAI,EAAE,OAAO,IAAI;IAChD,IAAIuB,sBAAsB,CAACrB,MAAM,KAAK,CAAC,EAAE,OAAO,IAAI;IACpD,MAAMe,QAAM,GAAGrB,cAAc,CAACI,OAAO;IACrC,MAAMyB,YAAU,GACdR,QAAM,CAACf,MAAM,GAAG,CAAC,IACjB,CAAC,KAAK,CAACa,IAAI,CAACE,QAAM,CAAC,IACnBM,sBAAsB,CAACrB,MAAM,GAAG,CAAC;IACnC,MAAMrB,KAAK,GAAGoC,QAAM,CAACf,MAAM,IAAIuB,YAAU,GAAG,CAAC,GAAG,CAAC,CAAC;IAClD,MAAM3C,GAAG,GAAGD,KAAK,GAAG0C,sBAAsB,CAACrB,MAAM;IACjD,OAAO;MAAErB,KAAK;MAAEC;IAAI,CAAC;EACvB,CAAC,EAAE,CAACyC,sBAAsB,CAAC,CAAC;EAE5B,OAAO;IACLnC,aAAa;IACbG,WAAW;IACX3C,cAAc,EAAEoF,KAAK,CAACpF,cAAc;IACpC6C;EACF,CAAC;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAAS8C,yBAAyBA,CAAC;EACxCC,mBAAmB;EACnBpD,aAAa;EACbG,WAAW;EACXkD;AAMF,CALC,EAAE;EACDD,mBAAmB,EAAE,CAAChD,UAAmB,CAAR,EAAE,MAAM,EAAE,GAAG,IAAI;EAClDJ,aAAa,EAAE,CAACC,QAAQ,EAAE,MAAM,EAAEC,IAAgB,CAAX,EAAEP,SAAS,EAAE,GAAG,MAAM;EAC7DQ,WAAW,EAAE,GAAG,GAAG,IAAI;EACvBkD,QAAQ,EAAE,OAAO;AACnB,CAAC,CAAC,EAAE;EAAEC,aAAa,EAAE,CAACvF,CAAC,EAAEvB,aAAa,EAAE,GAAG,IAAI;AAAC,CAAC,CAAC;EAChD,MAAM+G,aAAa,GAAGlH,gBAAgB,CAAC,CAAC;EACxC,MAAMmH,aAAa,GAAGlH,gBAAgB,CAAC,CAAC;EACxC,MAAMmH,iBAAiB,GAAG/G,4BAA4B,CAAC,CAAC;EACxD,MAAMgH,oBAAoB,GAAGtH,uBAAuB,CAAC,CAAC;EACtD;EACA,MAAM4F,YAAY,GAAGnG,OAAO,CAAC,YAAY,CAAC,GAAGiB,eAAe,CAAC,CAAC,GAAG,KAAK;EACtE,MAAMmF,UAAU,GAAGpG,OAAO,CAAC,YAAY,CAAC;EACpC;EACAU,aAAa,CAAC2F,CAAC,IAAIA,CAAC,CAACD,UAAU,CAAC,GAChC,MAAM;;EAEV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAM0B,cAAc,GAAG1H,OAAO,CAAC,EAAE,EAAEW,eAAe,GAAG,IAAI,IAAI;IAC3D,IAAI,CAAC6G,iBAAiB,EAAE,OAAOhF,uBAAuB;IACtD,IAAImF,MAAM,EAAEhH,eAAe,GAAG,IAAI,GAAG,IAAI;IACzC,KAAK,MAAMiH,OAAO,IAAIJ,iBAAiB,CAACK,QAAQ,EAAE;MAChD,IAAID,OAAO,CAACE,OAAO,KAAK,MAAM,EAAE;MAChC,IAAIF,OAAO,CAACG,KAAK,CAAClD,MAAM,KAAK,CAAC,EAAE;MAChC,MAAMmD,EAAE,GAAGJ,OAAO,CAACG,KAAK,CAAC,CAAC,CAAC;MAC3B,IAAI,CAACC,EAAE,EAAE;MACT,IAAIJ,OAAO,CAACK,MAAM,KAAK,kBAAkB,EAAE;QACzCN,MAAM,GAAGK,EAAE;MACb,CAAC,MAAM,IAAIL,MAAM,KAAK,IAAI,IAAIjH,eAAe,CAACsH,EAAE,EAAEL,MAAM,CAAC,EAAE;QACzD;QACAA,MAAM,GAAG,IAAI;MACf;IACF;IACA,OAAOA,MAAM;EACf,CAAC,EAAE,CAACH,iBAAiB,CAAC,CAAC;;EAEvB;EACA;EACA;EACA;EACA;EACA;EACA,MAAMU,QAAQ,GACZR,cAAc,KAAK,IAAI,IACvBA,cAAc,CAAC1F,GAAG,CAAC6C,MAAM,KAAK,CAAC,IAC/B,CAAC6C,cAAc,CAACxF,IAAI,IACpB,CAACwF,cAAc,CAACrF,GAAG,IACnB,CAACqF,cAAc,CAACvF,KAAK,IACrB,CAACuF,cAAc,CAACtF,IAAI,IACpB,CAACsF,cAAc,CAACnF,KAAK,GACjBmF,cAAc,CAAC1F,GAAG,GAClB,IAAI;EAEV,MAAMmG,aAAa,GAAGlI,MAAM,CAAC,CAAC,CAAC;EAC/B;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,MAAMmI,eAAe,GAAGnI,MAAM,CAAC,CAAC,CAAC;EACjC;EACA;EACA;EACA,MAAMoI,iBAAiB,GAAGpI,MAAM,CAAC,CAAC,CAAC;EACnC;EACA;EACA,MAAMqI,eAAe,GAAGrI,MAAM,CAAC,KAAK,CAAC;EACrC,MAAMsI,aAAa,GAAGtI,MAAM,CAACuI,UAAU,CAAC,OAAOC,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC,IAAI,CAAC;;EAExE;EACA;EACA;EACA;EACA1I,SAAS,CAAC,MAAM;IACd,IAAIiG,UAAU,KAAK,WAAW,EAAE;MAC9BsC,eAAe,CAAC3D,OAAO,GAAG,KAAK;MAC/BwD,aAAa,CAACxD,OAAO,GAAG,CAAC;MACzByD,eAAe,CAACzD,OAAO,GAAG,CAAC;MAC3B0D,iBAAiB,CAAC1D,OAAO,GAAG,CAAC;MAC7B4C,aAAa,CAAC7C,IAAI,IAAI;QACpB,IAAI,CAACA,IAAI,CAACgE,cAAc,EAAE,OAAOhE,IAAI;QACrC,OAAO;UAAE,GAAGA,IAAI;UAAEgE,cAAc,EAAE;QAAM,CAAC;MAC3C,CAAC,CAAC;IACJ;EACF,CAAC,EAAE,CAAC1C,UAAU,EAAEuB,aAAa,CAAC,CAAC;EAE/B,MAAMF,aAAa,GAAGA,CAACvF,CAAC,EAAEvB,aAAa,CAAC,EAAE,IAAI,IAAI;IAChD,IAAI,CAACwF,YAAY,EAAE;;IAEnB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAI,CAACqB,QAAQ,IAAIK,oBAAoB,EAAE;;IAEvC;IACA;IACA;IACA,IAAIC,cAAc,KAAK,IAAI,EAAE;;IAE7B;IACA;IACA;IACA;IACA,IAAIiB,WAAW,EAAE,MAAM;IACvB,IAAIT,QAAQ,KAAK,IAAI,EAAE;MACrB,IAAIpG,CAAC,CAACI,IAAI,IAAIJ,CAAC,CAACM,IAAI,IAAIN,CAAC,CAACK,KAAK,EAAE;MACjC;MACA;MACA,MAAMyG,UAAU,GACdV,QAAQ,KAAK,GAAG,GAAGtH,uBAAuB,CAACkB,CAAC,CAACE,GAAG,CAAC,GAAGF,CAAC,CAACE,GAAG;MAC3D;MACA;MACA;MACA,IAAI4G,UAAU,CAAC,CAAC,CAAC,KAAKV,QAAQ,EAAE;MAChC,IACEU,UAAU,CAAC/D,MAAM,GAAG,CAAC,IACrB+D,UAAU,KAAKV,QAAQ,CAACW,MAAM,CAACD,UAAU,CAAC/D,MAAM,CAAC,EAEjD;MACF8D,WAAW,GAAGC,UAAU,CAAC/D,MAAM;IACjC,CAAC,MAAM;MACL,IAAI,CAAChD,oBAAoB,CAACC,CAAC,EAAE4F,cAAc,CAAC,EAAE;MAC9CiB,WAAW,GAAG,CAAC;IACjB;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,MAAMG,iBAAiB,GAAGxB,aAAa,CAAC,CAAC,CAACtB,UAAU;IACpD,IAAIsC,eAAe,CAAC3D,OAAO,IAAImE,iBAAiB,KAAK,MAAM,EAAE;MAC3D;MACA;MACA;MACA;MACA;MACAhH,CAAC,CAACiH,wBAAwB,CAAC,CAAC;MAC5B,IAAIb,QAAQ,KAAK,IAAI,EAAE;QACrBnE,aAAa,CAAC4E,WAAW,EAAE;UACzBhF,IAAI,EAAEuE,QAAQ;UACdrE,KAAK,EAAEwE,iBAAiB,CAAC1D;QAC3B,CAAC,CAAC;MACJ;MACAwC,mBAAmB,CAAC,CAAC;MACrB;IACF;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA,IAAI2B,iBAAiB,KAAK,MAAM,EAAE;MAChC,IAAIZ,QAAQ,KAAK,IAAI,EAAEpG,CAAC,CAACiH,wBAAwB,CAAC,CAAC;MACnD;IACF;IAEA,MAAMC,WAAW,GAAGb,aAAa,CAACxD,OAAO;IACzCwD,aAAa,CAACxD,OAAO,IAAIgE,WAAW;;IAEpC;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAIT,QAAQ,KAAK,IAAI,IAAIC,aAAa,CAACxD,OAAO,IAAIhD,cAAc,EAAE;MAChEG,CAAC,CAACiH,wBAAwB,CAAC,CAAC;MAC5B,IAAIR,aAAa,CAAC5D,OAAO,EAAE;QACzBsE,YAAY,CAACV,aAAa,CAAC5D,OAAO,CAAC;QACnC4D,aAAa,CAAC5D,OAAO,GAAG,IAAI;MAC9B;MACAwD,aAAa,CAACxD,OAAO,GAAG,CAAC;MACzB2D,eAAe,CAAC3D,OAAO,GAAG,IAAI;MAC9B4C,aAAa,CAAC7C,MAAI,IAAI;QACpB,IAAI,CAACA,MAAI,CAACgE,cAAc,EAAE,OAAOhE,MAAI;QACrC,OAAO;UAAE,GAAGA,MAAI;UAAEgE,cAAc,EAAE;QAAM,CAAC;MAC3C,CAAC,CAAC;MACF,IAAIR,QAAQ,KAAK,IAAI,EAAE;QACrB;QACA;QACA;QACA;QACA;QACAG,iBAAiB,CAAC1D,OAAO,GAAGZ,aAAa,CACvCqE,eAAe,CAACzD,OAAO,GAAGgE,WAAW,EACrC;UAAEhF,IAAI,EAAEuE,QAAQ;UAAEtE,MAAM,EAAE;QAAK,CACjC,CAAC;QACDwE,eAAe,CAACzD,OAAO,GAAG,CAAC;QAC3BwC,mBAAmB,CAAC,CAAC;MACvB,CAAC,MAAM;QACL;QACA;QACA;QACA;QACA;QACApD,aAAa,CAAC,CAAC,EAAE;UAAEH,MAAM,EAAE;QAAK,CAAC,CAAC;QAClCuD,mBAAmB,CAACzF,gCAAgC,CAAC;MACvD;MACA;MACA;MACA;MACA;MACA;MACA;MACA,IAAI4F,aAAa,CAAC,CAAC,CAACtB,UAAU,KAAK,MAAM,EAAE;QACzCsC,eAAe,CAAC3D,OAAO,GAAG,KAAK;QAC/BT,WAAW,CAAC,CAAC;MACf;MACA;IACF;;IAEA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,IAAI8E,WAAW,IAAIpH,gBAAgB,EAAE;MACnCE,CAAC,CAACiH,wBAAwB,CAAC,CAAC;MAC5BhF,aAAa,CAAC4E,WAAW,EAAE;QACzBhF,IAAI,EAAEuE,QAAQ;QACdrE,KAAK,EAAEuE,eAAe,CAACzD;MACzB,CAAC,CAAC;IACJ,CAAC,MAAM;MACLyD,eAAe,CAACzD,OAAO,IAAIgE,WAAW;IACxC;;IAEA;IACA,IAAIR,aAAa,CAACxD,OAAO,IAAI/C,gBAAgB,EAAE;MAC7C2F,aAAa,CAAC7C,MAAI,IAAI;QACpB,IAAIA,MAAI,CAACgE,cAAc,EAAE,OAAOhE,MAAI;QACpC,OAAO;UAAE,GAAGA,MAAI;UAAEgE,cAAc,EAAE;QAAK,CAAC;MAC1C,CAAC,CAAC;IACJ;IAEA,IAAIH,aAAa,CAAC5D,OAAO,EAAE;MACzBsE,YAAY,CAACV,aAAa,CAAC5D,OAAO,CAAC;IACrC;IACA4D,aAAa,CAAC5D,OAAO,GAAG8D,UAAU,CAChC,CAACF,eAAa,EAAEJ,eAAa,EAAEC,iBAAe,EAAEb,eAAa,KAAK;MAChEgB,eAAa,CAAC5D,OAAO,GAAG,IAAI;MAC5BwD,eAAa,CAACxD,OAAO,GAAG,CAAC;MACzByD,iBAAe,CAACzD,OAAO,GAAG,CAAC;MAC3B4C,eAAa,CAAC7C,MAAI,IAAI;QACpB,IAAI,CAACA,MAAI,CAACgE,cAAc,EAAE,OAAOhE,MAAI;QACrC,OAAO;UAAE,GAAGA,MAAI;UAAEgE,cAAc,EAAE;QAAM,CAAC;MAC3C,CAAC,CAAC;IACJ,CAAC,EACDjH,gBAAgB,EAChB8G,aAAa,EACbJ,aAAa,EACbC,eAAe,EACfb,aACF,CAAC;EACH,CAAC;;EAED;EACA;EACA;EACA;EACA/G,QAAQ,CACN,CAAC0I,MAAM,EAAEC,IAAI,EAAEC,KAAK,KAAK;IACvB,MAAMC,OAAO,GAAG,IAAI9I,aAAa,CAAC6I,KAAK,CAACE,QAAQ,CAAC;IACjDjC,aAAa,CAACgC,OAAO,CAAC;IACtB;IACA;IACA;IACA,IAAIA,OAAO,CAACE,2BAA2B,CAAC,CAAC,EAAE;MACzCH,KAAK,CAACL,wBAAwB,CAAC,CAAC;IAClC;EACF,CAAC,EACD;IAAE3B;EAAS,CACb,CAAC;EAED,OAAO;IAAEC;EAAc,CAAC;AAC1B;;AAEA;AACA;AACA;AACA,OAAO,SAAAmC,uBAAAC,KAAA;EAMLvC,yBAAyB,CAACuC,KAAK,CAAC;EAAA,OACzB,IAAI;AAAA","ignoreList":[]}