claudekit-cli 1.2.1 → 1.3.0

package/dist/index.js

@@ -3004,6 +3004,2542 @@ var require_cli_progress = __commonJS((exports, module) => {
   };
 });
 
+// node_modules/ms/index.js
+var require_ms = __commonJS((exports, module) => {
+  var s = 1000;
+  var m2 = s * 60;
+  var h2 = m2 * 60;
+  var d3 = h2 * 24;
+  var w3 = d3 * 7;
+  var y3 = d3 * 365.25;
+  module.exports = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(val));
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str);
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y3;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w3;
+      case "days":
+      case "day":
+      case "d":
+        return n * d3;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h2;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m2;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return;
+    }
+  }
+  function fmtShort(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d3) {
+      return Math.round(ms / d3) + "d";
+    }
+    if (msAbs >= h2) {
+      return Math.round(ms / h2) + "h";
+    }
+    if (msAbs >= m2) {
+      return Math.round(ms / m2) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms / s) + "s";
+    }
+    return ms + "ms";
+  }
+  function fmtLong(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d3) {
+      return plural(ms, msAbs, d3, "day");
+    }
+    if (msAbs >= h2) {
+      return plural(ms, msAbs, h2, "hour");
+    }
+    if (msAbs >= m2) {
+      return plural(ms, msAbs, m2, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms, msAbs, s, "second");
+    }
+    return ms + " ms";
+  }
+  function plural(ms, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+  }
+});
+
+// node_modules/debug/src/common.js
+var require_common = __commonJS((exports, module) => {
+  function setup(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce2;
+    createDebug.disable = disable;
+    createDebug.enable = enable;
+    createDebug.enabled = enabled;
+    createDebug.humanize = require_ms();
+    createDebug.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug[key] = env[key];
+    });
+    createDebug.names = [];
+    createDebug.skips = [];
+    createDebug.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0;i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+    }
+    createDebug.selectColor = selectColor;
+    function createDebug(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug(...args) {
+        if (!debug.enabled) {
+          return;
+        }
+        const self = debug;
+        const curr = Number(new Date);
+        const ms = curr - (prevTime || curr);
+        self.diff = ms;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+          if (match === "%%") {
+            return "%";
+          }
+          index++;
+          const formatter = createDebug.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        createDebug.formatArgs.call(self, args);
+        const logFn = self.log || createDebug.log;
+        logFn.apply(self, args);
+      }
+      debug.namespace = namespace;
+      debug.useColors = createDebug.useColors();
+      debug.color = createDebug.selectColor(namespace);
+      debug.extend = extend;
+      debug.destroy = createDebug.destroy;
+      Object.defineProperty(debug, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug.namespaces) {
+            namespacesCache = createDebug.namespaces;
+            enabledCache = createDebug.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v2) => {
+          enableOverride = v2;
+        }
+      });
+      if (typeof createDebug.init === "function") {
+        createDebug.init(debug);
+      }
+      return debug;
+    }
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
+    }
+    function enable(namespaces) {
+      createDebug.save(namespaces);
+      createDebug.namespaces = namespaces;
+      createDebug.names = [];
+      createDebug.skips = [];
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+      for (const ns of split) {
+        if (ns[0] === "-") {
+          createDebug.skips.push(ns.slice(1));
+        } else {
+          createDebug.names.push(ns);
+        }
+      }
+    }
+    function matchesTemplate(search, template) {
+      let searchIndex = 0;
+      let templateIndex = 0;
+      let starIndex = -1;
+      let matchIndex = 0;
+      while (searchIndex < search.length) {
+        if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+          if (template[templateIndex] === "*") {
+            starIndex = templateIndex;
+            matchIndex = searchIndex;
+            templateIndex++;
+          } else {
+            searchIndex++;
+            templateIndex++;
+          }
+        } else if (starIndex !== -1) {
+          templateIndex = starIndex + 1;
+          matchIndex++;
+          searchIndex = matchIndex;
+        } else {
+          return false;
+        }
+      }
+      while (templateIndex < template.length && template[templateIndex] === "*") {
+        templateIndex++;
+      }
+      return templateIndex === template.length;
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug.names,
+        ...createDebug.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
+    }
+    function enabled(name) {
+      for (const skip of createDebug.skips) {
+        if (matchesTemplate(name, skip)) {
+          return false;
+        }
+      }
+      for (const ns of createDebug.names) {
+        if (matchesTemplate(name, ns)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function coerce2(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug.enable(createDebug.load());
+    return createDebug;
+  }
+  module.exports = setup;
+});
+
+// node_modules/debug/src/browser.js
+var require_browser = __commonJS((exports, module) => {
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.storage = localstorage();
+  exports.destroy = (() => {
+    let warned = false;
+    return () => {
+      if (!warned) {
+        warned = true;
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+    };
+  })();
+  exports.colors = [
+    "#0000CC",
+    "#0000FF",
+    "#0033CC",
+    "#0033FF",
+    "#0066CC",
+    "#0066FF",
+    "#0099CC",
+    "#0099FF",
+    "#00CC00",
+    "#00CC33",
+    "#00CC66",
+    "#00CC99",
+    "#00CCCC",
+    "#00CCFF",
+    "#3300CC",
+    "#3300FF",
+    "#3333CC",
+    "#3333FF",
+    "#3366CC",
+    "#3366FF",
+    "#3399CC",
+    "#3399FF",
+    "#33CC00",
+    "#33CC33",
+    "#33CC66",
+    "#33CC99",
+    "#33CCCC",
+    "#33CCFF",
+    "#6600CC",
+    "#6600FF",
+    "#6633CC",
+    "#6633FF",
+    "#66CC00",
+    "#66CC33",
+    "#9900CC",
+    "#9900FF",
+    "#9933CC",
+    "#9933FF",
+    "#99CC00",
+    "#99CC33",
+    "#CC0000",
+    "#CC0033",
+    "#CC0066",
+    "#CC0099",
+    "#CC00CC",
+    "#CC00FF",
+    "#CC3300",
+    "#CC3333",
+    "#CC3366",
+    "#CC3399",
+    "#CC33CC",
+    "#CC33FF",
+    "#CC6600",
+    "#CC6633",
+    "#CC9900",
+    "#CC9933",
+    "#CCCC00",
+    "#CCCC33",
+    "#FF0000",
+    "#FF0033",
+    "#FF0066",
+    "#FF0099",
+    "#FF00CC",
+    "#FF00FF",
+    "#FF3300",
+    "#FF3333",
+    "#FF3366",
+    "#FF3399",
+    "#FF33CC",
+    "#FF33FF",
+    "#FF6600",
+    "#FF6633",
+    "#FF9900",
+    "#FF9933",
+    "#FFCC00",
+    "#FFCC33"
+  ];
+  function useColors() {
+    if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+      return true;
+    }
+    if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+      return false;
+    }
+    let m2;
+    return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && (m2 = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m2[1], 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+  }
+  function formatArgs(args) {
+    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+    if (!this.useColors) {
+      return;
+    }
+    const c2 = "color: " + this.color;
+    args.splice(1, 0, c2, "color: inherit");
+    let index = 0;
+    let lastC = 0;
+    args[0].replace(/%[a-zA-Z%]/g, (match) => {
+      if (match === "%%") {
+        return;
+      }
+      index++;
+      if (match === "%c") {
+        lastC = index;
+      }
+    });
+    args.splice(lastC, 0, c2);
+  }
+  exports.log = console.debug || console.log || (() => {});
+  function save(namespaces) {
+    try {
+      if (namespaces) {
+        exports.storage.setItem("debug", namespaces);
+      } else {
+        exports.storage.removeItem("debug");
+      }
+    } catch (error) {}
+  }
+  function load() {
+    let r2;
+    try {
+      r2 = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+    } catch (error) {}
+    if (!r2 && typeof process !== "undefined" && "env" in process) {
+      r2 = process.env.DEBUG;
+    }
+    return r2;
+  }
+  function localstorage() {
+    try {
+      return localStorage;
+    } catch (error) {}
+  }
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.j = function(v2) {
+    try {
+      return JSON.stringify(v2);
+    } catch (error) {
+      return "[UnexpectedJSONParseError]: " + error.message;
+    }
+  };
+});
+
+// node_modules/has-flag/index.js
+var require_has_flag = __commonJS((exports, module) => {
+  module.exports = (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);
+  };
+});
+
+// node_modules/supports-color/index.js
+var require_supports_color = __commonJS((exports, module) => {
+  var os = __require("os");
+  var tty = __require("tty");
+  var hasFlag = require_has_flag();
+  var { env } = process;
+  var forceColor;
+  if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    forceColor = 0;
+  } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    forceColor = 1;
+  }
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      forceColor = 1;
+    } else if (env.FORCE_COLOR === "false") {
+      forceColor = 0;
+    } else {
+      forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(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) {
+    if (forceColor === 0) {
+      return 0;
+    }
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+    if (haveStream && !streamIsTTY && forceColor === undefined) {
+      return 0;
+    }
+    const min = forceColor || 0;
+    if (env.TERM === "dumb") {
+      return min;
+    }
+    if (process.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 (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].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 ("TERM_PROGRAM" in env) {
+      const version = 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 getSupportLevel(stream) {
+    const level = supportsColor(stream, stream && stream.isTTY);
+    return translateLevel(level);
+  }
+  module.exports = {
+    supportsColor: getSupportLevel,
+    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+  };
+});
+
+// node_modules/debug/src/node.js
+var require_node = __commonJS((exports, module) => {
+  var tty = __require("tty");
+  var util3 = __require("util");
+  exports.init = init;
+  exports.log = log;
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.destroy = util3.deprecate(() => {}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+  exports.colors = [6, 2, 3, 4, 5, 1];
+  try {
+    const supportsColor = require_supports_color();
+    if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+      exports.colors = [
+        20,
+        21,
+        26,
+        27,
+        32,
+        33,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        56,
+        57,
+        62,
+        63,
+        68,
+        69,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        92,
+        93,
+        98,
+        99,
+        112,
+        113,
+        128,
+        129,
+        134,
+        135,
+        148,
+        149,
+        160,
+        161,
+        162,
+        163,
+        164,
+        165,
+        166,
+        167,
+        168,
+        169,
+        170,
+        171,
+        172,
+        173,
+        178,
+        179,
+        184,
+        185,
+        196,
+        197,
+        198,
+        199,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        209,
+        214,
+        215,
+        220,
+        221
+      ];
+    }
+  } catch (error) {}
+  exports.inspectOpts = Object.keys(process.env).filter((key) => {
+    return /^debug_/i.test(key);
+  }).reduce((obj, key) => {
+    const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_3, k2) => {
+      return k2.toUpperCase();
+    });
+    let val = process.env[key];
+    if (/^(yes|on|true|enabled)$/i.test(val)) {
+      val = true;
+    } else if (/^(no|off|false|disabled)$/i.test(val)) {
+      val = false;
+    } else if (val === "null") {
+      val = null;
+    } else {
+      val = Number(val);
+    }
+    obj[prop] = val;
+    return obj;
+  }, {});
+  function useColors() {
+    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+  }
+  function formatArgs(args) {
+    const { namespace: name, useColors: useColors2 } = this;
+    if (useColors2) {
+      const c2 = this.color;
+      const colorCode = "\x1B[3" + (c2 < 8 ? c2 : "8;5;" + c2);
+      const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+      args[0] = prefix + args[0].split(`
+`).join(`
+` + prefix);
+      args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+    } else {
+      args[0] = getDate() + name + " " + args[0];
+    }
+  }
+  function getDate() {
+    if (exports.inspectOpts.hideDate) {
+      return "";
+    }
+    return new Date().toISOString() + " ";
+  }
+  function log(...args) {
+    return process.stderr.write(util3.formatWithOptions(exports.inspectOpts, ...args) + `
+`);
+  }
+  function save(namespaces) {
+    if (namespaces) {
+      process.env.DEBUG = namespaces;
+    } else {
+      delete process.env.DEBUG;
+    }
+  }
+  function load() {
+    return process.env.DEBUG;
+  }
+  function init(debug) {
+    debug.inspectOpts = {};
+    const keys = Object.keys(exports.inspectOpts);
+    for (let i = 0;i < keys.length; i++) {
+      debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+    }
+  }
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.o = function(v2) {
+    this.inspectOpts.colors = this.useColors;
+    return util3.inspect(v2, this.inspectOpts).split(`
+`).map((str) => str.trim()).join(" ");
+  };
+  formatters.O = function(v2) {
+    this.inspectOpts.colors = this.useColors;
+    return util3.inspect(v2, this.inspectOpts);
+  };
+});
+
+// node_modules/debug/src/index.js
+var require_src2 = __commonJS((exports, module) => {
+  if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
+    module.exports = require_browser();
+  } else {
+    module.exports = require_node();
+  }
+});
+
+// node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS((exports, module) => {
+  module.exports = 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(k2) {
+      wrapper[k2] = fn[k2];
+    });
+    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(k2) {
+          ret[k2] = cb2[k2];
+        });
+      }
+      return ret;
+    }
+  }
+});
+
+// node_modules/once/once.js
+var require_once = __commonJS((exports, module) => {
+  var wrappy = require_wrappy();
+  module.exports = wrappy(once);
+  module.exports.strict = wrappy(onceStrict);
+  once.proto = once(function() {
+    Object.defineProperty(Function.prototype, "once", {
+      value: function() {
+        return once(this);
+      },
+      configurable: true
+    });
+    Object.defineProperty(Function.prototype, "onceStrict", {
+      value: function() {
+        return onceStrict(this);
+      },
+      configurable: true
+    });
+  });
+  function once(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;
+  }
+});
+
+// node_modules/end-of-stream/index.js
+var require_end_of_stream = __commonJS((exports, module) => {
+  var once = require_once();
+  var noop = function() {};
+  var qnt = global.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 = once(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);
+    };
+  };
+  module.exports = eos;
+});
+
+// node_modules/pump/index.js
+var require_pump = __commonJS((exports, module) => {
+  var once = require_once();
+  var eos = require_end_of_stream();
+  var fs;
+  try {
+    fs = __require("fs");
+  } catch (e2) {}
+  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 (!fs)
+      return false;
+    return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
+  };
+  var isRequest = function(stream) {
+    return stream.setHeader && isFn(stream.abort);
+  };
+  var destroyer = function(stream, reading, writing, callback) {
+    callback = once(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);
+  };
+  module.exports = pump;
+});
+
+// node_modules/extract-zip/node_modules/get-stream/buffer-stream.js
+var require_buffer_stream = __commonJS((exports, module) => {
+  var { PassThrough: PassThroughStream } = __require("stream");
+  module.exports = (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;
+  };
+});
+
+// node_modules/extract-zip/node_modules/get-stream/index.js
+var require_get_stream = __commonJS((exports, module) => {
+  var { constants: BufferConstants } = __require("buffer");
+  var pump = require_pump();
+  var bufferStream = require_buffer_stream();
+
+  class MaxBufferError extends Error {
+    constructor() {
+      super("maxBuffer exceeded");
+      this.name = "MaxBufferError";
+    }
+  }
+  async function getStream(inputStream, options) {
+    if (!inputStream) {
+      return Promise.reject(new Error("Expected a stream"));
+    }
+    options = {
+      maxBuffer: Infinity,
+      ...options
+    };
+    const { maxBuffer } = options;
+    let stream;
+    await new Promise((resolve, reject) => {
+      const rejectPromise = (error) => {
+        if (error && stream.getBufferedLength() <= BufferConstants.MAX_LENGTH) {
+          error.bufferedData = stream.getBufferedValue();
+        }
+        reject(error);
+      };
+      stream = pump(inputStream, bufferStream(options), (error) => {
+        if (error) {
+          rejectPromise(error);
+          return;
+        }
+        resolve();
+      });
+      stream.on("data", () => {
+        if (stream.getBufferedLength() > maxBuffer) {
+          rejectPromise(new MaxBufferError);
+        }
+      });
+    });
+    return stream.getBufferedValue();
+  }
+  module.exports = getStream;
+  module.exports.default = getStream;
+  module.exports.buffer = (stream, options) => getStream(stream, { ...options, encoding: "buffer" });
+  module.exports.array = (stream, options) => getStream(stream, { ...options, array: true });
+  module.exports.MaxBufferError = MaxBufferError;
+});
+
+// node_modules/pend/index.js
+var require_pend = __commonJS((exports, module) => {
+  module.exports = 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(self) {
+    self.pending += 1;
+    var called = false;
+    return onCb;
+    function onCb(err) {
+      if (called)
+        throw new Error("callback called twice");
+      called = true;
+      self.error = self.error || err;
+      self.pending -= 1;
+      if (self.waiting.length > 0 && self.pending < self.max) {
+        pendGo(self, self.waiting.shift());
+      } else if (self.pending === 0) {
+        var listeners = self.listeners;
+        self.listeners = [];
+        listeners.forEach(cbListener);
+      }
+    }
+    function cbListener(listener) {
+      listener(self.error);
+    }
+  }
+  function pendGo(self, fn) {
+    fn(pendHold(self));
+  }
+});
+
+// node_modules/fd-slicer/index.js
+var require_fd_slicer = __commonJS((exports) => {
+  var fs = __require("fs");
+  var util3 = __require("util");
+  var stream = __require("stream");
+  var Readable = stream.Readable;
+  var Writable = stream.Writable;
+  var PassThrough = stream.PassThrough;
+  var Pend = require_pend();
+  var EventEmitter2 = __require("events").EventEmitter;
+  exports.createFromBuffer = createFromBuffer;
+  exports.createFromFd = createFromFd;
+  exports.BufferSlicer = BufferSlicer;
+  exports.FdSlicer = FdSlicer;
+  util3.inherits(FdSlicer, EventEmitter2);
+  function FdSlicer(fd, options) {
+    options = options || {};
+    EventEmitter2.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 self = this;
+    self.pend.go(function(cb) {
+      fs.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+        cb();
+        callback(err, bytesRead, buffer2);
+      });
+    });
+  };
+  FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
+    var self = this;
+    self.pend.go(function(cb) {
+      fs.write(self.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 self = this;
+    self.refCount -= 1;
+    if (self.refCount > 0)
+      return;
+    if (self.refCount < 0)
+      throw new Error("invalid unref");
+    if (self.autoClose) {
+      fs.close(self.fd, onCloseDone);
+    }
+    function onCloseDone(err) {
+      if (err) {
+        self.emit("error", err);
+      } else {
+        self.emit("close");
+      }
+    }
+  };
+  util3.inherits(ReadStream, Readable);
+  function ReadStream(context, options) {
+    options = options || {};
+    Readable.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 self = this;
+    if (self.destroyed)
+      return;
+    var toRead = Math.min(self._readableState.highWaterMark, n);
+    if (self.endOffset != null) {
+      toRead = Math.min(toRead, self.endOffset - self.pos);
+    }
+    if (toRead <= 0) {
+      self.destroyed = true;
+      self.push(null);
+      self.context.unref();
+      return;
+    }
+    self.context.pend.go(function(cb) {
+      if (self.destroyed)
+        return cb();
+      var buffer = new Buffer(toRead);
+      fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+        if (err) {
+          self.destroy(err);
+        } else if (bytesRead === 0) {
+          self.destroyed = true;
+          self.push(null);
+          self.context.unref();
+        } else {
+          self.pos += bytesRead;
+          self.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();
+  };
+  util3.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 self = this;
+    if (self.destroyed)
+      return;
+    if (self.pos + buffer.length > self.endOffset) {
+      var err = new Error("maximum file length exceeded");
+      err.code = "ETOOBIG";
+      self.destroy();
+      callback(err);
+      return;
+    }
+    self.context.pend.go(function(cb) {
+      if (self.destroyed)
+        return cb();
+      fs.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err2, bytes) {
+        if (err2) {
+          self.destroy();
+          cb();
+          callback(err2);
+        } else {
+          self.bytesWritten += bytes;
+          self.pos += bytes;
+          self.emit("progress");
+          cb();
+          callback();
+        }
+      });
+    });
+  };
+  WriteStream.prototype.destroy = function() {
+    if (this.destroyed)
+      return;
+    this.destroyed = true;
+    this.context.unref();
+  };
+  util3.inherits(BufferSlicer, EventEmitter2);
+  function BufferSlicer(buffer, options) {
+    EventEmitter2.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);
+  }
+});
+
+// node_modules/buffer-crc32/index.js
+var require_buffer_crc32 = __commonJS((exports, module) => {
+  var Buffer2 = __require("buffer").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,
+    936918000,
+    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;
+  };
+  module.exports = crc32;
+});
+
+// node_modules/yauzl/index.js
+var require_yauzl = __commonJS((exports) => {
+  var fs = __require("fs");
+  var zlib = __require("zlib");
+  var fd_slicer = require_fd_slicer();
+  var crc32 = require_buffer_crc32();
+  var util3 = __require("util");
+  var EventEmitter2 = __require("events").EventEmitter;
+  var Transform = __require("stream").Transform;
+  var PassThrough = __require("stream").PassThrough;
+  var Writable = __require("stream").Writable;
+  exports.open = open;
+  exports.fromFd = fromFd;
+  exports.fromBuffer = fromBuffer;
+  exports.fromRandomAccessReader = fromRandomAccessReader;
+  exports.dosDateTimeToDate = dosDateTimeToDate;
+  exports.validateFileName = validateFileName;
+  exports.ZipFile = ZipFile;
+  exports.Entry = Entry;
+  exports.RandomAccessReader = RandomAccessReader;
+  function open(path, 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;
+    fs.open(path, "r", function(err, fd) {
+      if (err)
+        return callback(err);
+      fromFd(fd, options, function(err2, zipfile) {
+        if (err2)
+          fs.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;
+    fs.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 fromBuffer(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"));
+    });
+  }
+  util3.inherits(ZipFile, EventEmitter2);
+  function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+    var self = this;
+    EventEmitter2.call(self);
+    self.reader = reader;
+    self.reader.on("error", function(err) {
+      emitError(self, err);
+    });
+    self.reader.once("close", function() {
+      self.emit("close");
+    });
+    self.readEntryCursor = centralDirectoryOffset;
+    self.fileSize = fileSize;
+    self.entryCount = entryCount;
+    self.comment = comment;
+    self.entriesRead = 0;
+    self.autoClose = !!autoClose;
+    self.lazyEntries = !!lazyEntries;
+    self.decodeStrings = !!decodeStrings;
+    self.validateEntrySizes = !!validateEntrySizes;
+    self.strictFileNames = !!strictFileNames;
+    self.isOpen = true;
+    self.emittedError = false;
+    if (!self.lazyEntries)
+      self._readEntry();
+  }
+  ZipFile.prototype.close = function() {
+    if (!this.isOpen)
+      return;
+    this.isOpen = false;
+    this.reader.unref();
+  };
+  function emitErrorAndAutoClose(self, err) {
+    if (self.autoClose)
+      self.close();
+    emitError(self, err);
+  }
+  function emitError(self, err) {
+    if (self.emittedError)
+      return;
+    self.emittedError = true;
+    self.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 self = this;
+    if (self.entryCount === self.entriesRead) {
+      setImmediate(function() {
+        if (self.autoClose)
+          self.close();
+        if (self.emittedError)
+          return;
+        self.emit("end");
+      });
+      return;
+    }
+    if (self.emittedError)
+      return;
+    var buffer = newBuffer(46);
+    readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+      if (err)
+        return emitErrorAndAutoClose(self, err);
+      if (self.emittedError)
+        return;
+      var entry = new Entry;
+      var signature = buffer.readUInt32LE(0);
+      if (signature !== 33639248)
+        return emitErrorAndAutoClose(self, 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(self, new Error("strong encryption is not supported"));
+      self.readEntryCursor += 46;
+      buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+      readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err2) {
+        if (err2)
+          return emitErrorAndAutoClose(self, err2);
+        if (self.emittedError)
+          return;
+        var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
+        entry.fileName = self.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(self, 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 = self.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8) : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+        entry.comment = entry.fileComment;
+        self.readEntryCursor += buffer.length;
+        self.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(self, new Error("expected zip64 extended information extra field"));
+          }
+          var index = 0;
+          if (entry.uncompressedSize === 4294967295) {
+            if (index + 8 > zip64EiefBuffer.length) {
+              return emitErrorAndAutoClose(self, 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(self, 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(self, new Error("zip64 extended information extra field does not include relative header offset"));
+            }
+            entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+            index += 8;
+          }
+        }
+        if (self.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 (self.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(self, new Error(msg));
+          }
+        }
+        if (self.decodeStrings) {
+          if (!self.strictFileNames) {
+            entry.fileName = entry.fileName.replace(/\\/g, "/");
+          }
+          var errorMessage = validateFileName(entry.fileName, self.validateFileNameOptions);
+          if (errorMessage != null)
+            return emitErrorAndAutoClose(self, new Error(errorMessage));
+        }
+        self.emit("entry", entry);
+        if (!self.lazyEntries)
+          self._readEntry();
+      });
+    });
+  };
+  ZipFile.prototype.openReadStream = function(entry, options, callback) {
+    var self = 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 (!self.isOpen)
+      return callback(new Error("closed"));
+    if (entry.isEncrypted()) {
+      if (options.decrypt !== false)
+        return callback(new Error("entry is encrypted, and options.decrypt !== false"));
+    }
+    self.reader.ref();
+    var buffer = newBuffer(30);
+    readAndAssertNoEof(self.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 > self.fileSize) {
+            return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));
+          }
+        }
+        var readStream = self.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 (self.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 {
+        self.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();
+    });
+  }
+  util3.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();
+  };
+  util3.inherits(RandomAccessReader, EventEmitter2);
+  function RandomAccessReader() {
+    EventEmitter2.call(this);
+    this.refCount = 0;
+  }
+  RandomAccessReader.prototype.ref = function() {
+    this.refCount += 1;
+  };
+  RandomAccessReader.prototype.unref = function() {
+    var self = this;
+    self.refCount -= 1;
+    if (self.refCount > 0)
+      return;
+    if (self.refCount < 0)
+      throw new Error("invalid unref");
+    self.close(onCloseDone);
+    function onCloseDone(err) {
+      if (err)
+        return self.emit("error", err);
+      self.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);
+  };
+  util3.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 = "\x00☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./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;
+  }
+});
+
+// node_modules/extract-zip/index.js
+var require_extract_zip = __commonJS((exports, module) => {
+  var debug = require_src2()("extract-zip");
+  var { createWriteStream: createWriteStream2, promises: fs } = __require("fs");
+  var getStream = require_get_stream();
+  var path = __require("path");
+  var { promisify } = __require("util");
+  var stream = __require("stream");
+  var yauzl = require_yauzl();
+  var openZip = promisify(yauzl.open);
+  var pipeline = promisify(stream.pipeline);
+
+  class Extractor {
+    constructor(zipPath, opts) {
+      this.zipPath = zipPath;
+      this.opts = opts;
+    }
+    async extract() {
+      debug("opening", this.zipPath, "with opts", this.opts);
+      this.zipfile = await openZip(this.zipPath, { lazyEntries: true });
+      this.canceled = false;
+      return new Promise((resolve, reject) => {
+        this.zipfile.on("error", (err) => {
+          this.canceled = true;
+          reject(err);
+        });
+        this.zipfile.readEntry();
+        this.zipfile.on("close", () => {
+          if (!this.canceled) {
+            debug("zip extraction complete");
+            resolve();
+          }
+        });
+        this.zipfile.on("entry", async (entry) => {
+          if (this.canceled) {
+            debug("skipping entry", entry.fileName, { cancelled: this.canceled });
+            return;
+          }
+          debug("zipfile entry", entry.fileName);
+          if (entry.fileName.startsWith("__MACOSX/")) {
+            this.zipfile.readEntry();
+            return;
+          }
+          const destDir = path.dirname(path.join(this.opts.dir, entry.fileName));
+          try {
+            await fs.mkdir(destDir, { recursive: true });
+            const canonicalDestDir = await fs.realpath(destDir);
+            const relativeDestDir = path.relative(this.opts.dir, canonicalDestDir);
+            if (relativeDestDir.split(path.sep).includes("..")) {
+              throw new Error(`Out of bound path "${canonicalDestDir}" found while processing file ${entry.fileName}`);
+            }
+            await this.extractEntry(entry);
+            debug("finished processing", entry.fileName);
+            this.zipfile.readEntry();
+          } catch (err) {
+            this.canceled = true;
+            this.zipfile.close();
+            reject(err);
+          }
+        });
+      });
+    }
+    async extractEntry(entry) {
+      if (this.canceled) {
+        debug("skipping entry extraction", entry.fileName, { cancelled: this.canceled });
+        return;
+      }
+      if (this.opts.onEntry) {
+        this.opts.onEntry(entry, this.zipfile);
+      }
+      const dest = path.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;
+      debug("extracting entry", { filename: entry.fileName, isDir, isSymlink: symlink });
+      const procMode = this.getExtractedMode(mode, isDir) & 511;
+      const destDir = isDir ? dest : path.dirname(dest);
+      const mkdirOptions = { recursive: true };
+      if (isDir) {
+        mkdirOptions.mode = procMode;
+      }
+      debug("mkdir", { dir: destDir, ...mkdirOptions });
+      await fs.mkdir(destDir, mkdirOptions);
+      if (isDir)
+        return;
+      debug("opening read stream", dest);
+      const readStream = await promisify(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+      if (symlink) {
+        const link = await getStream(readStream);
+        debug("creating symlink", link, dest);
+        await fs.symlink(link, dest);
+      } else {
+        await pipeline(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;
+    }
+  }
+  module.exports = async function(zipPath, opts) {
+    debug("creating target directory", opts.dir);
+    if (!path.isAbsolute(opts.dir)) {
+      throw new Error("Target directory is expected to be absolute");
+    }
+    await fs.mkdir(opts.dir, { recursive: true });
+    opts.dir = await fs.realpath(opts.dir);
+    return new Extractor(zipPath, opts).extract();
+  };
+});
+
 // node_modules/ignore/index.js
 var require_ignore = __commonJS((exports, module) => {
   function makeArray(subject) {
@@ -3264,11 +5800,6 @@ var require_ignore = __commonJS((exports, module) => {
   }
 });
 
-// src/index.ts
-import { readFileSync } from "fs";
-import { join as join6 } from "path";
-import { fileURLToPath } from "url";
-
 // node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
 function toArr(any) {
@@ -3872,7 +6403,7 @@ var cac = (name = "") => new CAC(name);
 
 // src/commands/new.ts
 var import_fs_extra2 = __toESM(require_lib(), 1);
-import { resolve } from "node:path";
+import { resolve as resolve2 } from "node:path";
 
 // src/lib/auth.ts
 import { execSync } from "node:child_process";
@@ -8394,7 +10925,8 @@ var KitType = exports_external.enum(["engineer", "marketing"]);
 var NewCommandOptionsSchema = exports_external.object({
   dir: exports_external.string().default("."),
   kit: KitType.optional(),
-  version: exports_external.string().optional()
+  version: exports_external.string().optional(),
+  force: exports_external.boolean().default(false)
 });
 var UpdateCommandOptionsSchema = exports_external.object({
   dir: exports_external.string().default("."),
@@ -8787,13 +11319,12 @@ class AuthManager {
 
 // src/lib/download.ts
 var import_cli_progress = __toESM(require_cli_progress(), 1);
+var import_extract_zip = __toESM(require_extract_zip(), 1);
 var import_ignore = __toESM(require_ignore(), 1);
-import { createReadStream, createWriteStream as createWriteStream2 } from "node:fs";
+import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir as mkdir3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join3 } from "node:path";
-import { pipeline } from "node:stream";
-import { promisify } from "node:util";
+import { join as join3, relative, resolve } from "node:path";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
 import EE from "events";
@@ -15596,9 +18127,6 @@ var mtimeFilter = (opt) => {
   }
   opt.filter = filter ? (path8, stat) => filter(path8, stat) && !((opt.mtimeCache?.get(path8) ?? stat.mtime ?? 0) > (stat.mtime ?? 0)) : (path8, stat) => !((opt.mtimeCache?.get(path8) ?? stat.mtime ?? 0) > (stat.mtime ?? 0));
 };
-// src/lib/download.ts
-import unzipper from "unzipper";
-
 // node_modules/ora/index.js
 import process8 from "node:process";
 
@@ -18671,9 +21199,8 @@ function createSpinner(options) {
 }
 
 // src/lib/download.ts
-var streamPipeline = promisify(pipeline);
-
 class DownloadManager {
+  static MAX_EXTRACTION_SIZE = 500 * 1024 * 1024;
   static EXCLUDE_PATTERNS = [
     ".git",
     ".git/**",
@@ -18685,10 +21212,26 @@ class DownloadManager {
     "Thumbs.db",
     "*.log"
   ];
+  totalExtractedSize = 0;
   shouldExclude(filePath) {
     const ig = import_ignore.default().add(DownloadManager.EXCLUDE_PATTERNS);
     return ig.ignores(filePath);
   }
+  isPathSafe(basePath, targetPath) {
+    const resolvedBase = resolve(basePath);
+    const resolvedTarget = resolve(targetPath);
+    const relativePath = relative(resolvedBase, resolvedTarget);
+    return !relativePath.startsWith("..") && !relativePath.startsWith("/") && resolvedTarget.startsWith(resolvedBase);
+  }
+  checkExtractionSize(fileSize) {
+    this.totalExtractedSize += fileSize;
+    if (this.totalExtractedSize > DownloadManager.MAX_EXTRACTION_SIZE) {
+      throw new ExtractionError(`Archive exceeds maximum extraction size of ${this.formatBytes(DownloadManager.MAX_EXTRACTION_SIZE)}. Possible archive bomb detected.`);
+    }
+  }
+  resetExtractionSize() {
+    this.totalExtractedSize = 0;
+  }
   async downloadAsset(asset, destDir) {
     try {
       const destPath = join3(destDir, asset.name);
@@ -18798,6 +21341,7 @@ class DownloadManager {
   async extractArchive(archivePath, destDir, archiveType) {
     const spinner = createSpinner("Extracting files...").start();
     try {
+      this.resetExtractionSize();
       const detectedType = archiveType || this.detectArchiveType(archivePath);
       await mkdir3(destDir, { recursive: true });
       if (detectedType === "tar.gz") {
@@ -18814,18 +21358,63 @@ class DownloadManager {
     }
   }
   async extractTarGz(archivePath, destDir) {
-    await extract({
-      file: archivePath,
-      cwd: destDir,
-      strip: 1,
-      filter: (path8) => {
-        const shouldInclude = !this.shouldExclude(path8);
-        if (!shouldInclude) {
-          logger.debug(`Excluding: ${path8}`);
+    const { readdir, stat, mkdir: mkdirPromise, copyFile, rm } = await import("node:fs/promises");
+    const { join: pathJoin } = await import("node:path");
+    const tempExtractDir = `${destDir}-temp`;
+    await mkdirPromise(tempExtractDir, { recursive: true });
+    try {
+      await extract({
+        file: archivePath,
+        cwd: tempExtractDir,
+        strip: 0,
+        filter: (path8) => {
+          const shouldInclude = !this.shouldExclude(path8);
+          if (!shouldInclude) {
+            logger.debug(`Excluding: ${path8}`);
+          }
+          return shouldInclude;
+        }
+      });
+      logger.debug(`Extracted TAR.GZ to temp: ${tempExtractDir}`);
+      const entries = await readdir(tempExtractDir);
+      logger.debug(`Root entries: ${entries.join(", ")}`);
+      if (entries.length === 1) {
+        const rootEntry = entries[0];
+        const rootPath = pathJoin(tempExtractDir, rootEntry);
+        const rootStat = await stat(rootPath);
+        if (rootStat.isDirectory()) {
+          const rootContents = await readdir(rootPath);
+          logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
+          const isWrapper = this.isWrapperDirectory(rootEntry);
+          logger.debug(`Is wrapper directory: ${isWrapper}`);
+          if (isWrapper) {
+            logger.debug(`Stripping wrapper directory: ${rootEntry}`);
+            await this.moveDirectoryContents(rootPath, destDir);
+          } else {
+            logger.debug("Preserving complete directory structure");
+            await this.moveDirectoryContents(tempExtractDir, destDir);
+          }
+        } else {
+          await mkdirPromise(destDir, { recursive: true });
+          await copyFile(rootPath, pathJoin(destDir, rootEntry));
         }
-        return shouldInclude;
+      } else {
+        logger.debug("Multiple root entries - moving all");
+        await this.moveDirectoryContents(tempExtractDir, destDir);
       }
-    });
+      logger.debug(`Moved contents to: ${destDir}`);
+      await rm(tempExtractDir, { recursive: true, force: true });
+    } catch (error2) {
+      try {
+        await rm(tempExtractDir, { recursive: true, force: true });
+      } catch {}
+      throw error2;
+    }
+  }
+  isWrapperDirectory(dirName) {
+    const versionPattern = /^[\w-]+-v?\d+\.\d+\.\d+(-[\w.]+)?$/;
+    const hashPattern = /^[\w-]+-[a-f0-9]{7,40}$/;
+    return versionPattern.test(dirName) || hashPattern.test(dirName);
   }
   async extractZip(archivePath, destDir) {
     const { readdir, stat, mkdir: mkdirPromise, copyFile, rm } = await import("node:fs/promises");
@@ -18833,21 +21422,35 @@ class DownloadManager {
     const tempExtractDir = `${destDir}-temp`;
     await mkdirPromise(tempExtractDir, { recursive: true });
     try {
-      await streamPipeline(createReadStream(archivePath), unzipper.Extract({ path: tempExtractDir }));
+      await import_extract_zip.default(archivePath, { dir: tempExtractDir });
+      logger.debug(`Extracted ZIP to temp: ${tempExtractDir}`);
       const entries = await readdir(tempExtractDir);
+      logger.debug(`Root entries: ${entries.join(", ")}`);
       if (entries.length === 1) {
         const rootEntry = entries[0];
         const rootPath = pathJoin(tempExtractDir, rootEntry);
         const rootStat = await stat(rootPath);
         if (rootStat.isDirectory()) {
-          await this.moveDirectoryContents(rootPath, destDir);
+          const rootContents = await readdir(rootPath);
+          logger.debug(`Root directory '${rootEntry}' contains: ${rootContents.join(", ")}`);
+          const isWrapper = this.isWrapperDirectory(rootEntry);
+          logger.debug(`Is wrapper directory: ${isWrapper}`);
+          if (isWrapper) {
+            logger.debug(`Stripping wrapper directory: ${rootEntry}`);
+            await this.moveDirectoryContents(rootPath, destDir);
+          } else {
+            logger.debug("Preserving complete directory structure");
+            await this.moveDirectoryContents(tempExtractDir, destDir);
+          }
         } else {
           await mkdirPromise(destDir, { recursive: true });
           await copyFile(rootPath, pathJoin(destDir, rootEntry));
         }
       } else {
+        logger.debug("Multiple root entries - moving all");
         await this.moveDirectoryContents(tempExtractDir, destDir);
       }
+      logger.debug(`Moved contents to: ${destDir}`);
       await rm(tempExtractDir, { recursive: true, force: true });
     } catch (error2) {
       try {
@@ -18858,13 +21461,17 @@ class DownloadManager {
   }
   async moveDirectoryContents(sourceDir, destDir) {
     const { readdir, stat, mkdir: mkdirPromise, copyFile } = await import("node:fs/promises");
-    const { join: pathJoin, relative } = await import("node:path");
+    const { join: pathJoin, relative: relative2 } = await import("node:path");
     await mkdirPromise(destDir, { recursive: true });
     const entries = await readdir(sourceDir);
     for (const entry of entries) {
       const sourcePath = pathJoin(sourceDir, entry);
       const destPath = pathJoin(destDir, entry);
-      const relativePath = relative(sourceDir, sourcePath);
+      const relativePath = relative2(sourceDir, sourcePath);
+      if (!this.isPathSafe(destDir, destPath)) {
+        logger.warning(`Skipping unsafe path: ${relativePath}`);
+        throw new ExtractionError(`Path traversal attempt detected: ${relativePath}`);
+      }
       if (this.shouldExclude(relativePath)) {
         logger.debug(`Excluding: ${relativePath}`);
         continue;
@@ -18873,19 +21480,24 @@ class DownloadManager {
       if (entryStat.isDirectory()) {
         await this.copyDirectory(sourcePath, destPath);
       } else {
+        this.checkExtractionSize(entryStat.size);
         await copyFile(sourcePath, destPath);
       }
     }
   }
   async copyDirectory(sourceDir, destDir) {
     const { readdir, stat, mkdir: mkdirPromise, copyFile } = await import("node:fs/promises");
-    const { join: pathJoin, relative } = await import("node:path");
+    const { join: pathJoin, relative: relative2 } = await import("node:path");
     await mkdirPromise(destDir, { recursive: true });
     const entries = await readdir(sourceDir);
     for (const entry of entries) {
       const sourcePath = pathJoin(sourceDir, entry);
       const destPath = pathJoin(destDir, entry);
-      const relativePath = relative(sourceDir, sourcePath);
+      const relativePath = relative2(sourceDir, sourcePath);
+      if (!this.isPathSafe(destDir, destPath)) {
+        logger.warning(`Skipping unsafe path: ${relativePath}`);
+        throw new ExtractionError(`Path traversal attempt detected: ${relativePath}`);
+      }
       if (this.shouldExclude(relativePath)) {
         logger.debug(`Excluding: ${relativePath}`);
         continue;
@@ -18894,6 +21506,7 @@ class DownloadManager {
       if (entryStat.isDirectory()) {
         await this.copyDirectory(sourcePath, destPath);
       } else {
+        this.checkExtractionSize(entryStat.size);
         await copyFile(sourcePath, destPath);
       }
     }
@@ -18907,6 +21520,38 @@ class DownloadManager {
     }
     throw new ExtractionError(`Cannot detect archive type from filename: ${filename}`);
   }
+  async validateExtraction(extractDir) {
+    const { readdir, access } = await import("node:fs/promises");
+    const { join: pathJoin } = await import("node:path");
+    const { constants: constants2 } = await import("node:fs");
+    try {
+      const entries = await readdir(extractDir);
+      logger.debug(`Extracted files: ${entries.join(", ")}`);
+      if (entries.length === 0) {
+        throw new ExtractionError("Extraction resulted in no files");
+      }
+      const criticalPaths = [".claude", "CLAUDE.md"];
+      const missingPaths = [];
+      for (const path8 of criticalPaths) {
+        try {
+          await access(pathJoin(extractDir, path8), constants2.F_OK);
+          logger.debug(`✓ Found: ${path8}`);
+        } catch {
+          logger.warning(`Expected path not found: ${path8}`);
+          missingPaths.push(path8);
+        }
+      }
+      if (missingPaths.length > 0) {
+        logger.warning(`Some expected paths are missing: ${missingPaths.join(", ")}. This may not be a ClaudeKit project.`);
+      }
+      logger.debug("Extraction validation passed");
+    } catch (error2) {
+      if (error2 instanceof ExtractionError) {
+        throw error2;
+      }
+      throw new ExtractionError(`Validation failed: ${error2 instanceof Error ? error2.message : "Unknown error"}`);
+    }
+  }
   async createTempDir() {
     const tempDir = join3(tmpdir(), `claudekit-${Date.now()}`);
     await mkdir3(tempDir, { recursive: true });
@@ -19064,7 +21709,7 @@ class GitHubClient {
 }
 
 // src/lib/merge.ts
-import { join as join4, relative } from "node:path";
+import { join as join4, relative as relative2 } from "node:path";
 var import_fs_extra = __toESM(require_lib(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
 class FileMerger {
@@ -19090,7 +21735,7 @@ class FileMerger {
     const conflicts = [];
     const files = await this.getFiles(sourceDir);
     for (const file of files) {
-      const relativePath = relative(sourceDir, file);
+      const relativePath = relative2(sourceDir, file);
       if (this.ig.ignores(relativePath)) {
         continue;
       }
@@ -19106,7 +21751,7 @@ class FileMerger {
     let copiedCount = 0;
     let skippedCount = 0;
     for (const file of files) {
-      const relativePath = relative(sourceDir, file);
+      const relativePath = relative2(sourceDir, file);
       if (this.ig.ignores(relativePath)) {
         logger.debug(`Skipping protected file: ${relativePath}`);
         skippedCount++;
@@ -19244,27 +21889,42 @@ async function newCommand(options) {
   prompts.intro("\uD83D\uDE80 ClaudeKit - Create New Project");
   try {
     const validOptions = NewCommandOptionsSchema.parse(options);
+    const isNonInteractive = !process.stdin.isTTY || process.env.CI === "true" || process.env.NON_INTERACTIVE === "true";
     const config = await ConfigManager.get();
     let kit = validOptions.kit || config.defaults?.kit;
     if (!kit) {
+      if (isNonInteractive) {
+        throw new Error("Kit must be specified via --kit flag in non-interactive mode");
+      }
       kit = await prompts.selectKit();
     }
     const kitConfig = AVAILABLE_KITS[kit];
     logger.info(`Selected kit: ${kitConfig.name}`);
     let targetDir = validOptions.dir || config.defaults?.dir || ".";
     if (!validOptions.dir && !config.defaults?.dir) {
-      targetDir = await prompts.getDirectory(targetDir);
+      if (isNonInteractive) {
+        targetDir = ".";
+      } else {
+        targetDir = await prompts.getDirectory(targetDir);
+      }
     }
-    const resolvedDir = resolve(targetDir);
+    const resolvedDir = resolve2(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
     if (await import_fs_extra2.pathExists(resolvedDir)) {
       const files = await import_fs_extra2.readdir(resolvedDir);
       const isEmpty = files.length === 0;
       if (!isEmpty) {
-        const continueAnyway = await prompts.confirm("Directory is not empty. Files may be overwritten. Continue?");
-        if (!continueAnyway) {
-          logger.warning("Operation cancelled");
-          return;
+        if (isNonInteractive) {
+          if (!validOptions.force) {
+            throw new Error("Directory is not empty. Use --force flag to overwrite in non-interactive mode");
+          }
+          logger.info("Directory is not empty. Proceeding with --force flag");
+        } else {
+          const continueAnyway = await prompts.confirm("Directory is not empty. Files may be overwritten. Continue?");
+          if (!continueAnyway) {
+            logger.warning("Operation cancelled");
+            return;
+          }
         }
       }
     }
@@ -19323,6 +21983,7 @@ async function newCommand(options) {
     }
     const extractDir = `${tempDir}/extracted`;
     await downloadManager.extractArchive(archivePath, extractDir);
+    await downloadManager.validateExtraction(extractDir);
     const merger = new FileMerger;
     await merger.merge(extractDir, resolvedDir, true);
     prompts.outro(`✨ Project created successfully at ${resolvedDir}`);
@@ -19337,11 +21998,11 @@ bun run dev`, "Next steps");
 
 // src/commands/update.ts
 var import_fs_extra4 = __toESM(require_lib(), 1);
-import { resolve as resolve3 } from "node:path";
+import { resolve as resolve4 } from "node:path";
 
 // src/utils/file-scanner.ts
 var import_fs_extra3 = __toESM(require_lib(), 1);
-import { join as join5, relative as relative2, resolve as resolve2 } from "node:path";
+import { join as join5, relative as relative3, resolve as resolve3 } from "node:path";
 class FileScanner {
   static async getFiles(dirPath, relativeTo) {
     const basePath = relativeTo || dirPath;
@@ -19366,7 +22027,7 @@ class FileScanner {
           const subFiles = await FileScanner.getFiles(fullPath, basePath);
           files.push(...subFiles);
         } else if (stats.isFile()) {
-          const relativePath = relative2(basePath, fullPath);
+          const relativePath = relative3(basePath, fullPath);
           files.push(relativePath);
         }
       }
@@ -19394,8 +22055,8 @@ class FileScanner {
     return customFiles;
   }
   static isSafePath(basePath, targetPath) {
-    const resolvedBase = resolve2(basePath);
-    const resolvedTarget = resolve2(targetPath);
+    const resolvedBase = resolve3(basePath);
+    const resolvedTarget = resolve3(targetPath);
     return resolvedTarget.startsWith(resolvedBase);
   }
 }
@@ -19417,7 +22078,7 @@ async function updateCommand(options) {
     if (!validOptions.dir && !config.defaults?.dir) {
       targetDir = await prompts.getDirectory(targetDir);
     }
-    const resolvedDir = resolve3(targetDir);
+    const resolvedDir = resolve4(targetDir);
     logger.info(`Target directory: ${resolvedDir}`);
     if (!await import_fs_extra4.pathExists(resolvedDir)) {
       logger.error(`Directory does not exist: ${resolvedDir}`);
@@ -19479,6 +22140,7 @@ async function updateCommand(options) {
     }
     const extractDir = `${tempDir}/extracted`;
     await downloadManager.extractArchive(archivePath, extractDir);
+    await downloadManager.validateExtraction(extractDir);
     logger.info("Scanning for custom .claude files...");
     const customClaudeFiles = await FileScanner.findCustomFiles(resolvedDir, extractDir, ".claude");
     const merger = new FileMerger;
@@ -19692,6 +22354,10 @@ class Logger2 {
   }
 }
 var logger2 = new Logger2;
+// src/version.json
+var version_default = {
+  version: "1.2.1"
+};
 
 // src/index.ts
 if (process.stdout.setEncoding) {
@@ -19700,12 +22366,11 @@ if (process.stdout.setEncoding) {
 if (process.stderr.setEncoding) {
   process.stderr.setEncoding("utf8");
 }
-var __dirname2 = fileURLToPath(new URL(".", import.meta.url));
-var packageJson = JSON.parse(readFileSync(join6(__dirname2, "../package.json"), "utf-8"));
+var packageVersion = version_default.version;
 var cli = cac("ck");
 cli.option("--verbose, -v", "Enable verbose logging for debugging");
 cli.option("--log-file <path>", "Write logs to file");
-cli.command("new", "Bootstrap a new ClaudeKit project").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer, marketing)").option("--version <version>", "Specific version to download (default: latest)").action(async (options) => {
+cli.command("new", "Bootstrap a new ClaudeKit project").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer, marketing)").option("--version <version>", "Specific version to download (default: latest)").option("--force", "Overwrite existing files without confirmation").action(async (options) => {
   await newCommand(options);
 });
 cli.command("update", "Update existing ClaudeKit project").option("--dir <dir>", "Target directory (default: .)").option("--kit <kit>", "Kit to use (engineer, marketing)").option("--version <version>", "Specific version to download (default: latest)").action(async (options) => {
@@ -19714,7 +22379,7 @@ cli.command("update", "Update existing ClaudeKit project").option("--dir <dir>",
 cli.command("versions", "List available versions of ClaudeKit repositories").option("--kit <kit>", "Filter by specific kit (engineer, marketing)").option("--limit <limit>", "Number of releases to show (default: 30)").option("--all", "Show all releases including prereleases").action(async (options) => {
   await versionCommand(options);
 });
-cli.version(packageJson.version);
+cli.version(packageVersion);
 cli.help();
 var parsed = cli.parse(process.argv, { run: false });
 var envVerbose = process.env.CLAUDEKIT_VERBOSE === "1" || process.env.CLAUDEKIT_VERBOSE === "true";
@@ -19726,7 +22391,7 @@ if (parsed.options.logFile) {
   logger2.setLogFile(parsed.options.logFile);
 }
 logger2.verbose("ClaudeKit CLI starting", {
-  version: packageJson.version,
+  version: packageVersion,
   command: parsed.args[0] || "none",
   options: parsed.options,
   cwd: process.cwd(),