@xortex/xcode 3.0.0

package/utils/swarm/It2SetupPrompt.tsx

@@ -0,0 +1,380 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useCallback, useEffect, useState } from 'react';
+import { type OptionWithDescription, Select } from '../../components/CustomSelect/index.js';
+import { Pane } from '../../components/design-system/Pane.js';
+import { Spinner } from '../../components/Spinner.js';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- enter to proceed through setup steps
+import { Box, Text, useInput } from '../../ink.js';
+import { useKeybinding } from '../../keybindings/useKeybinding.js';
+import { detectPythonPackageManager, getPythonApiInstructions, installIt2, markIt2SetupComplete, type PythonPackageManager, setPreferTmuxOverIterm2, verifyIt2Setup } from './backends/it2Setup.js';
+type SetupStep = 'initial' | 'installing' | 'install-failed' | 'verify-api' | 'api-instructions' | 'verifying' | 'success' | 'failed';
+type Props = {
+  onDone: (result: 'installed' | 'use-tmux' | 'cancelled') => void;
+  tmuxAvailable: boolean;
+};
+export function It2SetupPrompt(t0) {
+  const $ = _c(44);
+  const {
+    onDone,
+    tmuxAvailable
+  } = t0;
+  const [step, setStep] = useState("initial");
+  const [packageManager, setPackageManager] = useState(null);
+  const [error, setError] = useState(null);
+  const exitState = useExitOnCtrlCDWithKeybindings();
+  let t1;
+  let t2;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => {
+      detectPythonPackageManager().then(pm => {
+        setPackageManager(pm);
+      });
+    };
+    t2 = [];
+    $[0] = t1;
+    $[1] = t2;
+  } else {
+    t1 = $[0];
+    t2 = $[1];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[2] !== onDone) {
+    t3 = () => {
+      onDone("cancelled");
+    };
+    $[2] = onDone;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  const handleCancel = t3;
+  const t4 = step !== "installing" && step !== "verifying";
+  let t5;
+  if ($[4] !== t4) {
+    t5 = {
+      context: "Confirmation",
+      isActive: t4
+    };
+    $[4] = t4;
+    $[5] = t5;
+  } else {
+    t5 = $[5];
+  }
+  useKeybinding("confirm:no", handleCancel, t5);
+  let t6;
+  if ($[6] !== onDone || $[7] !== step) {
+    t6 = (_input, key) => {
+      if (step === "api-instructions" && key.return) {
+        setStep("verifying");
+        verifyIt2Setup().then(result => {
+          if (result.success) {
+            markIt2SetupComplete();
+            setStep("success");
+            setTimeout(onDone, 1500, "installed" as const);
+          } else {
+            setError(result.error || "Verification failed");
+            setStep("failed");
+          }
+        });
+      }
+    };
+    $[6] = onDone;
+    $[7] = step;
+    $[8] = t6;
+  } else {
+    t6 = $[8];
+  }
+  useInput(t6);
+  let t7;
+  if ($[9] !== packageManager) {
+    t7 = async function handleInstall() {
+      if (!packageManager) {
+        setError("No Python package manager found (uvx, pipx, or pip)");
+        setStep("failed");
+        return;
+      }
+      setStep("installing");
+      const result_0 = await installIt2(packageManager);
+      if (result_0.success) {
+        setStep("api-instructions");
+      } else {
+        setError(result_0.error || "Installation failed");
+        setStep("install-failed");
+      }
+    };
+    $[9] = packageManager;
+    $[10] = t7;
+  } else {
+    t7 = $[10];
+  }
+  const handleInstall = t7;
+  let t8;
+  if ($[11] !== onDone) {
+    t8 = function handleUseTmux() {
+      setPreferTmuxOverIterm2(true);
+      onDone("use-tmux");
+    };
+    $[11] = onDone;
+    $[12] = t8;
+  } else {
+    t8 = $[12];
+  }
+  const handleUseTmux = t8;
+  let T0;
+  let T1;
+  let t10;
+  let t11;
+  let t12;
+  let t13;
+  let t14;
+  let t9;
+  if ($[13] !== error || $[14] !== handleInstall || $[15] !== handleUseTmux || $[16] !== onDone || $[17] !== packageManager || $[18] !== step || $[19] !== tmuxAvailable) {
+    const renderContent = () => {
+      switch (step) {
+        case "initial":
+          {
+            return renderInitialPrompt();
+          }
+        case "installing":
+          {
+            return renderInstalling();
+          }
+        case "install-failed":
+          {
+            return renderInstallFailed();
+          }
+        case "api-instructions":
+          {
+            return renderApiInstructions();
+          }
+        case "verifying":
+          {
+            return renderVerifying();
+          }
+        case "success":
+          {
+            return renderSuccess();
+          }
+        case "failed":
+          {
+            return renderFailed();
+          }
+        default:
+          {
+            return null;
+          }
+      }
+    };
+    function renderInitialPrompt() {
+      const options = [{
+        label: "Install it2 now",
+        value: "install",
+        description: packageManager ? `Uses ${packageManager} to install the it2 CLI tool` : "Requires Python (uvx, pipx, or pip)"
+      }];
+      if (tmuxAvailable) {
+        options.push({
+          label: "Use tmux instead",
+          value: "tmux",
+          description: "Opens teammates in a separate tmux session"
+        });
+      }
+      options.push({
+        label: "Cancel",
+        value: "cancel",
+        description: "Skip teammate spawning for now"
+      });
+      return <Box flexDirection="column" gap={1}><Text>To use native iTerm2 split panes for teammates, you need the{" "}<Text bold={true}>it2</Text> CLI tool.</Text><Text dimColor={true}>This enables teammates to appear as split panes within your current window.</Text><Box marginTop={1}><Select options={options} onChange={value => {
+            bb61: switch (value) {
+              case "install":
+                {
+                  handleInstall();
+                  break bb61;
+                }
+              case "tmux":
+                {
+                  handleUseTmux();
+                  break bb61;
+                }
+              case "cancel":
+                {
+                  onDone("cancelled");
+                }
+            }
+          }} onCancel={() => onDone("cancelled")} /></Box></Box>;
+    }
+    function renderInstalling() {
+      return <Box flexDirection="column" gap={1}><Box><Spinner /><Text> Installing it2 using {packageManager}…</Text></Box><Text dimColor={true}>This may take a moment.</Text></Box>;
+    }
+    function renderInstallFailed() {
+      const options_0 = [{
+        label: "Try again",
+        value: "retry",
+        description: "Retry the installation"
+      }];
+      if (tmuxAvailable) {
+        options_0.push({
+          label: "Use tmux instead",
+          value: "tmux",
+          description: "Falls back to tmux for teammate panes"
+        });
+      }
+      options_0.push({
+        label: "Cancel",
+        value: "cancel",
+        description: "Skip teammate spawning for now"
+      });
+      return <Box flexDirection="column" gap={1}><Text color="error">Installation failed</Text>{error && <Text dimColor={true}>{error}</Text>}<Text dimColor={true}>You can try installing manually:{" "}{packageManager === "uvx" ? "uv tool install it2" : packageManager === "pipx" ? "pipx install it2" : "pip install --user it2"}</Text><Box marginTop={1}><Select options={options_0} onChange={value_0 => {
+            bb89: switch (value_0) {
+              case "retry":
+                {
+                  handleInstall();
+                  break bb89;
+                }
+              case "tmux":
+                {
+                  handleUseTmux();
+                  break bb89;
+                }
+              case "cancel":
+                {
+                  onDone("cancelled");
+                }
+            }
+          }} onCancel={() => onDone("cancelled")} /></Box></Box>;
+    }
+    function renderApiInstructions() {
+      const instructions = getPythonApiInstructions();
+      return <Box flexDirection="column" gap={1}><Text color="success">✓ it2 installed successfully</Text><Box flexDirection="column" marginTop={1}>{instructions.map(_temp)}</Box><Box marginTop={1}><Text dimColor={true}>Press Enter when ready to verify…</Text></Box></Box>;
+    }
+    function renderVerifying() {
+      return <Box><Spinner /><Text> Verifying it2 can communicate with iTerm2…</Text></Box>;
+    }
+    function renderSuccess() {
+      return <Box flexDirection="column"><Text color="success">✓ iTerm2 split pane support is ready</Text><Text dimColor={true}>Teammates will now appear as split panes.</Text></Box>;
+    }
+    function renderFailed() {
+      const options_1 = [{
+        label: "Try again",
+        value: "retry",
+        description: "Verify the connection again"
+      }];
+      if (tmuxAvailable) {
+        options_1.push({
+          label: "Use tmux instead",
+          value: "tmux",
+          description: "Falls back to tmux for teammate panes"
+        });
+      }
+      options_1.push({
+        label: "Cancel",
+        value: "cancel",
+        description: "Skip teammate spawning for now"
+      });
+      return <Box flexDirection="column" gap={1}><Text color="error">Verification failed</Text>{error && <Text dimColor={true}>{error}</Text>}<Text>Make sure:</Text><Box flexDirection="column" paddingLeft={2}><Text>· Python API is enabled in iTerm2 preferences</Text><Text>· You may need to restart iTerm2 after enabling</Text></Box><Box marginTop={1}><Select options={options_1} onChange={value_1 => {
+            bb115: switch (value_1) {
+              case "retry":
+                {
+                  setStep("verifying");
+                  verifyIt2Setup().then(result_1 => {
+                    if (result_1.success) {
+                      markIt2SetupComplete();
+                      setStep("success");
+                      setTimeout(onDone, 1500, "installed" as const);
+                    } else {
+                      setError(result_1.error || "Verification failed");
+                      setStep("failed");
+                    }
+                  });
+                  break bb115;
+                }
+              case "tmux":
+                {
+                  handleUseTmux();
+                  break bb115;
+                }
+              case "cancel":
+                {
+                  onDone("cancelled");
+                }
+            }
+          }} onCancel={() => onDone("cancelled")} /></Box></Box>;
+    }
+    T1 = Pane;
+    t14 = "permission";
+    T0 = Box;
+    t9 = "column";
+    t10 = 1;
+    t11 = 1;
+    if ($[28] === Symbol.for("react.memo_cache_sentinel")) {
+      t12 = <Text bold={true} color="permission">iTerm2 Split Pane Setup</Text>;
+      $[28] = t12;
+    } else {
+      t12 = $[28];
+    }
+    t13 = renderContent();
+    $[13] = error;
+    $[14] = handleInstall;
+    $[15] = handleUseTmux;
+    $[16] = onDone;
+    $[17] = packageManager;
+    $[18] = step;
+    $[19] = tmuxAvailable;
+    $[20] = T0;
+    $[21] = T1;
+    $[22] = t10;
+    $[23] = t11;
+    $[24] = t12;
+    $[25] = t13;
+    $[26] = t14;
+    $[27] = t9;
+  } else {
+    T0 = $[20];
+    T1 = $[21];
+    t10 = $[22];
+    t11 = $[23];
+    t12 = $[24];
+    t13 = $[25];
+    t14 = $[26];
+    t9 = $[27];
+  }
+  let t15;
+  if ($[29] !== exitState || $[30] !== step) {
+    t15 = step !== "installing" && step !== "verifying" && step !== "success" && <Text dimColor={true} italic={true}>{exitState.pending ? <>Press {exitState.keyName} again to exit</> : <>Esc to cancel</>}</Text>;
+    $[29] = exitState;
+    $[30] = step;
+    $[31] = t15;
+  } else {
+    t15 = $[31];
+  }
+  let t16;
+  if ($[32] !== T0 || $[33] !== t10 || $[34] !== t11 || $[35] !== t12 || $[36] !== t13 || $[37] !== t15 || $[38] !== t9) {
+    t16 = <T0 flexDirection={t9} gap={t10} paddingBottom={t11}>{t12}{t13}{t15}</T0>;
+    $[32] = T0;
+    $[33] = t10;
+    $[34] = t11;
+    $[35] = t12;
+    $[36] = t13;
+    $[37] = t15;
+    $[38] = t9;
+    $[39] = t16;
+  } else {
+    t16 = $[39];
+  }
+  let t17;
+  if ($[40] !== T1 || $[41] !== t14 || $[42] !== t16) {
+    t17 = <T1 color={t14}>{t16}</T1>;
+    $[40] = T1;
+    $[41] = t14;
+    $[42] = t16;
+    $[43] = t17;
+  } else {
+    t17 = $[43];
+  }
+  return t17;
+}
+function _temp(line, i) {
+  return <Text key={i}>{line}</Text>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","OptionWithDescription","Select","Pane","Spinner","useExitOnCtrlCDWithKeybindings","Box","Text","useInput","useKeybinding","detectPythonPackageManager","getPythonApiInstructions","installIt2","markIt2SetupComplete","PythonPackageManager","setPreferTmuxOverIterm2","verifyIt2Setup","SetupStep","Props","onDone","result","tmuxAvailable","It2SetupPrompt","t0","$","_c","step","setStep","packageManager","setPackageManager","error","setError","exitState","t1","t2","Symbol","for","then","pm","t3","handleCancel","t4","t5","context","isActive","t6","_input","key","return","success","setTimeout","const","t7","handleInstall","result_0","t8","handleUseTmux","T0","T1","t10","t11","t12","t13","t14","t9","renderContent","renderInitialPrompt","renderInstalling","renderInstallFailed","renderApiInstructions","renderVerifying","renderSuccess","renderFailed","options","label","value","description","push","bb61","options_0","value_0","bb89","instructions","map","_temp","options_1","value_1","bb115","result_1","t15","pending","keyName","t16","t17","line","i"],"sources":["It2SetupPrompt.tsx"],"sourcesContent":["import React, { useCallback, useEffect, useState } from 'react'\nimport {\n  type OptionWithDescription,\n  Select,\n} from '../../components/CustomSelect/index.js'\nimport { Pane } from '../../components/design-system/Pane.js'\nimport { Spinner } from '../../components/Spinner.js'\nimport { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js'\n// eslint-disable-next-line custom-rules/prefer-use-keybindings -- enter to proceed through setup steps\nimport { Box, Text, useInput } from '../../ink.js'\nimport { useKeybinding } from '../../keybindings/useKeybinding.js'\nimport {\n  detectPythonPackageManager,\n  getPythonApiInstructions,\n  installIt2,\n  markIt2SetupComplete,\n  type PythonPackageManager,\n  setPreferTmuxOverIterm2,\n  verifyIt2Setup,\n} from './backends/it2Setup.js'\n\ntype SetupStep =\n  | 'initial'\n  | 'installing'\n  | 'install-failed'\n  | 'verify-api'\n  | 'api-instructions'\n  | 'verifying'\n  | 'success'\n  | 'failed'\n\ntype Props = {\n  onDone: (result: 'installed' | 'use-tmux' | 'cancelled') => void\n  tmuxAvailable: boolean\n}\n\nexport function It2SetupPrompt({\n  onDone,\n  tmuxAvailable,\n}: Props): React.ReactNode {\n  const [step, setStep] = useState<SetupStep>('initial')\n  const [packageManager, setPackageManager] =\n    useState<PythonPackageManager | null>(null)\n  const [error, setError] = useState<string | null>(null)\n  const exitState = useExitOnCtrlCDWithKeybindings()\n\n  // Detect package manager on mount\n  useEffect(() => {\n    void detectPythonPackageManager().then(pm => {\n      setPackageManager(pm)\n    })\n  }, [])\n\n  const handleCancel = useCallback(() => {\n    onDone('cancelled')\n  }, [onDone])\n\n  useKeybinding('confirm:no', handleCancel, {\n    context: 'Confirmation',\n    isActive: step !== 'installing' && step !== 'verifying',\n  })\n\n  // Handle keyboard input for verification step\n  useInput((_input, key) => {\n    if (step === 'api-instructions' && key.return) {\n      setStep('verifying')\n      void verifyIt2Setup().then(result => {\n        if (result.success) {\n          markIt2SetupComplete()\n          setStep('success')\n          setTimeout(onDone, 1500, 'installed' as const)\n        } else {\n          setError(result.error || 'Verification failed')\n          setStep('failed')\n        }\n      })\n    }\n  })\n\n  // Handle installation\n  async function handleInstall(): Promise<void> {\n    if (!packageManager) {\n      setError('No Python package manager found (uvx, pipx, or pip)')\n      setStep('failed')\n      return\n    }\n\n    setStep('installing')\n    const result = await installIt2(packageManager)\n\n    if (result.success) {\n      // Show Python API instructions\n      setStep('api-instructions')\n    } else {\n      setError(result.error || 'Installation failed')\n      setStep('install-failed')\n    }\n  }\n\n  // Handle using tmux instead\n  function handleUseTmux(): void {\n    setPreferTmuxOverIterm2(true)\n    onDone('use-tmux')\n  }\n\n  // Render based on current step\n  const renderContent = (): React.ReactNode => {\n    switch (step) {\n      case 'initial':\n        return renderInitialPrompt()\n      case 'installing':\n        return renderInstalling()\n      case 'install-failed':\n        return renderInstallFailed()\n      case 'api-instructions':\n        return renderApiInstructions()\n      case 'verifying':\n        return renderVerifying()\n      case 'success':\n        return renderSuccess()\n      case 'failed':\n        return renderFailed()\n      default:\n        return null\n    }\n  }\n\n  function renderInitialPrompt(): React.ReactNode {\n    const options: OptionWithDescription<string>[] = [\n      {\n        label: 'Install it2 now',\n        value: 'install',\n        description: packageManager\n          ? `Uses ${packageManager} to install the it2 CLI tool`\n          : 'Requires Python (uvx, pipx, or pip)',\n      },\n    ]\n\n    if (tmuxAvailable) {\n      options.push({\n        label: 'Use tmux instead',\n        value: 'tmux',\n        description: 'Opens teammates in a separate tmux session',\n      })\n    }\n\n    options.push({\n      label: 'Cancel',\n      value: 'cancel',\n      description: 'Skip teammate spawning for now',\n    })\n\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text>\n          To use native iTerm2 split panes for teammates, you need the{' '}\n          <Text bold>it2</Text> CLI tool.\n        </Text>\n        <Text dimColor>\n          This enables teammates to appear as split panes within your current\n          window.\n        </Text>\n        <Box marginTop={1}>\n          <Select\n            options={options}\n            onChange={value => {\n              switch (value) {\n                case 'install':\n                  void handleInstall()\n                  break\n                case 'tmux':\n                  handleUseTmux()\n                  break\n                case 'cancel':\n                  onDone('cancelled')\n                  break\n              }\n            }}\n            onCancel={() => onDone('cancelled')}\n          />\n        </Box>\n      </Box>\n    )\n  }\n\n  function renderInstalling(): React.ReactNode {\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Box>\n          <Spinner />\n          <Text> Installing it2 using {packageManager}…</Text>\n        </Box>\n        <Text dimColor>This may take a moment.</Text>\n      </Box>\n    )\n  }\n\n  function renderInstallFailed(): React.ReactNode {\n    const options: OptionWithDescription<string>[] = [\n      {\n        label: 'Try again',\n        value: 'retry',\n        description: 'Retry the installation',\n      },\n    ]\n\n    if (tmuxAvailable) {\n      options.push({\n        label: 'Use tmux instead',\n        value: 'tmux',\n        description: 'Falls back to tmux for teammate panes',\n      })\n    }\n\n    options.push({\n      label: 'Cancel',\n      value: 'cancel',\n      description: 'Skip teammate spawning for now',\n    })\n\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"error\">Installation failed</Text>\n        {error && <Text dimColor>{error}</Text>}\n        <Text dimColor>\n          You can try installing manually:{' '}\n          {packageManager === 'uvx'\n            ? 'uv tool install it2'\n            : packageManager === 'pipx'\n              ? 'pipx install it2'\n              : 'pip install --user it2'}\n        </Text>\n        <Box marginTop={1}>\n          <Select\n            options={options}\n            onChange={value => {\n              switch (value) {\n                case 'retry':\n                  void handleInstall()\n                  break\n                case 'tmux':\n                  handleUseTmux()\n                  break\n                case 'cancel':\n                  onDone('cancelled')\n                  break\n              }\n            }}\n            onCancel={() => onDone('cancelled')}\n          />\n        </Box>\n      </Box>\n    )\n  }\n\n  function renderApiInstructions(): React.ReactNode {\n    const instructions = getPythonApiInstructions()\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"success\">✓ it2 installed successfully</Text>\n        <Box flexDirection=\"column\" marginTop={1}>\n          {instructions.map((line, i) => (\n            <Text key={i}>{line}</Text>\n          ))}\n        </Box>\n        <Box marginTop={1}>\n          <Text dimColor>Press Enter when ready to verify…</Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  function renderVerifying(): React.ReactNode {\n    return (\n      <Box>\n        <Spinner />\n        <Text> Verifying it2 can communicate with iTerm2…</Text>\n      </Box>\n    )\n  }\n\n  function renderSuccess(): React.ReactNode {\n    return (\n      <Box flexDirection=\"column\">\n        <Text color=\"success\">✓ iTerm2 split pane support is ready</Text>\n        <Text dimColor>Teammates will now appear as split panes.</Text>\n      </Box>\n    )\n  }\n\n  function renderFailed(): React.ReactNode {\n    const options: OptionWithDescription<string>[] = [\n      {\n        label: 'Try again',\n        value: 'retry',\n        description: 'Verify the connection again',\n      },\n    ]\n\n    if (tmuxAvailable) {\n      options.push({\n        label: 'Use tmux instead',\n        value: 'tmux',\n        description: 'Falls back to tmux for teammate panes',\n      })\n    }\n\n    options.push({\n      label: 'Cancel',\n      value: 'cancel',\n      description: 'Skip teammate spawning for now',\n    })\n\n    return (\n      <Box flexDirection=\"column\" gap={1}>\n        <Text color=\"error\">Verification failed</Text>\n        {error && <Text dimColor>{error}</Text>}\n        <Text>Make sure:</Text>\n        <Box flexDirection=\"column\" paddingLeft={2}>\n          <Text>· Python API is enabled in iTerm2 preferences</Text>\n          <Text>· You may need to restart iTerm2 after enabling</Text>\n        </Box>\n        <Box marginTop={1}>\n          <Select\n            options={options}\n            onChange={value => {\n              switch (value) {\n                case 'retry':\n                  setStep('verifying')\n                  void verifyIt2Setup().then(result => {\n                    if (result.success) {\n                      markIt2SetupComplete()\n                      setStep('success')\n                      setTimeout(onDone, 1500, 'installed' as const)\n                    } else {\n                      setError(result.error || 'Verification failed')\n                      setStep('failed')\n                    }\n                  })\n                  break\n                case 'tmux':\n                  handleUseTmux()\n                  break\n                case 'cancel':\n                  onDone('cancelled')\n                  break\n              }\n            }}\n            onCancel={() => onDone('cancelled')}\n          />\n        </Box>\n      </Box>\n    )\n  }\n\n  return (\n    <Pane color=\"permission\">\n      <Box flexDirection=\"column\" gap={1} paddingBottom={1}>\n        <Text bold color=\"permission\">\n          iTerm2 Split Pane Setup\n        </Text>\n        {renderContent()}\n        {step !== 'installing' &&\n          step !== 'verifying' &&\n          step !== 'success' && (\n            <Text dimColor italic>\n              {exitState.pending ? (\n                <>Press {exitState.keyName} again to exit</>\n              ) : (\n                <>Esc to cancel</>\n              )}\n            </Text>\n          )}\n      </Box>\n    </Pane>\n  )\n}\n"],"mappings":";AAAA,OAAOA,KAAK,IAAIC,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAC/D,SACE,KAAKC,qBAAqB,EAC1BC,MAAM,QACD,wCAAwC;AAC/C,SAASC,IAAI,QAAQ,wCAAwC;AAC7D,SAASC,OAAO,QAAQ,6BAA6B;AACrD,SAASC,8BAA8B,QAAQ,+CAA+C;AAC9F;AACA,SAASC,GAAG,EAAEC,IAAI,EAAEC,QAAQ,QAAQ,cAAc;AAClD,SAASC,aAAa,QAAQ,oCAAoC;AAClE,SACEC,0BAA0B,EAC1BC,wBAAwB,EACxBC,UAAU,EACVC,oBAAoB,EACpB,KAAKC,oBAAoB,EACzBC,uBAAuB,EACvBC,cAAc,QACT,wBAAwB;AAE/B,KAAKC,SAAS,GACV,SAAS,GACT,YAAY,GACZ,gBAAgB,GAChB,YAAY,GACZ,kBAAkB,GAClB,WAAW,GACX,SAAS,GACT,QAAQ;AAEZ,KAAKC,KAAK,GAAG;EACXC,MAAM,EAAE,CAACC,MAAM,EAAE,WAAW,GAAG,UAAU,GAAG,WAAW,EAAE,GAAG,IAAI;EAChEC,aAAa,EAAE,OAAO;AACxB,CAAC;AAED,OAAO,SAAAC,eAAAC,EAAA;EAAA,MAAAC,CAAA,GAAAC,EAAA;EAAwB;IAAAN,MAAA;IAAAE;EAAA,IAAAE,EAGvB;EACN,OAAAG,IAAA,EAAAC,OAAA,IAAwB3B,QAAQ,CAAY,SAAS,CAAC;EACtD,OAAA4B,cAAA,EAAAC,iBAAA,IACE7B,QAAQ,CAA8B,IAAI,CAAC;EAC7C,OAAA8B,KAAA,EAAAC,QAAA,IAA0B/B,QAAQ,CAAgB,IAAI,CAAC;EACvD,MAAAgC,SAAA,GAAkB3B,8BAA8B,CAAC,CAAC;EAAA,IAAA4B,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAV,CAAA,QAAAW,MAAA,CAAAC,GAAA;IAGxCH,EAAA,GAAAA,CAAA;MACHvB,0BAA0B,CAAC,CAAC,CAAA2B,IAAK,CAACC,EAAA;QACrCT,iBAAiB,CAACS,EAAE,CAAC;MAAA,CACtB,CAAC;IAAA,CACH;IAAEJ,EAAA,KAAE;IAAAV,CAAA,MAAAS,EAAA;IAAAT,CAAA,MAAAU,EAAA;EAAA;IAAAD,EAAA,GAAAT,CAAA;IAAAU,EAAA,GAAAV,CAAA;EAAA;EAJLzB,SAAS,CAACkC,EAIT,EAAEC,EAAE,CAAC;EAAA,IAAAK,EAAA;EAAA,IAAAf,CAAA,QAAAL,MAAA;IAE2BoB,EAAA,GAAAA,CAAA;MAC/BpB,MAAM,CAAC,WAAW,CAAC;IAAA,CACpB;IAAAK,CAAA,MAAAL,MAAA;IAAAK,CAAA,MAAAe,EAAA;EAAA;IAAAA,EAAA,GAAAf,CAAA;EAAA;EAFD,MAAAgB,YAAA,GAAqBD,EAET;EAIA,MAAAE,EAAA,GAAAf,IAAI,KAAK,YAAoC,IAApBA,IAAI,KAAK,WAAW;EAAA,IAAAgB,EAAA;EAAA,IAAAlB,CAAA,QAAAiB,EAAA;IAFfC,EAAA;MAAAC,OAAA,EAC/B,cAAc;MAAAC,QAAA,EACbH;IACZ,CAAC;IAAAjB,CAAA,MAAAiB,EAAA;IAAAjB,CAAA,MAAAkB,EAAA;EAAA;IAAAA,EAAA,GAAAlB,CAAA;EAAA;EAHDf,aAAa,CAAC,YAAY,EAAE+B,YAAY,EAAEE,EAGzC,CAAC;EAAA,IAAAG,EAAA;EAAA,IAAArB,CAAA,QAAAL,MAAA,IAAAK,CAAA,QAAAE,IAAA;IAGOmB,EAAA,GAAAA,CAAAC,MAAA,EAAAC,GAAA;MACP,IAAIrB,IAAI,KAAK,kBAAgC,IAAVqB,GAAG,CAAAC,MAAO;QAC3CrB,OAAO,CAAC,WAAW,CAAC;QACfX,cAAc,CAAC,CAAC,CAAAqB,IAAK,CAACjB,MAAA;UACzB,IAAIA,MAAM,CAAA6B,OAAQ;YAChBpC,oBAAoB,CAAC,CAAC;YACtBc,OAAO,CAAC,SAAS,CAAC;YAClBuB,UAAU,CAAC/B,MAAM,EAAE,IAAI,EAAE,WAAW,IAAIgC,KAAK,CAAC;UAAA;YAE9CpB,QAAQ,CAACX,MAAM,CAAAU,KAA+B,IAArC,qBAAqC,CAAC;YAC/CH,OAAO,CAAC,QAAQ,CAAC;UAAA;QAClB,CACF,CAAC;MAAA;IACH,CACF;IAAAH,CAAA,MAAAL,MAAA;IAAAK,CAAA,MAAAE,IAAA;IAAAF,CAAA,MAAAqB,EAAA;EAAA;IAAAA,EAAA,GAAArB,CAAA;EAAA;EAdDhB,QAAQ,CAACqC,EAcR,CAAC;EAAA,IAAAO,EAAA;EAAA,IAAA5B,CAAA,QAAAI,cAAA;IAGFwB,EAAA,kBAAAC,cAAA;MACE,IAAI,CAACzB,cAAc;QACjBG,QAAQ,CAAC,qDAAqD,CAAC;QAC/DJ,OAAO,CAAC,QAAQ,CAAC;QAAA;MAAA;MAInBA,OAAO,CAAC,YAAY,CAAC;MACrB,MAAA2B,QAAA,GAAe,MAAM1C,UAAU,CAACgB,cAAc,CAAC;MAE/C,IAAIR,QAAM,CAAA6B,OAAQ;QAEhBtB,OAAO,CAAC,kBAAkB,CAAC;MAAA;QAE3BI,QAAQ,CAACX,QAAM,CAAAU,KAA+B,IAArC,qBAAqC,CAAC;QAC/CH,OAAO,CAAC,gBAAgB,CAAC;MAAA;IAC1B,CACF;IAAAH,CAAA,MAAAI,cAAA;IAAAJ,CAAA,OAAA4B,EAAA;EAAA;IAAAA,EAAA,GAAA5B,CAAA;EAAA;EAjBD,MAAA6B,aAAA,GAAAD,EAiBC;EAAA,IAAAG,EAAA;EAAA,IAAA/B,CAAA,SAAAL,MAAA;IAGDoC,EAAA,YAAAC,cAAA;MACEzC,uBAAuB,CAAC,IAAI,CAAC;MAC7BI,MAAM,CAAC,UAAU,CAAC;IAAA,CACnB;IAAAK,CAAA,OAAAL,MAAA;IAAAK,CAAA,OAAA+B,EAAA;EAAA;IAAAA,EAAA,GAAA/B,CAAA;EAAA;EAHD,MAAAgC,aAAA,GAAAD,EAGC;EAAA,IAAAE,EAAA;EAAA,IAAAC,EAAA;EAAA,IAAAC,GAAA;EAAA,IAAAC,GAAA;EAAA,IAAAC,GAAA;EAAA,IAAAC,GAAA;EAAA,IAAAC,GAAA;EAAA,IAAAC,EAAA;EAAA,IAAAxC,CAAA,SAAAM,KAAA,IAAAN,CAAA,SAAA6B,aAAA,IAAA7B,CAAA,SAAAgC,aAAA,IAAAhC,CAAA,SAAAL,MAAA,IAAAK,CAAA,SAAAI,cAAA,IAAAJ,CAAA,SAAAE,IAAA,IAAAF,CAAA,SAAAH,aAAA;IAGD,MAAA4C,aAAA,GAAsBA,CAAA;MACpB,QAAQvC,IAAI;QAAA,KACL,SAAS;UAAA;YAAA,OACLwC,mBAAmB,CAAC,CAAC;UAAA;QAAA,KACzB,YAAY;UAAA;YAAA,OACRC,gBAAgB,CAAC,CAAC;UAAA;QAAA,KACtB,gBAAgB;UAAA;YAAA,OACZC,mBAAmB,CAAC,CAAC;UAAA;QAAA,KACzB,kBAAkB;UAAA;YAAA,OACdC,qBAAqB,CAAC,CAAC;UAAA;QAAA,KAC3B,WAAW;UAAA;YAAA,OACPC,eAAe,CAAC,CAAC;UAAA;QAAA,KACrB,SAAS;UAAA;YAAA,OACLC,aAAa,CAAC,CAAC;UAAA;QAAA,KACnB,QAAQ;UAAA;YAAA,OACJC,YAAY,CAAC,CAAC;UAAA;QAAA;UAAA;YAAA,OAEd,IAAI;UAAA;MACf;IAAC,CACF;IAED,SAAAN,oBAAA;MACE,MAAAO,OAAA,GAAiD,CAC/C;QAAAC,KAAA,EACS,iBAAiB;QAAAC,KAAA,EACjB,SAAS;QAAAC,WAAA,EACHhD,cAAc,GAAd,QACDA,cAAc,8BACe,GAF5B;MAGf,CAAC,CACF;MAED,IAAIP,aAAa;QACfoD,OAAO,CAAAI,IAAK,CAAC;UAAAH,KAAA,EACJ,kBAAkB;UAAAC,KAAA,EAClB,MAAM;UAAAC,WAAA,EACA;QACf,CAAC,CAAC;MAAA;MAGJH,OAAO,CAAAI,IAAK,CAAC;QAAAH,KAAA,EACJ,QAAQ;QAAAC,KAAA,EACR,QAAQ;QAAAC,WAAA,EACF;MACf,CAAC,CAAC;MAAA,OAGA,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAM,GAAC,CAAD,GAAC,CAChC,CAAC,IAAI,CAAC,4DACyD,IAAE,CAC/D,CAAC,IAAI,CAAC,IAAI,CAAJ,KAAG,CAAC,CAAC,GAAG,EAAb,IAAI,CAAgB,UACvB,EAHC,IAAI,CAIL,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,2EAGf,EAHC,IAAI,CAIL,CAAC,GAAG,CAAY,SAAC,CAAD,GAAC,CACf,CAAC,MAAM,CACIH,OAAO,CAAPA,QAAM,CAAC,CACN,QAYT,CAZS,CAAAE,KAAA;YAAAG,IAAA,EACR,QAAQH,KAAK;cAAA,KACN,SAAS;gBAAA;kBACPtB,aAAa,CAAC,CAAC;kBACpB,MAAAyB,IAAA;gBAAK;cAAA,KACF,MAAM;gBAAA;kBACTtB,aAAa,CAAC,CAAC;kBACf,MAAAsB,IAAA;gBAAK;cAAA,KACF,QAAQ;gBAAA;kBACX3D,MAAM,CAAC,WAAW,CAAC;gBAAA;YAEvB;UAAC,CACH,CAAC,CACS,QAAyB,CAAzB,OAAMA,MAAM,CAAC,WAAW,EAAC,GAEvC,EAlBC,GAAG,CAmBN,EA5BC,GAAG,CA4BE;IAAA;IAIV,SAAAgD,iBAAA;MAAA,OAEI,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAM,GAAC,CAAD,GAAC,CAChC,CAAC,GAAG,CACF,CAAC,OAAO,GACR,CAAC,IAAI,CAAC,sBAAuBvC,eAAa,CAAE,CAAC,EAA5C,IAAI,CACP,EAHC,GAAG,CAIJ,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,uBAAuB,EAArC,IAAI,CACP,EANC,GAAG,CAME;IAAA;IAIV,SAAAwC,oBAAA;MACE,MAAAW,SAAA,GAAiD,CAC/C;QAAAL,KAAA,EACS,WAAW;QAAAC,KAAA,EACX,OAAO;QAAAC,WAAA,EACD;MACf,CAAC,CACF;MAED,IAAIvD,aAAa;QACfoD,SAAO,CAAAI,IAAK,CAAC;UAAAH,KAAA,EACJ,kBAAkB;UAAAC,KAAA,EAClB,MAAM;UAAAC,WAAA,EACA;QACf,CAAC,CAAC;MAAA;MAGJH,SAAO,CAAAI,IAAK,CAAC;QAAAH,KAAA,EACJ,QAAQ;QAAAC,KAAA,EACR,QAAQ;QAAAC,WAAA,EACF;MACf,CAAC,CAAC;MAAA,OAGA,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAM,GAAC,CAAD,GAAC,CAChC,CAAC,IAAI,CAAO,KAAO,CAAP,OAAO,CAAC,mBAAmB,EAAtC,IAAI,CACJ,CAAA9C,KAAsC,IAA7B,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAEA,MAAI,CAAE,EAArB,IAAI,CAAuB,CACtC,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,gCACoB,IAAE,CAClC,CAAAF,cAAc,KAAK,KAIU,GAJ7B,qBAI6B,GAF1BA,cAAc,KAAK,MAEO,GAF1B,kBAE0B,GAF1B,wBAEyB,CAC/B,EAPC,IAAI,CAQL,CAAC,GAAG,CAAY,SAAC,CAAD,GAAC,CACf,CAAC,MAAM,CACI6C,OAAO,CAAPA,UAAM,CAAC,CACN,QAYT,CAZS,CAAAO,OAAA;YAAAC,IAAA,EACR,QAAQN,OAAK;cAAA,KACN,OAAO;gBAAA;kBACLtB,aAAa,CAAC,CAAC;kBACpB,MAAA4B,IAAA;gBAAK;cAAA,KACF,MAAM;gBAAA;kBACTzB,aAAa,CAAC,CAAC;kBACf,MAAAyB,IAAA;gBAAK;cAAA,KACF,QAAQ;gBAAA;kBACX9D,MAAM,CAAC,WAAW,CAAC;gBAAA;YAEvB;UAAC,CACH,CAAC,CACS,QAAyB,CAAzB,OAAMA,MAAM,CAAC,WAAW,EAAC,GAEvC,EAlBC,GAAG,CAmBN,EA9BC,GAAG,CA8BE;IAAA;IAIV,SAAAkD,sBAAA;MACE,MAAAa,YAAA,GAAqBvE,wBAAwB,CAAC,CAAC;MAAA,OAE7C,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAM,GAAC,CAAD,GAAC,CAChC,CAAC,IAAI,CAAO,KAAS,CAAT,SAAS,CAAC,4BAA4B,EAAjD,IAAI,CACL,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAY,SAAC,CAAD,GAAC,CACrC,CAAAuE,YAAY,CAAAC,GAAI,CAACC,KAEjB,EACH,EAJC,GAAG,CAKJ,CAAC,GAAG,CAAY,SAAC,CAAD,GAAC,CACf,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,iCAAiC,EAA/C,IAAI,CACP,EAFC,GAAG,CAGN,EAVC,GAAG,CAUE;IAAA;IAIV,SAAAd,gBAAA;MAAA,OAEI,CAAC,GAAG,CACF,CAAC,OAAO,GACR,CAAC,IAAI,CAAC,2CAA2C,EAAhD,IAAI,CACP,EAHC,GAAG,CAGE;IAAA;IAIV,SAAAC,cAAA;MAAA,OAEI,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CACzB,CAAC,IAAI,CAAO,KAAS,CAAT,SAAS,CAAC,oCAAoC,EAAzD,IAAI,CACL,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,yCAAyC,EAAvD,IAAI,CACP,EAHC,GAAG,CAGE;IAAA;IAIV,SAAAC,aAAA;MACE,MAAAa,SAAA,GAAiD,CAC/C;QAAAX,KAAA,EACS,WAAW;QAAAC,KAAA,EACX,OAAO;QAAAC,WAAA,EACD;MACf,CAAC,CACF;MAED,IAAIvD,aAAa;QACfoD,SAAO,CAAAI,IAAK,CAAC;UAAAH,KAAA,EACJ,kBAAkB;UAAAC,KAAA,EAClB,MAAM;UAAAC,WAAA,EACA;QACf,CAAC,CAAC;MAAA;MAGJH,SAAO,CAAAI,IAAK,CAAC;QAAAH,KAAA,EACJ,QAAQ;QAAAC,KAAA,EACR,QAAQ;QAAAC,WAAA,EACF;MACf,CAAC,CAAC;MAAA,OAGA,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAM,GAAC,CAAD,GAAC,CAChC,CAAC,IAAI,CAAO,KAAO,CAAP,OAAO,CAAC,mBAAmB,EAAtC,IAAI,CACJ,CAAA9C,KAAsC,IAA7B,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAEA,MAAI,CAAE,EAArB,IAAI,CAAuB,CACtC,CAAC,IAAI,CAAC,UAAU,EAAf,IAAI,CACL,CAAC,GAAG,CAAe,aAAQ,CAAR,QAAQ,CAAc,WAAC,CAAD,GAAC,CACxC,CAAC,IAAI,CAAC,6CAA6C,EAAlD,IAAI,CACL,CAAC,IAAI,CAAC,+CAA+C,EAApD,IAAI,CACP,EAHC,GAAG,CAIJ,CAAC,GAAG,CAAY,SAAC,CAAD,GAAC,CACf,CAAC,MAAM,CACI2C,OAAO,CAAPA,UAAM,CAAC,CACN,QAsBT,CAtBS,CAAAa,OAAA;YAAAC,KAAA,EACR,QAAQZ,OAAK;cAAA,KACN,OAAO;gBAAA;kBACVhD,OAAO,CAAC,WAAW,CAAC;kBACfX,cAAc,CAAC,CAAC,CAAAqB,IAAK,CAACmD,QAAA;oBACzB,IAAIpE,QAAM,CAAA6B,OAAQ;sBAChBpC,oBAAoB,CAAC,CAAC;sBACtBc,OAAO,CAAC,SAAS,CAAC;sBAClBuB,UAAU,CAAC/B,MAAM,EAAE,IAAI,EAAE,WAAW,IAAIgC,KAAK,CAAC;oBAAA;sBAE9CpB,QAAQ,CAACX,QAAM,CAAAU,KAA+B,IAArC,qBAAqC,CAAC;sBAC/CH,OAAO,CAAC,QAAQ,CAAC;oBAAA;kBAClB,CACF,CAAC;kBACF,MAAA4D,KAAA;gBAAK;cAAA,KACF,MAAM;gBAAA;kBACT/B,aAAa,CAAC,CAAC;kBACf,MAAA+B,KAAA;gBAAK;cAAA,KACF,QAAQ;gBAAA;kBACXpE,MAAM,CAAC,WAAW,CAAC;gBAAA;YAEvB;UAAC,CACH,CAAC,CACS,QAAyB,CAAzB,OAAMA,MAAM,CAAC,WAAW,EAAC,GAEvC,EA5BC,GAAG,CA6BN,EArCC,GAAG,CAqCE;IAAA;IAKPuC,EAAA,GAAAvD,IAAI;IAAO4D,GAAA,eAAY;IACrBN,EAAA,GAAAnD,GAAG;IAAe0D,EAAA,WAAQ;IAAML,GAAA,IAAC;IAAiBC,GAAA,IAAC;IAAA,IAAApC,CAAA,SAAAW,MAAA,CAAAC,GAAA;MAClDyB,GAAA,IAAC,IAAI,CAAC,IAAI,CAAJ,KAAG,CAAC,CAAO,KAAY,CAAZ,YAAY,CAAC,uBAE9B,EAFC,IAAI,CAEE;MAAArC,CAAA,OAAAqC,GAAA;IAAA;MAAAA,GAAA,GAAArC,CAAA;IAAA;IACNsC,GAAA,GAAAG,aAAa,CAAC,CAAC;IAAAzC,CAAA,OAAAM,KAAA;IAAAN,CAAA,OAAA6B,aAAA;IAAA7B,CAAA,OAAAgC,aAAA;IAAAhC,CAAA,OAAAL,MAAA;IAAAK,CAAA,OAAAI,cAAA;IAAAJ,CAAA,OAAAE,IAAA;IAAAF,CAAA,OAAAH,aAAA;IAAAG,CAAA,OAAAiC,EAAA;IAAAjC,CAAA,OAAAkC,EAAA;IAAAlC,CAAA,OAAAmC,GAAA;IAAAnC,CAAA,OAAAoC,GAAA;IAAApC,CAAA,OAAAqC,GAAA;IAAArC,CAAA,OAAAsC,GAAA;IAAAtC,CAAA,OAAAuC,GAAA;IAAAvC,CAAA,OAAAwC,EAAA;EAAA;IAAAP,EAAA,GAAAjC,CAAA;IAAAkC,EAAA,GAAAlC,CAAA;IAAAmC,GAAA,GAAAnC,CAAA;IAAAoC,GAAA,GAAApC,CAAA;IAAAqC,GAAA,GAAArC,CAAA;IAAAsC,GAAA,GAAAtC,CAAA;IAAAuC,GAAA,GAAAvC,CAAA;IAAAwC,EAAA,GAAAxC,CAAA;EAAA;EAAA,IAAAiE,GAAA;EAAA,IAAAjE,CAAA,SAAAQ,SAAA,IAAAR,CAAA,SAAAE,IAAA;IACf+D,GAAA,GAAA/D,IAAI,KAAK,YACY,IAApBA,IAAI,KAAK,WACS,IAAlBA,IAAI,KAAK,SAQR,IAPC,CAAC,IAAI,CAAC,QAAQ,CAAR,KAAO,CAAC,CAAC,MAAM,CAAN,KAAK,CAAC,CAClB,CAAAM,SAAS,CAAA0D,OAIT,GAJA,EACG,MAAO,CAAA1D,SAAS,CAAA2D,OAAO,CAAE,cAAc,GAG1C,GAJA,EAGG,aAAa,GACjB,CACF,EANC,IAAI,CAON;IAAAnE,CAAA,OAAAQ,SAAA;IAAAR,CAAA,OAAAE,IAAA;IAAAF,CAAA,OAAAiE,GAAA;EAAA;IAAAA,GAAA,GAAAjE,CAAA;EAAA;EAAA,IAAAoE,GAAA;EAAA,IAAApE,CAAA,SAAAiC,EAAA,IAAAjC,CAAA,SAAAmC,GAAA,IAAAnC,CAAA,SAAAoC,GAAA,IAAApC,CAAA,SAAAqC,GAAA,IAAArC,CAAA,SAAAsC,GAAA,IAAAtC,CAAA,SAAAiE,GAAA,IAAAjE,CAAA,SAAAwC,EAAA;IAfL4B,GAAA,IAAC,EAAG,CAAe,aAAQ,CAAR,CAAA5B,EAAO,CAAC,CAAM,GAAC,CAAD,CAAAL,GAAA,CAAC,CAAiB,aAAC,CAAD,CAAAC,GAAA,CAAC,CAClD,CAAAC,GAEM,CACL,CAAAC,GAAc,CACd,CAAA2B,GAUC,CACJ,EAhBC,EAAG,CAgBE;IAAAjE,CAAA,OAAAiC,EAAA;IAAAjC,CAAA,OAAAmC,GAAA;IAAAnC,CAAA,OAAAoC,GAAA;IAAApC,CAAA,OAAAqC,GAAA;IAAArC,CAAA,OAAAsC,GAAA;IAAAtC,CAAA,OAAAiE,GAAA;IAAAjE,CAAA,OAAAwC,EAAA;IAAAxC,CAAA,OAAAoE,GAAA;EAAA;IAAAA,GAAA,GAAApE,CAAA;EAAA;EAAA,IAAAqE,GAAA;EAAA,IAAArE,CAAA,SAAAkC,EAAA,IAAAlC,CAAA,SAAAuC,GAAA,IAAAvC,CAAA,SAAAoE,GAAA;IAjBRC,GAAA,IAAC,EAAI,CAAO,KAAY,CAAZ,CAAA9B,GAAW,CAAC,CACtB,CAAA6B,GAgBK,CACP,EAlBC,EAAI,CAkBE;IAAApE,CAAA,OAAAkC,EAAA;IAAAlC,CAAA,OAAAuC,GAAA;IAAAvC,CAAA,OAAAoE,GAAA;IAAApE,CAAA,OAAAqE,GAAA;EAAA;IAAAA,GAAA,GAAArE,CAAA;EAAA;EAAA,OAlBPqE,GAkBO;AAAA;AAlVJ,SAAAT,MAAAU,IAAA,EAAAC,CAAA;EAAA,OAkOK,CAAC,IAAI,CAAMA,GAAC,CAADA,EAAA,CAAC,CAAGD,KAAG,CAAE,EAAnB,IAAI,CAAsB;AAAA","ignoreList":[]}