dialogLaunchers.tsx

🖥️ Source preview

/**
 * Thin launchers for one-off dialog JSX sites in main.tsx.
 * Each launcher dynamically imports its component and wires the `done` callback
 * identically to the original inline call site. Zero behavior change.
 *
 * Part of the main.tsx React/JSX extraction effort. See sibling PRs
 * perf/extract-interactive-helpers and perf/launch-repl.
 */
import React from 'react';
import type { AssistantSession } from './assistant/sessionDiscovery.js';
import type { StatsStore } from './context/stats.js';
import type { Root } from './ink.js';
import { renderAndRun, showSetupDialog } from './interactiveHelpers.js';
import { KeybindingSetup } from './keybindings/KeybindingProviderSetup.js';
import type { AppState } from './state/AppStateStore.js';
import type { AgentMemoryScope } from './tools/AgentTool/agentMemory.js';
import type { TeleportRemoteResponse } from './utils/conversationRecovery.js';
import type { FpsMetrics } from './utils/fpsTracker.js';
import type { ValidationError } from './utils/settings/validation.js';

// Type-only access to ResumeConversation's Props via the module type.
// No runtime cost - erased at compile time.
type ResumeConversationProps = React.ComponentProps<typeof import('./screens/ResumeConversation.js').ResumeConversation>;

/**
 * Site ~3173: SnapshotUpdateDialog (agent memory snapshot update prompt).
 * Original callback wiring: onComplete={done}, onCancel={() => done('keep')}.
 */
export async function launchSnapshotUpdateDialog(root: Root, props: {
  agentType: string;
  scope: AgentMemoryScope;
  snapshotTimestamp: string;
}): Promise<'merge' | 'keep' | 'replace'> {
  const {
    SnapshotUpdateDialog
  } = await import('./components/agents/SnapshotUpdateDialog.js');
  return showSetupDialog<'merge' | 'keep' | 'replace'>(root, done => <SnapshotUpdateDialog agentType={props.agentType} scope={props.scope} snapshotTimestamp={props.snapshotTimestamp} onComplete={done} onCancel={() => done('keep')} />);
}

/**
 * Site ~3250: InvalidSettingsDialog (settings validation errors).
 * Original callback wiring: onContinue={done}, onExit passed through from caller.
 */
export async function launchInvalidSettingsDialog(root: Root, props: {
  settingsErrors: ValidationError[];
  onExit: () => void;
}): Promise<void> {
  const {
    InvalidSettingsDialog
  } = await import('./components/InvalidSettingsDialog.js');
  return showSetupDialog(root, done => <InvalidSettingsDialog settingsErrors={props.settingsErrors} onContinue={done} onExit={props.onExit} />);
}

/**
 * Site ~4229: AssistantSessionChooser (pick a bridge session to attach to).
 * Original callback wiring: onSelect={id => done(id)}, onCancel={() => done(null)}.
 */
export async function launchAssistantSessionChooser(root: Root, props: {
  sessions: AssistantSession[];
}): Promise<string | null> {
  const {
    AssistantSessionChooser
  } = await import('./assistant/AssistantSessionChooser.js');
  return showSetupDialog<string | null>(root, done => <AssistantSessionChooser sessions={props.sessions} onSelect={id => done(id)} onCancel={() => done(null)} />);
}

/**
 * `claude assistant` found zero sessions — show the same install wizard
 * as `/assistant` when daemon.json is empty. Resolves to the installed dir on
 * success, null on cancel. Rejects on install failure so the caller can
 * distinguish errors from user cancellation.
 */
export async function launchAssistantInstallWizard(root: Root): Promise<string | null> {
  const {
    NewInstallWizard,
    computeDefaultInstallDir
  } = await import('./commands/assistant/assistant.js');
  const defaultDir = await computeDefaultInstallDir();
  let rejectWithError: (reason: Error) => void;
  const errorPromise = new Promise<never>((_, reject) => {
    rejectWithError = reject;
  });
  const resultPromise = showSetupDialog<string | null>(root, done => <NewInstallWizard defaultDir={defaultDir} onInstalled={dir => done(dir)} onCancel={() => done(null)} onError={message => rejectWithError(new Error(`Installation failed: ${message}`))} />);
  return Promise.race([resultPromise, errorPromise]);
}

