shortcutxl 0.3.76 → 0.3.78

package/native-app/main/index.js

@@ -1,16 +1,30 @@
 import { app, BrowserWindow, ipcMain, dialog, shell } from "electron";
 import { resolve, extname, basename, join, dirname, isAbsolute } from "node:path";
-import { open, stat, readFile } from "node:fs/promises";
+import { open, stat, readFile, unlink } from "node:fs/promises";
 import require$$1 from "tty";
 import require$$1$1 from "util";
-import require$$0 from "os";
+import require$$0, { homedir, platform, arch } from "os";
 import { createRequire } from "module";
 import * as path from "path";
+import path__default, { dirname as dirname$1, join as join$1, basename as basename$1 } from "path";
 import { fileURLToPath } from "url";
 import { spawn } from "node:child_process";
 import * as readline from "node:readline";
 import { randomUUID } from "node:crypto";
 import { createRequire as createRequire$1 } from "node:module";
+import process$1 from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+import { spawnSync } from "child_process";
+import require$$0$2, { readFileSync, existsSync, mkdirSync, renameSync, chmodSync, rmSync, readdirSync, statSync } from "fs";
+import require$$0$1 from "buffer";
+import require$$6 from "stream";
+import require$$1$2 from "zlib";
+import require$$4 from "events";
+import "crypto";
+import { createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 import __cjs_mod__ from "node:module";
 const __filename = import.meta.filename;
 const __dirname = import.meta.dirname;
@@ -1052,7 +1066,7 @@ var hasRequiredCommon;
 function requireCommon() {
   if (hasRequiredCommon) return common;
   hasRequiredCommon = 1;
-  function setup(env) {
+  function setup(env2) {
     createDebug.debug = createDebug;
     createDebug.default = createDebug;
     createDebug.coerce = coerce;
@@ -1061,8 +1075,8 @@ function requireCommon() {
     createDebug.enabled = enabled;
     createDebug.humanize = requireMs();
     createDebug.destroy = destroy;
-    Object.keys(env).forEach((key) => {
-      createDebug[key] = env[key];
+    Object.keys(env2).forEach((key) => {
+      createDebug[key] = env2[key];
     });
     createDebug.names = [];
     createDebug.skips = [];
@@ -1398,46 +1412,46 @@ function requireBrowser() {
   return browser.exports;
 }
 var node = { exports: {} };
-var hasFlag;
+var hasFlag$1;
 var hasRequiredHasFlag;
 function requireHasFlag() {
-  if (hasRequiredHasFlag) return hasFlag;
+  if (hasRequiredHasFlag) return hasFlag$1;
   hasRequiredHasFlag = 1;
-  hasFlag = (flag, argv = process.argv) => {
+  hasFlag$1 = (flag, argv = process.argv) => {
     const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
     const position = argv.indexOf(prefix + flag);
     const terminatorPosition = argv.indexOf("--");
     return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
   };
-  return hasFlag;
+  return hasFlag$1;
 }
 var supportsColor_1;
 var hasRequiredSupportsColor;
 function requireSupportsColor() {
   if (hasRequiredSupportsColor) return supportsColor_1;
   hasRequiredSupportsColor = 1;
-  const os = require$$0;
-  const tty = require$$1;
+  const os2 = require$$0;
+  const tty2 = require$$1;
   const hasFlag2 = requireHasFlag();
-  const { env } = process;
-  let flagForceColor;
+  const { env: env2 } = process;
+  let flagForceColor2;
   if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false") || hasFlag2("color=never")) {
-    flagForceColor = 0;
+    flagForceColor2 = 0;
   } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
-    flagForceColor = 1;
+    flagForceColor2 = 1;
   }
-  function envForceColor() {
-    if ("FORCE_COLOR" in env) {
-      if (env.FORCE_COLOR === "true") {
+  function envForceColor2() {
+    if ("FORCE_COLOR" in env2) {
+      if (env2.FORCE_COLOR === "true") {
         return 1;
       }
-      if (env.FORCE_COLOR === "false") {
+      if (env2.FORCE_COLOR === "false") {
         return 0;
       }
-      return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+      return env2.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env2.FORCE_COLOR, 10), 3);
     }
   }
-  function translateLevel(level) {
+  function translateLevel2(level) {
     if (level === 0) {
       return false;
     }
@@ -1448,12 +1462,12 @@ function requireSupportsColor() {
       has16m: level >= 3
     };
   }
-  function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-    const noFlagForceColor = envForceColor();
+  function supportsColor2(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+    const noFlagForceColor = envForceColor2();
     if (noFlagForceColor !== void 0) {
-      flagForceColor = noFlagForceColor;
+      flagForceColor2 = noFlagForceColor;
     }
-    const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+    const forceColor = sniffFlags ? flagForceColor2 : noFlagForceColor;
     if (forceColor === 0) {
       return 0;
     }
@@ -1469,59 +1483,59 @@ function requireSupportsColor() {
       return 0;
     }
     const min = forceColor || 0;
-    if (env.TERM === "dumb") {
+    if (env2.TERM === "dumb") {
       return min;
     }
     if (process.platform === "win32") {
-      const osRelease = os.release().split(".");
+      const osRelease = os2.release().split(".");
       if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
         return Number(osRelease[2]) >= 14931 ? 3 : 2;
       }
       return 1;
     }
-    if ("CI" in env) {
-      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+    if ("CI" in env2) {
+      if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env2) || env2.CI_NAME === "codeship") {
         return 1;
       }
       return min;
     }
-    if ("TEAMCITY_VERSION" in env) {
-      return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+    if ("TEAMCITY_VERSION" in env2) {
+      return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
     }
-    if (env.COLORTERM === "truecolor") {
+    if (env2.COLORTERM === "truecolor") {
       return 3;
     }
-    if ("TERM_PROGRAM" in env) {
-      const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-      switch (env.TERM_PROGRAM) {
+    if ("TERM_PROGRAM" in env2) {
+      const version = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+      switch (env2.TERM_PROGRAM) {
         case "iTerm.app":
           return version >= 3 ? 3 : 2;
         case "Apple_Terminal":
           return 2;
       }
     }
-    if (/-256(color)?$/i.test(env.TERM)) {
+    if (/-256(color)?$/i.test(env2.TERM)) {
       return 2;
     }
-    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
       return 1;
     }
-    if ("COLORTERM" in env) {
+    if ("COLORTERM" in env2) {
       return 1;
     }
     return min;
   }
   function getSupportLevel(stream, options = {}) {
-    const level = supportsColor(stream, {
+    const level = supportsColor2(stream, {
       streamIsTTY: stream && stream.isTTY,
       ...options
     });
-    return translateLevel(level);
+    return translateLevel2(level);
   }
   supportsColor_1 = {
     supportsColor: getSupportLevel,
-    stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
-    stderr: getSupportLevel({ isTTY: tty.isatty(2) })
+    stdout: getSupportLevel({ isTTY: tty2.isatty(1) }),
+    stderr: getSupportLevel({ isTTY: tty2.isatty(2) })
   };
   return supportsColor_1;
 }
@@ -1530,7 +1544,7 @@ function requireNode() {
   if (hasRequiredNode) return node.exports;
   hasRequiredNode = 1;
   (function(module, exports$1) {
-    const tty = require$$1;
+    const tty2 = require$$1;
     const util = require$$1$1;
     exports$1.init = init;
     exports$1.log = log;
@@ -1545,8 +1559,8 @@ function requireNode() {
     );
     exports$1.colors = [6, 2, 3, 4, 5, 1];
     try {
-      const supportsColor = requireSupportsColor();
-      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+      const supportsColor2 = requireSupportsColor();
+      if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) {
         exports$1.colors = [
           20,
           21,
@@ -1648,7 +1662,7 @@ function requireNode() {
       return obj;
     }, {});
     function useColors() {
-      return "colors" in exports$1.inspectOpts ? Boolean(exports$1.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+      return "colors" in exports$1.inspectOpts ? Boolean(exports$1.inspectOpts.colors) : tty2.isatty(process.stderr.fd);
     }
     function formatArgs(args) {
       const { namespace: name, useColors: useColors2 } = this;
@@ -4744,7 +4758,7 @@ async function loadPhoton() {
   loadPromise = (async () => {
     const restoreReadFileSync = patchPhotonWasmRead();
     try {
-      photonModule = await import("./photon_rs-SoVDgheu.js").then((n) => n.p);
+      photonModule = await import("./photon_rs-XkYyYTVA.js").then((n) => n.p);
       return photonModule;
     } catch {
       photonModule = null;
@@ -5251,6 +5265,7 @@ const AgentIpcChannel = {
   Event: "agent:event",
   OpenWorkspace: "agent:open-workspace",
   PickAttachments: "agent:pick-attachments",
+  FileMentionSuggestions: "agent:file-mention-suggestions",
   OpenFolder: "app:open-folder",
   Quit: "app:quit"
 };
@@ -5344,6 +5359,3137 @@ class AgentProcessManager {
     await Promise.all([...this.agents.keys()].map((hostId) => this.stop(hostId)));
   }
 }
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+const wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+const styles$1 = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+Object.keys(styles$1.modifier);
+const foregroundColorNames = Object.keys(styles$1.color);
+const backgroundColorNames = Object.keys(styles$1.bgColor);
+[...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles$1)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles$1[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles$1[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles$1, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles$1, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles$1.color.close = "\x1B[39m";
+  styles$1.bgColor.close = "\x1B[49m";
+  styles$1.color.ansi = wrapAnsi16();
+  styles$1.color.ansi256 = wrapAnsi256();
+  styles$1.color.ansi16m = wrapAnsi16m();
+  styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles$1, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles$1;
+}
+const ansiStyles = assembleStyles();
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process$1.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+const { env } = process$1;
+let flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process$1.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+const supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+const GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+const STYLER = /* @__PURE__ */ Symbol("STYLER");
+const IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+const levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+const styles = /* @__PURE__ */ Object.create(null);
+const applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === void 0 ? colorLevel : options.level;
+};
+const chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+  styles[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+const getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansiStyles[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+    }
+    return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansiStyles.hexToRgb(...arguments_));
+  }
+  return ansiStyles[type][model](...arguments_);
+};
+const usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+const proto = Object.defineProperties(() => {
+}, {
+  ...styles,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+const createStyler = (open2, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open2;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open2;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open: open2,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+const createBuilder = (self2, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self2;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+const applyStyle = (self2, string) => {
+  if (self2.level <= 0 || !string) {
+    return self2[IS_EMPTY] ? "" : string;
+  }
+  let styler = self2[STYLER];
+  if (styler === void 0) {
+    return string;
+  }
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== void 0) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string.indexOf("\n");
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+const chalk = createChalk();
+createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var getStream = { exports: {} };
+var once = { exports: {} };
+var wrappy_1;
+var hasRequiredWrappy;
+function requireWrappy() {
+  if (hasRequiredWrappy) return wrappy_1;
+  hasRequiredWrappy = 1;
+  wrappy_1 = wrappy;
+  function wrappy(fn, cb) {
+    if (fn && cb) return wrappy(fn)(cb);
+    if (typeof fn !== "function")
+      throw new TypeError("need wrapper function");
+    Object.keys(fn).forEach(function(k) {
+      wrapper[k] = fn[k];
+    });
+    return wrapper;
+    function wrapper() {
+      var args = new Array(arguments.length);
+      for (var i = 0; i < args.length; i++) {
+        args[i] = arguments[i];
+      }
+      var ret = fn.apply(this, args);
+      var cb2 = args[args.length - 1];
+      if (typeof ret === "function" && ret !== cb2) {
+        Object.keys(cb2).forEach(function(k) {
+          ret[k] = cb2[k];
+        });
+      }
+      return ret;
+    }
+  }
+  return wrappy_1;
+}
+var hasRequiredOnce;
+function requireOnce() {
+  if (hasRequiredOnce) return once.exports;
+  hasRequiredOnce = 1;
+  var wrappy = requireWrappy();
+  once.exports = wrappy(once$1);
+  once.exports.strict = wrappy(onceStrict);
+  once$1.proto = once$1(function() {
+    Object.defineProperty(Function.prototype, "once", {
+      value: function() {
+        return once$1(this);
+      },
+      configurable: true
+    });
+    Object.defineProperty(Function.prototype, "onceStrict", {
+      value: function() {
+        return onceStrict(this);
+      },
+      configurable: true
+    });
+  });
+  function once$1(fn) {
+    var f = function() {
+      if (f.called) return f.value;
+      f.called = true;
+      return f.value = fn.apply(this, arguments);
+    };
+    f.called = false;
+    return f;
+  }
+  function onceStrict(fn) {
+    var f = function() {
+      if (f.called)
+        throw new Error(f.onceError);
+      f.called = true;
+      return f.value = fn.apply(this, arguments);
+    };
+    var name = fn.name || "Function wrapped with `once`";
+    f.onceError = name + " shouldn't be called more than once";
+    f.called = false;
+    return f;
+  }
+  return once.exports;
+}
+var endOfStream;
+var hasRequiredEndOfStream;
+function requireEndOfStream() {
+  if (hasRequiredEndOfStream) return endOfStream;
+  hasRequiredEndOfStream = 1;
+  var once2 = requireOnce();
+  var noop = function() {
+  };
+  var qnt = commonjsGlobal.Bare ? queueMicrotask : process.nextTick.bind(process);
+  var isRequest = function(stream) {
+    return stream.setHeader && typeof stream.abort === "function";
+  };
+  var isChildProcess = function(stream) {
+    return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3;
+  };
+  var eos = function(stream, opts, callback) {
+    if (typeof opts === "function") return eos(stream, null, opts);
+    if (!opts) opts = {};
+    callback = once2(callback || noop);
+    var ws = stream._writableState;
+    var rs = stream._readableState;
+    var readable = opts.readable || opts.readable !== false && stream.readable;
+    var writable = opts.writable || opts.writable !== false && stream.writable;
+    var cancelled = false;
+    var onlegacyfinish = function() {
+      if (!stream.writable) onfinish();
+    };
+    var onfinish = function() {
+      writable = false;
+      if (!readable) callback.call(stream);
+    };
+    var onend = function() {
+      readable = false;
+      if (!writable) callback.call(stream);
+    };
+    var onexit = function(exitCode) {
+      callback.call(stream, exitCode ? new Error("exited with error code: " + exitCode) : null);
+    };
+    var onerror = function(err) {
+      callback.call(stream, err);
+    };
+    var onclose = function() {
+      qnt(onclosenexttick);
+    };
+    var onclosenexttick = function() {
+      if (cancelled) return;
+      if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error("premature close"));
+      if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error("premature close"));
+    };
+    var onrequest = function() {
+      stream.req.on("finish", onfinish);
+    };
+    if (isRequest(stream)) {
+      stream.on("complete", onfinish);
+      stream.on("abort", onclose);
+      if (stream.req) onrequest();
+      else stream.on("request", onrequest);
+    } else if (writable && !ws) {
+      stream.on("end", onlegacyfinish);
+      stream.on("close", onlegacyfinish);
+    }
+    if (isChildProcess(stream)) stream.on("exit", onexit);
+    stream.on("end", onend);
+    stream.on("finish", onfinish);
+    if (opts.error !== false) stream.on("error", onerror);
+    stream.on("close", onclose);
+    return function() {
+      cancelled = true;
+      stream.removeListener("complete", onfinish);
+      stream.removeListener("abort", onclose);
+      stream.removeListener("request", onrequest);
+      if (stream.req) stream.req.removeListener("finish", onfinish);
+      stream.removeListener("end", onlegacyfinish);
+      stream.removeListener("close", onlegacyfinish);
+      stream.removeListener("finish", onfinish);
+      stream.removeListener("exit", onexit);
+      stream.removeListener("end", onend);
+      stream.removeListener("error", onerror);
+      stream.removeListener("close", onclose);
+    };
+  };
+  endOfStream = eos;
+  return endOfStream;
+}
+var pump_1;
+var hasRequiredPump;
+function requirePump() {
+  if (hasRequiredPump) return pump_1;
+  hasRequiredPump = 1;
+  var once2 = requireOnce();
+  var eos = requireEndOfStream();
+  var fs2;
+  try {
+    fs2 = require2("fs");
+  } catch (e) {
+  }
+  var noop = function() {
+  };
+  var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
+  var isFn = function(fn) {
+    return typeof fn === "function";
+  };
+  var isFS = function(stream) {
+    if (!ancient) return false;
+    if (!fs2) return false;
+    return (stream instanceof (fs2.ReadStream || noop) || stream instanceof (fs2.WriteStream || noop)) && isFn(stream.close);
+  };
+  var isRequest = function(stream) {
+    return stream.setHeader && isFn(stream.abort);
+  };
+  var destroyer = function(stream, reading, writing, callback) {
+    callback = once2(callback);
+    var closed = false;
+    stream.on("close", function() {
+      closed = true;
+    });
+    eos(stream, { readable: reading, writable: writing }, function(err) {
+      if (err) return callback(err);
+      closed = true;
+      callback();
+    });
+    var destroyed = false;
+    return function(err) {
+      if (closed) return;
+      if (destroyed) return;
+      destroyed = true;
+      if (isFS(stream)) return stream.close(noop);
+      if (isRequest(stream)) return stream.abort();
+      if (isFn(stream.destroy)) return stream.destroy();
+      callback(err || new Error("stream was destroyed"));
+    };
+  };
+  var call = function(fn) {
+    fn();
+  };
+  var pipe = function(from, to) {
+    return from.pipe(to);
+  };
+  var pump = function() {
+    var streams = Array.prototype.slice.call(arguments);
+    var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
+    if (Array.isArray(streams[0])) streams = streams[0];
+    if (streams.length < 2) throw new Error("pump requires two streams per minimum");
+    var error;
+    var destroys = streams.map(function(stream, i) {
+      var reading = i < streams.length - 1;
+      var writing = i > 0;
+      return destroyer(stream, reading, writing, function(err) {
+        if (!error) error = err;
+        if (err) destroys.forEach(call);
+        if (reading) return;
+        destroys.forEach(call);
+        callback(error);
+      });
+    });
+    return streams.reduce(pipe);
+  };
+  pump_1 = pump;
+  return pump_1;
+}
+var bufferStream;
+var hasRequiredBufferStream;
+function requireBufferStream() {
+  if (hasRequiredBufferStream) return bufferStream;
+  hasRequiredBufferStream = 1;
+  const { PassThrough: PassThroughStream } = require$$6;
+  bufferStream = (options) => {
+    options = { ...options };
+    const { array } = options;
+    let { encoding } = options;
+    const isBuffer = encoding === "buffer";
+    let objectMode = false;
+    if (array) {
+      objectMode = !(encoding || isBuffer);
+    } else {
+      encoding = encoding || "utf8";
+    }
+    if (isBuffer) {
+      encoding = null;
+    }
+    const stream = new PassThroughStream({ objectMode });
+    if (encoding) {
+      stream.setEncoding(encoding);
+    }
+    let length = 0;
+    const chunks = [];
+    stream.on("data", (chunk) => {
+      chunks.push(chunk);
+      if (objectMode) {
+        length = chunks.length;
+      } else {
+        length += chunk.length;
+      }
+    });
+    stream.getBufferedValue = () => {
+      if (array) {
+        return chunks;
+      }
+      return isBuffer ? Buffer.concat(chunks, length) : chunks.join("");
+    };
+    stream.getBufferedLength = () => length;
+    return stream;
+  };
+  return bufferStream;
+}
+var hasRequiredGetStream;
+function requireGetStream() {
+  if (hasRequiredGetStream) return getStream.exports;
+  hasRequiredGetStream = 1;
+  const { constants: BufferConstants } = require$$0$1;
+  const pump = requirePump();
+  const bufferStream2 = requireBufferStream();
+  class MaxBufferError extends Error {
+    constructor() {
+      super("maxBuffer exceeded");
+      this.name = "MaxBufferError";
+    }
+  }
+  async function getStream$1(inputStream, options) {
+    if (!inputStream) {
+      return Promise.reject(new Error("Expected a stream"));
+    }
+    options = {
+      maxBuffer: Infinity,
+      ...options
+    };
+    const { maxBuffer } = options;
+    let stream;
+    await new Promise((resolve2, reject) => {
+      const rejectPromise = (error) => {
+        if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+          error.bufferedData = stream.getBufferedValue();
+        }
+        reject(error);
+      };
+      stream = pump(inputStream, bufferStream2(options), (error) => {
+        if (error) {
+          rejectPromise(error);
+          return;
+        }
+        resolve2();
+      });
+      stream.on("data", () => {
+        if (stream.getBufferedLength() > maxBuffer) {
+          rejectPromise(new MaxBufferError());
+        }
+      });
+    });
+    return stream.getBufferedValue();
+  }
+  getStream.exports = getStream$1;
+  getStream.exports.default = getStream$1;
+  getStream.exports.buffer = (stream, options) => getStream$1(stream, { ...options, encoding: "buffer" });
+  getStream.exports.array = (stream, options) => getStream$1(stream, { ...options, array: true });
+  getStream.exports.MaxBufferError = MaxBufferError;
+  return getStream.exports;
+}
+var yauzl = {};
+var fdSlicer = {};
+var pend;
+var hasRequiredPend;
+function requirePend() {
+  if (hasRequiredPend) return pend;
+  hasRequiredPend = 1;
+  pend = Pend;
+  function Pend() {
+    this.pending = 0;
+    this.max = Infinity;
+    this.listeners = [];
+    this.waiting = [];
+    this.error = null;
+  }
+  Pend.prototype.go = function(fn) {
+    if (this.pending < this.max) {
+      pendGo(this, fn);
+    } else {
+      this.waiting.push(fn);
+    }
+  };
+  Pend.prototype.wait = function(cb) {
+    if (this.pending === 0) {
+      cb(this.error);
+    } else {
+      this.listeners.push(cb);
+    }
+  };
+  Pend.prototype.hold = function() {
+    return pendHold(this);
+  };
+  function pendHold(self2) {
+    self2.pending += 1;
+    var called = false;
+    return onCb;
+    function onCb(err) {
+      if (called) throw new Error("callback called twice");
+      called = true;
+      self2.error = self2.error || err;
+      self2.pending -= 1;
+      if (self2.waiting.length > 0 && self2.pending < self2.max) {
+        pendGo(self2, self2.waiting.shift());
+      } else if (self2.pending === 0) {
+        var listeners = self2.listeners;
+        self2.listeners = [];
+        listeners.forEach(cbListener);
+      }
+    }
+    function cbListener(listener) {
+      listener(self2.error);
+    }
+  }
+  function pendGo(self2, fn) {
+    fn(pendHold(self2));
+  }
+  return pend;
+}
+var hasRequiredFdSlicer;
+function requireFdSlicer() {
+  if (hasRequiredFdSlicer) return fdSlicer;
+  hasRequiredFdSlicer = 1;
+  var fs2 = require$$0$2;
+  var util = require$$1$1;
+  var stream = require$$6;
+  var Readable2 = stream.Readable;
+  var Writable = stream.Writable;
+  var PassThrough = stream.PassThrough;
+  var Pend = requirePend();
+  var EventEmitter = require$$4.EventEmitter;
+  fdSlicer.createFromBuffer = createFromBuffer;
+  fdSlicer.createFromFd = createFromFd;
+  fdSlicer.BufferSlicer = BufferSlicer;
+  fdSlicer.FdSlicer = FdSlicer;
+  util.inherits(FdSlicer, EventEmitter);
+  function FdSlicer(fd, options) {
+    options = options || {};
+    EventEmitter.call(this);
+    this.fd = fd;
+    this.pend = new Pend();
+    this.pend.max = 1;
+    this.refCount = 0;
+    this.autoClose = !!options.autoClose;
+  }
+  FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+    var self2 = this;
+    self2.pend.go(function(cb) {
+      fs2.read(self2.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        cb();
+        callback(err, bytesRead, buffer2);
+      });
+    });
+  };
+  FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+    var self2 = this;
+    self2.pend.go(function(cb) {
+      fs2.write(self2.fd, buffer, offset, length, position, function(err, written, buffer2) {
+        cb();
+        callback(err, written, buffer2);
+      });
+    });
+  };
+  FdSlicer.prototype.createReadStream = function(options) {
+    return new ReadStream(this, options);
+  };
+  FdSlicer.prototype.createWriteStream = function(options) {
+    return new WriteStream(this, options);
+  };
+  FdSlicer.prototype.ref = function() {
+    this.refCount += 1;
+  };
+  FdSlicer.prototype.unref = function() {
+    var self2 = this;
+    self2.refCount -= 1;
+    if (self2.refCount > 0) return;
+    if (self2.refCount < 0) throw new Error("invalid unref");
+    if (self2.autoClose) {
+      fs2.close(self2.fd, onCloseDone);
+    }
+    function onCloseDone(err) {
+      if (err) {
+        self2.emit("error", err);
+      } else {
+        self2.emit("close");
+      }
+    }
+  };
+  util.inherits(ReadStream, Readable2);
+  function ReadStream(context, options) {
+    options = options || {};
+    Readable2.call(this, options);
+    this.context = context;
+    this.context.ref();
+    this.start = options.start || 0;
+    this.endOffset = options.end;
+    this.pos = this.start;
+    this.destroyed = false;
+  }
+  ReadStream.prototype._read = function(n) {
+    var self2 = this;
+    if (self2.destroyed) return;
+    var toRead = Math.min(self2._readableState.highWaterMark, n);
+    if (self2.endOffset != null) {
+      toRead = Math.min(toRead, self2.endOffset - self2.pos);
+    }
+    if (toRead <= 0) {
+      self2.destroyed = true;
+      self2.push(null);
+      self2.context.unref();
+      return;
+    }
+    self2.context.pend.go(function(cb) {
+      if (self2.destroyed) return cb();
+      var buffer = new Buffer(toRead);
+      fs2.read(self2.context.fd, buffer, 0, toRead, self2.pos, function(err, bytesRead) {
+        if (err) {
+          self2.destroy(err);
+        } else if (bytesRead === 0) {
+          self2.destroyed = true;
+          self2.push(null);
+          self2.context.unref();
+        } else {
+          self2.pos += bytesRead;
+          self2.push(buffer.slice(0, bytesRead));
+        }
+        cb();
+      });
+    });
+  };
+  ReadStream.prototype.destroy = function(err) {
+    if (this.destroyed) return;
+    err = err || new Error("stream destroyed");
+    this.destroyed = true;
+    this.emit("error", err);
+    this.context.unref();
+  };
+  util.inherits(WriteStream, Writable);
+  function WriteStream(context, options) {
+    options = options || {};
+    Writable.call(this, options);
+    this.context = context;
+    this.context.ref();
+    this.start = options.start || 0;
+    this.endOffset = options.end == null ? Infinity : +options.end;
+    this.bytesWritten = 0;
+    this.pos = this.start;
+    this.destroyed = false;
+    this.on("finish", this.destroy.bind(this));
+  }
+  WriteStream.prototype._write = function(buffer, encoding, callback) {
+    var self2 = this;
+    if (self2.destroyed) return;
+    if (self2.pos + buffer.length > self2.endOffset) {
+      var err = new Error("maximum file length exceeded");
+      err.code = "ETOOBIG";
+      self2.destroy();
+      callback(err);
+      return;
+    }
+    self2.context.pend.go(function(cb) {
+      if (self2.destroyed) return cb();
+      fs2.write(self2.context.fd, buffer, 0, buffer.length, self2.pos, function(err2, bytes) {
+        if (err2) {
+          self2.destroy();
+          cb();
+          callback(err2);
+        } else {
+          self2.bytesWritten += bytes;
+          self2.pos += bytes;
+          self2.emit("progress");
+          cb();
+          callback();
+        }
+      });
+    });
+  };
+  WriteStream.prototype.destroy = function() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.context.unref();
+  };
+  util.inherits(BufferSlicer, EventEmitter);
+  function BufferSlicer(buffer, options) {
+    EventEmitter.call(this);
+    options = options || {};
+    this.refCount = 0;
+    this.buffer = buffer;
+    this.maxChunkSize = options.maxChunkSize || Number.MAX_SAFE_INTEGER;
+  }
+  BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+    var end = position + length;
+    var delta = end - this.buffer.length;
+    var written = delta > 0 ? delta : length;
+    this.buffer.copy(buffer, offset, position, end);
+    setImmediate(function() {
+      callback(null, written);
+    });
+  };
+  BufferSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+    buffer.copy(this.buffer, position, offset, offset + length);
+    setImmediate(function() {
+      callback(null, length, buffer);
+    });
+  };
+  BufferSlicer.prototype.createReadStream = function(options) {
+    options = options || {};
+    var readStream = new PassThrough(options);
+    readStream.destroyed = false;
+    readStream.start = options.start || 0;
+    readStream.endOffset = options.end;
+    readStream.pos = readStream.endOffset || this.buffer.length;
+    var entireSlice = this.buffer.slice(readStream.start, readStream.pos);
+    var offset = 0;
+    while (true) {
+      var nextOffset = offset + this.maxChunkSize;
+      if (nextOffset >= entireSlice.length) {
+        if (offset < entireSlice.length) {
+          readStream.write(entireSlice.slice(offset, entireSlice.length));
+        }
+        break;
+      }
+      readStream.write(entireSlice.slice(offset, nextOffset));
+      offset = nextOffset;
+    }
+    readStream.end();
+    readStream.destroy = function() {
+      readStream.destroyed = true;
+    };
+    return readStream;
+  };
+  BufferSlicer.prototype.createWriteStream = function(options) {
+    var bufferSlicer = this;
+    options = options || {};
+    var writeStream = new Writable(options);
+    writeStream.start = options.start || 0;
+    writeStream.endOffset = options.end == null ? this.buffer.length : +options.end;
+    writeStream.bytesWritten = 0;
+    writeStream.pos = writeStream.start;
+    writeStream.destroyed = false;
+    writeStream._write = function(buffer, encoding, callback) {
+      if (writeStream.destroyed) return;
+      var end = writeStream.pos + buffer.length;
+      if (end > writeStream.endOffset) {
+        var err = new Error("maximum file length exceeded");
+        err.code = "ETOOBIG";
+        writeStream.destroyed = true;
+        callback(err);
+        return;
+      }
+      buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length);
+      writeStream.bytesWritten += buffer.length;
+      writeStream.pos = end;
+      writeStream.emit("progress");
+      callback();
+    };
+    writeStream.destroy = function() {
+      writeStream.destroyed = true;
+    };
+    return writeStream;
+  };
+  BufferSlicer.prototype.ref = function() {
+    this.refCount += 1;
+  };
+  BufferSlicer.prototype.unref = function() {
+    this.refCount -= 1;
+    if (this.refCount < 0) {
+      throw new Error("invalid unref");
+    }
+  };
+  function createFromBuffer(buffer, options) {
+    return new BufferSlicer(buffer, options);
+  }
+  function createFromFd(fd, options) {
+    return new FdSlicer(fd, options);
+  }
+  return fdSlicer;
+}
+var bufferCrc32;
+var hasRequiredBufferCrc32;
+function requireBufferCrc32() {
+  if (hasRequiredBufferCrc32) return bufferCrc32;
+  hasRequiredBufferCrc32 = 1;
+  var Buffer2 = require$$0$1.Buffer;
+  var CRC_TABLE = [
+    0,
+    1996959894,
+    3993919788,
+    2567524794,
+    124634137,
+    1886057615,
+    3915621685,
+    2657392035,
+    249268274,
+    2044508324,
+    3772115230,
+    2547177864,
+    162941995,
+    2125561021,
+    3887607047,
+    2428444049,
+    498536548,
+    1789927666,
+    4089016648,
+    2227061214,
+    450548861,
+    1843258603,
+    4107580753,
+    2211677639,
+    325883990,
+    1684777152,
+    4251122042,
+    2321926636,
+    335633487,
+    1661365465,
+    4195302755,
+    2366115317,
+    997073096,
+    1281953886,
+    3579855332,
+    2724688242,
+    1006888145,
+    1258607687,
+    3524101629,
+    2768942443,
+    901097722,
+    1119000684,
+    3686517206,
+    2898065728,
+    853044451,
+    1172266101,
+    3705015759,
+    2882616665,
+    651767980,
+    1373503546,
+    3369554304,
+    3218104598,
+    565507253,
+    1454621731,
+    3485111705,
+    3099436303,
+    671266974,
+    1594198024,
+    3322730930,
+    2970347812,
+    795835527,
+    1483230225,
+    3244367275,
+    3060149565,
+    1994146192,
+    31158534,
+    2563907772,
+    4023717930,
+    1907459465,
+    112637215,
+    2680153253,
+    3904427059,
+    2013776290,
+    251722036,
+    2517215374,
+    3775830040,
+    2137656763,
+    141376813,
+    2439277719,
+    3865271297,
+    1802195444,
+    476864866,
+    2238001368,
+    4066508878,
+    1812370925,
+    453092731,
+    2181625025,
+    4111451223,
+    1706088902,
+    314042704,
+    2344532202,
+    4240017532,
+    1658658271,
+    366619977,
+    2362670323,
+    4224994405,
+    1303535960,
+    984961486,
+    2747007092,
+    3569037538,
+    1256170817,
+    1037604311,
+    2765210733,
+    3554079995,
+    1131014506,
+    879679996,
+    2909243462,
+    3663771856,
+    1141124467,
+    855842277,
+    2852801631,
+    3708648649,
+    1342533948,
+    654459306,
+    3188396048,
+    3373015174,
+    1466479909,
+    544179635,
+    3110523913,
+    3462522015,
+    1591671054,
+    702138776,
+    2966460450,
+    3352799412,
+    1504918807,
+    783551873,
+    3082640443,
+    3233442989,
+    3988292384,
+    2596254646,
+    62317068,
+    1957810842,
+    3939845945,
+    2647816111,
+    81470997,
+    1943803523,
+    3814918930,
+    2489596804,
+    225274430,
+    2053790376,
+    3826175755,
+    2466906013,
+    167816743,
+    2097651377,
+    4027552580,
+    2265490386,
+    503444072,
+    1762050814,
+    4150417245,
+    2154129355,
+    426522225,
+    1852507879,
+    4275313526,
+    2312317920,
+    282753626,
+    1742555852,
+    4189708143,
+    2394877945,
+    397917763,
+    1622183637,
+    3604390888,
+    2714866558,
+    953729732,
+    1340076626,
+    3518719985,
+    2797360999,
+    1068828381,
+    1219638859,
+    3624741850,
+    2936675148,
+    906185462,
+    1090812512,
+    3747672003,
+    2825379669,
+    829329135,
+    1181335161,
+    3412177804,
+    3160834842,
+    628085408,
+    1382605366,
+    3423369109,
+    3138078467,
+    570562233,
+    1426400815,
+    3317316542,
+    2998733608,
+    733239954,
+    1555261956,
+    3268935591,
+    3050360625,
+    752459403,
+    1541320221,
+    2607071920,
+    3965973030,
+    1969922972,
+    40735498,
+    2617837225,
+    3943577151,
+    1913087877,
+    83908371,
+    2512341634,
+    3803740692,
+    2075208622,
+    213261112,
+    2463272603,
+    3855990285,
+    2094854071,
+    198958881,
+    2262029012,
+    4057260610,
+    1759359992,
+    534414190,
+    2176718541,
+    4139329115,
+    1873836001,
+    414664567,
+    2282248934,
+    4279200368,
+    1711684554,
+    285281116,
+    2405801727,
+    4167216745,
+    1634467795,
+    376229701,
+    2685067896,
+    3608007406,
+    1308918612,
+    956543938,
+    2808555105,
+    3495958263,
+    1231636301,
+    1047427035,
+    2932959818,
+    3654703836,
+    1088359270,
+    936918e3,
+    2847714899,
+    3736837829,
+    1202900863,
+    817233897,
+    3183342108,
+    3401237130,
+    1404277552,
+    615818150,
+    3134207493,
+    3453421203,
+    1423857449,
+    601450431,
+    3009837614,
+    3294710456,
+    1567103746,
+    711928724,
+    3020668471,
+    3272380065,
+    1510334235,
+    755167117
+  ];
+  if (typeof Int32Array !== "undefined") {
+    CRC_TABLE = new Int32Array(CRC_TABLE);
+  }
+  function ensureBuffer(input) {
+    if (Buffer2.isBuffer(input)) {
+      return input;
+    }
+    var hasNewBufferAPI = typeof Buffer2.alloc === "function" && typeof Buffer2.from === "function";
+    if (typeof input === "number") {
+      return hasNewBufferAPI ? Buffer2.alloc(input) : new Buffer2(input);
+    } else if (typeof input === "string") {
+      return hasNewBufferAPI ? Buffer2.from(input) : new Buffer2(input);
+    } else {
+      throw new Error("input must be buffer, number, or string, received " + typeof input);
+    }
+  }
+  function bufferizeInt(num) {
+    var tmp = ensureBuffer(4);
+    tmp.writeInt32BE(num, 0);
+    return tmp;
+  }
+  function _crc32(buf, previous) {
+    buf = ensureBuffer(buf);
+    if (Buffer2.isBuffer(previous)) {
+      previous = previous.readUInt32BE(0);
+    }
+    var crc = ~~previous ^ -1;
+    for (var n = 0; n < buf.length; n++) {
+      crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
+    }
+    return crc ^ -1;
+  }
+  function crc32() {
+    return bufferizeInt(_crc32.apply(null, arguments));
+  }
+  crc32.signed = function() {
+    return _crc32.apply(null, arguments);
+  };
+  crc32.unsigned = function() {
+    return _crc32.apply(null, arguments) >>> 0;
+  };
+  bufferCrc32 = crc32;
+  return bufferCrc32;
+}
+var hasRequiredYauzl;
+function requireYauzl() {
+  if (hasRequiredYauzl) return yauzl;
+  hasRequiredYauzl = 1;
+  var fs2 = require$$0$2;
+  var zlib = require$$1$2;
+  var fd_slicer = requireFdSlicer();
+  var crc32 = requireBufferCrc32();
+  var util = require$$1$1;
+  var EventEmitter = require$$4.EventEmitter;
+  var Transform = require$$6.Transform;
+  var PassThrough = require$$6.PassThrough;
+  var Writable = require$$6.Writable;
+  yauzl.open = open2;
+  yauzl.fromFd = fromFd;
+  yauzl.fromBuffer = fromBuffer2;
+  yauzl.fromRandomAccessReader = fromRandomAccessReader;
+  yauzl.dosDateTimeToDate = dosDateTimeToDate;
+  yauzl.validateFileName = validateFileName;
+  yauzl.ZipFile = ZipFile;
+  yauzl.Entry = Entry;
+  yauzl.RandomAccessReader = RandomAccessReader;
+  function open2(path2, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = null;
+    }
+    if (options == null) options = {};
+    if (options.autoClose == null) options.autoClose = true;
+    if (options.lazyEntries == null) options.lazyEntries = false;
+    if (options.decodeStrings == null) options.decodeStrings = true;
+    if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+    if (options.strictFileNames == null) options.strictFileNames = false;
+    if (callback == null) callback = defaultCallback;
+    fs2.open(path2, "r", function(err, fd) {
+      if (err) return callback(err);
+      fromFd(fd, options, function(err2, zipfile) {
+        if (err2) fs2.close(fd, defaultCallback);
+        callback(err2, zipfile);
+      });
+    });
+  }
+  function fromFd(fd, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = null;
+    }
+    if (options == null) options = {};
+    if (options.autoClose == null) options.autoClose = false;
+    if (options.lazyEntries == null) options.lazyEntries = false;
+    if (options.decodeStrings == null) options.decodeStrings = true;
+    if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+    if (options.strictFileNames == null) options.strictFileNames = false;
+    if (callback == null) callback = defaultCallback;
+    fs2.fstat(fd, function(err, stats) {
+      if (err) return callback(err);
+      var reader = fd_slicer.createFromFd(fd, { autoClose: true });
+      fromRandomAccessReader(reader, stats.size, options, callback);
+    });
+  }
+  function fromBuffer2(buffer, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = null;
+    }
+    if (options == null) options = {};
+    options.autoClose = false;
+    if (options.lazyEntries == null) options.lazyEntries = false;
+    if (options.decodeStrings == null) options.decodeStrings = true;
+    if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+    if (options.strictFileNames == null) options.strictFileNames = false;
+    var reader = fd_slicer.createFromBuffer(buffer, { maxChunkSize: 65536 });
+    fromRandomAccessReader(reader, buffer.length, options, callback);
+  }
+  function fromRandomAccessReader(reader, totalSize, options, callback) {
+    if (typeof options === "function") {
+      callback = options;
+      options = null;
+    }
+    if (options == null) options = {};
+    if (options.autoClose == null) options.autoClose = true;
+    if (options.lazyEntries == null) options.lazyEntries = false;
+    if (options.decodeStrings == null) options.decodeStrings = true;
+    var decodeStrings = !!options.decodeStrings;
+    if (options.validateEntrySizes == null) options.validateEntrySizes = true;
+    if (options.strictFileNames == null) options.strictFileNames = false;
+    if (callback == null) callback = defaultCallback;
+    if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
+    if (totalSize > Number.MAX_SAFE_INTEGER) {
+      throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
+    }
+    reader.ref();
+    var eocdrWithoutCommentSize = 22;
+    var maxCommentSize = 65535;
+    var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize);
+    var buffer = newBuffer(bufferSize);
+    var bufferReadStart = totalSize - buffer.length;
+    readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
+      if (err) return callback(err);
+      for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
+        if (buffer.readUInt32LE(i) !== 101010256) continue;
+        var eocdrBuffer = buffer.slice(i);
+        var diskNumber = eocdrBuffer.readUInt16LE(4);
+        if (diskNumber !== 0) {
+          return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+        }
+        var entryCount = eocdrBuffer.readUInt16LE(10);
+        var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
+        var commentLength = eocdrBuffer.readUInt16LE(20);
+        var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
+        if (commentLength !== expectedCommentLength) {
+          return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
+        }
+        var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false) : eocdrBuffer.slice(22);
+        if (!(entryCount === 65535 || centralDirectoryOffset === 4294967295)) {
+          return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+        }
+        var zip64EocdlBuffer = newBuffer(20);
+        var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
+        readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err2) {
+          if (err2) return callback(err2);
+          if (zip64EocdlBuffer.readUInt32LE(0) !== 117853008) {
+            return callback(new Error("invalid zip64 end of central directory locator signature"));
+          }
+          var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
+          var zip64EocdrBuffer = newBuffer(56);
+          readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err3) {
+            if (err3) return callback(err3);
+            if (zip64EocdrBuffer.readUInt32LE(0) !== 101075792) {
+              return callback(new Error("invalid zip64 end of central directory record signature"));
+            }
+            entryCount = readUInt64LE(zip64EocdrBuffer, 32);
+            centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
+            return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
+          });
+        });
+        return;
+      }
+      callback(new Error("end of central directory record signature not found"));
+    });
+  }
+  util.inherits(ZipFile, EventEmitter);
+  function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+    var self2 = this;
+    EventEmitter.call(self2);
+    self2.reader = reader;
+    self2.reader.on("error", function(err) {
+      emitError(self2, err);
+    });
+    self2.reader.once("close", function() {
+      self2.emit("close");
+    });
+    self2.readEntryCursor = centralDirectoryOffset;
+    self2.fileSize = fileSize;
+    self2.entryCount = entryCount;
+    self2.comment = comment;
+    self2.entriesRead = 0;
+    self2.autoClose = !!autoClose;
+    self2.lazyEntries = !!lazyEntries;
+    self2.decodeStrings = !!decodeStrings;
+    self2.validateEntrySizes = !!validateEntrySizes;
+    self2.strictFileNames = !!strictFileNames;
+    self2.isOpen = true;
+    self2.emittedError = false;
+    if (!self2.lazyEntries) self2._readEntry();
+  }
+  ZipFile.prototype.close = function() {
+    if (!this.isOpen) return;
+    this.isOpen = false;
+    this.reader.unref();
+  };
+  function emitErrorAndAutoClose(self2, err) {
+    if (self2.autoClose) self2.close();
+    emitError(self2, err);
+  }
+  function emitError(self2, err) {
+    if (self2.emittedError) return;
+    self2.emittedError = true;
+    self2.emit("error", err);
+  }
+  ZipFile.prototype.readEntry = function() {
+    if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
+    this._readEntry();
+  };
+  ZipFile.prototype._readEntry = function() {
+    var self2 = this;
+    if (self2.entryCount === self2.entriesRead) {
+      setImmediate(function() {
+        if (self2.autoClose) self2.close();
+        if (self2.emittedError) return;
+        self2.emit("end");
+      });
+      return;
+    }
+    if (self2.emittedError) return;
+    var buffer = newBuffer(46);
+    readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err) {
+      if (err) return emitErrorAndAutoClose(self2, err);
+      if (self2.emittedError) return;
+      var entry = new Entry();
+      var signature = buffer.readUInt32LE(0);
+      if (signature !== 33639248) return emitErrorAndAutoClose(self2, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
+      entry.versionMadeBy = buffer.readUInt16LE(4);
+      entry.versionNeededToExtract = buffer.readUInt16LE(6);
+      entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
+      entry.compressionMethod = buffer.readUInt16LE(10);
+      entry.lastModFileTime = buffer.readUInt16LE(12);
+      entry.lastModFileDate = buffer.readUInt16LE(14);
+      entry.crc32 = buffer.readUInt32LE(16);
+      entry.compressedSize = buffer.readUInt32LE(20);
+      entry.uncompressedSize = buffer.readUInt32LE(24);
+      entry.fileNameLength = buffer.readUInt16LE(28);
+      entry.extraFieldLength = buffer.readUInt16LE(30);
+      entry.fileCommentLength = buffer.readUInt16LE(32);
+      entry.internalFileAttributes = buffer.readUInt16LE(36);
+      entry.externalFileAttributes = buffer.readUInt32LE(38);
+      entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
+      if (entry.generalPurposeBitFlag & 64) return emitErrorAndAutoClose(self2, new Error("strong encryption is not supported"));
+      self2.readEntryCursor += 46;
+      buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+      readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, self2.readEntryCursor, function(err2) {
+        if (err2) return emitErrorAndAutoClose(self2, err2);
+        if (self2.emittedError) return;
+        var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
+        entry.fileName = self2.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8) : buffer.slice(0, entry.fileNameLength);
+        var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
+        var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart);
+        entry.extraFields = [];
+        var i = 0;
+        while (i < extraFieldBuffer.length - 3) {
+          var headerId = extraFieldBuffer.readUInt16LE(i + 0);
+          var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
+          var dataStart = i + 4;
+          var dataEnd = dataStart + dataSize;
+          if (dataEnd > extraFieldBuffer.length) return emitErrorAndAutoClose(self2, new Error("extra field length exceeds extra field buffer size"));
+          var dataBuffer = newBuffer(dataSize);
+          extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd);
+          entry.extraFields.push({
+            id: headerId,
+            data: dataBuffer
+          });
+          i = dataEnd;
+        }
+        entry.fileComment = self2.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8) : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+        entry.comment = entry.fileComment;
+        self2.readEntryCursor += buffer.length;
+        self2.entriesRead += 1;
+        if (entry.uncompressedSize === 4294967295 || entry.compressedSize === 4294967295 || entry.relativeOffsetOfLocalHeader === 4294967295) {
+          var zip64EiefBuffer = null;
+          for (var i = 0; i < entry.extraFields.length; i++) {
+            var extraField = entry.extraFields[i];
+            if (extraField.id === 1) {
+              zip64EiefBuffer = extraField.data;
+              break;
+            }
+          }
+          if (zip64EiefBuffer == null) {
+            return emitErrorAndAutoClose(self2, new Error("expected zip64 extended information extra field"));
+          }
+          var index = 0;
+          if (entry.uncompressedSize === 4294967295) {
+            if (index + 8 > zip64EiefBuffer.length) {
+              return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include uncompressed size"));
+            }
+            entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+          }
+          if (entry.compressedSize === 4294967295) {
+            if (index + 8 > zip64EiefBuffer.length) {
+              return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include compressed size"));
+            }
+            entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+          }
+          if (entry.relativeOffsetOfLocalHeader === 4294967295) {
+            if (index + 8 > zip64EiefBuffer.length) {
+              return emitErrorAndAutoClose(self2, new Error("zip64 extended information extra field does not include relative header offset"));
+            }
+            entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+          }
+        }
+        if (self2.decodeStrings) {
+          for (var i = 0; i < entry.extraFields.length; i++) {
+            var extraField = entry.extraFields[i];
+            if (extraField.id === 28789) {
+              if (extraField.data.length < 6) {
+                continue;
+              }
+              if (extraField.data.readUInt8(0) !== 1) {
+                continue;
+              }
+              var oldNameCrc32 = extraField.data.readUInt32LE(1);
+              if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
+                continue;
+              }
+              entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
+              break;
+            }
+          }
+        }
+        if (self2.validateEntrySizes && entry.compressionMethod === 0) {
+          var expectedCompressedSize = entry.uncompressedSize;
+          if (entry.isEncrypted()) {
+            expectedCompressedSize += 12;
+          }
+          if (entry.compressedSize !== expectedCompressedSize) {
+            var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
+            return emitErrorAndAutoClose(self2, new Error(msg));
+          }
+        }
+        if (self2.decodeStrings) {
+          if (!self2.strictFileNames) {
+            entry.fileName = entry.fileName.replace(/\\/g, "/");
+          }
+          var errorMessage = validateFileName(entry.fileName, self2.validateFileNameOptions);
+          if (errorMessage != null) return emitErrorAndAutoClose(self2, new Error(errorMessage));
+        }
+        self2.emit("entry", entry);
+        if (!self2.lazyEntries) self2._readEntry();
+      });
+    });
+  };
+  ZipFile.prototype.openReadStream = function(entry, options, callback) {
+    var self2 = this;
+    var relativeStart = 0;
+    var relativeEnd = entry.compressedSize;
+    if (callback == null) {
+      callback = options;
+      options = {};
+    } else {
+      if (options.decrypt != null) {
+        if (!entry.isEncrypted()) {
+          throw new Error("options.decrypt can only be specified for encrypted entries");
+        }
+        if (options.decrypt !== false) throw new Error("invalid options.decrypt value: " + options.decrypt);
+        if (entry.isCompressed()) {
+          if (options.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false");
+        }
+      }
+      if (options.decompress != null) {
+        if (!entry.isCompressed()) {
+          throw new Error("options.decompress can only be specified for compressed entries");
+        }
+        if (!(options.decompress === false || options.decompress === true)) {
+          throw new Error("invalid options.decompress value: " + options.decompress);
+        }
+      }
+      if (options.start != null || options.end != null) {
+        if (entry.isCompressed() && options.decompress !== false) {
+          throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
+        }
+        if (entry.isEncrypted() && options.decrypt !== false) {
+          throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
+        }
+      }
+      if (options.start != null) {
+        relativeStart = options.start;
+        if (relativeStart < 0) throw new Error("options.start < 0");
+        if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
+      }
+      if (options.end != null) {
+        relativeEnd = options.end;
+        if (relativeEnd < 0) throw new Error("options.end < 0");
+        if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
+        if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
+      }
+    }
+    if (!self2.isOpen) return callback(new Error("closed"));
+    if (entry.isEncrypted()) {
+      if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
+    }
+    self2.reader.ref();
+    var buffer = newBuffer(30);
+    readAndAssertNoEof(self2.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
+      try {
+        if (err) return callback(err);
+        var signature = buffer.readUInt32LE(0);
+        if (signature !== 67324752) {
+          return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
+        }
+        var fileNameLength = buffer.readUInt16LE(26);
+        var extraFieldLength = buffer.readUInt16LE(28);
+        var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
+        var decompress;
+        if (entry.compressionMethod === 0) {
+          decompress = false;
+        } else if (entry.compressionMethod === 8) {
+          decompress = options.decompress != null ? options.decompress : true;
+        } else {
+          return callback(new Error("unsupported compression method: " + entry.compressionMethod));
+        }
+        var fileDataStart = localFileHeaderEnd;
+        var fileDataEnd = fileDataStart + entry.compressedSize;
+        if (entry.compressedSize !== 0) {
+          if (fileDataEnd > self2.fileSize) {
+            return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self2.fileSize));
+          }
+        }
+        var readStream = self2.reader.createReadStream({
+          start: fileDataStart + relativeStart,
+          end: fileDataStart + relativeEnd
+        });
+        var endpointStream = readStream;
+        if (decompress) {
+          var destroyed = false;
+          var inflateFilter = zlib.createInflateRaw();
+          readStream.on("error", function(err2) {
+            setImmediate(function() {
+              if (!destroyed) inflateFilter.emit("error", err2);
+            });
+          });
+          readStream.pipe(inflateFilter);
+          if (self2.validateEntrySizes) {
+            endpointStream = new AssertByteCountStream(entry.uncompressedSize);
+            inflateFilter.on("error", function(err2) {
+              setImmediate(function() {
+                if (!destroyed) endpointStream.emit("error", err2);
+              });
+            });
+            inflateFilter.pipe(endpointStream);
+          } else {
+            endpointStream = inflateFilter;
+          }
+          endpointStream.destroy = function() {
+            destroyed = true;
+            if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
+            readStream.unpipe(inflateFilter);
+            readStream.destroy();
+          };
+        }
+        callback(null, endpointStream);
+      } finally {
+        self2.reader.unref();
+      }
+    });
+  };
+  function Entry() {
+  }
+  Entry.prototype.getLastModDate = function() {
+    return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
+  };
+  Entry.prototype.isEncrypted = function() {
+    return (this.generalPurposeBitFlag & 1) !== 0;
+  };
+  Entry.prototype.isCompressed = function() {
+    return this.compressionMethod === 8;
+  };
+  function dosDateTimeToDate(date, time) {
+    var day = date & 31;
+    var month = (date >> 5 & 15) - 1;
+    var year = (date >> 9 & 127) + 1980;
+    var millisecond = 0;
+    var second = (time & 31) * 2;
+    var minute = time >> 5 & 63;
+    var hour = time >> 11 & 31;
+    return new Date(year, month, day, hour, minute, second, millisecond);
+  }
+  function validateFileName(fileName) {
+    if (fileName.indexOf("\\") !== -1) {
+      return "invalid characters in fileName: " + fileName;
+    }
+    if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
+      return "absolute path: " + fileName;
+    }
+    if (fileName.split("/").indexOf("..") !== -1) {
+      return "invalid relative path: " + fileName;
+    }
+    return null;
+  }
+  function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
+    if (length === 0) {
+      return setImmediate(function() {
+        callback(null, newBuffer(0));
+      });
+    }
+    reader.read(buffer, offset, length, position, function(err, bytesRead) {
+      if (err) return callback(err);
+      if (bytesRead < length) {
+        return callback(new Error("unexpected EOF"));
+      }
+      callback();
+    });
+  }
+  util.inherits(AssertByteCountStream, Transform);
+  function AssertByteCountStream(byteCount) {
+    Transform.call(this);
+    this.actualByteCount = 0;
+    this.expectedByteCount = byteCount;
+  }
+  AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
+    this.actualByteCount += chunk.length;
+    if (this.actualByteCount > this.expectedByteCount) {
+      var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
+      return cb(new Error(msg));
+    }
+    cb(null, chunk);
+  };
+  AssertByteCountStream.prototype._flush = function(cb) {
+    if (this.actualByteCount < this.expectedByteCount) {
+      var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
+      return cb(new Error(msg));
+    }
+    cb();
+  };
+  util.inherits(RandomAccessReader, EventEmitter);
+  function RandomAccessReader() {
+    EventEmitter.call(this);
+    this.refCount = 0;
+  }
+  RandomAccessReader.prototype.ref = function() {
+    this.refCount += 1;
+  };
+  RandomAccessReader.prototype.unref = function() {
+    var self2 = this;
+    self2.refCount -= 1;
+    if (self2.refCount > 0) return;
+    if (self2.refCount < 0) throw new Error("invalid unref");
+    self2.close(onCloseDone);
+    function onCloseDone(err) {
+      if (err) return self2.emit("error", err);
+      self2.emit("close");
+    }
+  };
+  RandomAccessReader.prototype.createReadStream = function(options) {
+    var start = options.start;
+    var end = options.end;
+    if (start === end) {
+      var emptyStream = new PassThrough();
+      setImmediate(function() {
+        emptyStream.end();
+      });
+      return emptyStream;
+    }
+    var stream = this._readStreamForRange(start, end);
+    var destroyed = false;
+    var refUnrefFilter = new RefUnrefFilter(this);
+    stream.on("error", function(err) {
+      setImmediate(function() {
+        if (!destroyed) refUnrefFilter.emit("error", err);
+      });
+    });
+    refUnrefFilter.destroy = function() {
+      stream.unpipe(refUnrefFilter);
+      refUnrefFilter.unref();
+      stream.destroy();
+    };
+    var byteCounter = new AssertByteCountStream(end - start);
+    refUnrefFilter.on("error", function(err) {
+      setImmediate(function() {
+        if (!destroyed) byteCounter.emit("error", err);
+      });
+    });
+    byteCounter.destroy = function() {
+      destroyed = true;
+      refUnrefFilter.unpipe(byteCounter);
+      refUnrefFilter.destroy();
+    };
+    return stream.pipe(refUnrefFilter).pipe(byteCounter);
+  };
+  RandomAccessReader.prototype._readStreamForRange = function(start, end) {
+    throw new Error("not implemented");
+  };
+  RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
+    var readStream = this.createReadStream({ start: position, end: position + length });
+    var writeStream = new Writable();
+    var written = 0;
+    writeStream._write = function(chunk, encoding, cb) {
+      chunk.copy(buffer, offset + written, 0, chunk.length);
+      written += chunk.length;
+      cb();
+    };
+    writeStream.on("finish", callback);
+    readStream.on("error", function(error) {
+      callback(error);
+    });
+    readStream.pipe(writeStream);
+  };
+  RandomAccessReader.prototype.close = function(callback) {
+    setImmediate(callback);
+  };
+  util.inherits(RefUnrefFilter, PassThrough);
+  function RefUnrefFilter(context) {
+    PassThrough.call(this);
+    this.context = context;
+    this.context.ref();
+    this.unreffedYet = false;
+  }
+  RefUnrefFilter.prototype._flush = function(cb) {
+    this.unref();
+    cb();
+  };
+  RefUnrefFilter.prototype.unref = function(cb) {
+    if (this.unreffedYet) return;
+    this.unreffedYet = true;
+    this.context.unref();
+  };
+  var cp437 = "\0☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ";
+  function decodeBuffer(buffer, start, end, isUtf8) {
+    if (isUtf8) {
+      return buffer.toString("utf8", start, end);
+    } else {
+      var result = "";
+      for (var i = start; i < end; i++) {
+        result += cp437[buffer[i]];
+      }
+      return result;
+    }
+  }
+  function readUInt64LE(buffer, offset) {
+    var lower32 = buffer.readUInt32LE(offset);
+    var upper32 = buffer.readUInt32LE(offset + 4);
+    return upper32 * 4294967296 + lower32;
+  }
+  var newBuffer;
+  if (typeof Buffer.allocUnsafe === "function") {
+    newBuffer = function(len) {
+      return Buffer.allocUnsafe(len);
+    };
+  } else {
+    newBuffer = function(len) {
+      return new Buffer(len);
+    };
+  }
+  function defaultCallback(err) {
+    if (err) throw err;
+  }
+  return yauzl;
+}
+var extractZip$1;
+var hasRequiredExtractZip;
+function requireExtractZip() {
+  if (hasRequiredExtractZip) return extractZip$1;
+  hasRequiredExtractZip = 1;
+  const debug2 = requireSrc()("extract-zip");
+  const { createWriteStream: createWriteStream2, promises: fs2 } = require$$0$2;
+  const getStream2 = requireGetStream();
+  const path2 = path__default;
+  const { promisify } = require$$1$1;
+  const stream = require$$6;
+  const yauzl2 = requireYauzl();
+  const openZip = promisify(yauzl2.open);
+  const pipeline2 = promisify(stream.pipeline);
+  class Extractor {
+    constructor(zipPath, opts) {
+      this.zipPath = zipPath;
+      this.opts = opts;
+    }
+    async extract() {
+      debug2("opening", this.zipPath, "with opts", this.opts);
+      this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
+      this.canceled = false;
+      return new Promise((resolve2, reject) => {
+        this.zipfile.on("error", (err) => {
+          this.canceled = true;
+          reject(err);
+        });
+        this.zipfile.readEntry();
+        this.zipfile.on("close", () => {
+          if (!this.canceled) {
+            debug2("zip extraction complete");
+            resolve2();
+          }
+        });
+        this.zipfile.on("entry", async (entry) => {
+          if (this.canceled) {
+            debug2("skipping entry", entry.fileName, { cancelled: this.canceled });
+            return;
+          }
+          debug2("zipfile entry", entry.fileName);
+          if (entry.fileName.startsWith("__MACOSX/")) {
+            this.zipfile.readEntry();
+            return;
+          }
+          const destDir = path2.dirname(path2.join(this.opts.dir, entry.fileName));
+          try {
+            await fs2.mkdir(destDir, { recursive: true });
+            const canonicalDestDir = await fs2.realpath(destDir);
+            const relativeDestDir = path2.relative(this.opts.dir, canonicalDestDir);
+            if (relativeDestDir.split(path2.sep).includes("..")) {
+              throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
+            }
+            await this.extractEntry(entry);
+            debug2("finished processing", entry.fileName);
+            this.zipfile.readEntry();
+          } catch (err) {
+            this.canceled = true;
+            this.zipfile.close();
+            reject(err);
+          }
+        });
+      });
+    }
+    async extractEntry(entry) {
+      if (this.canceled) {
+        debug2("skipping entry extraction", entry.fileName, { cancelled: this.canceled });
+        return;
+      }
+      if (this.opts.onEntry) {
+        this.opts.onEntry(entry, this.zipfile);
+      }
+      const dest = path2.join(this.opts.dir, entry.fileName);
+      const mode = entry.externalFileAttributes >> 16 & 65535;
+      const IFMT = 61440;
+      const IFDIR = 16384;
+      const IFLNK = 40960;
+      const symlink = (mode & IFMT) === IFLNK;
+      let isDir = (mode & IFMT) === IFDIR;
+      if (!isDir && entry.fileName.endsWith("/")) {
+        isDir = true;
+      }
+      const madeBy = entry.versionMadeBy >> 8;
+      if (!isDir) isDir = madeBy === 0 && entry.externalFileAttributes === 16;
+      debug2("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink });
+      const procMode = this.getExtractedMode(mode, isDir) & 511;
+      const destDir = isDir ? dest : path2.dirname(dest);
+      const mkdirOptions = { recursive: true };
+      if (isDir) {
+        mkdirOptions.mode = procMode;
+      }
+      debug2("mkdir", { dir: destDir, ...mkdirOptions });
+      await fs2.mkdir(destDir, mkdirOptions);
+      if (isDir) return;
+      debug2("opening read stream", dest);
+      const readStream = await promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+      if (symlink) {
+        const link = await getStream2(readStream);
+        debug2("creating symlink", link, dest);
+        await fs2.symlink(link, dest);
+      } else {
+        await pipeline2(readStream, createWriteStream2(dest, { mode: procMode }));
+      }
+    }
+    getExtractedMode(entryMode, isDir) {
+      let mode = entryMode;
+      if (mode === 0) {
+        if (isDir) {
+          if (this.opts.defaultDirMode) {
+            mode = parseInt(this.opts.defaultDirMode, 10);
+          }
+          if (!mode) {
+            mode = 493;
+          }
+        } else {
+          if (this.opts.defaultFileMode) {
+            mode = parseInt(this.opts.defaultFileMode, 10);
+          }
+          if (!mode) {
+            mode = 420;
+          }
+        }
+      }
+      return mode;
+    }
+  }
+  extractZip$1 = async function(zipPath, opts) {
+    debug2("creating target directory", opts.dir);
+    if (!path2.isAbsolute(opts.dir)) {
+      throw new Error("Target directory is expected to be absolute");
+    }
+    await fs2.mkdir(opts.dir, { recursive: true });
+    opts.dir = await fs2.realpath(opts.dir);
+    return new Extractor(zipPath, opts).extract();
+  };
+  return extractZip$1;
+}
+var extractZipExports = requireExtractZip();
+const extractZip = /* @__PURE__ */ getDefaultExportFromCjs(extractZipExports);
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname$1(__filename$1);
+function getPackageDir() {
+  const envDir = process.env.SHORTCUT_PACKAGE_DIR;
+  if (envDir) {
+    if (envDir === "~")
+      return homedir();
+    if (envDir.startsWith("~/"))
+      return homedir() + envDir.slice(1);
+    return envDir;
+  }
+  let dir = __dirname$1;
+  while (dir !== dirname$1(dir)) {
+    if (existsSync(join$1(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname$1(dir);
+  }
+  return __dirname$1;
+}
+function getPackageJsonPath() {
+  return join$1(getPackageDir(), "package.json");
+}
+const pkg = JSON.parse(readFileSync(getPackageJsonPath(), "utf-8"));
+const APP_NAME = pkg.shortcutConfig?.name || "shortcut";
+const CONFIG_DIR_NAME = pkg.shortcutConfig?.configDir || ".shortcut";
+pkg.version;
+const NPM_PACKAGE_NAME = pkg.name || "shortcutxl";
+const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
+process.env.SHORTCUT_NPM_REGISTRY_URL?.trim() || `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+function getAgentDir() {
+  const envDir = process.env[ENV_AGENT_DIR];
+  if (envDir) {
+    if (envDir === "~")
+      return homedir();
+    if (envDir.startsWith("~/"))
+      return homedir() + envDir.slice(1);
+    return envDir;
+  }
+  return join$1(homedir(), CONFIG_DIR_NAME, "agent");
+}
+function getBinDir() {
+  return join$1(getAgentDir(), "bin");
+}
+async function writeWebStreamToFile(body, destinationPath) {
+  try {
+    await pipeline(Readable.fromWeb(body), createWriteStream(destinationPath));
+  } catch (error) {
+    try {
+      await unlink(destinationPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+const TOOLS_DIR = getBinDir();
+const NETWORK_TIMEOUT_MS = 1e4;
+function isOfflineModeEnabled() {
+  const value = process.env.SHORTCUT_OFFLINE;
+  if (!value)
+    return false;
+  return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
+const TOOLS = {
+  fd: {
+    name: "fd",
+    repo: "sharkdp/fd",
+    binaryName: "fd",
+    tagPrefix: "v",
+    getAssetName: (version, plat, architecture) => {
+      if (plat === "darwin") {
+        const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+        return `fd-v${version}-${archStr}-apple-darwin.tar.gz`;
+      } else if (plat === "linux") {
+        const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+        return `fd-v${version}-${archStr}-unknown-linux-gnu.tar.gz`;
+      } else if (plat === "win32") {
+        const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+        return `fd-v${version}-${archStr}-pc-windows-msvc.zip`;
+      }
+      return null;
+    }
+  },
+  rg: {
+    name: "ripgrep",
+    repo: "BurntSushi/ripgrep",
+    binaryName: "rg",
+    tagPrefix: "",
+    getAssetName: (version, plat, architecture) => {
+      if (plat === "darwin") {
+        const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+        return `ripgrep-${version}-${archStr}-apple-darwin.tar.gz`;
+      } else if (plat === "linux") {
+        if (architecture === "arm64") {
+          return `ripgrep-${version}-aarch64-unknown-linux-gnu.tar.gz`;
+        }
+        return `ripgrep-${version}-x86_64-unknown-linux-musl.tar.gz`;
+      } else if (plat === "win32") {
+        const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+        return `ripgrep-${version}-${archStr}-pc-windows-msvc.zip`;
+      }
+      return null;
+    }
+  }
+};
+function commandExists(cmd) {
+  try {
+    const result = spawnSync(cmd, ["--version"], { stdio: "pipe" });
+    return result.error === void 0 || result.error === null;
+  } catch {
+    return false;
+  }
+}
+function getToolPath(tool) {
+  const config = TOOLS[tool];
+  if (!config)
+    return null;
+  const localPath = join$1(TOOLS_DIR, config.binaryName + (platform() === "win32" ? ".exe" : ""));
+  if (existsSync(localPath)) {
+    return localPath;
+  }
+  if (commandExists(config.binaryName)) {
+    return config.binaryName;
+  }
+  return null;
+}
+async function getLatestVersion(repo) {
+  const response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+    headers: { "User-AgentController": `${APP_NAME}-coding-agent` },
+    signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status}`);
+  }
+  const data = await response.json();
+  return data.tag_name.replace(/^v/, "");
+}
+async function downloadFile(url, dest) {
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to download: ${response.status}`);
+  }
+  if (!response.body) {
+    throw new Error("No response body");
+  }
+  await writeWebStreamToFile(response.body, dest);
+}
+function findBinaryRecursively(rootDir, binaryFileName) {
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    if (!currentDir)
+      continue;
+    const entries = readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join$1(currentDir, entry.name);
+      if (entry.isFile() && entry.name === binaryFileName) {
+        return fullPath;
+      }
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      }
+    }
+  }
+  return null;
+}
+async function downloadTool(tool) {
+  const config = TOOLS[tool];
+  if (!config)
+    throw new Error(`Unknown tool: ${tool}`);
+  const plat = platform();
+  const architecture = arch();
+  const version = await getLatestVersion(config.repo);
+  const assetName = config.getAssetName(version, plat, architecture);
+  if (!assetName) {
+    throw new Error(`Unsupported platform: ${plat}/${architecture}`);
+  }
+  mkdirSync(TOOLS_DIR, { recursive: true });
+  const downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`;
+  const archivePath = join$1(TOOLS_DIR, assetName);
+  const binaryExt = plat === "win32" ? ".exe" : "";
+  const binaryPath = join$1(TOOLS_DIR, config.binaryName + binaryExt);
+  await downloadFile(downloadUrl, archivePath);
+  const extractDir = join$1(TOOLS_DIR, `extract_tmp_${config.binaryName}_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync(extractDir, { recursive: true });
+  try {
+    if (assetName.endsWith(".tar.gz")) {
+      const extractResult = spawnSync("tar", ["xzf", archivePath, "-C", extractDir], {
+        stdio: "pipe"
+      });
+      if (extractResult.error || extractResult.status !== 0) {
+        const errMsg = extractResult.error?.message ?? extractResult.stderr?.toString().trim() ?? "unknown error";
+        throw new Error(`Failed to extract ${assetName}: ${errMsg}`);
+      }
+    } else if (assetName.endsWith(".zip")) {
+      await extractZip(archivePath, { dir: extractDir });
+    } else {
+      throw new Error(`Unsupported archive format: ${assetName}`);
+    }
+    const binaryFileName = config.binaryName + binaryExt;
+    const extractedDir = join$1(extractDir, assetName.replace(/\.(tar\.gz|zip)$/, ""));
+    const extractedBinaryCandidates = [
+      join$1(extractedDir, binaryFileName),
+      join$1(extractDir, binaryFileName)
+    ];
+    let extractedBinary = extractedBinaryCandidates.find((candidate) => existsSync(candidate));
+    if (!extractedBinary) {
+      extractedBinary = findBinaryRecursively(extractDir, binaryFileName) ?? void 0;
+    }
+    if (extractedBinary) {
+      renameSync(extractedBinary, binaryPath);
+    } else {
+      throw new Error(`Binary not found in archive: expected ${binaryFileName} under ${extractDir}`);
+    }
+    if (plat !== "win32") {
+      chmodSync(binaryPath, 493);
+    }
+  } finally {
+    rmSync(archivePath, { force: true });
+    rmSync(extractDir, { recursive: true, force: true });
+  }
+  return binaryPath;
+}
+const TERMUX_PACKAGES = {
+  fd: "fd",
+  rg: "ripgrep"
+};
+async function ensureTool(tool, silent = false) {
+  const existingPath = getToolPath(tool);
+  if (existingPath) {
+    return existingPath;
+  }
+  const config = TOOLS[tool];
+  if (!config)
+    return void 0;
+  if (isOfflineModeEnabled()) {
+    if (!silent) {
+      console.log(chalk.yellow(`${config.name} not found. Offline mode enabled, skipping download.`));
+    }
+    return void 0;
+  }
+  if (platform() === "android") {
+    const pkgName = TERMUX_PACKAGES[tool];
+    if (!silent) {
+      console.log(chalk.yellow(`${config.name} not found. Install with: pkg install ${pkgName}`));
+    }
+    return void 0;
+  }
+  if (!silent) {
+    console.log(chalk.dim(`${config.name} not found. Downloading...`));
+  }
+  try {
+    const path2 = await downloadTool(tool);
+    if (!silent) {
+      console.log(chalk.dim(`${config.name} installed to ${path2}`));
+    }
+    return path2;
+  } catch (e) {
+    if (!silent) {
+      console.log(chalk.yellow(`Failed to download ${config.name}: ${e instanceof Error ? e.message : e}`));
+    }
+    return void 0;
+  }
+}
+const PATH_DELIMITERS = /* @__PURE__ */ new Set([" ", "	", '"', "'", "="]);
+function findLastDelimiter(text) {
+  for (let i = text.length - 1; i >= 0; i -= 1) {
+    if (PATH_DELIMITERS.has(text[i] ?? "")) return i;
+  }
+  return -1;
+}
+function findUnclosedQuoteStart(text) {
+  let inQuotes = false;
+  let quoteStart = -1;
+  for (let i = 0; i < text.length; i += 1) {
+    if (text[i] === '"') {
+      inQuotes = !inQuotes;
+      if (inQuotes) quoteStart = i;
+    }
+  }
+  return inQuotes ? quoteStart : null;
+}
+function isTokenStart(text, index) {
+  return index === 0 || PATH_DELIMITERS.has(text[index - 1] ?? "");
+}
+function extractQuotedPrefix(text) {
+  const quoteStart = findUnclosedQuoteStart(text);
+  if (quoteStart === null) return null;
+  if (quoteStart > 0 && text[quoteStart - 1] === "@") {
+    if (!isTokenStart(text, quoteStart - 1)) return null;
+    return text.slice(quoteStart - 1);
+  }
+  if (!isTokenStart(text, quoteStart)) return null;
+  return text.slice(quoteStart);
+}
+function extractAtPrefix(text) {
+  const quotedPrefix = extractQuotedPrefix(text);
+  if (quotedPrefix?.startsWith('@"')) return quotedPrefix;
+  const lastDelimiterIndex = findLastDelimiter(text);
+  const tokenStart = lastDelimiterIndex === -1 ? 0 : lastDelimiterIndex + 1;
+  return text[tokenStart] === "@" ? text.slice(tokenStart) : null;
+}
+function parsePathPrefix(prefix) {
+  if (prefix.startsWith('@"')) {
+    return { rawPrefix: prefix.slice(2), isAtPrefix: true, isQuotedPrefix: true };
+  }
+  if (prefix.startsWith('"')) {
+    return { rawPrefix: prefix.slice(1), isAtPrefix: false, isQuotedPrefix: true };
+  }
+  if (prefix.startsWith("@")) {
+    return { rawPrefix: prefix.slice(1), isAtPrefix: true, isQuotedPrefix: false };
+  }
+  return { rawPrefix: prefix, isAtPrefix: false, isQuotedPrefix: false };
+}
+function buildCompletionValue(path2, options) {
+  const needsQuotes = options.isQuotedPrefix || path2.includes(" ");
+  const prefix = options.isAtPrefix ? "@" : "";
+  return needsQuotes ? `${prefix}"${path2}"` : `${prefix}${path2}`;
+}
+function applyAutocompleteCompletion(lines, cursorLine, cursorCol, item, prefix) {
+  const currentLine = lines[cursorLine] || "";
+  const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+  const afterCursor = currentLine.slice(cursorCol);
+  const isQuotedPrefix = prefix.startsWith('"') || prefix.startsWith('@"');
+  const adjustedAfterCursor = isQuotedPrefix && item.value.endsWith('"') && afterCursor.startsWith('"') ? afterCursor.slice(1) : afterCursor;
+  const isSlashCommand = prefix.startsWith("/") && !prefix.slice(1).includes("/") && (beforePrefix.trim() === "" || item.value.startsWith("skill:"));
+  if (isSlashCommand) {
+    const newLines2 = [...lines];
+    newLines2[cursorLine] = `${beforePrefix}/${item.value} ${adjustedAfterCursor}`;
+    return {
+      lines: newLines2,
+      cursorLine,
+      cursorCol: beforePrefix.length + item.value.length + 2
+    };
+  }
+  if (prefix.startsWith("@")) {
+    const isDirectory2 = item.label.endsWith("/");
+    const suffix = isDirectory2 ? "" : " ";
+    const newLines2 = [...lines];
+    newLines2[cursorLine] = `${beforePrefix + item.value}${suffix}${adjustedAfterCursor}`;
+    const cursorOffset2 = isDirectory2 && item.value.endsWith('"') ? item.value.length - 1 : item.value.length;
+    return {
+      lines: newLines2,
+      cursorLine,
+      cursorCol: beforePrefix.length + cursorOffset2 + suffix.length
+    };
+  }
+  const newLines = [...lines];
+  newLines[cursorLine] = beforePrefix + item.value + adjustedAfterCursor;
+  const isDirectory = item.label.endsWith("/");
+  const cursorOffset = isDirectory && item.value.endsWith('"') ? item.value.length - 1 : item.value.length;
+  return {
+    lines: newLines,
+    cursorLine,
+    cursorCol: beforePrefix.length + cursorOffset
+  };
+}
+function fuzzyMatch(query, text) {
+  const queryLower = query.toLowerCase();
+  const textLower = text.toLowerCase();
+  const matchQuery = (normalizedQuery) => {
+    if (normalizedQuery.length === 0) {
+      return { matches: true, score: 0 };
+    }
+    if (normalizedQuery.length > textLower.length) {
+      return { matches: false, score: 0 };
+    }
+    let queryIndex = 0;
+    let score = 0;
+    let lastMatchIndex = -1;
+    let consecutiveMatches = 0;
+    for (let i = 0; i < textLower.length && queryIndex < normalizedQuery.length; i++) {
+      if (textLower[i] === normalizedQuery[queryIndex]) {
+        const isWordBoundary = i === 0 || /[\s\-_./:]/.test(textLower[i - 1]);
+        if (lastMatchIndex === i - 1) {
+          consecutiveMatches++;
+          score -= consecutiveMatches * 5;
+        } else {
+          consecutiveMatches = 0;
+          if (lastMatchIndex >= 0) {
+            score += (i - lastMatchIndex - 1) * 2;
+          }
+        }
+        if (isWordBoundary) {
+          score -= 10;
+        }
+        score += i * 0.1;
+        lastMatchIndex = i;
+        queryIndex++;
+      }
+    }
+    if (queryIndex < normalizedQuery.length) {
+      return { matches: false, score: 0 };
+    }
+    return { matches: true, score };
+  };
+  const primaryMatch = matchQuery(queryLower);
+  if (primaryMatch.matches) {
+    return primaryMatch;
+  }
+  const alphaNumericMatch = queryLower.match(/^(?<letters>[a-z]+)(?<digits>[0-9]+)$/);
+  const numericAlphaMatch = queryLower.match(/^(?<digits>[0-9]+)(?<letters>[a-z]+)$/);
+  const swappedQuery = alphaNumericMatch ? `${alphaNumericMatch.groups?.digits ?? ""}${alphaNumericMatch.groups?.letters ?? ""}` : numericAlphaMatch ? `${numericAlphaMatch.groups?.letters ?? ""}${numericAlphaMatch.groups?.digits ?? ""}` : "";
+  if (!swappedQuery) {
+    return primaryMatch;
+  }
+  const swappedMatch = matchQuery(swappedQuery);
+  if (!swappedMatch.matches) {
+    return primaryMatch;
+  }
+  return { matches: true, score: swappedMatch.score + 5 };
+}
+function fuzzyFilter(items, query, getText) {
+  if (!query.trim()) {
+    return items;
+  }
+  const tokens = query.trim().split(/\s+/).filter((t) => t.length > 0);
+  if (tokens.length === 0) {
+    return items;
+  }
+  const results = [];
+  for (const item of items) {
+    const text = getText(item);
+    let totalScore = 0;
+    let allMatch = true;
+    for (const token of tokens) {
+      const match = fuzzyMatch(token, text);
+      if (match.matches) {
+        totalScore += match.score;
+      } else {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) {
+      results.push({ item, totalScore });
+    }
+  }
+  results.sort((a, b) => a.totalScore - b.totalScore);
+  return results.map((r) => r.item);
+}
+const LEFT_BOUNDARY_CHARS = /* @__PURE__ */ new Set(["(", "[", "{", '"', "'", ",", ":", ";", "!", "?"]);
+function isWhitespaceChar(char) {
+  return char === " " || char === "	" || char === "\n" || char === "\r";
+}
+function isInlineSkillLeftBoundary(char) {
+  return char === void 0 || isWhitespaceChar(char) || LEFT_BOUNDARY_CHARS.has(char);
+}
+function extractInlineSkillAutocompleteToken(textBeforeCursor) {
+  const slashIndex = textBeforeCursor.lastIndexOf("/");
+  if (slashIndex === -1) return null;
+  if (!isInlineSkillLeftBoundary(textBeforeCursor[slashIndex - 1])) return null;
+  const token = textBeforeCursor.slice(slashIndex);
+  if (token.includes("/", 1) || token.includes(" ")) return null;
+  if (token === "/") {
+    return { token, query: "", explicit: false };
+  }
+  if (token.startsWith("/skill:")) {
+    const query2 = token.slice("/skill:".length);
+    return /^[a-z0-9-]*$/.test(query2) ? { token, query: query2, explicit: true } : null;
+  }
+  const query = token.slice(1);
+  return /^[a-z0-9-]*$/.test(query) ? { token, query, explicit: false } : null;
+}
+function walkDirectoryWithFd(baseDir, fdPath, query, maxResults) {
+  const args = [
+    "--base-directory",
+    baseDir,
+    "--max-results",
+    String(maxResults),
+    "--type",
+    "f",
+    "--type",
+    "d",
+    "--full-path",
+    "--hidden",
+    "--exclude",
+    ".git",
+    "--exclude",
+    ".git/*",
+    "--exclude",
+    ".git/**"
+  ];
+  if (query) {
+    args.push(query);
+  }
+  const result = spawnSync(fdPath, args, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+    maxBuffer: 10 * 1024 * 1024
+  });
+  if (result.status !== 0 || !result.stdout) {
+    return [];
+  }
+  const lines = result.stdout.trim().split(/\r?\n/).filter(Boolean);
+  const results = [];
+  for (const line of lines) {
+    const posixPath = line.replaceAll("\\", "/");
+    const normalizedPath = posixPath.endsWith("/") ? posixPath.slice(0, -1) : posixPath;
+    if (normalizedPath === ".git" || normalizedPath.startsWith(".git/") || normalizedPath.includes("/.git/")) {
+      continue;
+    }
+    const isDirectory = posixPath.endsWith("/");
+    results.push({
+      path: posixPath,
+      isDirectory
+    });
+  }
+  return results;
+}
+function walkDirectoryWithoutFd(baseDir, query, maxResults) {
+  const normalizedQuery = query.toLowerCase();
+  const results = [];
+  const pendingDirectories = [""];
+  let visitedEntries = 0;
+  const maxVisitedEntries = 2e4;
+  while (pendingDirectories.length > 0 && results.length < maxResults && visitedEntries < maxVisitedEntries) {
+    const relativeDirectory = pendingDirectories.shift() ?? "";
+    const directory = relativeDirectory ? join$1(baseDir, relativeDirectory) : baseDir;
+    let entries;
+    try {
+      entries = readdirSync(directory, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    entries.sort((a, b) => {
+      if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+    for (const entry of entries) {
+      visitedEntries++;
+      if (entry.name === ".git" || entry.name === "node_modules") continue;
+      const relativePath = relativeDirectory ? join$1(relativeDirectory, entry.name) : entry.name;
+      const displayPath = relativePath.split("\\").join("/");
+      const isDirectory = entry.isDirectory();
+      if (isDirectory) pendingDirectories.push(relativePath);
+      if (!normalizedQuery || displayPath.toLowerCase().includes(normalizedQuery)) {
+        results.push({ path: isDirectory ? `${displayPath}/` : displayPath, isDirectory });
+        if (results.length >= maxResults) break;
+      }
+      if (visitedEntries >= maxVisitedEntries) break;
+    }
+  }
+  return results;
+}
+class CombinedAutocompleteProvider {
+  commands;
+  basePath;
+  fdPath;
+  atMentionItems;
+  constructor(commands = [], basePath = process.cwd(), fdPath = null, atMentionItems = []) {
+    this.commands = commands;
+    this.basePath = basePath;
+    this.fdPath = fdPath;
+    this.atMentionItems = atMentionItems;
+  }
+  setAtMentionItems(items) {
+    this.atMentionItems = items;
+  }
+  getSuggestions(lines, cursorLine, cursorCol) {
+    const currentLine = lines[cursorLine] || "";
+    const textBeforeCursor = currentLine.slice(0, cursorCol);
+    const atPrefix = this.extractAtPrefix(textBeforeCursor);
+    if (atPrefix) {
+      const { rawPrefix, isQuotedPrefix } = parsePathPrefix(atPrefix);
+      const mentionSuggestions = isQuotedPrefix ? [] : fuzzyFilter(this.atMentionItems, rawPrefix, (item) => item.label);
+      const fileSuggestions = this.getFuzzyFileSuggestions(rawPrefix, {
+        isQuotedPrefix
+      });
+      const suggestions = [...mentionSuggestions, ...fileSuggestions];
+      if (suggestions.length === 0) return null;
+      return {
+        items: suggestions,
+        prefix: atPrefix
+      };
+    }
+    if (textBeforeCursor.startsWith("/")) {
+      const spaceIndex = textBeforeCursor.indexOf(" ");
+      if (spaceIndex === -1) {
+        const prefix = textBeforeCursor.slice(1);
+        const commandItems = this.commands.map((cmd) => ({
+          name: "name" in cmd ? cmd.name : cmd.value,
+          label: "name" in cmd ? cmd.name : cmd.label,
+          description: cmd.description
+        }));
+        const filtered = fuzzyFilter(commandItems, prefix, (item) => item.name).map((item) => ({
+          value: item.name,
+          label: item.label,
+          ...item.description && { description: item.description }
+        }));
+        if (filtered.length === 0) return null;
+        return {
+          items: filtered,
+          prefix: textBeforeCursor
+        };
+      } else {
+        const commandName = textBeforeCursor.slice(1, spaceIndex);
+        const argumentText = textBeforeCursor.slice(spaceIndex + 1);
+        const command = this.commands.find((cmd) => {
+          const name = "name" in cmd ? cmd.name : cmd.value;
+          return name === commandName;
+        });
+        if (!command || !("getArgumentCompletions" in command) || !command.getArgumentCompletions) {
+          return null;
+        }
+        const argumentSuggestions = command.getArgumentCompletions(argumentText);
+        if (!argumentSuggestions || argumentSuggestions.length === 0) {
+          return null;
+        }
+        return {
+          items: argumentSuggestions,
+          prefix: argumentText
+        };
+      }
+    }
+    const inlineSkillToken = !textBeforeCursor.startsWith("/") ? extractInlineSkillAutocompleteToken(textBeforeCursor) : null;
+    if (inlineSkillToken) {
+      const rawQuery = inlineSkillToken.query;
+      const commandItems = this.commands.map((cmd) => ({
+        name: "name" in cmd ? cmd.name : cmd.value,
+        label: "name" in cmd ? cmd.name : cmd.label,
+        description: cmd.description
+      })).filter((item) => item.name.startsWith("skill:")).map((item) => ({
+        ...item,
+        matchName: item.name.slice("skill:".length)
+      }));
+      const filtered = fuzzyFilter(commandItems, rawQuery, (item) => item.matchName).map(
+        (item) => ({
+          value: item.name,
+          label: item.label,
+          ...item.description && { description: item.description }
+        })
+      );
+      if (filtered.length === 0) return null;
+      return {
+        items: filtered,
+        prefix: inlineSkillToken.token
+      };
+    }
+    const pathMatch = this.extractPathPrefix(textBeforeCursor, false);
+    if (pathMatch !== null) {
+      const suggestions = this.getFileSuggestions(pathMatch);
+      if (suggestions.length === 0) return null;
+      if (suggestions.length === 1 && suggestions[0]?.value === pathMatch && !pathMatch.endsWith("/")) {
+        return {
+          items: suggestions,
+          prefix: pathMatch
+        };
+      }
+      return {
+        items: suggestions,
+        prefix: pathMatch
+      };
+    }
+    return null;
+  }
+  applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+    return applyAutocompleteCompletion(lines, cursorLine, cursorCol, item, prefix);
+  }
+  // Extract @ prefix for fuzzy file suggestions
+  extractAtPrefix(text) {
+    return extractAtPrefix(text);
+  }
+  // Extract a path-like prefix from the text before cursor
+  extractPathPrefix(text, forceExtract = false) {
+    const quotedPrefix = extractQuotedPrefix(text);
+    if (quotedPrefix) {
+      return quotedPrefix;
+    }
+    const lastDelimiterIndex = findLastDelimiter(text);
+    const pathPrefix = lastDelimiterIndex === -1 ? text : text.slice(lastDelimiterIndex + 1);
+    if (forceExtract) {
+      return pathPrefix;
+    }
+    if (pathPrefix.includes("/") || pathPrefix.startsWith(".") || pathPrefix.startsWith("~/")) {
+      return pathPrefix;
+    }
+    if (pathPrefix === "" && text.endsWith(" ")) {
+      return pathPrefix;
+    }
+    return null;
+  }
+  // Expand home directory (~/) to actual home path
+  expandHomePath(path2) {
+    if (path2.startsWith("~/")) {
+      const expandedPath = join$1(homedir(), path2.slice(2));
+      return path2.endsWith("/") && !expandedPath.endsWith("/") ? `${expandedPath}/` : expandedPath;
+    } else if (path2 === "~") {
+      return homedir();
+    }
+    return path2;
+  }
+  resolveScopedFuzzyQuery(rawQuery) {
+    const slashIndex = rawQuery.lastIndexOf("/");
+    if (slashIndex === -1) {
+      return null;
+    }
+    const displayBase = rawQuery.slice(0, slashIndex + 1);
+    const query = rawQuery.slice(slashIndex + 1);
+    let baseDir;
+    if (displayBase.startsWith("~/")) {
+      baseDir = this.expandHomePath(displayBase);
+    } else if (displayBase.startsWith("/")) {
+      baseDir = displayBase;
+    } else {
+      baseDir = join$1(this.basePath, displayBase);
+    }
+    try {
+      if (!statSync(baseDir).isDirectory()) {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+    return { baseDir, query, displayBase };
+  }
+  scopedPathForDisplay(displayBase, relativePath) {
+    if (displayBase === "/") {
+      return `/${relativePath}`;
+    }
+    return `${displayBase}${relativePath}`;
+  }
+  // Get file/directory suggestions for a given path prefix
+  getFileSuggestions(prefix) {
+    try {
+      let searchDir;
+      let searchPrefix;
+      const { rawPrefix, isAtPrefix, isQuotedPrefix } = parsePathPrefix(prefix);
+      let expandedPrefix = rawPrefix;
+      if (expandedPrefix.startsWith("~")) {
+        expandedPrefix = this.expandHomePath(expandedPrefix);
+      }
+      const isRootPrefix = rawPrefix === "" || rawPrefix === "./" || rawPrefix === "../" || rawPrefix === "~" || rawPrefix === "~/" || rawPrefix === "/" || isAtPrefix && rawPrefix === "";
+      if (isRootPrefix) {
+        if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) {
+          searchDir = expandedPrefix;
+        } else {
+          searchDir = join$1(this.basePath, expandedPrefix);
+        }
+        searchPrefix = "";
+      } else if (rawPrefix.endsWith("/")) {
+        if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) {
+          searchDir = expandedPrefix;
+        } else {
+          searchDir = join$1(this.basePath, expandedPrefix);
+        }
+        searchPrefix = "";
+      } else {
+        const dir = dirname$1(expandedPrefix);
+        const file = basename$1(expandedPrefix);
+        if (rawPrefix.startsWith("~") || expandedPrefix.startsWith("/")) {
+          searchDir = dir;
+        } else {
+          searchDir = join$1(this.basePath, dir);
+        }
+        searchPrefix = file;
+      }
+      const entries = readdirSync(searchDir, { withFileTypes: true });
+      const suggestions = [];
+      for (const entry of entries) {
+        if (!entry.name.toLowerCase().startsWith(searchPrefix.toLowerCase())) {
+          continue;
+        }
+        let isDirectory = entry.isDirectory();
+        if (!isDirectory && entry.isSymbolicLink()) {
+          try {
+            const fullPath = join$1(searchDir, entry.name);
+            isDirectory = statSync(fullPath).isDirectory();
+          } catch {
+          }
+        }
+        let relativePath;
+        const name = entry.name;
+        const displayPrefix = rawPrefix;
+        if (displayPrefix.endsWith("/")) {
+          relativePath = displayPrefix + name;
+        } else if (displayPrefix.includes("/")) {
+          if (displayPrefix.startsWith("~/")) {
+            const homeRelativeDir = displayPrefix.slice(2);
+            const dir = dirname$1(homeRelativeDir);
+            relativePath = `~/${dir === "." ? name : join$1(dir, name)}`;
+          } else if (displayPrefix.startsWith("/")) {
+            const dir = dirname$1(displayPrefix);
+            if (dir === "/") {
+              relativePath = `/${name}`;
+            } else {
+              relativePath = `${dir}/${name}`;
+            }
+          } else {
+            relativePath = join$1(dirname$1(displayPrefix), name);
+          }
+        } else {
+          if (displayPrefix.startsWith("~")) {
+            relativePath = `~/${name}`;
+          } else {
+            relativePath = name;
+          }
+        }
+        const pathValue = isDirectory ? `${relativePath}/` : relativePath;
+        const value = buildCompletionValue(pathValue, {
+          isDirectory,
+          isAtPrefix,
+          isQuotedPrefix
+        });
+        suggestions.push({
+          value,
+          label: name + (isDirectory ? "/" : "")
+        });
+      }
+      suggestions.sort((a, b) => {
+        const aIsDir = a.value.endsWith("/");
+        const bIsDir = b.value.endsWith("/");
+        if (aIsDir && !bIsDir) return -1;
+        if (!aIsDir && bIsDir) return 1;
+        return a.label.localeCompare(b.label);
+      });
+      return suggestions;
+    } catch (_e) {
+      return [];
+    }
+  }
+  // Score an entry against the query (higher = better match)
+  // isDirectory adds bonus to prioritize folders
+  scoreEntry(filePath, query, isDirectory) {
+    const fileName = basename$1(filePath);
+    const lowerFileName = fileName.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    let score = 0;
+    if (lowerFileName === lowerQuery) score = 100;
+    else if (lowerFileName.startsWith(lowerQuery)) score = 80;
+    else if (lowerFileName.includes(lowerQuery)) score = 50;
+    else if (filePath.toLowerCase().includes(lowerQuery)) score = 30;
+    if (isDirectory && score > 0) score += 10;
+    return score;
+  }
+  // Fuzzy file search using fd (fast, respects .gitignore)
+  getFuzzyFileSuggestions(query, options) {
+    try {
+      const scopedQuery = this.resolveScopedFuzzyQuery(query);
+      const fdBaseDir = scopedQuery?.baseDir ?? this.basePath;
+      const fdQuery = scopedQuery?.query ?? query;
+      const entries = this.fdPath ? walkDirectoryWithFd(fdBaseDir, this.fdPath, fdQuery, 100) : walkDirectoryWithoutFd(fdBaseDir, fdQuery, 100);
+      const scoredEntries = entries.map((entry) => ({
+        ...entry,
+        score: fdQuery ? this.scoreEntry(entry.path, fdQuery, entry.isDirectory) : 1
+      })).filter((entry) => entry.score > 0);
+      scoredEntries.sort((a, b) => b.score - a.score);
+      const topEntries = scoredEntries.slice(0, 20);
+      const suggestions = [];
+      for (const { path: entryPath, isDirectory } of topEntries) {
+        const pathWithoutSlash = isDirectory ? entryPath.slice(0, -1) : entryPath;
+        const displayPath = scopedQuery ? this.scopedPathForDisplay(scopedQuery.displayBase, pathWithoutSlash) : pathWithoutSlash;
+        const entryName = basename$1(pathWithoutSlash);
+        const completionPath = isDirectory ? `${displayPath}/` : displayPath;
+        const value = buildCompletionValue(completionPath, {
+          isDirectory,
+          isAtPrefix: true,
+          isQuotedPrefix: options.isQuotedPrefix
+        });
+        suggestions.push({
+          value,
+          label: entryName + (isDirectory ? "/" : ""),
+          description: displayPath
+        });
+      }
+      return suggestions;
+    } catch {
+      return [];
+    }
+  }
+  // Force file completion (called on Tab key) - always returns suggestions
+  getForceFileSuggestions(lines, cursorLine, cursorCol) {
+    const currentLine = lines[cursorLine] || "";
+    const textBeforeCursor = currentLine.slice(0, cursorCol);
+    if (textBeforeCursor.trim().startsWith("/") && !textBeforeCursor.trim().includes(" ")) {
+      return null;
+    }
+    const pathMatch = this.extractPathPrefix(textBeforeCursor, true);
+    if (pathMatch !== null) {
+      const suggestions = this.getFileSuggestions(pathMatch);
+      if (suggestions.length === 0) return null;
+      return {
+        items: suggestions,
+        prefix: pathMatch
+      };
+    }
+    return null;
+  }
+  // Check if we should trigger file completion (called on Tab key)
+  shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+    const currentLine = lines[cursorLine] || "";
+    const textBeforeCursor = currentLine.slice(0, cursorCol);
+    if (textBeforeCursor.trim().startsWith("/") && !textBeforeCursor.trim().includes(" ")) {
+      return false;
+    }
+    return true;
+  }
+}
+class FileMentionSearchService {
+  constructor(ensureFd = () => ensureTool("fd", true)) {
+    this.ensureFd = ensureFd;
+  }
+  ensureFd;
+  fdPathPromise;
+  providers = /* @__PURE__ */ new Map();
+  initialize() {
+    this.fdPathPromise ??= this.ensureFd().catch(() => void 0);
+    return this.fdPathPromise;
+  }
+  async search(request) {
+    if (!isAbsolute(request.cwd)) throw new Error("File mention cwd must be absolute");
+    if (!request.prefix.startsWith("@")) throw new Error("File mention prefix must start with @");
+    let provider = this.providers.get(request.cwd);
+    if (!provider) {
+      provider = new CombinedAutocompleteProvider([], request.cwd, await this.initialize());
+      this.providers.set(request.cwd, provider);
+    }
+    const suggestions = provider.getSuggestions([request.prefix], 0, request.prefix.length);
+    return suggestions?.prefix.startsWith("@") ? suggestions : null;
+  }
+}
 function readLaunchArgument(name) {
   return readLaunchArguments(name).at(-1);
 }
@@ -5355,6 +8501,7 @@ const agents = new AgentProcessManager({
   cliPath: readLaunchArgument("shortcut-runtime-cli"),
   runtimeArgs: readLaunchArguments("shortcut-runtime-arg")
 });
+const fileMentions = new FileMentionSearchService();
 let mainWindow = null;
 let launchCwd = readLaunchArgument("shortcut-cwd") ?? process.cwd();
 function registerAgentIpc() {
@@ -5375,6 +8522,10 @@ function registerAgentIpc() {
     const result = mainWindow ? await dialog.showOpenDialog(mainWindow, options) : await dialog.showOpenDialog(options);
     return result.canceled ? [] : prepareRpcAttachments(result.filePaths);
   });
+  ipcMain.handle(
+    AgentIpcChannel.FileMentionSuggestions,
+    (_event, request) => fileMentions.search(request)
+  );
   ipcMain.handle(AgentIpcChannel.OpenFolder, async (_event, folderPath) => {
     if (!isAbsolute(folderPath)) throw new Error("Folder path must be absolute");
     const error = await shell.openPath(folderPath);
@@ -5398,7 +8549,7 @@ function createWindow() {
     minWidth: 820,
     minHeight: 560,
     title: "Shortcut CLI",
-    backgroundColor: "#f7f9f6",
+    backgroundColor: "#f5f5f5",
     webPreferences: {
       preload: join(__dirname, "../preload/index.cjs"),
       contextIsolation: true,
@@ -5447,6 +8598,7 @@ const singleInstance = app.requestSingleInstanceLock({ cwd: launchCwd });
 if (!singleInstance) {
   app.quit();
 } else {
+  void fileMentions.initialize();
   app.on("second-instance", (_event, _argv, _workingDirectory, additionalData) => {
     if (!mainWindow) return;
     const requestedCwd = additionalData.cwd;