ya-git-jira 1.3.0 → 1.5.0

package/dist/bin/git-lab.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun run
+#!/usr/bin/env bun
 // @bun
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -21,7 +21,7 @@ var __require = (id) => {
   return import.meta.require(id);
 };
 
-// node_modules/commander/lib/error.js
+// bine_modules/commander/lib/suggestS
 var require_error = __commonJS((exports) => {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
@@ -45,7 +45,7 @@ var require_error = __commonJS((exports) => {
   exports.InvalidArgumentError = InvalidArgumentError;
 });
 
-// node_modules/commander/lib/argument.js
+// bine_modules/commander/lib/suggestSimi
 var require_argument = __commonJS((exports) => {
   var humanReadableArgName = function(arg) {
     const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
@@ -124,7 +124,7 @@ var require_argument = __commonJS((exports) => {
   exports.humanReadableArgName = humanReadableArgName;
 });
 
-// node_modules/commander/lib/help.js
+// bine_modules/commander/lib/suggest
 var require_help = __commonJS((exports) => {
   var { humanReadableArgName } = require_argument();
 
@@ -364,7 +364,7 @@ var require_help = __commonJS((exports) => {
   exports.Help = Help;
 });
 
-// node_modules/commander/lib/option.js
+// bine_modules/commander/lib/suggestSi
 var require_option = __commonJS((exports) => {
   var camelcase = function(str) {
     return str.split("-").reduce((str2, word) => {
@@ -516,7 +516,7 @@ var require_option = __commonJS((exports) => {
   exports.DualOptions = DualOptions;
 });
 
-// node_modules/commander/lib/suggestSimilar.js
+// bine_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS((exports) => {
   var editDistance = function(a, b) {
     if (Math.abs(a.length - b.length) > maxDistance)
@@ -587,7 +587,7 @@ var require_suggestSimilar = __commonJS((exports) => {
   exports.suggestSimilar = suggestSimilar;
 });
 
-// node_modules/commander/lib/command.js
+// bine_modules/commander/lib/suggestSim
 var require_command = __commonJS((exports) => {
   var outputHelpIfRequested = function(cmd, args) {
     const helpOption = cmd._hasHelpOption && args.find((arg) => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag);
@@ -1765,7 +1765,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.Command = Command;
 });
 
-// node_modules/commander/index.js
+// bine_modules/commander/lib/sugg
 var require_commander = __commonJS((exports, module) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
@@ -1783,7 +1783,728 @@ var require_commander = __commonJS((exports, module) => {
   exports.Option = Option;
 });
 
-// node_modules/commander/esm.mjs
+// bine_modules/commander/l
+var require_ms = __commonJS((exports, module) => {
+  var parse = function(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 * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      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;
+    }
+  };
+  var fmtShort = function(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return Math.round(ms / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms / s) + "s";
+    }
+    return ms + "ms";
+  };
+  var fmtLong = function(ms) {
+    var msAbs = Math.abs(ms);
+    if (msAbs >= d) {
+      return plural(ms, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms, msAbs, s, "second");
+    }
+    return ms + " ms";
+  };
+  var plural = function(ms, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+  };
+  var s = 1000;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 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));
+  };
+});
+
+// bine_modules/commander/lib/sugge
+var require_common = __commonJS((exports, module) => {
+  var setup = function(env) {
+    createDebug.debug = createDebug;
+    createDebug.default = createDebug;
+    createDebug.coerce = coerce;
+    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: (v) => {
+          enableOverride = v;
+        }
+      });
+      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 = [];
+      let i;
+      const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+      const len = split.length;
+      for (i = 0;i < len; i++) {
+        if (!split[i]) {
+          continue;
+        }
+        namespaces = split[i].replace(/\*/g, ".*?");
+        if (namespaces[0] === "-") {
+          createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
+        } else {
+          createDebug.names.push(new RegExp("^" + namespaces + "$"));
+        }
+      }
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug.names.map(toNamespace),
+        ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug.enable("");
+      return namespaces;
+    }
+    function enabled(name) {
+      if (name[name.length - 1] === "*") {
+        return true;
+      }
+      let i;
+      let len;
+      for (i = 0, len = createDebug.skips.length;i < len; i++) {
+        if (createDebug.skips[i].test(name)) {
+          return false;
+        }
+      }
+      for (i = 0, len = createDebug.names.length;i < len; i++) {
+        if (createDebug.names[i].test(name)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function toNamespace(regexp) {
+      return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
+    }
+    function coerce(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;
+});
+
+// bine_modules/commander/lib/sugges
+var require_browser = __commonJS((exports, module) => {
+  var useColors = function() {
+    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;
+    }
+    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 && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+  };
+  var formatArgs = function(args) {
+    args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + exports.humanize(this.diff);
+    if (!this.useColors) {
+      return;
+    }
+    const c = "color: " + this.color;
+    args.splice(1, 0, c, "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, c);
+  };
+  var save = function(namespaces) {
+    try {
+      if (namespaces) {
+        exports.storage.setItem("debug", namespaces);
+      } else {
+        exports.storage.removeItem("debug");
+      }
+    } catch (error) {
+    }
+  };
+  var load = function() {
+    let r;
+    try {
+      r = exports.storage.getItem("debug");
+    } catch (error) {
+    }
+    if (!r && typeof process !== "undefined" && ("env" in process)) {
+      r = process.env.DEBUG;
+    }
+    return r;
+  };
+  var localstorage = function() {
+    try {
+      return localStorage;
+    } catch (error) {
+    }
+  };
+  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"
+  ];
+  exports.log = console.debug || console.log || (() => {
+  });
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.j = function(v) {
+    try {
+      return JSON.stringify(v);
+    } catch (error) {
+      return "[UnexpectedJSONParseError]: " + error.message;
+    }
+  };
+});
+
+// /home/jim/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);
+  };
+});
+
+// /home/jim/node_modules/supports-color/index.js
+var require_supports_color = __commonJS((exports, module) => {
+  var translateLevel = function(level) {
+    if (level === 0) {
+      return false;
+    }
+    return {
+      level,
+      hasBasic: true,
+      has256: level >= 2,
+      has16m: level >= 3
+    };
+  };
+  var supportsColor = function(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;
+  };
+  var getSupportLevel = function(stream) {
+    const level = supportsColor(stream, stream && stream.isTTY);
+    return translateLevel(level);
+  };
+  var os = import.meta.require("os");
+  var tty = import.meta.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);
+    }
+  }
+  module.exports = {
+    supportsColor: getSupportLevel,
+    stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+    stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+  };
+});
+
+// bine_modules/commander/lib/sug
+var require_node = __commonJS((exports, module) => {
+  var useColors = function() {
+    return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+  };
+  var formatArgs = function(args) {
+    const { namespace: name, useColors: useColors2 } = this;
+    if (useColors2) {
+      const c = this.color;
+      const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+      const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+      args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+      args.push(colorCode + "m+" + exports.humanize(this.diff) + "\x1B[0m");
+    } else {
+      args[0] = getDate() + name + " " + args[0];
+    }
+  };
+  var getDate = function() {
+    if (exports.inspectOpts.hideDate) {
+      return "";
+    }
+    return new Date().toISOString() + " ";
+  };
+  var log = function(...args) {
+    return process.stderr.write(util.format(...args) + "\n");
+  };
+  var save = function(namespaces) {
+    if (namespaces) {
+      process.env.DEBUG = namespaces;
+    } else {
+      delete process.env.DEBUG;
+    }
+  };
+  var load = function() {
+    return process.env.DEBUG;
+  };
+  var init = function(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]];
+    }
+  };
+  var tty = import.meta.require("tty");
+  var util = import.meta.require("util");
+  exports.init = init;
+  exports.log = log;
+  exports.formatArgs = formatArgs;
+  exports.save = save;
+  exports.load = load;
+  exports.useColors = useColors;
+  exports.destroy = util.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, (_, k) => {
+      return k.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;
+  }, {});
+  module.exports = require_common()(exports);
+  var { formatters } = module.exports;
+  formatters.o = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+  };
+  formatters.O = function(v) {
+    this.inspectOpts.colors = this.useColors;
+    return util.inspect(v, this.inspectOpts);
+  };
+});
+
+// bine_modules/commander/lib/sugg
+var require_src = __commonJS((exports, module) => {
+  if (typeof process === "undefined" || process.type === "renderer" || false || process.__nwjs) {
+    module.exports = require_browser();
+  } else {
+    module.exports = require_node();
+  }
+});
+
+// bine_modules/commander/lib/sug
 var import_ = __toESM(require_commander(), 1);
 var {
   program,
@@ -1799,7 +2520,36 @@ var {
   Help
 } = import_.default;
 
-// lib/spawn.ts
+// bine_modules/c
+import path from "path";
+import fs from "fs";
+function findPackageJson() {
+  const cwd = import.meta.dir;
+  let dir = cwd;
+  while (dir !== "/") {
+    const packageJson = path.join(dir, "package.json");
+    if (fs.existsSync(packageJson)) {
+      return packageJson;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+async function getPackageJson() {
+  const packagePath = findPackageJson();
+  if (!packagePath) {
+    throw new Error(`No package.json found in ${import.meta.dir} or any parent directory`);
+  }
+  const packageJsonText = fs.readFileSync(packagePath, "utf8");
+  return JSON.parse(packageJsonText);
+}
+async function getPackageVersion() {
+  const packageJson = await packageJsonPromise;
+  return packageJson.version;
+}
+var packageJsonPromise = getPackageJson();
+
+// bine_modules
 async function spawn(args, options = defaultOptions) {
   const proc = Bun.spawn(args, { stdout: "pipe", stderr: "pipe" });
   const stdout = new Response(proc.stdout);
@@ -1824,7 +2574,7 @@ var defaultOptions = {
   expectQuiet: false
 };
 
-// lib/git.ts
+// bine_modul
 async function getConfig(key) {
   return doCommand(["git", "config", "--get", key]);
 }
@@ -1838,25 +2588,44 @@ async function getRemote() {
   return doCommand(["git", "ls-remote", "--get-url", "origin"]);
 }
 
-// lib/gitlab.ts
-import path from "path";
+// bine_modules/command
 async function getGitlabConfig() {
-  const host = await getConfig("gitlab.host");
+  const host = await hostP;
   if (!host)
     throw new Error("gitlab.host not in git config");
-  const user = await getConfig("user.email");
+  const user = await userP;
   if (!user)
     throw new Error("user.email not in git config");
-  const token = await getConfig("gitlab.token");
+  const token = await tokenP;
   if (!token)
     throw new Error("gitlab.token not in git config");
   return { host, user, token };
 }
-async function get(endpoint) {
+var hostP = getConfig("gitlab.host");
+var userP = getConfig("user.email");
+var tokenP = getConfig("gitlab.token");
+
+// bine_modules/comm
+var getNextLink = function(link) {
+  if (!link) {
+    return;
+  }
+  const regex = /<([^>]+)>; rel="next"/;
+  const match = link.match(regex);
+  const next = match ? match[1] : undefined;
+  return next;
+};
+async function gitlabApi(endpoint) {
+  if (endpoint.startsWith("/")) {
+    console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`);
+    endpoint = endpoint.slice(1);
+  }
   const method = "GET";
   const { host, token } = await getGitlabConfig();
   const base = `https://${host}/api/v4`;
-  const uri = `${base}/${endpoint}`;
+  const requested = 100;
+  const sep = endpoint.includes("?") ? "&" : "?";
+  const uri = `${base}/${endpoint}${sep}per_page=${requested}`;
   const headers = new Headers;
   headers.append("Accept", "application/json");
   headers.append("Private-Token", token);
@@ -1864,51 +2633,265 @@ async function get(endpoint) {
     method,
     headers
   };
-  const request = new Request(uri, options);
+  let request = new Request(uri, options);
   const response = await fetch(request);
-  return await response.json();
+  let link = getNextLink(response.headers.get("Link"));
+  let partial = await response.json();
+  let result = partial;
+  while (partial.length == requested && link) {
+    let request2 = new Request(link, options);
+    const next_response = await fetch(request2);
+    link = getNextLink(next_response.headers.get("Link"));
+    partial = await next_response.json();
+    result = result.concat(partial);
+  }
+  return result;
 }
-async function whoami() {
-  return await get("/user");
+// bine_modules/comman
+async function getGroups() {
+  return await gitlabApi(`groups`);
 }
-async function getProjects(paths) {
+// bine_modules/commande
+import path2 from "path";
+
+// bine_modules/comma
+var import_debug = __toESM(require_src(), 1);
+var dlog = import_debug.default("gitlab");
+
+// bine_modules/commande
+async function getProjects(match) {
   let search = "";
-  if (paths.length > 0) {
-    search = "&search=" + paths.join(",");
+  if (match) {
+    const m = encodeURIComponent(match);
+    search = `&search=${m}`;
   }
-  return await get(`/projects?visibility=private&membership=true&simple=true${search}`);
+  const projects = await gitlabApi(`projects?membership=true&simple=true${search}`);
+  if (!projects) {
+    throw new Error(`No projects!`);
+  } else if (!Array.isArray(projects)) {
+    console.log(projects);
+    throw new Error(`Projects is not an array!`);
+  }
+  const projs = projects;
+  const filtered = projs.filter((p) => {
+    return p.path_with_namespace.toLowerCase().includes(match.toLowerCase());
+  });
+  return filtered;
 }
 async function findProject(ssh_url) {
   const parts = ssh_url.split(":");
   if (parts.length != 2) {
     throw new Error(`${ssh_url} is invalid, could not be split into two parts at :`);
   }
-  const name = path.basename(parts[1], ".git");
-  const projects = await getProjects([name]);
+  const name = path2.basename(parts[1], ".git");
+  const projects = await getProjects(name);
   const project = projects.find((p) => {
     return p.ssh_url_to_repo === ssh_url;
   });
+  return project;
+}
+async function projectScopedGet(endpoint) {
+  if (endpoint.startsWith("/")) {
+    console.warn(`gitlabApi: endpoint ${endpoint} starts with /, removing it`);
+    endpoint = endpoint.slice(1);
+  }
+  const method = "GET";
+  const { host, token } = await getGitlabConfig();
+  const remote = await getRemote();
+  const project = await findProject(remote);
   if (!project) {
-    throw new Error(`No project with ssh_url_to_repo ${ssh_url} found`);
+    throw new Error(`Could not find project for remote ${remote}`);
   }
-  return project;
+  const base = `https://${host}/api/v4/projects/${project.id}`;
+  const uri = `${base}/${endpoint}`;
+  dlog(`projectScopedGet uri: ${uri}`);
+  const headers = new Headers;
+  headers.append("Accept", "application/json");
+  headers.append("Private-Token", token);
+  const options = {
+    method,
+    headers
+  };
+  const request = new Request(uri, options);
+  const response = await fetch(request);
+  return await response.json();
 }
-async function getMergeRequest(id) {
-  return await get(`/merge_requests/${id}`);
+
+// bine_modules/comma
+async function whoami() {
+  return await gitlabApi("user");
 }
 
-// lib/is_main.ts
-import path2 from "path";
+// bine_modules/commander/lib/
+async function getMergeRequest(id) {
+  return await projectScopedGet(`merge_requests/${id}`);
+}
+async function getMyMergeRequestsInProgress() {
+  const me = await whoami();
+  return await gitlabApi(`merge_requests?state=opened&author_id=${me.id}`);
+}
+async function getMyMergeRequestsToReview() {
+  const me = await whoami();
+  return await gitlabApi(`merge_requests?state=opened&reviewer_id=${me.id}`);
+}
+// bine_modules/commander/
+async function getNamespaces() {
+  return await gitlabApi(`namespaces`);
+}
+// bine_modules/commander
+async function getProjectPipelines(options) {
+  const { days, status } = options;
+  const me = await whoami();
+  const username = me.username;
+  const date = new Date;
+  const pastDate = date.getDate() - days;
+  date.setDate(pastDate);
+  const updated = date.toISOString();
+  dlog(`updated: ${updated}`);
+  return await projectScopedGet(`pipelines?status=${status}&username=${username}&updated_after=${updated}`);
+}
+// bine_modules/c
+import path3 from "path";
+var justBase = function(filename) {
+  const ext = path3.extname(filename);
+  const base = path3.basename(filename, ext);
+  return base;
+};
 function isMain(self) {
-  const exe = path2.basename(Bun.argv[1]).split(".")[0];
-  return exe == self || import.meta.main;
+  const arg1 = Bun.argv[1];
+  const argv1Base = justBase(arg1);
+  const selfBase = justBase(self);
+  const result = argv1Base === selfBase;
+  return result;
 }
 
-// bin/git-lab-projects.ts
+// bine_modules/commander/lib/
 function create() {
   const program2 = new Command;
-  program2.name("projects").description("List projects for current user").option("-v, --verbose", "Verbose output").argument("[path...]", "Namespace paths to filter by").action(async (paths, options) => {
-    const projects = await getProjects(paths);
+  program2.version(version).name("active").description("List my MRs in progress").option("-v, --verbose", "Verbose output").action(async (options) => {
+    const merges = await getMyMergeRequestsInProgress();
+    if (!merges) {
+      console.error(`No MRs!`);
+      process.exit(1);
+    }
+    if (options.verbose) {
+      console.log(merges);
+      process.exit(0);
+    } else {
+      const filtered = merges.map((m) => {
+        const { title, web_url, source_branch, target_branch } = m;
+        return { title, web_url, source_branch, target_branch };
+      });
+      console.log(filtered);
+    }
+  });
+  return program2;
+}
+var version = await getPackageVersion();
+var git_lab_merge_active_default = create;
+if (isMain("git-lab-merge-active")) {
+  await create().parseAsync(Bun.argv);
+}
+
+// bine_modules/commander/li
+function create2() {
+  const program2 = new Command;
+  program2.version(version2).name("todo").description("MRs needing my review").option("-v, --verbose", "Verbose output").action(async (options) => {
+    const mrs = await getMyMergeRequestsToReview();
+    if (options.verbose) {
+      console.log(mrs);
+    } else {
+      const filtered = mrs.map((mr) => {
+        const { title, web_url, source_branch, target_branch } = mr;
+        return { title, web_url, source_branch, target_branch };
+      });
+      console.log(filtered);
+    }
+  });
+  return program2;
+}
+var version2 = await getPackageVersion();
+var git_lab_merge_todo_default = create2;
+if (isMain("git-lab-merge-todo")) {
+  await create2().parseAsync(Bun.argv);
+}
+
+// bine_modules/commander/lib
+async function getMergeTrains() {
+  return await projectScopedGet(`merge_trains`);
+}
+
+// bine_modules/commander/lib/sugg
+function create3() {
+  const program2 = new Command;
+  program2.version(version3).name("list").description("List merge trains for the current project").action(async () => {
+    const trains = await getMergeTrains();
+    console.log(trains);
+  });
+  return program2;
+}
+var version3 = await getPackageVersion();
+var git_lab_merge_train_list_default = create3;
+if (isMain("git-lab-merge-train-list")) {
+  await create3().parseAsync(Bun.argv);
+}
+
+// bine_modules/commander/lib
+function create4() {
+  const program2 = new Command;
+  program2.version(version4).name("train").description("Commands for working with GitLab merge trains.").addCommand(git_lab_merge_train_list_default()).action(() => program2.help());
+  return program2;
+}
+var version4 = await getPackageVersion();
+var git_lab_merge_train_default = create4;
+if (isMain("git-lab-merge-train")) {
+  await create4().parseAsync(Bun.argv);
+}
+
+// bine_modules/command
+function create5() {
+  const program2 = new Command;
+  program2.version(version5).name("merge").description("Commands for working with GitLab merge requests").addCommand(git_lab_merge_active_default()).addCommand(git_lab_merge_todo_default()).addCommand(git_lab_merge_train_default()).action(() => program2.help());
+  return program2;
+}
+var version5 = await getPackageVersion();
+var git_lab_merge_default = create5;
+if (isMain("git-lab-merge")) {
+  await create5().parseAsync(Bun.argv);
+}
+
+// bine_modules/commander/lib/su
+function create6() {
+  const program2 = new Command;
+  program2.version(version6).name("list").description("List namespaces for the current user").action(async () => {
+    const namespaces = await getNamespaces();
+    console.log(namespaces);
+  });
+  return program2;
+}
+var version6 = await getPackageVersion();
+var git_lab_namespace_list_default = create6;
+if (isMain("git-lab-namespace-list")) {
+  await create6().parseAsync(Bun.argv);
+}
+
+// bine_modules/commander/l
+function create7() {
+  const program2 = new Command;
+  program2.version(version7).name("namespace").description("Commands for working with GitLab namespaces").addCommand(git_lab_namespace_list_default()).action(() => program2.help());
+  return program2;
+}
+var version7 = await getPackageVersion();
+var git_lab_namespace_default = create7;
+if (isMain("git-lab-namespace")) {
+  await create7().parseAsync(Bun.argv);
+}
+
+// bine_modules/commander/lib/
+function create8() {
+  const program2 = new Command;
+  program2.version(version8).name("list").description("List projects for current user").option("-v, --verbose", "Verbose output").option("-m, --match <match>", "Match projects with paths containing <match>").action(async (options) => {
+    const projects = await getProjects(options.match);
     if (!projects) {
       console.error(`No projects!`);
       process.exit(1);
@@ -1925,45 +2908,127 @@ function create() {
   });
   return program2;
 }
-if (isMain("git-lab-projects")) {
-  await create().parseAsync(Bun.argv);
+var version8 = await getPackageVersion();
+var git_lab_project_list_default = create8;
+if (isMain("git-lab-project-list")) {
+  await create8().parseAsync(Bun.argv);
 }
-var git_lab_projects_default = create;
 
-// bin/git-lab-whoami.ts
-function create2() {
+// bine_modules/commander/lib/sugg
+function create9() {
+  const program2 = new Command;
+  program2.version(version9).name("whereami").description("Show current project based on current directory").option("-v, --verbose", "Verbose output").action(async (options) => {
+    const ssh_url = await getRemote();
+    if (!ssh_url) {
+      console.error(`No remote!`);
+      process.exit(1);
+    }
+    console.log(`Remote: ${ssh_url}`);
+    const project7 = await findProject(ssh_url);
+    if (!project7) {
+      console.error(`No project!`);
+      process.exit(1);
+    }
+    if (options.verbose) {
+      console.log(project7);
+    } else {
+      const { id, name, path_with_namespace, ssh_url_to_repo } = project7;
+      console.log({ id, name, path_with_namespace, ssh_url_to_repo });
+    }
+  });
+  return program2;
+}
+var version9 = await getPackageVersion();
+var git_lab_project_whereami_default = create9;
+if (isMain("git-lab-project-whereami")) {
+  await create9().parseAsync(Bun.argv);
+}
+
+// bine_modules/commander
+function create10() {
+  const program2 = new Command;
+  program2.version(version10).name("projects").description("Commands for working with GitLab projects").addCommand(git_lab_project_list_default()).addCommand(git_lab_project_whereami_default()).action(() => {
+    program2.help();
+  });
+  return program2;
+}
+var version10 = await getPackageVersion();
+var git_lab_project_default = create10;
+if (isMain("git-lab-project")) {
+  await create10().parseAsync(Bun.argv);
+}
+
+// bine_modules/commander/li
+function create11() {
   const program2 = new Command;
-  program2.name("whoami").description("get GitLab user information for current user").option("-v, --verbose", "Verbose output").action(async (options) => {
-    const user = await whoami();
-    if (!user) {
+  program2.version(version11).name("list").description("List groups for the current user").option("-v, --verbose", "Verbose output").action(async (options) => {
+    const groups = await getGroups();
+    if (options.verbose)
+      console.log(groups);
+    else {
+      const filtered = groups.map((g) => {
+        const { id, name, full_path } = g;
+        return { id, name, full_path };
+      });
+      console.log(filtered);
+    }
+  });
+  return program2;
+}
+var version11 = await getPackageVersion();
+var git_lab_group_list_default = create11;
+if (isMain("git-lab-group-list")) {
+  await create11().parseAsync(Bun.argv);
+}
+
+// bine_modules/command
+function create12() {
+  const program2 = new Command;
+  program2.version(version12).name("group").description("Commands for working with GitLab groups").addCommand(git_lab_group_list_default()).action(() => program2.help());
+  return program2;
+}
+var version12 = await getPackageVersion();
+var git_lab_group_default = create12;
+if (isMain("git-lab-group")) {
+  await create12().parseAsync(Bun.argv);
+}
+
+// bine_modules/commande
+function create13() {
+  const program2 = new Command;
+  program2.version(version13).name("whoami").description("get GitLab user information for current user").option("-v, --verbose", "Verbose output").action(async (options) => {
+    const user5 = await whoami();
+    if (!user5) {
       console.error(`No user!`);
       process.exit(1);
     }
     if (options.verbose) {
-      console.log(user);
+      console.log(user5);
       process.exit(0);
     } else {
-      console.log(user.username);
+      console.log(user5.username);
     }
   });
   return program2;
 }
+var version13 = await getPackageVersion();
+var git_lab_whoami_default = create13;
 if (isMain("git-lab-whoami")) {
-  await create2().parseAsync(Bun.argv);
+  await create13().parseAsync(Bun.argv);
 }
-var git_lab_whoami_default = create2;
 
-// bin/git-lab.ts
-function create3() {
+// bine_modules/c
+function create14() {
   const program2 = new Command;
-  program2.name("lab").description("A set of commands for working with GitLab").addCommand(git_lab_whoami_default()).addCommand(git_lab_projects_default());
+  program2.version(version14).name("lab").description("Commands for working with GitLab").addCommand(git_lab_group_default()).addCommand(git_lab_merge_default()).addCommand(git_lab_namespace_default()).addCommand(git_lab_project_default()).addCommand(git_lab_whoami_default()).action(() => program2.help());
   return program2;
 }
-if (isMain("git-jira")) {
-  await create3().parseAsync(Bun.argv);
+var version14 = await getPackageVersion();
+var git_lab_default = create14;
+if (isMain("git-lab")) {
+  await create14().parseAsync(Bun.argv);
 }
-var git_lab_default = create3;
 export {
   git_lab_default as default,
-  create3 as create
+  create14 as create
 };