/**
 * Site ~4549: TeleportResumeWrapper (interactive teleport session picker).
 * Original callback wiring: onComplete={done}, onCancel={() => done(null)}, source="cliArg".
 */
export async function launchTeleportResumeWrapper(root: Root): Promise<TeleportRemoteResponse | null> {
  const {
    TeleportResumeWrapper
  } = await import('./components/TeleportResumeWrapper.js');
  return showSetupDialog<TeleportRemoteResponse | null>(root, done => <TeleportResumeWrapper onComplete={done} onCancel={() => done(null)} source="cliArg" />);
}

/**
 * Site ~4597: TeleportRepoMismatchDialog (pick a local checkout of the target repo).
 * Original callback wiring: onSelectPath={done}, onCancel={() => done(null)}.
 */
export async function launchTeleportRepoMismatchDialog(root: Root, props: {
  targetRepo: string;
  initialPaths: string[];
}): Promise<string | null> {
  const {
    TeleportRepoMismatchDialog
  } = await import('./components/TeleportRepoMismatchDialog.js');
  return showSetupDialog<string | null>(root, done => <TeleportRepoMismatchDialog targetRepo={props.targetRepo} initialPaths={props.initialPaths} onSelectPath={done} onCancel={() => done(null)} />);
}

/**
 * Site ~4903: ResumeConversation mount (interactive session picker).
 * Uses renderAndRun, NOT showSetupDialog. Wraps in <App><KeybindingSetup>.
 * Preserves original Promise.all parallelism between getWorktreePaths and imports.
 */
export async function launchResumeChooser(root: Root, appProps: {
  getFpsMetrics: () => FpsMetrics | undefined;
  stats: StatsStore;
  initialState: AppState;
}, worktreePathsPromise: Promise<string[]>, resumeProps: Omit<ResumeConversationProps, 'worktreePaths'>): Promise<void> {
  const [worktreePaths, {
    ResumeConversation
  }, {
    App
  }] = await Promise.all([worktreePathsPromise, import('./screens/ResumeConversation.js'), import('./components/App.js')]);
  await renderAndRun(root, <App getFpsMetrics={appProps.getFpsMetrics} stats={appProps.stats} initialState={appProps.initialState}>
      <KeybindingSetup>
        <ResumeConversation {...resumeProps} worktreePaths={worktreePaths} />
      </KeybindingSetup>
    </App>);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","AssistantSession","StatsStore","Root","renderAndRun","showSetupDialog","KeybindingSetup","AppState","AgentMemoryScope","TeleportRemoteResponse","FpsMetrics","ValidationError","ResumeConversationProps","ComponentProps","ResumeConversation","launchSnapshotUpdateDialog","root","props","agentType","scope","snapshotTimestamp","Promise","SnapshotUpdateDialog","done","launchInvalidSettingsDialog","settingsErrors","onExit","InvalidSettingsDialog","launchAssistantSessionChooser","sessions","AssistantSessionChooser","id","launchAssistantInstallWizard","NewInstallWizard","computeDefaultInstallDir","defaultDir","rejectWithError","reason","Error","errorPromise","_","reject","resultPromise","dir","message","race","launchTeleportResumeWrapper","TeleportResumeWrapper","launchTeleportRepoMismatchDialog","targetRepo","initialPaths","TeleportRepoMismatchDialog","launchResumeChooser","appProps","getFpsMetrics","stats","initialState","worktreePathsPromise","resumeProps","Omit","worktreePaths","App","all"],"sources":["dialogLaunchers.tsx"],"sourcesContent":["/**\n * Thin launchers for one-off dialog JSX sites in main.tsx.\n * Each launcher dynamically imports its component and wires the `done` callback\n * identically to the original inline call site. Zero behavior change.\n *\n * Part of the main.tsx React/JSX extraction effort. See sibling PRs\n * perf/extract-interactive-helpers and perf/launch-repl.\n */\nimport React from 'react'\nimport type { AssistantSession } from './assistant/sessionDiscovery.js'\nimport type { StatsStore } from './context/stats.js'\nimport type { Root } from './ink.js'\nimport { renderAndRun, showSetupDialog } from './interactiveHelpers.js'\nimport { KeybindingSetup } from './keybindings/KeybindingProviderSetup.js'\nimport type { AppState } from './state/AppStateStore.js'\nimport type { AgentMemoryScope } from './tools/AgentTool/agentMemory.js'\nimport type { TeleportRemoteResponse } from './utils/conversationRecovery.js'\nimport type { FpsMetrics } from './utils/fpsTracker.js'\nimport type { ValidationError } from './utils/settings/validation.js'\n\n// Type-only access to ResumeConversation's Props via the module type.\n// No runtime cost - erased at compile time.\ntype ResumeConversationProps = React.ComponentProps<\n  typeof import('./screens/ResumeConversation.js').ResumeConversation\n>\n\n/**\n * Site ~3173: SnapshotUpdateDialog (agent memory snapshot update prompt).\n * Original callback wiring: onComplete={done}, onCancel={() => done('keep')}.\n */\nexport async function launchSnapshotUpdateDialog(\n  root: Root,\n  props: {\n    agentType: string\n    scope: AgentMemoryScope\n    snapshotTimestamp: string\n  },\n): Promise<'merge' | 'keep' | 'replace'> {\n  const { SnapshotUpdateDialog } = await import(\n    './components/agents/SnapshotUpdateDialog.js'\n  )\n  return showSetupDialog<'merge' | 'keep' | 'replace'>(root, done => (\n    <SnapshotUpdateDialog\n      agentType={props.agentType}\n      scope={props.scope}\n      snapshotTimestamp={props.snapshotTimestamp}\n      onComplete={done}\n      onCancel={() => done('keep')}\n    />\n  ))\n}\n\n/**\n * Site ~3250: InvalidSettingsDialog (settings validation errors).\n * Original callback wiring: onContinue={done}, onExit passed through from caller.\n */\nexport async function launchInvalidSettingsDialog(\n  root: Root,\n  props: {\n    settingsErrors: ValidationError[]\n    onExit: () => void\n  },\n): Promise<void> {\n  const { InvalidSettingsDialog } = await import(\n    './components/InvalidSettingsDialog.js'\n  )\n  return showSetupDialog(root, done => (\n    <InvalidSettingsDialog\n      settingsErrors={props.settingsErrors}\n      onContinue={done}\n      onExit={props.onExit}\n    />\n  ))\n}\n\n/**\n * Site ~4229: AssistantSessionChooser (pick a bridge session to attach to).\n * Original callback wiring: onSelect={id => done(id)}, onCancel={() => done(null)}.\n */\nexport async function launchAssistantSessionChooser(\n  root: Root,\n  props: { sessions: AssistantSession[] },\n): Promise<string | null> {\n  const { AssistantSessionChooser } = await import(\n    './assistant/AssistantSessionChooser.js'\n  )\n  return showSetupDialog<string | null>(root, done => (\n    <AssistantSessionChooser\n      sessions={props.sessions}\n      onSelect={id => done(id)}\n      onCancel={() => done(null)}\n    />\n  ))\n}\n\n/**\n * `claude assistant` found zero sessions — show the same install wizard\n * as `/assistant` when daemon.json is empty. Resolves to the installed dir on\n * success, null on cancel. Rejects on install failure so the caller can\n * distinguish errors from user cancellation.\n */\nexport async function launchAssistantInstallWizard(\n  root: Root,\n): Promise<string | null> {\n  const { NewInstallWizard, computeDefaultInstallDir } = await import(\n    './commands/assistant/assistant.js'\n  )\n  const defaultDir = await computeDefaultInstallDir()\n  let rejectWithError: (reason: Error) => void\n  const errorPromise = new Promise<never>((_, reject) => {\n    rejectWithError = reject\n  })\n  const resultPromise = showSetupDialog<string | null>(root, done => (\n    <NewInstallWizard\n      defaultDir={defaultDir}\n      onInstalled={dir => done(dir)}\n      onCancel={() => done(null)}\n      onError={message =>\n        rejectWithError(new Error(`Installation failed: ${message}`))\n      }\n    />\n  ))\n  return Promise.race([resultPromise, errorPromise])\n}\n\n/**\n * Site ~4549: TeleportResumeWrapper (interactive teleport session picker).\n * Original callback wiring: onComplete={done}, onCancel={() => done(null)}, source=\"cliArg\".\n */\nexport async function launchTeleportResumeWrapper(\n  root: Root,\n): Promise<TeleportRemoteResponse | null> {\n  const { TeleportResumeWrapper } = await import(\n    './components/TeleportResumeWrapper.js'\n  )\n  return showSetupDialog<TeleportRemoteResponse | null>(root, done => (\n    <TeleportResumeWrapper\n      onComplete={done}\n      onCancel={() => done(null)}\n      source=\"cliArg\"\n    />\n  ))\n}\n\n/**\n * Site ~4597: TeleportRepoMismatchDialog (pick a local checkout of the target repo).\n * Original callback wiring: onSelectPath={done}, onCancel={() => done(null)}.\n */\nexport async function launchTeleportRepoMismatchDialog(\n  root: Root,\n  props: {\n    targetRepo: string\n    initialPaths: string[]\n  },\n): Promise<string | null> {\n  const { TeleportRepoMismatchDialog } = await import(\n    './components/TeleportRepoMismatchDialog.js'\n  )\n  return showSetupDialog<string | null>(root, done => (\n    <TeleportRepoMismatchDialog\n      targetRepo={props.targetRepo}\n      initialPaths={props.initialPaths}\n      onSelectPath={done}\n      onCancel={() => done(null)}\n    />\n  ))\n}\n\n/**\n * Site ~4903: ResumeConversation mount (interactive session picker).\n * Uses renderAndRun, NOT showSetupDialog. Wraps in <App><KeybindingSetup>.\n * Preserves original Promise.all parallelism between getWorktreePaths and imports.\n */\nexport async function launchResumeChooser(\n  root: Root,\n  appProps: {\n    getFpsMetrics: () => FpsMetrics | undefined\n    stats: StatsStore\n    initialState: AppState\n  },\n  worktreePathsPromise: Promise<string[]>,\n  resumeProps: Omit<ResumeConversationProps, 'worktreePaths'>,\n): Promise<void> {\n  const [worktreePaths, { ResumeConversation }, { App }] = await Promise.all([\n    worktreePathsPromise,\n    import('./screens/ResumeConversation.js'),\n    import('./components/App.js'),\n  ])\n  await renderAndRun(\n    root,\n    <App\n      getFpsMetrics={appProps.getFpsMetrics}\n      stats={appProps.stats}\n      initialState={appProps.initialState}\n    >\n      <KeybindingSetup>\n        <ResumeConversation {...resumeProps} worktreePaths={worktreePaths} />\n      </KeybindingSetup>\n    </App>,\n  )\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAOA,KAAK,MAAM,OAAO;AACzB,cAAcC,gBAAgB,QAAQ,iCAAiC;AACvE,cAAcC,UAAU,QAAQ,oBAAoB;AACpD,cAAcC,IAAI,QAAQ,UAAU;AACpC,SAASC,YAAY,EAAEC,eAAe,QAAQ,yBAAyB;AACvE,SAASC,eAAe,QAAQ,0CAA0C;AAC1E,cAAcC,QAAQ,QAAQ,0BAA0B;AACxD,cAAcC,gBAAgB,QAAQ,kCAAkC;AACxE,cAAcC,sBAAsB,QAAQ,iCAAiC;AAC7E,cAAcC,UAAU,QAAQ,uBAAuB;AACvD,cAAcC,eAAe,QAAQ,gCAAgC;;AAErE;AACA;AACA,KAAKC,uBAAuB,GAAGZ,KAAK,CAACa,cAAc,CACjD,OAAO,OAAO,iCAAiC,EAAEC,kBAAkB,CACpE;;AAED;AACA;AACA;AACA;AACA,OAAO,eAAeC,0BAA0BA,CAC9CC,IAAI,EAAEb,IAAI,EACVc,KAAK,EAAE;EACLC,SAAS,EAAE,MAAM;EACjBC,KAAK,EAAEX,gBAAgB;EACvBY,iBAAiB,EAAE,MAAM;AAC3B,CAAC,CACF,EAAEC,OAAO,CAAC,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;EACvC,MAAM;IAAEC;EAAqB,CAAC,GAAG,MAAM,MAAM,CAC3C,6CACF,CAAC;EACD,OAAOjB,eAAe,CAAC,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC,CAACW,IAAI,EAAEO,IAAI,IAC7D,CAAC,oBAAoB,CACnB,SAAS,CAAC,CAACN,KAAK,CAACC,SAAS,CAAC,CAC3B,KAAK,CAAC,CAACD,KAAK,CAACE,KAAK,CAAC,CACnB,iBAAiB,CAAC,CAACF,KAAK,CAACG,iBAAiB,CAAC,CAC3C,UAAU,CAAC,CAACG,IAAI,CAAC,CACjB,QAAQ,CAAC,CAAC,MAAMA,IAAI,CAAC,MAAM,CAAC,CAAC,GAEhC,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA,OAAO,eAAeC,2BAA2BA,CAC/CR,IAAI,EAAEb,IAAI,EACVc,KAAK,EAAE;EACLQ,cAAc,EAAEd,eAAe,EAAE;EACjCe,MAAM,EAAE,GAAG,GAAG,IAAI;AACpB,CAAC,CACF,EAAEL,OAAO,CAAC,IAAI,CAAC,CAAC;EACf,MAAM;IAAEM;EAAsB,CAAC,GAAG,MAAM,MAAM,CAC5C,uCACF,CAAC;EACD,OAAOtB,eAAe,CAACW,IAAI,EAAEO,IAAI,IAC/B,CAAC,qBAAqB,CACpB,cAAc,CAAC,CAACN,KAAK,CAACQ,cAAc,CAAC,CACrC,UAAU,CAAC,CAACF,IAAI,CAAC,CACjB,MAAM,CAAC,CAACN,KAAK,CAACS,MAAM,CAAC,GAExB,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA,OAAO,eAAeE,6BAA6BA,CACjDZ,IAAI,EAAEb,IAAI,EACVc,KAAK,EAAE;EAAEY,QAAQ,EAAE5B,gBAAgB,EAAE;AAAC,CAAC,CACxC,EAAEoB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;EACxB,MAAM;IAAES;EAAwB,CAAC,GAAG,MAAM,MAAM,CAC9C,wCACF,CAAC;EACD,OAAOzB,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC,CAACW,IAAI,EAAEO,IAAI,IAC9C,CAAC,uBAAuB,CACtB,QAAQ,CAAC,CAACN,KAAK,CAACY,QAAQ,CAAC,CACzB,QAAQ,CAAC,CAACE,EAAE,IAAIR,IAAI,CAACQ,EAAE,CAAC,CAAC,CACzB,QAAQ,CAAC,CAAC,MAAMR,IAAI,CAAC,IAAI,CAAC,CAAC,GAE9B,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeS,4BAA4BA,CAChDhB,IAAI,EAAEb,IAAI,CACX,EAAEkB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;EACxB,MAAM;IAAEY,gBAAgB;IAAEC;EAAyB,CAAC,GAAG,MAAM,MAAM,CACjE,mCACF,CAAC;EACD,MAAMC,UAAU,GAAG,MAAMD,wBAAwB,CAAC,CAAC;EACnD,IAAIE,eAAe,EAAE,CAACC,MAAM,EAAEC,KAAK,EAAE,GAAG,IAAI;EAC5C,MAAMC,YAAY,GAAG,IAAIlB,OAAO,CAAC,KAAK,CAAC,CAAC,CAACmB,CAAC,EAAEC,MAAM,KAAK;IACrDL,eAAe,GAAGK,MAAM;EAC1B,CAAC,CAAC;EACF,MAAMC,aAAa,GAAGrC,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC,CAACW,IAAI,EAAEO,IAAI,IAC7D,CAAC,gBAAgB,CACf,UAAU,CAAC,CAACY,UAAU,CAAC,CACvB,WAAW,CAAC,CAACQ,GAAG,IAAIpB,IAAI,CAACoB,GAAG,CAAC,CAAC,CAC9B,QAAQ,CAAC,CAAC,MAAMpB,IAAI,CAAC,IAAI,CAAC,CAAC,CAC3B,OAAO,CAAC,CAACqB,OAAO,IACdR,eAAe,CAAC,IAAIE,KAAK,CAAC,wBAAwBM,OAAO,EAAE,CAAC,CAC9D,CAAC,GAEJ,CAAC;EACF,OAAOvB,OAAO,CAACwB,IAAI,CAAC,CAACH,aAAa,EAAEH,YAAY,CAAC,CAAC;AACpD;;AAEA;AACA;AACA;AACA;AACA,OAAO,eAAeO,2BAA2BA,CAC/C9B,IAAI,EAAEb,IAAI,CACX,EAAEkB,OAAO,CAACZ,sBAAsB,GAAG,IAAI,CAAC,CAAC;EACxC,MAAM;IAAEsC;EAAsB,CAAC,GAAG,MAAM,MAAM,CAC5C,uCACF,CAAC;EACD,OAAO1C,eAAe,CAACI,sBAAsB,GAAG,IAAI,CAAC,CAACO,IAAI,EAAEO,IAAI,IAC9D,CAAC,qBAAqB,CACpB,UAAU,CAAC,CAACA,IAAI,CAAC,CACjB,QAAQ,CAAC,CAAC,MAAMA,IAAI,CAAC,IAAI,CAAC,CAAC,CAC3B,MAAM,CAAC,QAAQ,GAElB,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA,OAAO,eAAeyB,gCAAgCA,CACpDhC,IAAI,EAAEb,IAAI,EACVc,KAAK,EAAE;EACLgC,UAAU,EAAE,MAAM;EAClBC,YAAY,EAAE,MAAM,EAAE;AACxB,CAAC,CACF,EAAE7B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;EACxB,MAAM;IAAE8B;EAA2B,CAAC,GAAG,MAAM,MAAM,CACjD,4CACF,CAAC;EACD,OAAO9C,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC,CAACW,IAAI,EAAEO,IAAI,IAC9C,CAAC,0BAA0B,CACzB,UAAU,CAAC,CAACN,KAAK,CAACgC,UAAU,CAAC,CAC7B,YAAY,CAAC,CAAChC,KAAK,CAACiC,YAAY,CAAC,CACjC,YAAY,CAAC,CAAC3B,IAAI,CAAC,CACnB,QAAQ,CAAC,CAAC,MAAMA,IAAI,CAAC,IAAI,CAAC,CAAC,GAE9B,CAAC;AACJ;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAe6B,mBAAmBA,CACvCpC,IAAI,EAAEb,IAAI,EACVkD,QAAQ,EAAE;EACRC,aAAa,EAAE,GAAG,GAAG5C,UAAU,GAAG,SAAS;EAC3C6C,KAAK,EAAErD,UAAU;EACjBsD,YAAY,EAAEjD,QAAQ;AACxB,CAAC,EACDkD,oBAAoB,EAAEpC,OAAO,CAAC,MAAM,EAAE,CAAC,EACvCqC,WAAW,EAAEC,IAAI,CAAC/C,uBAAuB,EAAE,eAAe,CAAC,CAC5D,EAAES,OAAO,CAAC,IAAI,CAAC,CAAC;EACf,MAAM,CAACuC,aAAa,EAAE;IAAE9C;EAAmB,CAAC,EAAE;IAAE+C;EAAI,CAAC,CAAC,GAAG,MAAMxC,OAAO,CAACyC,GAAG,CAAC,CACzEL,oBAAoB,EACpB,MAAM,CAAC,iCAAiC,CAAC,EACzC,MAAM,CAAC,qBAAqB,CAAC,CAC9B,CAAC;EACF,MAAMrD,YAAY,CAChBY,IAAI,EACJ,CAAC,GAAG,CACF,aAAa,CAAC,CAACqC,QAAQ,CAACC,aAAa,CAAC,CACtC,KAAK,CAAC,CAACD,QAAQ,CAACE,KAAK,CAAC,CACtB,YAAY,CAAC,CAACF,QAAQ,CAACG,YAAY,CAAC;AAE1C,MAAM,CAAC,eAAe;AACtB,QAAQ,CAAC,kBAAkB,CAAC,IAAIE,WAAW,CAAC,CAAC,aAAa,CAAC,CAACE,aAAa,CAAC;AAC1E,MAAM,EAAE,eAAe;AACvB,IAAI,EAAE,GAAG,CACP,CAAC;AACH","ignoreList":[]}