@hasna/connectors 1.3.31 → 1.3.33

package/connectors/connect-googlephotos/bin/index.js

@@ -1,4911 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = import.meta.require;
-
-// ../../node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
-  class CommanderError extends Error {
-    constructor(exitCode, code, message) {
-      super(message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-      this.code = code;
-      this.exitCode = exitCode;
-      this.nestedError = undefined;
-    }
-  }
-
-  class InvalidArgumentError extends CommanderError {
-    constructor(message) {
-      super(1, "commander.invalidArgument", message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-    }
-  }
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-});
-
-// ../../node_modules/commander/lib/argument.js
-var require_argument = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Argument {
-    constructor(name, description) {
-      this.description = description || "";
-      this.variadic = false;
-      this.parseArg = undefined;
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.argChoices = undefined;
-      switch (name[0]) {
-        case "<":
-          this.required = true;
-          this._name = name.slice(1, -1);
-          break;
-        case "[":
-          this.required = false;
-          this._name = name.slice(1, -1);
-          break;
-        default:
-          this.required = true;
-          this._name = name;
-          break;
-      }
-      if (this._name.length > 3 && this._name.slice(-3) === "...") {
-        this.variadic = true;
-        this._name = this._name.slice(0, -3);
-      }
-    }
-    name() {
-      return this._name;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    argRequired() {
-      this.required = true;
-      return this;
-    }
-    argOptional() {
-      this.required = false;
-      return this;
-    }
-  }
-  function humanReadableArgName(arg) {
-    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
-  }
-  exports.Argument = Argument;
-  exports.humanReadableArgName = humanReadableArgName;
-});
-
-// ../../node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument();
-
-  class Help {
-    constructor() {
-      this.helpWidth = undefined;
-      this.sortSubcommands = false;
-      this.sortOptions = false;
-      this.showGlobalOptions = false;
-    }
-    visibleCommands(cmd) {
-      const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-      const helpCommand = cmd._getHelpCommand();
-      if (helpCommand && !helpCommand._hidden) {
-        visibleCommands.push(helpCommand);
-      }
-      if (this.sortSubcommands) {
-        visibleCommands.sort((a, b) => {
-          return a.name().localeCompare(b.name());
-        });
-      }
-      return visibleCommands;
-    }
-    compareOptions(a, b) {
-      const getSortKey = (option) => {
-        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-      };
-      return getSortKey(a).localeCompare(getSortKey(b));
-    }
-    visibleOptions(cmd) {
-      const visibleOptions = cmd.options.filter((option) => !option.hidden);
-      const helpOption = cmd._getHelpOption();
-      if (helpOption && !helpOption.hidden) {
-        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
-        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
-        if (!removeShort && !removeLong) {
-          visibleOptions.push(helpOption);
-        } else if (helpOption.long && !removeLong) {
-          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
-        } else if (helpOption.short && !removeShort) {
-          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
-        }
-      }
-      if (this.sortOptions) {
-        visibleOptions.sort(this.compareOptions);
-      }
-      return visibleOptions;
-    }
-    visibleGlobalOptions(cmd) {
-      if (!this.showGlobalOptions)
-        return [];
-      const globalOptions = [];
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
-        globalOptions.push(...visibleOptions);
-      }
-      if (this.sortOptions) {
-        globalOptions.sort(this.compareOptions);
-      }
-      return globalOptions;
-    }
-    visibleArguments(cmd) {
-      if (cmd._argsDescription) {
-        cmd.registeredArguments.forEach((argument) => {
-          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
-        });
-      }
-      if (cmd.registeredArguments.find((argument) => argument.description)) {
-        return cmd.registeredArguments;
-      }
-      return [];
-    }
-    subcommandTerm(cmd) {
-      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
-      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
-    }
-    optionTerm(option) {
-      return option.flags;
-    }
-    argumentTerm(argument) {
-      return argument.name();
-    }
-    longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, helper.subcommandTerm(command).length);
-      }, 0);
-    }
-    longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
-      }, 0);
-    }
-    longestGlobalOptionTermLength(cmd, helper) {
-      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, helper.optionTerm(option).length);
-      }, 0);
-    }
-    longestArgumentTermLength(cmd, helper) {
-      return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, helper.argumentTerm(argument).length);
-      }, 0);
-    }
-    commandUsage(cmd) {
-      let cmdName = cmd._name;
-      if (cmd._aliases[0]) {
-        cmdName = cmdName + "|" + cmd._aliases[0];
-      }
-      let ancestorCmdNames = "";
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
-      }
-      return ancestorCmdNames + cmdName + " " + cmd.usage();
-    }
-    commandDescription(cmd) {
-      return cmd.description();
-    }
-    subcommandDescription(cmd) {
-      return cmd.summary() || cmd.description();
-    }
-    optionDescription(option) {
-      const extraInfo = [];
-      if (option.argChoices) {
-        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (option.defaultValue !== undefined) {
-        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
-        if (showDefault) {
-          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
-        }
-      }
-      if (option.presetArg !== undefined && option.optional) {
-        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
-      }
-      if (option.envVar !== undefined) {
-        extraInfo.push(`env: ${option.envVar}`);
-      }
-      if (extraInfo.length > 0) {
-        return `${option.description} (${extraInfo.join(", ")})`;
-      }
-      return option.description;
-    }
-    argumentDescription(argument) {
-      const extraInfo = [];
-      if (argument.argChoices) {
-        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (argument.defaultValue !== undefined) {
-        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
-      }
-      if (extraInfo.length > 0) {
-        const extraDescripton = `(${extraInfo.join(", ")})`;
-        if (argument.description) {
-          return `${argument.description} ${extraDescripton}`;
-        }
-        return extraDescripton;
-      }
-      return argument.description;
-    }
-    formatHelp(cmd, helper) {
-      const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth || 80;
-      const itemIndentWidth = 2;
-      const itemSeparatorWidth = 2;
-      function formatItem(term, description) {
-        if (description) {
-          const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
-          return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
-        }
-        return term;
-      }
-      function formatList(textArray) {
-        return textArray.join(`
-`).replace(/^/gm, " ".repeat(itemIndentWidth));
-      }
-      let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
-      const commandDescription = helper.commandDescription(cmd);
-      if (commandDescription.length > 0) {
-        output = output.concat([
-          helper.wrap(commandDescription, helpWidth, 0),
-          ""
-        ]);
-      }
-      const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
-      });
-      if (argumentList.length > 0) {
-        output = output.concat(["Arguments:", formatList(argumentList), ""]);
-      }
-      const optionList = helper.visibleOptions(cmd).map((option) => {
-        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
-      });
-      if (optionList.length > 0) {
-        output = output.concat(["Options:", formatList(optionList), ""]);
-      }
-      if (this.showGlobalOptions) {
-        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
-        });
-        if (globalOptionList.length > 0) {
-          output = output.concat([
-            "Global Options:",
-            formatList(globalOptionList),
-            ""
-          ]);
-        }
-      }
-      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
-      });
-      if (commandList.length > 0) {
-        output = output.concat(["Commands:", formatList(commandList), ""]);
-      }
-      return output.join(`
-`);
-    }
-    padWidth(cmd, helper) {
-      return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
-    }
-    wrap(str, width, indent, minColumnWidth = 40) {
-      const indents = " \\f\\t\\v\xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF";
-      const manualIndent = new RegExp(`[\\n][${indents}]+`);
-      if (str.match(manualIndent))
-        return str;
-      const columnWidth = width - indent;
-      if (columnWidth < minColumnWidth)
-        return str;
-      const leadingStr = str.slice(0, indent);
-      const columnText = str.slice(indent).replace(`\r
-`, `
-`);
-      const indentString = " ".repeat(indent);
-      const zeroWidthSpace = "\u200B";
-      const breaks = `\\s${zeroWidthSpace}`;
-      const regex = new RegExp(`
-|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
-      const lines = columnText.match(regex) || [];
-      return leadingStr + lines.map((line, i) => {
-        if (line === `
-`)
-          return "";
-        return (i > 0 ? indentString : "") + line.trimEnd();
-      }).join(`
-`);
-    }
-  }
-  exports.Help = Help;
-});
-
-// ../../node_modules/commander/lib/option.js
-var require_option = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Option {
-    constructor(flags, description) {
-      this.flags = flags;
-      this.description = description || "";
-      this.required = flags.includes("<");
-      this.optional = flags.includes("[");
-      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
-      this.mandatory = false;
-      const optionFlags = splitOptionFlags(flags);
-      this.short = optionFlags.shortFlag;
-      this.long = optionFlags.longFlag;
-      this.negate = false;
-      if (this.long) {
-        this.negate = this.long.startsWith("--no-");
-      }
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.presetArg = undefined;
-      this.envVar = undefined;
-      this.parseArg = undefined;
-      this.hidden = false;
-      this.argChoices = undefined;
-      this.conflictsWith = [];
-      this.implied = undefined;
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    preset(arg) {
-      this.presetArg = arg;
-      return this;
-    }
-    conflicts(names) {
-      this.conflictsWith = this.conflictsWith.concat(names);
-      return this;
-    }
-    implies(impliedOptionValues) {
-      let newImplied = impliedOptionValues;
-      if (typeof impliedOptionValues === "string") {
-        newImplied = { [impliedOptionValues]: true };
-      }
-      this.implied = Object.assign(this.implied || {}, newImplied);
-      return this;
-    }
-    env(name) {
-      this.envVar = name;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    makeOptionMandatory(mandatory = true) {
-      this.mandatory = !!mandatory;
-      return this;
-    }
-    hideHelp(hide = true) {
-      this.hidden = !!hide;
-      return this;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    name() {
-      if (this.long) {
-        return this.long.replace(/^--/, "");
-      }
-      return this.short.replace(/^-/, "");
-    }
-    attributeName() {
-      return camelcase(this.name().replace(/^no-/, ""));
-    }
-    is(arg) {
-      return this.short === arg || this.long === arg;
-    }
-    isBoolean() {
-      return !this.required && !this.optional && !this.negate;
-    }
-  }
-
-  class DualOptions {
-    constructor(options) {
-      this.positiveOptions = new Map;
-      this.negativeOptions = new Map;
-      this.dualOptions = new Set;
-      options.forEach((option) => {
-        if (option.negate) {
-          this.negativeOptions.set(option.attributeName(), option);
-        } else {
-          this.positiveOptions.set(option.attributeName(), option);
-        }
-      });
-      this.negativeOptions.forEach((value, key) => {
-        if (this.positiveOptions.has(key)) {
-          this.dualOptions.add(key);
-        }
-      });
-    }
-    valueFromOption(value, option) {
-      const optionKey = option.attributeName();
-      if (!this.dualOptions.has(optionKey))
-        return true;
-      const preset = this.negativeOptions.get(optionKey).presetArg;
-      const negativeValue = preset !== undefined ? preset : false;
-      return option.negate === (negativeValue === value);
-    }
-  }
-  function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
-    });
-  }
-  function splitOptionFlags(flags) {
-    let shortFlag;
-    let longFlag;
-    const flagParts = flags.split(/[ |,]+/);
-    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
-      shortFlag = flagParts.shift();
-    longFlag = flagParts.shift();
-    if (!shortFlag && /^-[^-]$/.test(longFlag)) {
-      shortFlag = longFlag;
-      longFlag = undefined;
-    }
-    return { shortFlag, longFlag };
-  }
-  exports.Option = Option;
-  exports.DualOptions = DualOptions;
-});
-
-// ../../node_modules/commander/lib/suggestSimilar.js
-var require_suggestSimilar = __commonJS((exports) => {
-  var maxDistance = 3;
-  function editDistance(a, b) {
-    if (Math.abs(a.length - b.length) > maxDistance)
-      return Math.max(a.length, b.length);
-    const d = [];
-    for (let i = 0;i <= a.length; i++) {
-      d[i] = [i];
-    }
-    for (let j = 0;j <= b.length; j++) {
-      d[0][j] = j;
-    }
-    for (let j = 1;j <= b.length; j++) {
-      for (let i = 1;i <= a.length; i++) {
-        let cost = 1;
-        if (a[i - 1] === b[j - 1]) {
-          cost = 0;
-        } else {
-          cost = 1;
-        }
-        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-          d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
-        }
-      }
-    }
-    return d[a.length][b.length];
-  }
-  function suggestSimilar(word, candidates) {
-    if (!candidates || candidates.length === 0)
-      return "";
-    candidates = Array.from(new Set(candidates));
-    const searchingOptions = word.startsWith("--");
-    if (searchingOptions) {
-      word = word.slice(2);
-      candidates = candidates.map((candidate) => candidate.slice(2));
-    }
-    let similar = [];
-    let bestDistance = maxDistance;
-    const minSimilarity = 0.4;
-    candidates.forEach((candidate) => {
-      if (candidate.length <= 1)
-        return;
-      const distance = editDistance(word, candidate);
-      const length = Math.max(word.length, candidate.length);
-      const similarity = (length - distance) / length;
-      if (similarity > minSimilarity) {
-        if (distance < bestDistance) {
-          bestDistance = distance;
-          similar = [candidate];
-        } else if (distance === bestDistance) {
-          similar.push(candidate);
-        }
-      }
-    });
-    similar.sort((a, b) => a.localeCompare(b));
-    if (searchingOptions) {
-      similar = similar.map((candidate) => `--${candidate}`);
-    }
-    if (similar.length > 1) {
-      return `
-(Did you mean one of ${similar.join(", ")}?)`;
-    }
-    if (similar.length === 1) {
-      return `
-(Did you mean ${similar[0]}?)`;
-    }
-    return "";
-  }
-  exports.suggestSimilar = suggestSimilar;
-});
-
-// ../../node_modules/commander/lib/command.js
-var require_command = __commonJS((exports) => {
-  var EventEmitter = __require("events").EventEmitter;
-  var childProcess = __require("child_process");
-  var path = __require("path");
-  var fs = __require("fs");
-  var process2 = __require("process");
-  var { Argument, humanReadableArgName } = require_argument();
-  var { CommanderError } = require_error();
-  var { Help } = require_help();
-  var { Option, DualOptions } = require_option();
-  var { suggestSimilar } = require_suggestSimilar();
-
-  class Command extends EventEmitter {
-    constructor(name) {
-      super();
-      this.commands = [];
-      this.options = [];
-      this.parent = null;
-      this._allowUnknownOption = false;
-      this._allowExcessArguments = true;
-      this.registeredArguments = [];
-      this._args = this.registeredArguments;
-      this.args = [];
-      this.rawArgs = [];
-      this.processedArgs = [];
-      this._scriptPath = null;
-      this._name = name || "";
-      this._optionValues = {};
-      this._optionValueSources = {};
-      this._storeOptionsAsProperties = false;
-      this._actionHandler = null;
-      this._executableHandler = false;
-      this._executableFile = null;
-      this._executableDir = null;
-      this._defaultCommandName = null;
-      this._exitCallback = null;
-      this._aliases = [];
-      this._combineFlagAndOptionalValue = true;
-      this._description = "";
-      this._summary = "";
-      this._argsDescription = undefined;
-      this._enablePositionalOptions = false;
-      this._passThroughOptions = false;
-      this._lifeCycleHooks = {};
-      this._showHelpAfterError = false;
-      this._showSuggestionAfterError = true;
-      this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
-        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-        outputError: (str, write) => write(str)
-      };
-      this._hidden = false;
-      this._helpOption = undefined;
-      this._addImplicitHelpCommand = undefined;
-      this._helpCommand = undefined;
-      this._helpConfiguration = {};
-    }
-    copyInheritedSettings(sourceCommand) {
-      this._outputConfiguration = sourceCommand._outputConfiguration;
-      this._helpOption = sourceCommand._helpOption;
-      this._helpCommand = sourceCommand._helpCommand;
-      this._helpConfiguration = sourceCommand._helpConfiguration;
-      this._exitCallback = sourceCommand._exitCallback;
-      this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
-      this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
-      this._allowExcessArguments = sourceCommand._allowExcessArguments;
-      this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
-      this._showHelpAfterError = sourceCommand._showHelpAfterError;
-      this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
-      return this;
-    }
-    _getCommandAndAncestors() {
-      const result = [];
-      for (let command = this;command; command = command.parent) {
-        result.push(command);
-      }
-      return result;
-    }
-    command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
-      let desc = actionOptsOrExecDesc;
-      let opts = execOpts;
-      if (typeof desc === "object" && desc !== null) {
-        opts = desc;
-        desc = null;
-      }
-      opts = opts || {};
-      const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
-      const cmd = this.createCommand(name);
-      if (desc) {
-        cmd.description(desc);
-        cmd._executableHandler = true;
-      }
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      cmd._hidden = !!(opts.noHelp || opts.hidden);
-      cmd._executableFile = opts.executableFile || null;
-      if (args)
-        cmd.arguments(args);
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd.copyInheritedSettings(this);
-      if (desc)
-        return this;
-      return cmd;
-    }
-    createCommand(name) {
-      return new Command(name);
-    }
-    createHelp() {
-      return Object.assign(new Help, this.configureHelp());
-    }
-    configureHelp(configuration) {
-      if (configuration === undefined)
-        return this._helpConfiguration;
-      this._helpConfiguration = configuration;
-      return this;
-    }
-    configureOutput(configuration) {
-      if (configuration === undefined)
-        return this._outputConfiguration;
-      Object.assign(this._outputConfiguration, configuration);
-      return this;
-    }
-    showHelpAfterError(displayHelp = true) {
-      if (typeof displayHelp !== "string")
-        displayHelp = !!displayHelp;
-      this._showHelpAfterError = displayHelp;
-      return this;
-    }
-    showSuggestionAfterError(displaySuggestion = true) {
-      this._showSuggestionAfterError = !!displaySuggestion;
-      return this;
-    }
-    addCommand(cmd, opts) {
-      if (!cmd._name) {
-        throw new Error(`Command passed to .addCommand() must have a name
-- specify the name in Command constructor or using .name()`);
-      }
-      opts = opts || {};
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      if (opts.noHelp || opts.hidden)
-        cmd._hidden = true;
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd._checkForBrokenPassThrough();
-      return this;
-    }
-    createArgument(name, description) {
-      return new Argument(name, description);
-    }
-    argument(name, description, fn, defaultValue) {
-      const argument = this.createArgument(name, description);
-      if (typeof fn === "function") {
-        argument.default(defaultValue).argParser(fn);
-      } else {
-        argument.default(fn);
-      }
-      this.addArgument(argument);
-      return this;
-    }
-    arguments(names) {
-      names.trim().split(/ +/).forEach((detail) => {
-        this.argument(detail);
-      });
-      return this;
-    }
-    addArgument(argument) {
-      const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument && previousArgument.variadic) {
-        throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
-      }
-      if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
-        throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
-      }
-      this.registeredArguments.push(argument);
-      return this;
-    }
-    helpCommand(enableOrNameAndArgs, description) {
-      if (typeof enableOrNameAndArgs === "boolean") {
-        this._addImplicitHelpCommand = enableOrNameAndArgs;
-        return this;
-      }
-      enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
-      const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
-      const helpDescription = description ?? "display help for command";
-      const helpCommand = this.createCommand(helpName);
-      helpCommand.helpOption(false);
-      if (helpArgs)
-        helpCommand.arguments(helpArgs);
-      if (helpDescription)
-        helpCommand.description(helpDescription);
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
-      return this;
-    }
-    addHelpCommand(helpCommand, deprecatedDescription) {
-      if (typeof helpCommand !== "object") {
-        this.helpCommand(helpCommand, deprecatedDescription);
-        return this;
-      }
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
-      return this;
-    }
-    _getHelpCommand() {
-      const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
-      if (hasImplicitHelpCommand) {
-        if (this._helpCommand === undefined) {
-          this.helpCommand(undefined, undefined);
-        }
-        return this._helpCommand;
-      }
-      return null;
-    }
-    hook(event, listener) {
-      const allowedValues = ["preSubcommand", "preAction", "postAction"];
-      if (!allowedValues.includes(event)) {
-        throw new Error(`Unexpected value for event passed to hook : '${event}'.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      if (this._lifeCycleHooks[event]) {
-        this._lifeCycleHooks[event].push(listener);
-      } else {
-        this._lifeCycleHooks[event] = [listener];
-      }
-      return this;
-    }
-    exitOverride(fn) {
-      if (fn) {
-        this._exitCallback = fn;
-      } else {
-        this._exitCallback = (err) => {
-          if (err.code !== "commander.executeSubCommandAsync") {
-            throw err;
-          } else {}
-        };
-      }
-      return this;
-    }
-    _exit(exitCode, code, message) {
-      if (this._exitCallback) {
-        this._exitCallback(new CommanderError(exitCode, code, message));
-      }
-      process2.exit(exitCode);
-    }
-    action(fn) {
-      const listener = (args) => {
-        const expectedArgsCount = this.registeredArguments.length;
-        const actionArgs = args.slice(0, expectedArgsCount);
-        if (this._storeOptionsAsProperties) {
-          actionArgs[expectedArgsCount] = this;
-        } else {
-          actionArgs[expectedArgsCount] = this.opts();
-        }
-        actionArgs.push(this);
-        return fn.apply(this, actionArgs);
-      };
-      this._actionHandler = listener;
-      return this;
-    }
-    createOption(flags, description) {
-      return new Option(flags, description);
-    }
-    _callParseArg(target, value, previous, invalidArgumentMessage) {
-      try {
-        return target.parseArg(value, previous);
-      } catch (err) {
-        if (err.code === "commander.invalidArgument") {
-          const message = `${invalidArgumentMessage} ${err.message}`;
-          this.error(message, { exitCode: err.exitCode, code: err.code });
-        }
-        throw err;
-      }
-    }
-    _registerOption(option) {
-      const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
-      if (matchingOption) {
-        const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
-        throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
--  already used by option '${matchingOption.flags}'`);
-      }
-      this.options.push(option);
-    }
-    _registerCommand(command) {
-      const knownBy = (cmd) => {
-        return [cmd.name()].concat(cmd.aliases());
-      };
-      const alreadyUsed = knownBy(command).find((name) => this._findCommand(name));
-      if (alreadyUsed) {
-        const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
-        const newCmd = knownBy(command).join("|");
-        throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
-      }
-      this.commands.push(command);
-    }
-    addOption(option) {
-      this._registerOption(option);
-      const oname = option.name();
-      const name = option.attributeName();
-      if (option.negate) {
-        const positiveLongFlag = option.long.replace(/^--no-/, "--");
-        if (!this._findOption(positiveLongFlag)) {
-          this.setOptionValueWithSource(name, option.defaultValue === undefined ? true : option.defaultValue, "default");
-        }
-      } else if (option.defaultValue !== undefined) {
-        this.setOptionValueWithSource(name, option.defaultValue, "default");
-      }
-      const handleOptionValue = (val, invalidValueMessage, valueSource) => {
-        if (val == null && option.presetArg !== undefined) {
-          val = option.presetArg;
-        }
-        const oldValue = this.getOptionValue(name);
-        if (val !== null && option.parseArg) {
-          val = this._callParseArg(option, val, oldValue, invalidValueMessage);
-        } else if (val !== null && option.variadic) {
-          val = option._concatValue(val, oldValue);
-        }
-        if (val == null) {
-          if (option.negate) {
-            val = false;
-          } else if (option.isBoolean() || option.optional) {
-            val = true;
-          } else {
-            val = "";
-          }
-        }
-        this.setOptionValueWithSource(name, val, valueSource);
-      };
-      this.on("option:" + oname, (val) => {
-        const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
-        handleOptionValue(val, invalidValueMessage, "cli");
-      });
-      if (option.envVar) {
-        this.on("optionEnv:" + oname, (val) => {
-          const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
-          handleOptionValue(val, invalidValueMessage, "env");
-        });
-      }
-      return this;
-    }
-    _optionEx(config, flags, description, fn, defaultValue) {
-      if (typeof flags === "object" && flags instanceof Option) {
-        throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
-      }
-      const option = this.createOption(flags, description);
-      option.makeOptionMandatory(!!config.mandatory);
-      if (typeof fn === "function") {
-        option.default(defaultValue).argParser(fn);
-      } else if (fn instanceof RegExp) {
-        const regex = fn;
-        fn = (val, def) => {
-          const m = regex.exec(val);
-          return m ? m[0] : def;
-        };
-        option.default(defaultValue).argParser(fn);
-      } else {
-        option.default(fn);
-      }
-      return this.addOption(option);
-    }
-    option(flags, description, parseArg, defaultValue) {
-      return this._optionEx({}, flags, description, parseArg, defaultValue);
-    }
-    requiredOption(flags, description, parseArg, defaultValue) {
-      return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
-    }
-    combineFlagAndOptionalValue(combine = true) {
-      this._combineFlagAndOptionalValue = !!combine;
-      return this;
-    }
-    allowUnknownOption(allowUnknown = true) {
-      this._allowUnknownOption = !!allowUnknown;
-      return this;
-    }
-    allowExcessArguments(allowExcess = true) {
-      this._allowExcessArguments = !!allowExcess;
-      return this;
-    }
-    enablePositionalOptions(positional = true) {
-      this._enablePositionalOptions = !!positional;
-      return this;
-    }
-    passThroughOptions(passThrough = true) {
-      this._passThroughOptions = !!passThrough;
-      this._checkForBrokenPassThrough();
-      return this;
-    }
-    _checkForBrokenPassThrough() {
-      if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
-        throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
-      }
-    }
-    storeOptionsAsProperties(storeAsProperties = true) {
-      if (this.options.length) {
-        throw new Error("call .storeOptionsAsProperties() before adding options");
-      }
-      if (Object.keys(this._optionValues).length) {
-        throw new Error("call .storeOptionsAsProperties() before setting option values");
-      }
-      this._storeOptionsAsProperties = !!storeAsProperties;
-      return this;
-    }
-    getOptionValue(key) {
-      if (this._storeOptionsAsProperties) {
-        return this[key];
-      }
-      return this._optionValues[key];
-    }
-    setOptionValue(key, value) {
-      return this.setOptionValueWithSource(key, value, undefined);
-    }
-    setOptionValueWithSource(key, value, source) {
-      if (this._storeOptionsAsProperties) {
-        this[key] = value;
-      } else {
-        this._optionValues[key] = value;
-      }
-      this._optionValueSources[key] = source;
-      return this;
-    }
-    getOptionValueSource(key) {
-      return this._optionValueSources[key];
-    }
-    getOptionValueSourceWithGlobals(key) {
-      let source;
-      this._getCommandAndAncestors().forEach((cmd) => {
-        if (cmd.getOptionValueSource(key) !== undefined) {
-          source = cmd.getOptionValueSource(key);
-        }
-      });
-      return source;
-    }
-    _prepareUserArgs(argv, parseOptions) {
-      if (argv !== undefined && !Array.isArray(argv)) {
-        throw new Error("first parameter to parse must be array or undefined");
-      }
-      parseOptions = parseOptions || {};
-      if (argv === undefined && parseOptions.from === undefined) {
-        if (process2.versions?.electron) {
-          parseOptions.from = "electron";
-        }
-        const execArgv = process2.execArgv ?? [];
-        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
-          parseOptions.from = "eval";
-        }
-      }
-      if (argv === undefined) {
-        argv = process2.argv;
-      }
-      this.rawArgs = argv.slice();
-      let userArgs;
-      switch (parseOptions.from) {
-        case undefined:
-        case "node":
-          this._scriptPath = argv[1];
-          userArgs = argv.slice(2);
-          break;
-        case "electron":
-          if (process2.defaultApp) {
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
-          } else {
-            userArgs = argv.slice(1);
-          }
-          break;
-        case "user":
-          userArgs = argv.slice(0);
-          break;
-        case "eval":
-          userArgs = argv.slice(1);
-          break;
-        default:
-          throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
-      }
-      if (!this._name && this._scriptPath)
-        this.nameFromFilename(this._scriptPath);
-      this._name = this._name || "program";
-      return userArgs;
-    }
-    parse(argv, parseOptions) {
-      const userArgs = this._prepareUserArgs(argv, parseOptions);
-      this._parseCommand([], userArgs);
-      return this;
-    }
-    async parseAsync(argv, parseOptions) {
-      const userArgs = this._prepareUserArgs(argv, parseOptions);
-      await this._parseCommand([], userArgs);
-      return this;
-    }
-    _executeSubCommand(subcommand, args) {
-      args = args.slice();
-      let launchWithNode = false;
-      const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
-      function findFile(baseDir, baseName) {
-        const localBin = path.resolve(baseDir, baseName);
-        if (fs.existsSync(localBin))
-          return localBin;
-        if (sourceExt.includes(path.extname(baseName)))
-          return;
-        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
-        if (foundExt)
-          return `${localBin}${foundExt}`;
-        return;
-      }
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
-      let executableDir = this._executableDir || "";
-      if (this._scriptPath) {
-        let resolvedScriptPath;
-        try {
-          resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch (err) {
-          resolvedScriptPath = this._scriptPath;
-        }
-        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
-      }
-      if (executableDir) {
-        let localFile = findFile(executableDir, executableFile);
-        if (!localFile && !subcommand._executableFile && this._scriptPath) {
-          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
-          if (legacyName !== this._name) {
-            localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
-          }
-        }
-        executableFile = localFile || executableFile;
-      }
-      launchWithNode = sourceExt.includes(path.extname(executableFile));
-      let proc;
-      if (process2.platform !== "win32") {
-        if (launchWithNode) {
-          args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
-        } else {
-          proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
-        }
-      } else {
-        args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
-      }
-      if (!proc.killed) {
-        const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
-        signals.forEach((signal) => {
-          process2.on(signal, () => {
-            if (proc.killed === false && proc.exitCode === null) {
-              proc.kill(signal);
-            }
-          });
-        });
-      }
-      const exitCallback = this._exitCallback;
-      proc.on("close", (code) => {
-        code = code ?? 1;
-        if (!exitCallback) {
-          process2.exit(code);
-        } else {
-          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
-        }
-      });
-      proc.on("error", (err) => {
-        if (err.code === "ENOENT") {
-          const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-          const executableMissing = `'${executableFile}' does not exist
- - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-          throw new Error(executableMissing);
-        } else if (err.code === "EACCES") {
-          throw new Error(`'${executableFile}' not executable`);
-        }
-        if (!exitCallback) {
-          process2.exit(1);
-        } else {
-          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
-          wrappedError.nestedError = err;
-          exitCallback(wrappedError);
-        }
-      });
-      this.runningCommand = proc;
-    }
-    _dispatchSubcommand(commandName, operands, unknown) {
-      const subCommand = this._findCommand(commandName);
-      if (!subCommand)
-        this.help({ error: true });
-      let promiseChain;
-      promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
-      promiseChain = this._chainOrCall(promiseChain, () => {
-        if (subCommand._executableHandler) {
-          this._executeSubCommand(subCommand, operands.concat(unknown));
-        } else {
-          return subCommand._parseCommand(operands, unknown);
-        }
-      });
-      return promiseChain;
-    }
-    _dispatchHelpCommand(subcommandName) {
-      if (!subcommandName) {
-        this.help();
-      }
-      const subCommand = this._findCommand(subcommandName);
-      if (subCommand && !subCommand._executableHandler) {
-        subCommand.help();
-      }
-      return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
-    }
-    _checkNumberOfArguments() {
-      this.registeredArguments.forEach((arg, i) => {
-        if (arg.required && this.args[i] == null) {
-          this.missingArgument(arg.name());
-        }
-      });
-      if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
-        return;
-      }
-      if (this.args.length > this.registeredArguments.length) {
-        this._excessArguments(this.args);
-      }
-    }
-    _processArguments() {
-      const myParseArg = (argument, value, previous) => {
-        let parsedValue = value;
-        if (value !== null && argument.parseArg) {
-          const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
-          parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
-        }
-        return parsedValue;
-      };
-      this._checkNumberOfArguments();
-      const processedArgs = [];
-      this.registeredArguments.forEach((declaredArg, index) => {
-        let value = declaredArg.defaultValue;
-        if (declaredArg.variadic) {
-          if (index < this.args.length) {
-            value = this.args.slice(index);
-            if (declaredArg.parseArg) {
-              value = value.reduce((processed, v) => {
-                return myParseArg(declaredArg, v, processed);
-              }, declaredArg.defaultValue);
-            }
-          } else if (value === undefined) {
-            value = [];
-          }
-        } else if (index < this.args.length) {
-          value = this.args[index];
-          if (declaredArg.parseArg) {
-            value = myParseArg(declaredArg, value, declaredArg.defaultValue);
-          }
-        }
-        processedArgs[index] = value;
-      });
-      this.processedArgs = processedArgs;
-    }
-    _chainOrCall(promise, fn) {
-      if (promise && promise.then && typeof promise.then === "function") {
-        return promise.then(() => fn());
-      }
-      return fn();
-    }
-    _chainOrCallHooks(promise, event) {
-      let result = promise;
-      const hooks = [];
-      this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== undefined).forEach((hookedCommand) => {
-        hookedCommand._lifeCycleHooks[event].forEach((callback) => {
-          hooks.push({ hookedCommand, callback });
-        });
-      });
-      if (event === "postAction") {
-        hooks.reverse();
-      }
-      hooks.forEach((hookDetail) => {
-        result = this._chainOrCall(result, () => {
-          return hookDetail.callback(hookDetail.hookedCommand, this);
-        });
-      });
-      return result;
-    }
-    _chainOrCallSubCommandHook(promise, subCommand, event) {
-      let result = promise;
-      if (this._lifeCycleHooks[event] !== undefined) {
-        this._lifeCycleHooks[event].forEach((hook) => {
-          result = this._chainOrCall(result, () => {
-            return hook(this, subCommand);
-          });
-        });
-      }
-      return result;
-    }
-    _parseCommand(operands, unknown) {
-      const parsed = this.parseOptions(unknown);
-      this._parseOptionsEnv();
-      this._parseOptionsImplied();
-      operands = operands.concat(parsed.operands);
-      unknown = parsed.unknown;
-      this.args = operands.concat(unknown);
-      if (operands && this._findCommand(operands[0])) {
-        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
-      }
-      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
-        return this._dispatchHelpCommand(operands[1]);
-      }
-      if (this._defaultCommandName) {
-        this._outputHelpIfRequested(unknown);
-        return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
-      }
-      if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
-        this.help({ error: true });
-      }
-      this._outputHelpIfRequested(parsed.unknown);
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      const checkForUnknownOptions = () => {
-        if (parsed.unknown.length > 0) {
-          this.unknownOption(parsed.unknown[0]);
-        }
-      };
-      const commandEvent = `command:${this.name()}`;
-      if (this._actionHandler) {
-        checkForUnknownOptions();
-        this._processArguments();
-        let promiseChain;
-        promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
-        promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
-        if (this.parent) {
-          promiseChain = this._chainOrCall(promiseChain, () => {
-            this.parent.emit(commandEvent, operands, unknown);
-          });
-        }
-        promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
-        return promiseChain;
-      }
-      if (this.parent && this.parent.listenerCount(commandEvent)) {
-        checkForUnknownOptions();
-        this._processArguments();
-        this.parent.emit(commandEvent, operands, unknown);
-      } else if (operands.length) {
-        if (this._findCommand("*")) {
-          return this._dispatchSubcommand("*", operands, unknown);
-        }
-        if (this.listenerCount("command:*")) {
-          this.emit("command:*", operands, unknown);
-        } else if (this.commands.length) {
-          this.unknownCommand();
-        } else {
-          checkForUnknownOptions();
-          this._processArguments();
-        }
-      } else if (this.commands.length) {
-        checkForUnknownOptions();
-        this.help({ error: true });
-      } else {
-        checkForUnknownOptions();
-        this._processArguments();
-      }
-    }
-    _findCommand(name) {
-      if (!name)
-        return;
-      return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
-    }
-    _findOption(arg) {
-      return this.options.find((option) => option.is(arg));
-    }
-    _checkForMissingMandatoryOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd.options.forEach((anOption) => {
-          if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === undefined) {
-            cmd.missingMandatoryOptionValue(anOption);
-          }
-        });
-      });
-    }
-    _checkForConflictingLocalOptions() {
-      const definedNonDefaultOptions = this.options.filter((option) => {
-        const optionKey = option.attributeName();
-        if (this.getOptionValue(optionKey) === undefined) {
-          return false;
-        }
-        return this.getOptionValueSource(optionKey) !== "default";
-      });
-      const optionsWithConflicting = definedNonDefaultOptions.filter((option) => option.conflictsWith.length > 0);
-      optionsWithConflicting.forEach((option) => {
-        const conflictingAndDefined = definedNonDefaultOptions.find((defined) => option.conflictsWith.includes(defined.attributeName()));
-        if (conflictingAndDefined) {
-          this._conflictingOption(option, conflictingAndDefined);
-        }
-      });
-    }
-    _checkForConflictingOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd._checkForConflictingLocalOptions();
-      });
-    }
-    parseOptions(argv) {
-      const operands = [];
-      const unknown = [];
-      let dest = operands;
-      const args = argv.slice();
-      function maybeOption(arg) {
-        return arg.length > 1 && arg[0] === "-";
-      }
-      let activeVariadicOption = null;
-      while (args.length) {
-        const arg = args.shift();
-        if (arg === "--") {
-          if (dest === unknown)
-            dest.push(arg);
-          dest.push(...args);
-          break;
-        }
-        if (activeVariadicOption && !maybeOption(arg)) {
-          this.emit(`option:${activeVariadicOption.name()}`, arg);
-          continue;
-        }
-        activeVariadicOption = null;
-        if (maybeOption(arg)) {
-          const option = this._findOption(arg);
-          if (option) {
-            if (option.required) {
-              const value = args.shift();
-              if (value === undefined)
-                this.optionMissingArgument(option);
-              this.emit(`option:${option.name()}`, value);
-            } else if (option.optional) {
-              let value = null;
-              if (args.length > 0 && !maybeOption(args[0])) {
-                value = args.shift();
-              }
-              this.emit(`option:${option.name()}`, value);
-            } else {
-              this.emit(`option:${option.name()}`);
-            }
-            activeVariadicOption = option.variadic ? option : null;
-            continue;
-          }
-        }
-        if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
-          const option = this._findOption(`-${arg[1]}`);
-          if (option) {
-            if (option.required || option.optional && this._combineFlagAndOptionalValue) {
-              this.emit(`option:${option.name()}`, arg.slice(2));
-            } else {
-              this.emit(`option:${option.name()}`);
-              args.unshift(`-${arg.slice(2)}`);
-            }
-            continue;
-          }
-        }
-        if (/^--[^=]+=/.test(arg)) {
-          const index = arg.indexOf("=");
-          const option = this._findOption(arg.slice(0, index));
-          if (option && (option.required || option.optional)) {
-            this.emit(`option:${option.name()}`, arg.slice(index + 1));
-            continue;
-          }
-        }
-        if (maybeOption(arg)) {
-          dest = unknown;
-        }
-        if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
-          if (this._findCommand(arg)) {
-            operands.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
-            break;
-          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg);
-            if (args.length > 0)
-              operands.push(...args);
-            break;
-          } else if (this._defaultCommandName) {
-            unknown.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
-            break;
-          }
-        }
-        if (this._passThroughOptions) {
-          dest.push(arg);
-          if (args.length > 0)
-            dest.push(...args);
-          break;
-        }
-        dest.push(arg);
-      }
-      return { operands, unknown };
-    }
-    opts() {
-      if (this._storeOptionsAsProperties) {
-        const result = {};
-        const len = this.options.length;
-        for (let i = 0;i < len; i++) {
-          const key = this.options[i].attributeName();
-          result[key] = key === this._versionOptionName ? this._version : this[key];
-        }
-        return result;
-      }
-      return this._optionValues;
-    }
-    optsWithGlobals() {
-      return this._getCommandAndAncestors().reduce((combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()), {});
-    }
-    error(message, errorOptions) {
-      this._outputConfiguration.outputError(`${message}
-`, this._outputConfiguration.writeErr);
-      if (typeof this._showHelpAfterError === "string") {
-        this._outputConfiguration.writeErr(`${this._showHelpAfterError}
-`);
-      } else if (this._showHelpAfterError) {
-        this._outputConfiguration.writeErr(`
-`);
-        this.outputHelp({ error: true });
-      }
-      const config = errorOptions || {};
-      const exitCode = config.exitCode || 1;
-      const code = config.code || "commander.error";
-      this._exit(exitCode, code, message);
-    }
-    _parseOptionsEnv() {
-      this.options.forEach((option) => {
-        if (option.envVar && option.envVar in process2.env) {
-          const optionKey = option.attributeName();
-          if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
-            if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
-            } else {
-              this.emit(`optionEnv:${option.name()}`);
-            }
-          }
-        }
-      });
-    }
-    _parseOptionsImplied() {
-      const dualHelper = new DualOptions(this.options);
-      const hasCustomOptionValue = (optionKey) => {
-        return this.getOptionValue(optionKey) !== undefined && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
-      };
-      this.options.filter((option) => option.implied !== undefined && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option) => {
-        Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
-          this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], "implied");
-        });
-      });
-    }
-    missingArgument(name) {
-      const message = `error: missing required argument '${name}'`;
-      this.error(message, { code: "commander.missingArgument" });
-    }
-    optionMissingArgument(option) {
-      const message = `error: option '${option.flags}' argument missing`;
-      this.error(message, { code: "commander.optionMissingArgument" });
-    }
-    missingMandatoryOptionValue(option) {
-      const message = `error: required option '${option.flags}' not specified`;
-      this.error(message, { code: "commander.missingMandatoryOptionValue" });
-    }
-    _conflictingOption(option, conflictingOption) {
-      const findBestOptionFromValue = (option2) => {
-        const optionKey = option2.attributeName();
-        const optionValue = this.getOptionValue(optionKey);
-        const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
-        const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
-        if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
-          return negativeOption;
-        }
-        return positiveOption || option2;
-      };
-      const getErrorMessage = (option2) => {
-        const bestOption = findBestOptionFromValue(option2);
-        const optionKey = bestOption.attributeName();
-        const source = this.getOptionValueSource(optionKey);
-        if (source === "env") {
-          return `environment variable '${bestOption.envVar}'`;
-        }
-        return `option '${bestOption.flags}'`;
-      };
-      const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
-      this.error(message, { code: "commander.conflictingOption" });
-    }
-    unknownOption(flag) {
-      if (this._allowUnknownOption)
-        return;
-      let suggestion = "";
-      if (flag.startsWith("--") && this._showSuggestionAfterError) {
-        let candidateFlags = [];
-        let command = this;
-        do {
-          const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
-          candidateFlags = candidateFlags.concat(moreFlags);
-          command = command.parent;
-        } while (command && !command._enablePositionalOptions);
-        suggestion = suggestSimilar(flag, candidateFlags);
-      }
-      const message = `error: unknown option '${flag}'${suggestion}`;
-      this.error(message, { code: "commander.unknownOption" });
-    }
-    _excessArguments(receivedArgs) {
-      if (this._allowExcessArguments)
-        return;
-      const expected = this.registeredArguments.length;
-      const s = expected === 1 ? "" : "s";
-      const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
-      const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
-      this.error(message, { code: "commander.excessArguments" });
-    }
-    unknownCommand() {
-      const unknownName = this.args[0];
-      let suggestion = "";
-      if (this._showSuggestionAfterError) {
-        const candidateNames = [];
-        this.createHelp().visibleCommands(this).forEach((command) => {
-          candidateNames.push(command.name());
-          if (command.alias())
-            candidateNames.push(command.alias());
-        });
-        suggestion = suggestSimilar(unknownName, candidateNames);
-      }
-      const message = `error: unknown command '${unknownName}'${suggestion}`;
-      this.error(message, { code: "commander.unknownCommand" });
-    }
-    version(str, flags, description) {
-      if (str === undefined)
-        return this._version;
-      this._version = str;
-      flags = flags || "-V, --version";
-      description = description || "output the version number";
-      const versionOption = this.createOption(flags, description);
-      this._versionOptionName = versionOption.attributeName();
-      this._registerOption(versionOption);
-      this.on("option:" + versionOption.name(), () => {
-        this._outputConfiguration.writeOut(`${str}
-`);
-        this._exit(0, "commander.version", str);
-      });
-      return this;
-    }
-    description(str, argsDescription) {
-      if (str === undefined && argsDescription === undefined)
-        return this._description;
-      this._description = str;
-      if (argsDescription) {
-        this._argsDescription = argsDescription;
-      }
-      return this;
-    }
-    summary(str) {
-      if (str === undefined)
-        return this._summary;
-      this._summary = str;
-      return this;
-    }
-    alias(alias) {
-      if (alias === undefined)
-        return this._aliases[0];
-      let command = this;
-      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-        command = this.commands[this.commands.length - 1];
-      }
-      if (alias === command._name)
-        throw new Error("Command alias can't be the same as its name");
-      const matchingCommand = this.parent?._findCommand(alias);
-      if (matchingCommand) {
-        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
-        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
-      }
-      command._aliases.push(alias);
-      return this;
-    }
-    aliases(aliases) {
-      if (aliases === undefined)
-        return this._aliases;
-      aliases.forEach((alias) => this.alias(alias));
-      return this;
-    }
-    usage(str) {
-      if (str === undefined) {
-        if (this._usage)
-          return this._usage;
-        const args = this.registeredArguments.map((arg) => {
-          return humanReadableArgName(arg);
-        });
-        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
-      }
-      this._usage = str;
-      return this;
-    }
-    name(str) {
-      if (str === undefined)
-        return this._name;
-      this._name = str;
-      return this;
-    }
-    nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
-      return this;
-    }
-    executableDir(path2) {
-      if (path2 === undefined)
-        return this._executableDir;
-      this._executableDir = path2;
-      return this;
-    }
-    helpInformation(contextOptions) {
-      const helper = this.createHelp();
-      if (helper.helpWidth === undefined) {
-        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
-      }
-      return helper.formatHelp(this, helper);
-    }
-    _getHelpContext(contextOptions) {
-      contextOptions = contextOptions || {};
-      const context = { error: !!contextOptions.error };
-      let write;
-      if (context.error) {
-        write = (arg) => this._outputConfiguration.writeErr(arg);
-      } else {
-        write = (arg) => this._outputConfiguration.writeOut(arg);
-      }
-      context.write = contextOptions.write || write;
-      context.command = this;
-      return context;
-    }
-    outputHelp(contextOptions) {
-      let deprecatedCallback;
-      if (typeof contextOptions === "function") {
-        deprecatedCallback = contextOptions;
-        contextOptions = undefined;
-      }
-      const context = this._getHelpContext(contextOptions);
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
-      this.emit("beforeHelp", context);
-      let helpInformation = this.helpInformation(context);
-      if (deprecatedCallback) {
-        helpInformation = deprecatedCallback(helpInformation);
-        if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
-          throw new Error("outputHelp callback must return a string or a Buffer");
-        }
-      }
-      context.write(helpInformation);
-      if (this._getHelpOption()?.long) {
-        this.emit(this._getHelpOption().long);
-      }
-      this.emit("afterHelp", context);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
-    }
-    helpOption(flags, description) {
-      if (typeof flags === "boolean") {
-        if (flags) {
-          this._helpOption = this._helpOption ?? undefined;
-        } else {
-          this._helpOption = null;
-        }
-        return this;
-      }
-      flags = flags ?? "-h, --help";
-      description = description ?? "display help for command";
-      this._helpOption = this.createOption(flags, description);
-      return this;
-    }
-    _getHelpOption() {
-      if (this._helpOption === undefined) {
-        this.helpOption(undefined, undefined);
-      }
-      return this._helpOption;
-    }
-    addHelpOption(option) {
-      this._helpOption = option;
-      return this;
-    }
-    help(contextOptions) {
-      this.outputHelp(contextOptions);
-      let exitCode = process2.exitCode || 0;
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
-      }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
-    }
-    addHelpText(position, text) {
-      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
-      if (!allowedValues.includes(position)) {
-        throw new Error(`Unexpected value for position to addHelpText.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      const helpEvent = `${position}Help`;
-      this.on(helpEvent, (context) => {
-        let helpStr;
-        if (typeof text === "function") {
-          helpStr = text({ error: context.error, command: context.command });
-        } else {
-          helpStr = text;
-        }
-        if (helpStr) {
-          context.write(`${helpStr}
-`);
-        }
-      });
-      return this;
-    }
-    _outputHelpIfRequested(args) {
-      const helpOption = this._getHelpOption();
-      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
-      if (helpRequested) {
-        this.outputHelp();
-        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
-      }
-    }
-  }
-  function incrementNodeInspectorPort(args) {
-    return args.map((arg) => {
-      if (!arg.startsWith("--inspect")) {
-        return arg;
-      }
-      let debugOption;
-      let debugHost = "127.0.0.1";
-      let debugPort = "9229";
-      let match;
-      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
-        debugOption = match[1];
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-        debugOption = match[1];
-        if (/^\d+$/.test(match[3])) {
-          debugPort = match[3];
-        } else {
-          debugHost = match[3];
-        }
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-        debugOption = match[1];
-        debugHost = match[3];
-        debugPort = match[4];
-      }
-      if (debugOption && debugPort !== "0") {
-        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
-      }
-      return arg;
-    });
-  }
-  exports.Command = Command;
-});
-
-// ../../node_modules/commander/index.js
-var require_commander = __commonJS((exports) => {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  var { Help } = require_help();
-  var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
-  exports.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-});
-
-// ../../node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
-
-// ../../node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
-        }
-        if (code < 16) {
-          return 90 + (code - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
-    }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// ../../node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "process";
-import os from "os";
-import tty from "tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.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);
-}
-var { env } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-    return 1;
-  }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
-      return 3;
-    }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
-  }
-  if (env.TERM === "wezterm") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
-    }
-  }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// ../../node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
-// ../../node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-}
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === undefined) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === undefined) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
-// ../../node_modules/open/index.js
-import process9 from "process";
-import path from "path";
-import { fileURLToPath } from "url";
-import childProcess3 from "child_process";
-import fs5, { constants as fsConstants2 } from "fs/promises";
-
-// ../../node_modules/wsl-utils/index.js
-import { promisify as promisify2 } from "util";
-import childProcess2 from "child_process";
-import fs4, { constants as fsConstants } from "fs/promises";
-
-// ../../node_modules/is-wsl/index.js
-import process3 from "process";
-import os2 from "os";
-import fs3 from "fs";
-
-// ../../node_modules/is-inside-container/index.js
-import fs2 from "fs";
-
-// ../../node_modules/is-docker/index.js
-import fs from "fs";
-var isDockerCached;
-function hasDockerEnv() {
-  try {
-    fs.statSync("/.dockerenv");
-    return true;
-  } catch {
-    return false;
-  }
-}
-function hasDockerCGroup() {
-  try {
-    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
-  } catch {
-    return false;
-  }
-}
-function isDocker() {
-  if (isDockerCached === undefined) {
-    isDockerCached = hasDockerEnv() || hasDockerCGroup();
-  }
-  return isDockerCached;
-}
-
-// ../../node_modules/is-inside-container/index.js
-var cachedResult;
-var hasContainerEnv = () => {
-  try {
-    fs2.statSync("/run/.containerenv");
-    return true;
-  } catch {
-    return false;
-  }
-};
-function isInsideContainer() {
-  if (cachedResult === undefined) {
-    cachedResult = hasContainerEnv() || isDocker();
-  }
-  return cachedResult;
-}
-
-// ../../node_modules/is-wsl/index.js
-var isWsl = () => {
-  if (process3.platform !== "linux") {
-    return false;
-  }
-  if (os2.release().toLowerCase().includes("microsoft")) {
-    if (isInsideContainer()) {
-      return false;
-    }
-    return true;
-  }
-  try {
-    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
-      return !isInsideContainer();
-    }
-  } catch {}
-  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
-    return !isInsideContainer();
-  }
-  return false;
-};
-var is_wsl_default = process3.env.__IS_WSL_TEST__ ? isWsl : isWsl();
-
-// ../../node_modules/powershell-utils/index.js
-import process4 from "process";
-import { Buffer as Buffer2 } from "buffer";
-import { promisify } from "util";
-import childProcess from "child_process";
-var execFile = promisify(childProcess.execFile);
-var powerShellPath = () => `${process4.env.SYSTEMROOT || process4.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
-var executePowerShell = async (command, options = {}) => {
-  const {
-    powerShellPath: psPath,
-    ...execFileOptions
-  } = options;
-  const encodedCommand = executePowerShell.encodeCommand(command);
-  return execFile(psPath ?? powerShellPath(), [
-    ...executePowerShell.argumentsPrefix,
-    encodedCommand
-  ], {
-    encoding: "utf8",
-    ...execFileOptions
-  });
-};
-executePowerShell.argumentsPrefix = [
-  "-NoProfile",
-  "-NonInteractive",
-  "-ExecutionPolicy",
-  "Bypass",
-  "-EncodedCommand"
-];
-executePowerShell.encodeCommand = (command) => Buffer2.from(command, "utf16le").toString("base64");
-executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
-
-// ../../node_modules/wsl-utils/utilities.js
-function parseMountPointFromConfig(content) {
-  for (const line of content.split(`
-`)) {
-    if (/^\s*#/.test(line)) {
-      continue;
-    }
-    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
-    if (!match) {
-      continue;
-    }
-    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
-  }
-}
-
-// ../../node_modules/wsl-utils/index.js
-var execFile2 = promisify2(childProcess2.execFile);
-var wslDrivesMountPoint = (() => {
-  const defaultMountPoint = "/mnt/";
-  let mountPoint;
-  return async function() {
-    if (mountPoint) {
-      return mountPoint;
-    }
-    const configFilePath = "/etc/wsl.conf";
-    let isConfigFileExists = false;
-    try {
-      await fs4.access(configFilePath, fsConstants.F_OK);
-      isConfigFileExists = true;
-    } catch {}
-    if (!isConfigFileExists) {
-      return defaultMountPoint;
-    }
-    const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
-    const parsedMountPoint = parseMountPointFromConfig(configContent);
-    if (parsedMountPoint === undefined) {
-      return defaultMountPoint;
-    }
-    mountPoint = parsedMountPoint;
-    mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
-    return mountPoint;
-  };
-})();
-var powerShellPathFromWsl = async () => {
-  const mountPoint = await wslDrivesMountPoint();
-  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
-};
-var powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
-var canAccessPowerShellPromise;
-var canAccessPowerShell = async () => {
-  canAccessPowerShellPromise ??= (async () => {
-    try {
-      const psPath = await powerShellPath2();
-      await fs4.access(psPath, fsConstants.X_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  return canAccessPowerShellPromise;
-};
-var wslDefaultBrowser = async () => {
-  const psPath = await powerShellPath2();
-  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
-  const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
-  return stdout.trim();
-};
-var convertWslPathToWindows = async (path) => {
-  if (/^[a-z]+:\/\//i.test(path)) {
-    return path;
-  }
-  try {
-    const { stdout } = await execFile2("wslpath", ["-aw", path], { encoding: "utf8" });
-    return stdout.trim();
-  } catch {
-    return path;
-  }
-};
-
-// ../../node_modules/define-lazy-prop/index.js
-function defineLazyProperty(object, propertyName, valueGetter) {
-  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
-  Object.defineProperty(object, propertyName, {
-    configurable: true,
-    enumerable: true,
-    get() {
-      const result = valueGetter();
-      define(result);
-      return result;
-    },
-    set(value) {
-      define(value);
-    }
-  });
-  return object;
-}
-
-// ../../node_modules/default-browser/index.js
-import { promisify as promisify6 } from "util";
-import process7 from "process";
-import { execFile as execFile6 } from "child_process";
-
-// ../../node_modules/default-browser-id/index.js
-import { promisify as promisify3 } from "util";
-import process5 from "process";
-import { execFile as execFile3 } from "child_process";
-var execFileAsync = promisify3(execFile3);
-async function defaultBrowserId() {
-  if (process5.platform !== "darwin") {
-    throw new Error("macOS only");
-  }
-  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
-  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
-  const browserId = match?.groups.id ?? "com.apple.Safari";
-  if (browserId === "com.apple.safari") {
-    return "com.apple.Safari";
-  }
-  return browserId;
-}
-
-// ../../node_modules/run-applescript/index.js
-import process6 from "process";
-import { promisify as promisify4 } from "util";
-import { execFile as execFile4, execFileSync } from "child_process";
-var execFileAsync2 = promisify4(execFile4);
-async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
-  if (process6.platform !== "darwin") {
-    throw new Error("macOS only");
-  }
-  const outputArguments = humanReadableOutput ? [] : ["-ss"];
-  const execOptions = {};
-  if (signal) {
-    execOptions.signal = signal;
-  }
-  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
-  return stdout.trim();
-}
-
-// ../../node_modules/bundle-name/index.js
-async function bundleName(bundleId) {
-  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
-tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
-}
-
-// ../../node_modules/default-browser/windows.js
-import { promisify as promisify5 } from "util";
-import { execFile as execFile5 } from "child_process";
-var execFileAsync3 = promisify5(execFile5);
-var windowsBrowserProgIds = {
-  MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
-  MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
-  MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
-  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
-  ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
-  ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
-  ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
-  ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
-  BraveHTML: { name: "Brave", id: "com.brave.Browser" },
-  BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
-  BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
-  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
-  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
-  OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
-  VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
-  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
-};
-var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
-
-class UnknownBrowserError extends Error {
-}
-async function defaultBrowser(_execFileAsync = execFileAsync3) {
-  const { stdout } = await _execFileAsync("reg", [
-    "QUERY",
-    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
-    "/v",
-    "ProgId"
-  ]);
-  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
-  if (!match) {
-    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
-  }
-  const { id } = match.groups;
-  const dotIndex = id.lastIndexOf(".");
-  const hyphenIndex = id.lastIndexOf("-");
-  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
-  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
-  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
-}
-
-// ../../node_modules/default-browser/index.js
-var execFileAsync4 = promisify6(execFile6);
-var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
-async function defaultBrowser2() {
-  if (process7.platform === "darwin") {
-    const id = await defaultBrowserId();
-    const name = await bundleName(id);
-    return { name, id };
-  }
-  if (process7.platform === "linux") {
-    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
-    const id = stdout.trim();
-    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
-    return { name, id };
-  }
-  if (process7.platform === "win32") {
-    return defaultBrowser();
-  }
-  throw new Error("Only macOS, Linux, and Windows are supported");
-}
-
-// ../../node_modules/is-in-ssh/index.js
-import process8 from "process";
-var isInSsh = Boolean(process8.env.SSH_CONNECTION || process8.env.SSH_CLIENT || process8.env.SSH_TTY);
-var is_in_ssh_default = isInSsh;
-
-// ../../node_modules/open/index.js
-var fallbackAttemptSymbol = Symbol("fallbackAttempt");
-var __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
-var localXdgOpenPath = path.join(__dirname2, "xdg-open");
-var { platform, arch } = process9;
-var tryEachApp = async (apps, opener) => {
-  if (apps.length === 0) {
-    return;
-  }
-  const errors = [];
-  for (const app of apps) {
-    try {
-      return await opener(app);
-    } catch (error) {
-      errors.push(error);
-    }
-  }
-  throw new AggregateError(errors, "Failed to open in all supported apps");
-};
-var baseOpen = async (options) => {
-  options = {
-    wait: false,
-    background: false,
-    newInstance: false,
-    allowNonzeroExitCode: false,
-    ...options
-  };
-  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
-  delete options[fallbackAttemptSymbol];
-  if (Array.isArray(options.app)) {
-    return tryEachApp(options.app, (singleApp) => baseOpen({
-      ...options,
-      app: singleApp,
-      [fallbackAttemptSymbol]: true
-    }));
-  }
-  let { name: app, arguments: appArguments = [] } = options.app ?? {};
-  appArguments = [...appArguments];
-  if (Array.isArray(app)) {
-    return tryEachApp(app, (appName) => baseOpen({
-      ...options,
-      app: {
-        name: appName,
-        arguments: appArguments
-      },
-      [fallbackAttemptSymbol]: true
-    }));
-  }
-  if (app === "browser" || app === "browserPrivate") {
-    const ids = {
-      "com.google.chrome": "chrome",
-      "google-chrome.desktop": "chrome",
-      "com.brave.browser": "brave",
-      "org.mozilla.firefox": "firefox",
-      "firefox.desktop": "firefox",
-      "com.microsoft.msedge": "edge",
-      "com.microsoft.edge": "edge",
-      "com.microsoft.edgemac": "edge",
-      "microsoft-edge.desktop": "edge",
-      "com.apple.safari": "safari"
-    };
-    const flags = {
-      chrome: "--incognito",
-      brave: "--incognito",
-      firefox: "--private-window",
-      edge: "--inPrivate"
-    };
-    let browser;
-    if (is_wsl_default) {
-      const progId = await wslDefaultBrowser();
-      const browserInfo = _windowsBrowserProgIdMap.get(progId);
-      browser = browserInfo ?? {};
-    } else {
-      browser = await defaultBrowser2();
-    }
-    if (browser.id in ids) {
-      const browserName = ids[browser.id.toLowerCase()];
-      if (app === "browserPrivate") {
-        if (browserName === "safari") {
-          throw new Error("Safari doesn't support opening in private mode via command line");
-        }
-        appArguments.push(flags[browserName]);
-      }
-      return baseOpen({
-        ...options,
-        app: {
-          name: apps[browserName],
-          arguments: appArguments
-        }
-      });
-    }
-    throw new Error(`${browser.name} is not supported as a default browser`);
-  }
-  let command;
-  const cliArguments = [];
-  const childProcessOptions = {};
-  let shouldUseWindowsInWsl = false;
-  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
-    shouldUseWindowsInWsl = await canAccessPowerShell();
-  }
-  if (platform === "darwin") {
-    command = "open";
-    if (options.wait) {
-      cliArguments.push("--wait-apps");
-    }
-    if (options.background) {
-      cliArguments.push("--background");
-    }
-    if (options.newInstance) {
-      cliArguments.push("--new");
-    }
-    if (app) {
-      cliArguments.push("-a", app);
-    }
-  } else if (platform === "win32" || shouldUseWindowsInWsl) {
-    command = await powerShellPath2();
-    cliArguments.push(...executePowerShell.argumentsPrefix);
-    if (!is_wsl_default) {
-      childProcessOptions.windowsVerbatimArguments = true;
-    }
-    if (is_wsl_default && options.target) {
-      options.target = await convertWslPathToWindows(options.target);
-    }
-    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
-    if (options.wait) {
-      encodedArguments.push("-Wait");
-    }
-    if (app) {
-      encodedArguments.push(executePowerShell.escapeArgument(app));
-      if (options.target) {
-        appArguments.push(options.target);
-      }
-    } else if (options.target) {
-      encodedArguments.push(executePowerShell.escapeArgument(options.target));
-    }
-    if (appArguments.length > 0) {
-      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
-      encodedArguments.push("-ArgumentList", appArguments.join(","));
-    }
-    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
-    if (!options.wait) {
-      childProcessOptions.stdio = "ignore";
-    }
-  } else {
-    if (app) {
-      command = app;
-    } else {
-      const isBundled = !__dirname2 || __dirname2 === "/";
-      let exeLocalXdgOpen = false;
-      try {
-        await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
-        exeLocalXdgOpen = true;
-      } catch {}
-      const useSystemXdgOpen = process9.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
-      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
-    }
-    if (appArguments.length > 0) {
-      cliArguments.push(...appArguments);
-    }
-    if (!options.wait) {
-      childProcessOptions.stdio = "ignore";
-      childProcessOptions.detached = true;
-    }
-  }
-  if (platform === "darwin" && appArguments.length > 0) {
-    cliArguments.push("--args", ...appArguments);
-  }
-  if (options.target) {
-    cliArguments.push(options.target);
-  }
-  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
-  if (options.wait) {
-    return new Promise((resolve, reject) => {
-      subprocess.once("error", reject);
-      subprocess.once("close", (exitCode) => {
-        if (!options.allowNonzeroExitCode && exitCode !== 0) {
-          reject(new Error(`Exited with code ${exitCode}`));
-          return;
-        }
-        resolve(subprocess);
-      });
-    });
-  }
-  if (isFallbackAttempt) {
-    return new Promise((resolve, reject) => {
-      subprocess.once("error", reject);
-      subprocess.once("spawn", () => {
-        subprocess.once("close", (exitCode) => {
-          subprocess.off("error", reject);
-          if (exitCode !== 0) {
-            reject(new Error(`Exited with code ${exitCode}`));
-            return;
-          }
-          subprocess.unref();
-          resolve(subprocess);
-        });
-      });
-    });
-  }
-  subprocess.unref();
-  return new Promise((resolve, reject) => {
-    subprocess.once("error", reject);
-    subprocess.once("spawn", () => {
-      subprocess.off("error", reject);
-      resolve(subprocess);
-    });
-  });
-};
-var open = (target, options) => {
-  if (typeof target !== "string") {
-    throw new TypeError("Expected a `target`");
-  }
-  return baseOpen({
-    ...options,
-    target
-  });
-};
-function detectArchBinary(binary) {
-  if (typeof binary === "string" || Array.isArray(binary)) {
-    return binary;
-  }
-  const { [arch]: archBinary } = binary;
-  if (!archBinary) {
-    throw new Error(`${arch} is not supported`);
-  }
-  return archBinary;
-}
-function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
-  if (wsl && is_wsl_default) {
-    return detectArchBinary(wsl);
-  }
-  if (!platformBinary) {
-    throw new Error(`${platform} is not supported`);
-  }
-  return detectArchBinary(platformBinary);
-}
-var apps = {
-  browser: "browser",
-  browserPrivate: "browserPrivate"
-};
-defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
-  darwin: "google chrome",
-  win32: "chrome",
-  linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
-}, {
-  wsl: {
-    ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
-    x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
-  }
-}));
-defineLazyProperty(apps, "brave", () => detectPlatformBinary({
-  darwin: "brave browser",
-  win32: "brave",
-  linux: ["brave-browser", "brave"]
-}, {
-  wsl: {
-    ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
-    x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
-  }
-}));
-defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
-  darwin: "firefox",
-  win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
-  linux: "firefox"
-}, {
-  wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
-}));
-defineLazyProperty(apps, "edge", () => detectPlatformBinary({
-  darwin: "microsoft edge",
-  win32: "msedge",
-  linux: ["microsoft-edge", "microsoft-edge-dev"]
-}, {
-  wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
-}));
-defineLazyProperty(apps, "safari", () => detectPlatformBinary({
-  darwin: "Safari"
-}));
-var open_default = open;
-
-// src/cli/index.ts
-import { writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join2, basename as basename2 } from "path";
-
-// src/types/index.ts
-class PhotosApiError extends Error {
-  statusCode;
-  status;
-  details;
-  constructor(message, statusCode, status, details) {
-    super(message);
-    this.name = "PhotosApiError";
-    this.statusCode = statusCode;
-    this.status = status;
-    this.details = details;
-  }
-}
-
-// src/utils/auth.ts
-import { createServer } from "http";
-
-// src/utils/config.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync, renameSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var DEFAULT_PROFILE = "default";
-var CURRENT_PROFILE_FILE = "current_profile";
-var PROFILES_DIR = "profiles";
-var profileOverride;
-function resolveBaseConfigDir() {
-  return join(homedir(), ".hasna", "connectors", "connect-googlephotos");
-}
-var BASE_CONFIG_DIR = resolveBaseConfigDir();
-function setProfileOverride(profile) {
-  profileOverride = profile;
-}
-function ensureBaseConfigDir() {
-  if (!existsSync(BASE_CONFIG_DIR)) {
-    mkdirSync(BASE_CONFIG_DIR, { recursive: true });
-  }
-}
-function getProfilesDir() {
-  return join(BASE_CONFIG_DIR, PROFILES_DIR);
-}
-function getCurrentProfileFile() {
-  return join(BASE_CONFIG_DIR, CURRENT_PROFILE_FILE);
-}
-function migrateToProfileStructure() {
-  const profilesDir = getProfilesDir();
-  const defaultProfileDir = join(profilesDir, DEFAULT_PROFILE);
-  if (existsSync(profilesDir)) {
-    return;
-  }
-  const oldConfigFile = join(BASE_CONFIG_DIR, "config.json");
-  const oldTokensFile = join(BASE_CONFIG_DIR, "tokens.json");
-  const hasOldStructure = existsSync(oldConfigFile) || existsSync(oldTokensFile);
-  if (!hasOldStructure) {
-    mkdirSync(profilesDir, { recursive: true });
-    return;
-  }
-  mkdirSync(defaultProfileDir, { recursive: true });
-  if (existsSync(oldConfigFile)) {
-    renameSync(oldConfigFile, join(defaultProfileDir, "config.json"));
-  }
-  if (existsSync(oldTokensFile)) {
-    renameSync(oldTokensFile, join(defaultProfileDir, "tokens.json"));
-  }
-  writeFileSync(getCurrentProfileFile(), DEFAULT_PROFILE);
-}
-function getCurrentProfile() {
-  if (profileOverride) {
-    return profileOverride;
-  }
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  const currentProfileFile = getCurrentProfileFile();
-  if (existsSync(currentProfileFile)) {
-    try {
-      const profile = readFileSync(currentProfileFile, "utf-8").trim();
-      if (profile && profileExists(profile)) {
-        return profile;
-      }
-    } catch {}
-  }
-  return DEFAULT_PROFILE;
-}
-function setCurrentProfile(profile) {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  if (!profileExists(profile)) {
-    throw new Error(`Profile "${profile}" does not exist. Create it first with "profile create ${profile}"`);
-  }
-  writeFileSync(getCurrentProfileFile(), profile);
-}
-function profileExists(profile) {
-  const profileDir = join(getProfilesDir(), profile);
-  return existsSync(profileDir);
-}
-function listProfiles() {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  const profilesDir = getProfilesDir();
-  if (!existsSync(profilesDir)) {
-    return [];
-  }
-  return readdirSync(profilesDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name).sort();
-}
-function createProfile(profile) {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  if (profileExists(profile)) {
-    throw new Error(`Profile "${profile}" already exists`);
-  }
-  if (!/^[a-zA-Z0-9_-]+$/.test(profile)) {
-    throw new Error("Profile name can only contain letters, numbers, hyphens, and underscores");
-  }
-  const profileDir = join(getProfilesDir(), profile);
-  mkdirSync(profileDir, { recursive: true });
-}
-function deleteProfile(profile) {
-  if (profile === DEFAULT_PROFILE) {
-    throw new Error("Cannot delete the default profile");
-  }
-  if (!profileExists(profile)) {
-    throw new Error(`Profile "${profile}" does not exist`);
-  }
-  const currentProfile = getCurrentProfile();
-  if (currentProfile === profile) {
-    setCurrentProfile(DEFAULT_PROFILE);
-  }
-  const profileDir = join(getProfilesDir(), profile);
-  rmSync(profileDir, { recursive: true });
-}
-function resolveConfigDir() {
-  ensureBaseConfigDir();
-  migrateToProfileStructure();
-  const profile = getCurrentProfile();
-  const profileDir = join(getProfilesDir(), profile);
-  if (!existsSync(profileDir)) {
-    mkdirSync(profileDir, { recursive: true });
-  }
-  return profileDir;
-}
-function getConfigDirInternal() {
-  return resolveConfigDir();
-}
-function getConfigDir() {
-  return getConfigDirInternal();
-}
-function getBaseConfigDir() {
-  return BASE_CONFIG_DIR;
-}
-function ensureConfigDir() {
-  const configDir = getConfigDirInternal();
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
-  }
-}
-function getDownloadsDir() {
-  return join(getConfigDirInternal(), "downloads");
-}
-function ensureDownloadsDir() {
-  const dir = getDownloadsDir();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-function loadConfig() {
-  ensureConfigDir();
-  const configFile = join(getConfigDirInternal(), "config.json");
-  if (!existsSync(configFile)) {
-    return {};
-  }
-  try {
-    const content = readFileSync(configFile, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function saveConfig(config) {
-  ensureConfigDir();
-  const configFile = join(getConfigDirInternal(), "config.json");
-  writeFileSync(configFile, JSON.stringify(config, null, 2));
-}
-function loadBaseConfig() {
-  ensureBaseConfigDir();
-  const configFile = join(BASE_CONFIG_DIR, "credentials.json");
-  if (!existsSync(configFile)) {
-    const profiles = listProfiles();
-    for (const profile of profiles) {
-      const profileConfigFile = join(getProfilesDir(), profile, "config.json");
-      if (existsSync(profileConfigFile)) {
-        try {
-          const content = readFileSync(profileConfigFile, "utf-8");
-          const profileConfig = JSON.parse(content);
-          if (profileConfig.clientId && profileConfig.clientSecret) {
-            writeFileSync(configFile, JSON.stringify({
-              clientId: profileConfig.clientId,
-              clientSecret: profileConfig.clientSecret
-            }, null, 2));
-            return { clientId: profileConfig.clientId, clientSecret: profileConfig.clientSecret };
-          }
-        } catch {}
-      }
-    }
-    return {};
-  }
-  try {
-    const content = readFileSync(configFile, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function saveBaseConfig(config) {
-  ensureBaseConfigDir();
-  const configFile = join(BASE_CONFIG_DIR, "credentials.json");
-  writeFileSync(configFile, JSON.stringify(config, null, 2));
-}
-function getClientId() {
-  return process.env.GOOGLE_PHOTOS_CLIENT_ID || loadBaseConfig().clientId;
-}
-function getClientSecret() {
-  return process.env.GOOGLE_PHOTOS_CLIENT_SECRET || loadBaseConfig().clientSecret;
-}
-function setCredentials(clientId, clientSecret) {
-  const config = loadBaseConfig();
-  config.clientId = clientId;
-  config.clientSecret = clientSecret;
-  saveBaseConfig(config);
-}
-function loadTokens() {
-  ensureConfigDir();
-  const tokensFile = join(getConfigDirInternal(), "tokens.json");
-  if (!existsSync(tokensFile)) {
-    return null;
-  }
-  try {
-    const content = readFileSync(tokensFile, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function saveTokens(tokens) {
-  ensureConfigDir();
-  const tokensFile = join(getConfigDirInternal(), "tokens.json");
-  writeFileSync(tokensFile, JSON.stringify(tokens, null, 2), { mode: 384 });
-}
-function getUserEmail() {
-  return loadConfig().userEmail;
-}
-function setUserEmail(email) {
-  const config = loadConfig();
-  config.userEmail = email;
-  saveConfig(config);
-}
-function clearTokens() {
-  const tokensFile = join(getConfigDirInternal(), "tokens.json");
-  if (existsSync(tokensFile)) {
-    writeFileSync(tokensFile, "{}");
-  }
-}
-function clearConfig() {
-  saveConfig({});
-  clearTokens();
-}
-function isAuthenticated() {
-  const tokens = loadTokens();
-  return tokens !== null && tokens.accessToken !== undefined && tokens.refreshToken !== undefined;
-}
-
-// src/utils/auth.ts
-var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
-var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
-var PHOTOS_SCOPES = [
-  "https://www.googleapis.com/auth/photoslibrary.appendonly",
-  "https://www.googleapis.com/auth/photoslibrary.readonly.appcreateddata",
-  "https://www.googleapis.com/auth/photoslibrary.edit.appcreateddata",
-  "https://www.googleapis.com/auth/userinfo.email"
-].join(" ");
-var REDIRECT_PORT = 8090;
-var REDIRECT_URI = `http://localhost:${REDIRECT_PORT}/callback`;
-function getAuthUrl() {
-  const clientId = getClientId();
-  if (!clientId) {
-    throw new Error('Client ID not configured. Run "connect-googlephotos config set-credentials" first.');
-  }
-  const params = new URLSearchParams({
-    client_id: clientId,
-    redirect_uri: REDIRECT_URI,
-    response_type: "code",
-    scope: PHOTOS_SCOPES,
-    access_type: "offline",
-    prompt: "consent"
-  });
-  return `${GOOGLE_AUTH_URL}?${params.toString()}`;
-}
-async function exchangeCodeForTokens(code) {
-  const clientId = getClientId();
-  const clientSecret = getClientSecret();
-  if (!clientId || !clientSecret) {
-    throw new Error("OAuth credentials not configured");
-  }
-  const response = await fetch(GOOGLE_TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      code,
-      client_id: clientId,
-      client_secret: clientSecret,
-      redirect_uri: REDIRECT_URI,
-      grant_type: "authorization_code"
-    })
-  });
-  if (!response.ok) {
-    const error = await response.json();
-    throw new Error(`Token exchange failed: ${error.error_description || error.error}`);
-  }
-  const data = await response.json();
-  const tokens = {
-    accessToken: data.access_token,
-    refreshToken: data.refresh_token,
-    expiresAt: Date.now() + data.expires_in * 1000,
-    tokenType: data.token_type,
-    scope: data.scope
-  };
-  return tokens;
-}
-async function refreshAccessToken() {
-  const clientId = getClientId();
-  const clientSecret = getClientSecret();
-  const currentTokens = loadTokens();
-  if (!clientId || !clientSecret) {
-    throw new Error("OAuth credentials not configured");
-  }
-  if (!currentTokens?.refreshToken) {
-    throw new Error("No refresh token available. Please login again.");
-  }
-  const response = await fetch(GOOGLE_TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      client_id: clientId,
-      client_secret: clientSecret,
-      refresh_token: currentTokens.refreshToken,
-      grant_type: "refresh_token"
-    })
-  });
-  if (!response.ok) {
-    const error = await response.json();
-    throw new Error(`Token refresh failed: ${error.error_description || error.error}`);
-  }
-  const data = await response.json();
-  const tokens = {
-    accessToken: data.access_token,
-    refreshToken: currentTokens.refreshToken,
-    expiresAt: Date.now() + data.expires_in * 1000,
-    tokenType: data.token_type,
-    scope: data.scope || currentTokens.scope
-  };
-  saveTokens(tokens);
-  return tokens;
-}
-function startCallbackServer() {
-  return new Promise((resolve) => {
-    const server = createServer(async (req, res) => {
-      const url = new URL(req.url || "", `http://localhost:${REDIRECT_PORT}`);
-      if (url.pathname === "/callback") {
-        const code = url.searchParams.get("code");
-        const error = url.searchParams.get("error");
-        if (error) {
-          res.writeHead(200, { "Content-Type": "text/html" });
-          res.end(`
-            <html>
-              <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
-                <div style="text-align: center;">
-                  <h1 style="color: #dc3545;">Authentication Failed</h1>
-                  <p>Error: ${error}</p>
-                  <p>You can close this window.</p>
-                </div>
-              </body>
-            </html>
-          `);
-          server.close();
-          resolve({ success: false, error });
-          return;
-        }
-        if (code) {
-          try {
-            const tokens = await exchangeCodeForTokens(code);
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end(`
-              <html>
-                <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
-                  <div style="text-align: center;">
-                    <h1 style="color: #28a745;">Authentication Successful!</h1>
-                    <p>You can close this window and return to the terminal.</p>
-                  </div>
-                </body>
-              </html>
-            `);
-            server.close();
-            resolve({ success: true, tokens });
-          } catch (err) {
-            res.writeHead(200, { "Content-Type": "text/html" });
-            res.end(`
-              <html>
-                <body style="font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
-                  <div style="text-align: center;">
-                    <h1 style="color: #dc3545;">Authentication Failed</h1>
-                    <p>Error: ${String(err)}</p>
-                    <p>You can close this window.</p>
-                  </div>
-                </body>
-              </html>
-            `);
-            server.close();
-            resolve({ success: false, error: String(err) });
-          }
-        }
-      }
-    });
-    server.listen(REDIRECT_PORT, () => {});
-    setTimeout(() => {
-      server.close();
-      resolve({ success: false, error: "Authentication timed out" });
-    }, 5 * 60 * 1000);
-  });
-}
-async function getValidAccessToken() {
-  const tokens = loadTokens();
-  if (!tokens) {
-    throw new Error('Not authenticated. Run "connect-googlephotos auth login" first.');
-  }
-  if (Date.now() >= tokens.expiresAt - 5 * 60 * 1000) {
-    const newTokens = await refreshAccessToken();
-    return newTokens.accessToken;
-  }
-  return tokens.accessToken;
-}
-async function getUserInfo(accessToken) {
-  const response = await fetch("https://www.googleapis.com/oauth2/v2/userinfo", {
-    headers: {
-      Authorization: `Bearer ${accessToken}`
-    }
-  });
-  if (!response.ok) {
-    throw new Error("Failed to get user info");
-  }
-  const data = await response.json();
-  return {
-    email: data.email,
-    name: data.name
-  };
-}
-
-// src/api/client.ts
-var PHOTOS_API_BASE = "https://photoslibrary.googleapis.com/v1";
-
-class PhotosClient {
-  buildUrl(path2, params) {
-    const url = new URL(`${PHOTOS_API_BASE}${path2}`);
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== undefined && value !== null && value !== "") {
-          url.searchParams.append(key, String(value));
-        }
-      });
-    }
-    return url.toString();
-  }
-  async request(path2, options = {}) {
-    const { method = "GET", params, body, headers = {} } = options;
-    const accessToken = await getValidAccessToken();
-    const url = this.buildUrl(path2, params);
-    const requestHeaders = {
-      Authorization: `Bearer ${accessToken}`,
-      Accept: "application/json",
-      ...headers
-    };
-    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
-      if (typeof body === "string") {
-        if (!requestHeaders["Content-Type"]) {
-          requestHeaders["Content-Type"] = "application/octet-stream";
-        }
-      } else {
-        requestHeaders["Content-Type"] = "application/json";
-      }
-    }
-    const fetchOptions = {
-      method,
-      headers: requestHeaders
-    };
-    if (body && ["POST", "PUT", "PATCH"].includes(method)) {
-      fetchOptions.body = typeof body === "string" ? body : JSON.stringify(body);
-    }
-    const response = await fetch(url, fetchOptions);
-    if (response.status === 204) {
-      return {};
-    }
-    let data;
-    const contentType = response.headers.get("content-type") || "";
-    if (contentType.includes("application/json")) {
-      const text = await response.text();
-      if (text) {
-        try {
-          data = JSON.parse(text);
-        } catch {
-          data = text;
-        }
-      }
-    } else {
-      data = await response.text();
-    }
-    if (!response.ok) {
-      const errorData = data;
-      const errorMessage = errorData?.error?.message || String(data || response.statusText);
-      const errorStatus = errorData?.error?.status || "UNKNOWN";
-      throw new PhotosApiError(errorMessage, response.status, errorStatus, errorData?.error?.details);
-    }
-    return data;
-  }
-  async get(path2, params) {
-    return this.request(path2, { method: "GET", params });
-  }
-  async post(path2, body, params) {
-    return this.request(path2, { method: "POST", body, params });
-  }
-  async put(path2, body, params) {
-    return this.request(path2, { method: "PUT", body, params });
-  }
-  async patch(path2, body, params) {
-    return this.request(path2, { method: "PATCH", body, params });
-  }
-  async delete(path2, params) {
-    return this.request(path2, { method: "DELETE", params });
-  }
-  async uploadBytes(data, mimeType, filename) {
-    const accessToken = await getValidAccessToken();
-    const headers = {
-      Authorization: `Bearer ${accessToken}`,
-      "Content-Type": "application/octet-stream",
-      "X-Goog-Upload-Content-Type": mimeType,
-      "X-Goog-Upload-Protocol": "raw"
-    };
-    if (filename) {
-      headers["X-Goog-Upload-File-Name"] = filename;
-    }
-    const response = await fetch("https://photoslibrary.googleapis.com/v1/uploads", {
-      method: "POST",
-      headers,
-      body: data
-    });
-    if (!response.ok) {
-      const text = await response.text();
-      throw new PhotosApiError(`Upload failed: ${text}`, response.status, "UPLOAD_FAILED");
-    }
-    const uploadToken = await response.text();
-    return uploadToken;
-  }
-}
-
-// src/api/albums.ts
-class AlbumsApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(options = {}) {
-    const params = {
-      pageSize: options.pageSize || 50,
-      pageToken: options.pageToken,
-      excludeNonAppCreatedData: options.excludeNonAppCreatedData
-    };
-    return this.client.get("/albums", params);
-  }
-  async listAll(options = {}) {
-    const albums = [];
-    let pageToken;
-    do {
-      const response = await this.list({ ...options, pageToken });
-      if (response.albums) {
-        albums.push(...response.albums);
-      }
-      pageToken = response.nextPageToken;
-    } while (pageToken);
-    return albums;
-  }
-  async get(albumId) {
-    return this.client.get(`/albums/${albumId}`);
-  }
-  async create(title) {
-    return this.client.post("/albums", {
-      album: { title }
-    });
-  }
-  async addEnrichment(albumId, enrichment, position = "LAST_IN_ALBUM") {
-    return this.client.post(`/albums/${albumId}:addEnrichment`, {
-      newEnrichmentItem: enrichment,
-      albumPosition: { position }
-    });
-  }
-  async share(albumId, options) {
-    const request = {};
-    if (options) {
-      request.sharedAlbumOptions = options;
-    }
-    return this.client.post(`/albums/${albumId}:share`, request);
-  }
-  async unshare(albumId) {
-    await this.client.post(`/albums/${albumId}:unshare`, {});
-  }
-  async listShared(options = {}) {
-    const params = {
-      pageSize: options.pageSize || 50,
-      pageToken: options.pageToken,
-      excludeNonAppCreatedData: options.excludeNonAppCreatedData
-    };
-    return this.client.get("/sharedAlbums", params);
-  }
-  async join(shareToken) {
-    return this.client.post("/sharedAlbums:join", { shareToken });
-  }
-  async leave(shareToken) {
-    await this.client.post("/sharedAlbums:leave", { shareToken });
-  }
-  async addMediaItems(albumId, mediaItemIds) {
-    await this.client.post(`/albums/${albumId}:batchAddMediaItems`, {
-      mediaItemIds
-    });
-  }
-  async removeMediaItems(albumId, mediaItemIds) {
-    await this.client.post(`/albums/${albumId}:batchRemoveMediaItems`, {
-      mediaItemIds
-    });
-  }
-  async updateTitle(albumId, title) {
-    return this.client.patch(`/albums/${albumId}`, { title }, { updateMask: "title" });
-  }
-  async updateCoverPhoto(albumId, coverPhotoMediaItemId) {
-    return this.client.patch(`/albums/${albumId}`, { coverPhotoMediaItemId }, { updateMask: "coverPhotoMediaItemId" });
-  }
-}
-
-// src/api/media.ts
-class MediaApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async list(options = {}) {
-    const params = {
-      pageSize: options.pageSize || 25,
-      pageToken: options.pageToken
-    };
-    return this.client.get("/mediaItems", params);
-  }
-  async listAll(options = {}, maxItems) {
-    const items = [];
-    let pageToken;
-    do {
-      const response = await this.list({ ...options, pageToken });
-      if (response.mediaItems) {
-        items.push(...response.mediaItems);
-        if (maxItems && items.length >= maxItems) {
-          return items.slice(0, maxItems);
-        }
-      }
-      pageToken = response.nextPageToken;
-    } while (pageToken);
-    return items;
-  }
-  async get(mediaItemId) {
-    return this.client.get(`/mediaItems/${mediaItemId}`);
-  }
-  async batchGet(mediaItemIds) {
-    const params = {};
-    mediaItemIds.forEach((id, index) => {
-      params[`mediaItemIds[${index}]`] = id;
-    });
-    return this.client.get("/mediaItems:batchGet", params);
-  }
-  async search(options = {}) {
-    const body = {
-      pageSize: options.pageSize || 25,
-      pageToken: options.pageToken
-    };
-    if (options.albumId) {
-      body.albumId = options.albumId;
-    }
-    if (options.filters) {
-      body.filters = options.filters;
-    }
-    if (options.orderBy) {
-      body.orderBy = options.orderBy;
-    }
-    return this.client.post("/mediaItems:search", body);
-  }
-  async searchAll(options = {}, maxItems) {
-    const items = [];
-    let pageToken;
-    do {
-      const response = await this.search({ ...options, pageToken });
-      if (response.mediaItems) {
-        items.push(...response.mediaItems);
-        if (maxItems && items.length >= maxItems) {
-          return items.slice(0, maxItems);
-        }
-      }
-      pageToken = response.nextPageToken;
-    } while (pageToken);
-    return items;
-  }
-  async searchByDate(startDate, endDate, options = {}) {
-    const filters = {
-      dateFilter: endDate ? { ranges: [{ startDate, endDate }] } : { dates: [startDate] }
-    };
-    return this.searchAll({ ...options, filters });
-  }
-  async searchByCategory(categories, options = {}) {
-    const filters = {
-      contentFilter: {
-        includedContentCategories: categories
-      }
-    };
-    return this.searchAll({ ...options, filters });
-  }
-  async searchByMediaType(mediaTypes, options = {}) {
-    const filters = {
-      mediaTypeFilter: { mediaTypes }
-    };
-    return this.searchAll({ ...options, filters });
-  }
-  async getFavorites(options = {}) {
-    const filters = {
-      featureFilter: {
-        includedFeatures: ["FAVORITES"]
-      }
-    };
-    return this.searchAll({ ...options, filters });
-  }
-  async getInAlbum(albumId, options = {}) {
-    return this.searchAll({ ...options, albumId });
-  }
-  getDownloadUrl(mediaItem, width, height) {
-    let url = mediaItem.baseUrl;
-    if (mediaItem.mediaMetadata.photo) {
-      if (width && height) {
-        url += `=w${width}-h${height}`;
-      } else if (width) {
-        url += `=w${width}`;
-      } else if (height) {
-        url += `=h${height}`;
-      } else {
-        url += `=d`;
-      }
-    }
-    if (mediaItem.mediaMetadata.video) {
-      url += "=dv";
-    }
-    return url;
-  }
-  async download(mediaItem, width, height) {
-    const url = this.getDownloadUrl(mediaItem, width, height);
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to download media item: ${response.statusText}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    return Buffer.from(arrayBuffer);
-  }
-  async updateDescription(mediaItemId, description) {
-    return this.client.patch(`/mediaItems/${mediaItemId}`, { description }, { updateMask: "description" });
-  }
-}
-
-// src/api/upload.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { basename, extname } from "path";
-var MIME_TYPES = {
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".png": "image/png",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".heic": "image/heic",
-  ".heif": "image/heif",
-  ".bmp": "image/bmp",
-  ".tiff": "image/tiff",
-  ".tif": "image/tiff",
-  ".raw": "image/raw",
-  ".ico": "image/x-icon",
-  ".mp4": "video/mp4",
-  ".mov": "video/quicktime",
-  ".avi": "video/x-msvideo",
-  ".mkv": "video/x-matroska",
-  ".webm": "video/webm",
-  ".m4v": "video/x-m4v",
-  ".3gp": "video/3gpp",
-  ".mpg": "video/mpeg",
-  ".mpeg": "video/mpeg",
-  ".wmv": "video/x-ms-wmv"
-};
-
-class UploadApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  getMimeType(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return MIME_TYPES[ext] || "application/octet-stream";
-  }
-  async uploadFile(filePath) {
-    const data = readFileSync2(filePath);
-    const mimeType = this.getMimeType(filePath);
-    const filename = basename(filePath);
-    return this.client.uploadBytes(data, mimeType, filename);
-  }
-  async uploadBytes(data, mimeType, filename) {
-    return this.client.uploadBytes(data, mimeType, filename);
-  }
-  async createMediaItems(uploadTokens, albumId) {
-    const newMediaItems = uploadTokens.map((item) => ({
-      description: item.description,
-      simpleMediaItem: {
-        fileName: item.filename,
-        uploadToken: item.uploadToken
-      }
-    }));
-    const request = {
-      newMediaItems
-    };
-    if (albumId) {
-      request.albumId = albumId;
-    }
-    return this.client.post("/mediaItems:batchCreate", request);
-  }
-  async uploadAndCreate(filePath, options = {}) {
-    const uploadToken = await this.uploadFile(filePath);
-    const filename = basename(filePath);
-    const response = await this.createMediaItems([{ uploadToken, filename, description: options.description }], options.albumId);
-    const result = response.newMediaItemResults[0];
-    if (result.status?.code && result.status.code !== 0) {
-      throw new Error(`Failed to create media item: ${result.status.message}`);
-    }
-    return result.mediaItem || null;
-  }
-  async uploadMultiple(filePaths, options = {}) {
-    const uploadTokens = [];
-    for (let i = 0;i < filePaths.length; i++) {
-      const filePath = filePaths[i];
-      const filename = basename(filePath);
-      if (options.onProgress) {
-        options.onProgress(i, filePaths.length, filename);
-      }
-      const uploadToken = await this.uploadFile(filePath);
-      uploadTokens.push({ uploadToken, filename });
-    }
-    if (options.onProgress) {
-      options.onProgress(filePaths.length, filePaths.length, "Creating media items...");
-    }
-    return this.createMediaItems(uploadTokens, options.albumId);
-  }
-  async uploadDirectory(dirPath, options = {}) {
-    const { readdirSync: readdirSync2, statSync } = await import("fs");
-    const { join: join2 } = await import("path");
-    const supportedExtensions = options.extensions || Object.keys(MIME_TYPES);
-    const files = [];
-    const collectFiles = (dir) => {
-      const entries = readdirSync2(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join2(dir, entry.name);
-        if (entry.isDirectory() && options.recursive) {
-          collectFiles(fullPath);
-        } else if (entry.isFile()) {
-          const ext = extname(entry.name).toLowerCase();
-          if (supportedExtensions.includes(ext)) {
-            files.push(fullPath);
-          }
-        }
-      }
-    };
-    collectFiles(dirPath);
-    if (files.length === 0) {
-      return { newMediaItemResults: [] };
-    }
-    return this.uploadMultiple(files, {
-      albumId: options.albumId,
-      onProgress: options.onProgress
-    });
-  }
-  getSupportedExtensions() {
-    return Object.keys(MIME_TYPES);
-  }
-  isSupported(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return ext in MIME_TYPES;
-  }
-}
-
-// src/api/bulk.ts
-class BulkApi {
-  client;
-  constructor(client) {
-    this.client = client;
-  }
-  async preview(options) {
-    const items = await this.fetchMediaItems({
-      albumId: options?.albumId,
-      mediaType: options?.mediaType,
-      favoritesOnly: options?.favoritesOnly,
-      maxResults: options?.maxResults || 50
-    });
-    return { items, total: items.length };
-  }
-  async removeFromAlbums(options) {
-    const { albumIds, mediaItemIds, ...rest } = options;
-    let items;
-    if (mediaItemIds && mediaItemIds.length > 0) {
-      items = mediaItemIds.map((id) => ({
-        id,
-        filename: id,
-        mimeType: "unknown",
-        created: "",
-        productUrl: ""
-      }));
-    } else {
-      items = await this.fetchMediaItems({
-        albumId: albumIds[0],
-        maxResults: rest.maxResults || 100
-      });
-    }
-    return this.executeBatch(items, {
-      dryRun: rest.dryRun || false,
-      concurrency: rest.concurrency || 10,
-      onProgress: rest.onProgress,
-      onError: rest.onError,
-      operation: async (item) => {
-        for (const albumId of albumIds) {
-          await this.client.post(`/albums/${albumId}:batchRemoveMediaItems`, {
-            mediaItemIds: [item.id]
-          });
-        }
-      }
-    });
-  }
-  async addToAlbum(options) {
-    let itemIds = options.mediaItemIds;
-    if (!itemIds || itemIds.length === 0) {
-      const items = await this.fetchMediaItems({
-        albumId: options.albumId,
-        mediaType: options.mediaType,
-        favoritesOnly: options.favoritesOnly,
-        includeArchived: options.includeArchived,
-        maxResults: options.maxResults || 100
-      });
-      itemIds = items.map((i) => i.id);
-    }
-    const summaries = itemIds.map((id) => ({
-      id,
-      filename: id,
-      mimeType: "unknown",
-      created: "",
-      productUrl: ""
-    }));
-    return this.executeBatch(summaries, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (item) => {
-        await this.client.post(`/albums/${options.targetAlbumId}:batchAddMediaItems`, {
-          mediaItemIds: [item.id]
-        });
-      }
-    });
-  }
-  async removeFromAlbum(options) {
-    let itemIds = options.mediaItemIds;
-    if (!itemIds || itemIds.length === 0) {
-      const items = await this.fetchMediaItems({
-        albumId: options.albumId,
-        maxResults: options.maxResults || 100
-      });
-      itemIds = items.map((i) => i.id);
-    }
-    const summaries = itemIds.map((id) => ({
-      id,
-      filename: id,
-      mimeType: "unknown",
-      created: "",
-      productUrl: ""
-    }));
-    return this.executeBatch(summaries, {
-      dryRun: options.dryRun || false,
-      concurrency: options.concurrency || 10,
-      onProgress: options.onProgress,
-      onError: options.onError,
-      operation: async (item) => {
-        await this.client.post(`/albums/${options.albumId}:batchRemoveMediaItems`, {
-          mediaItemIds: [item.id]
-        });
-      }
-    });
-  }
-  async createAlbums(options) {
-    const { titles, concurrency = 10, dryRun = false, onProgress, onError } = options;
-    const result = {
-      total: titles.length,
-      success: 0,
-      failed: 0,
-      errors: [],
-      createdAlbums: []
-    };
-    if (titles.length === 0)
-      return result;
-    const chunks = this.chunkArray(titles, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (title) => {
-        try {
-          if (dryRun) {
-            result.success++;
-          } else {
-            const album = await this.client.post("/albums", { album: { title } });
-            result.success++;
-            result.createdAlbums.push(album);
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, title);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ title, error: errorMessage });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), title);
-        }
-      }));
-    }
-    return result;
-  }
-  async listFavorites(options) {
-    const items = await this.fetchMediaItems({
-      favoritesOnly: true,
-      maxResults: options?.maxResults || 100
-    });
-    return { items, total: items.length };
-  }
-  async fetchMediaItems(params) {
-    const items = [];
-    let pageToken;
-    const max = params.maxResults || 100;
-    while (items.length < max) {
-      const body = {
-        pageSize: Math.min(100, max - items.length)
-      };
-      if (params.albumId) {
-        body.albumId = params.albumId;
-      }
-      const filters = {};
-      if (params.mediaType) {
-        filters.mediaTypeFilter = { mediaTypes: [params.mediaType] };
-      }
-      if (params.favoritesOnly) {
-        filters.featureFilter = { includedFeatures: ["FAVORITES"] };
-      }
-      if (params.includeArchived) {
-        filters.includeArchivedMedia = true;
-      }
-      if (Object.keys(filters).length > 0) {
-        body.filters = filters;
-      }
-      if (pageToken) {
-        body.pageToken = pageToken;
-      }
-      const response = await this.client.post("/mediaItems:search", body);
-      if (!response.mediaItems || response.mediaItems.length === 0)
-        break;
-      for (const item of response.mediaItems) {
-        items.push({
-          id: item.id,
-          filename: item.filename,
-          mimeType: item.mimeType,
-          created: item.mediaMetadata.creationTime,
-          productUrl: item.productUrl
-        });
-      }
-      pageToken = response.nextPageToken;
-      if (!pageToken)
-        break;
-    }
-    return items;
-  }
-  async executeBatch(items, options) {
-    const { dryRun, concurrency, onProgress, onError, operation } = options;
-    const result = {
-      total: items.length,
-      success: 0,
-      failed: 0,
-      skipped: 0,
-      errors: [],
-      processedItems: []
-    };
-    if (items.length === 0)
-      return result;
-    const chunks = this.chunkArray(items, concurrency);
-    for (const chunk of chunks) {
-      await Promise.all(chunk.map(async (item) => {
-        try {
-          if (dryRun) {
-            result.success++;
-            result.processedItems.push(item);
-          } else {
-            await operation(item);
-            result.success++;
-            result.processedItems.push(item);
-          }
-          if (onProgress)
-            onProgress(result.success + result.failed, result.total, item);
-        } catch (err) {
-          result.failed++;
-          const errorMessage = err instanceof Error ? err.message : String(err);
-          result.errors.push({ mediaId: item.id, error: errorMessage });
-          if (onError)
-            onError(err instanceof Error ? err : new Error(errorMessage), item);
-        }
-      }));
-    }
-    return result;
-  }
-  chunkArray(array, size) {
-    const chunks = [];
-    for (let i = 0;i < array.length; i += size) {
-      chunks.push(array.slice(i, i + size));
-    }
-    return chunks;
-  }
-}
-
-// src/api/index.ts
-class GooglePhotos {
-  client;
-  albums;
-  media;
-  upload;
-  bulk;
-  constructor() {
-    this.client = new PhotosClient;
-    this.albums = new AlbumsApi(this.client);
-    this.media = new MediaApi(this.client);
-    this.upload = new UploadApi(this.client);
-    this.bulk = new BulkApi(this.client);
-  }
-  static create() {
-    return new GooglePhotos;
-  }
-  getClient() {
-    return this.client;
-  }
-}
-
-// src/utils/output.ts
-function success(message) {
-  console.log(source_default.green("\u2713"), message);
-}
-function error(message) {
-  console.error(source_default.red("\u2717"), message);
-}
-function info(message) {
-  console.log(source_default.blue("\u2139"), message);
-}
-function warn(message) {
-  console.log(source_default.yellow("\u26A0"), message);
-}
-function print(data, format = "pretty") {
-  switch (format) {
-    case "json":
-      console.log(JSON.stringify(data, null, 2));
-      break;
-    case "table":
-      printTable(data);
-      break;
-    case "pretty":
-    default:
-      printPretty(data);
-      break;
-  }
-}
-function printTable(data) {
-  if (Array.isArray(data)) {
-    if (data.length === 0) {
-      console.log("No data");
-      return;
-    }
-    const keys = Array.from(new Set(data.flatMap((item) => typeof item === "object" && item ? Object.keys(item) : [])));
-    if (keys.length === 0) {
-      console.log(data);
-      return;
-    }
-    const widths = {};
-    for (const key of keys) {
-      widths[key] = Math.max(key.length, ...data.map((item) => {
-        const val = item?.[key];
-        return String(val ?? "").substring(0, 50).length;
-      }));
-    }
-    const header = keys.map((k) => k.padEnd(widths[k])).join(" | ");
-    console.log(source_default.bold(header));
-    console.log(keys.map((k) => "-".repeat(widths[k])).join("-+-"));
-    for (const item of data) {
-      const row = keys.map((k) => {
-        const val = item?.[k];
-        return String(val ?? "").substring(0, 50).padEnd(widths[k]);
-      }).join(" | ");
-      console.log(row);
-    }
-  } else if (typeof data === "object" && data !== null) {
-    const entries = Object.entries(data);
-    const maxKeyLen = Math.max(...entries.map(([k]) => k.length));
-    for (const [key, value] of entries) {
-      const displayValue = typeof value === "object" ? JSON.stringify(value) : String(value);
-      console.log(`${source_default.cyan(key.padEnd(maxKeyLen))}: ${displayValue}`);
-    }
-  } else {
-    console.log(data);
-  }
-}
-function printPretty(data) {
-  if (Array.isArray(data)) {
-    if (data.length === 0) {
-      console.log("No data");
-      return;
-    }
-    for (let i = 0;i < data.length; i++) {
-      if (i > 0)
-        console.log("");
-      printPrettyObject(data[i], i + 1);
-    }
-  } else if (typeof data === "object" && data !== null) {
-    printPrettyObject(data);
-  } else {
-    console.log(data);
-  }
-}
-function printPrettyObject(obj, index) {
-  if (typeof obj !== "object" || obj === null) {
-    console.log(obj);
-    return;
-  }
-  const entries = Object.entries(obj);
-  if (index !== undefined) {
-    console.log(source_default.gray(`[${index}]`));
-  }
-  for (const [key, value] of entries) {
-    const displayKey = formatKey(key);
-    const displayValue = formatValue(value);
-    console.log(`  ${source_default.cyan(displayKey)}: ${displayValue}`);
-  }
-}
-function formatKey(key) {
-  return key.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()).trim();
-}
-function formatValue(value) {
-  if (value === null || value === undefined) {
-    return source_default.gray("\u2014");
-  }
-  if (typeof value === "boolean") {
-    return value ? source_default.green("Yes") : source_default.red("No");
-  }
-  if (typeof value === "number") {
-    return source_default.yellow(String(value));
-  }
-  if (typeof value === "string") {
-    if (value.startsWith("http://") || value.startsWith("https://")) {
-      return source_default.blue(value);
-    }
-    if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
-      return source_default.magenta(value);
-    }
-    if (value.length > 100) {
-      return value.substring(0, 100) + source_default.gray("...");
-    }
-    return value;
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      return source_default.gray("[]");
-    }
-    return source_default.gray(`[${value.length} items]`);
-  }
-  if (typeof value === "object") {
-    const keys = Object.keys(value);
-    if (keys.length === 0) {
-      return source_default.gray("{}");
-    }
-    return source_default.gray(`{${keys.join(", ")}}`);
-  }
-  return String(value);
-}
-function formatBytes(bytes) {
-  if (bytes === 0)
-    return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB", "TB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
-}
-
-// src/cli/index.ts
-var program2 = new Command;
-program2.name("connect-googlephotos").description("Google Photos API connector CLI - Browse, download, and upload photos with ease").version("0.1.0").option("-f, --format <format>", "Output format (json, table, pretty)", "pretty").option("-p, --profile <profile>", "Use a specific profile").hook("preAction", (thisCommand) => {
-  const opts = thisCommand.opts();
-  if (opts.profile) {
-    if (!profileExists(opts.profile)) {
-      error(`Profile "${opts.profile}" does not exist. Create it with "connect-googlephotos profiles create ${opts.profile}"`);
-      process.exit(1);
-    }
-    setProfileOverride(opts.profile);
-  }
-});
-function getFormat(cmd) {
-  const parent = cmd.parent;
-  return parent?.opts().format || "pretty";
-}
-function requireAuth() {
-  if (!isAuthenticated()) {
-    error('Not authenticated. Run "connect-googlephotos auth login" first.');
-    process.exit(1);
-  }
-  return GooglePhotos.create();
-}
-var authCmd = program2.command("auth").description("Authentication commands");
-authCmd.command("login").description("Login to Google Photos via OAuth2 (opens browser) - auto-creates profile from email").action(async () => {
-  const clientId = getClientId();
-  const clientSecret = getClientSecret();
-  if (!clientId || !clientSecret) {
-    error("OAuth credentials not configured.");
-    info('Run "connect-googlephotos config set-credentials <client-id> <client-secret>" first.');
-    info("Or set GOOGLE_PHOTOS_CLIENT_ID and GOOGLE_PHOTOS_CLIENT_SECRET environment variables.");
-    process.exit(1);
-  }
-  info("Starting OAuth2 authentication flow...");
-  info("A browser window will open for you to authorize the application.");
-  const serverPromise = startCallbackServer();
-  const authUrl = getAuthUrl();
-  await open_default(authUrl);
-  info("Waiting for authentication...");
-  const result = await serverPromise;
-  if (result.success) {
-    success("Successfully authenticated!");
-    try {
-      setProfileOverride("default");
-      if (result.tokens) {
-        saveTokens(result.tokens);
-      }
-      const userInfo = await getUserInfo(result.tokens.accessToken);
-      const email = userInfo.email;
-      const profileSlug = email.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
-      if (!profileExists(profileSlug)) {
-        createProfile(profileSlug);
-        info(`Created profile: ${profileSlug}`);
-      }
-      setCurrentProfile(profileSlug);
-      setProfileOverride(profileSlug);
-      setUserEmail(email);
-      if (result.tokens) {
-        saveTokens(result.tokens);
-      }
-      success(`Profile: ${profileSlug}`);
-      info(`Email: ${email}`);
-    } catch (err) {
-      warn(`Could not auto-create profile: ${err}`);
-    }
-  } else {
-    error(`Authentication failed: ${result.error}`);
-    process.exit(1);
-  }
-});
-authCmd.command("status").description("Check authentication status").action(async () => {
-  if (isAuthenticated()) {
-    const tokens = loadTokens();
-    const email = getUserEmail();
-    success("Authenticated");
-    if (email) {
-      info(`Email: ${email}`);
-    }
-    if (tokens) {
-      const expiresIn = Math.max(0, Math.floor((tokens.expiresAt - Date.now()) / 1000 / 60));
-      info(`Access token expires in: ${expiresIn} minutes`);
-      info(`Has refresh token: ${tokens.refreshToken ? "Yes" : "No"}`);
-    }
-  } else {
-    warn("Not authenticated");
-    info('Run "connect-googlephotos auth login" to authenticate.');
-  }
-});
-authCmd.command("logout").description("Clear stored authentication tokens").action(() => {
-  clearConfig();
-  success("Logged out successfully");
-});
-var configCmd = program2.command("config").description("Manage CLI configuration");
-configCmd.command("set-credentials <clientId> <clientSecret>").description("Set OAuth2 client credentials").action((clientId, clientSecret) => {
-  setCredentials(clientId, clientSecret);
-  success("OAuth credentials saved successfully");
-  info(`Config stored in: ${getBaseConfigDir()}`);
-});
-configCmd.command("show").description("Show current configuration").action(() => {
-  const clientId = getClientId();
-  const clientSecret = getClientSecret();
-  const email = getUserEmail();
-  const tokens = loadTokens();
-  info(`Base config directory: ${getBaseConfigDir()}`);
-  info(`Profile config directory: ${getConfigDir()}`);
-  info(`Client ID: ${clientId ? `${clientId.substring(0, 20)}...` : source_default.gray("not set")}`);
-  info(`Client Secret: ${clientSecret ? "********" : source_default.gray("not set")}`);
-  info(`Authenticated: ${isAuthenticated() ? source_default.green("Yes") : source_default.red("No")}`);
-  if (email) {
-    info(`Email: ${email}`);
-  }
-  if (tokens) {
-    info(`Token expires: ${new Date(tokens.expiresAt).toLocaleString()}`);
-  }
-});
-configCmd.command("clear").description("Clear all configuration and tokens").action(() => {
-  clearConfig();
-  success("Configuration cleared");
-});
-var profilesCmd = program2.command("profiles").description("Manage multiple Google Photos profiles");
-profilesCmd.command("list").description("List all profiles").action(() => {
-  try {
-    const profiles = listProfiles();
-    const current = getCurrentProfile();
-    if (profiles.length === 0) {
-      info("No profiles found");
-      return;
-    }
-    success(`${profiles.length} profile(s):`);
-    for (const p of profiles) {
-      if (p === current) {
-        info(`  ${source_default.green("\u2192")} ${p} ${source_default.gray("(current)")}`);
-      } else {
-        info(`    ${p}`);
-      }
-    }
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-profilesCmd.command("current").description("Show current profile").action(() => {
-  const current = getCurrentProfile();
-  info(`Current profile: ${source_default.green(current)}`);
-  info(`Config directory: ${getConfigDir()}`);
-});
-profilesCmd.command("create <name>").description("Create a new profile").action((name) => {
-  try {
-    createProfile(name);
-    success(`Profile "${name}" created`);
-    info(`Switch to it with: connect-googlephotos profiles switch ${name}`);
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-profilesCmd.command("switch <name>").alias("use").description("Switch to a different profile").action((name) => {
-  try {
-    setCurrentProfile(name);
-    success(`Switched to profile "${name}"`);
-    info(`Config directory: ${getConfigDir()}`);
-    if (isAuthenticated()) {
-      const email = getUserEmail();
-      if (email) {
-        info(`Logged in as: ${email}`);
-      }
-    } else {
-      warn('Profile not authenticated. Run "connect-googlephotos auth login"');
-    }
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-profilesCmd.command("delete <name>").description("Delete a profile").action((name) => {
-  try {
-    deleteProfile(name);
-    success(`Profile "${name}" deleted`);
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-profilesCmd.command("show").description("Show all profiles with their status").action(async () => {
-  try {
-    const profiles = listProfiles();
-    const current = getCurrentProfile();
-    if (profiles.length === 0) {
-      info("No profiles found");
-      return;
-    }
-    success(`${profiles.length} profile(s):
-`);
-    for (const p of profiles) {
-      setProfileOverride(p);
-      const authenticated = isAuthenticated();
-      const email = authenticated ? getUserEmail() : null;
-      setProfileOverride(undefined);
-      const isCurrent = p === current;
-      const marker = isCurrent ? source_default.green("\u2192") : " ";
-      const status = authenticated ? source_default.green("authenticated") : source_default.yellow("not authenticated");
-      const emailStr = email ? source_default.gray(`(${email})`) : "";
-      const currentStr = isCurrent ? source_default.gray(" [current]") : "";
-      info(`  ${marker} ${p}${currentStr}`);
-      info(`      Status: ${status} ${emailStr}`);
-    }
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-var albumsCmd = program2.command("albums").description("Album management commands");
-albumsCmd.command("list").description("List all albums").option("-n, --max <number>", "Maximum albums to return", "50").option("--shared", "List shared albums instead").action(async (opts) => {
-  try {
-    const photos = requireAuth();
-    let albums;
-    if (opts.shared) {
-      const response = await photos.albums.listShared({ pageSize: parseInt(opts.max) });
-      albums = response.albums || [];
-    } else {
-      const response = await photos.albums.list({ pageSize: parseInt(opts.max) });
-      albums = response.albums || [];
-    }
-    if (albums.length === 0) {
-      info("No albums found");
-      return;
-    }
-    success(`Found ${albums.length} album(s):`);
-    const formatted = albums.map((album) => ({
-      id: album.id,
-      title: album.title,
-      itemCount: album.mediaItemsCount || "0",
-      shared: album.shareInfo ? "Yes" : "No"
-    }));
-    print(formatted, getFormat(albumsCmd));
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-albumsCmd.command("get <albumId>").description("Get album details").action(async (albumId) => {
-  try {
-    const photos = requireAuth();
-    const album = await photos.albums.get(albumId);
-    print(album, getFormat(albumsCmd));
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-albumsCmd.command("create <title>").description("Create a new album").action(async (title) => {
-  try {
-    const photos = requireAuth();
-    const album = await photos.albums.create(title);
-    success(`Album created: ${album.title}`);
-    info(`Album ID: ${album.id}`);
-    info(`URL: ${album.productUrl}`);
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-albumsCmd.command("share <albumId>").description("Share an album").option("--collaborative", "Allow others to add photos").option("--commentable", "Allow comments").action(async (albumId, opts) => {
-  try {
-    const photos = requireAuth();
-    const result = await photos.albums.share(albumId, {
-      isCollaborative: opts.collaborative || false,
-      isCommentable: opts.commentable || false
-    });
-    success("Album shared!");
-    info(`Share URL: ${result.shareInfo.shareableUrl}`);
-    info(`Share token: ${result.shareInfo.shareToken}`);
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-albumsCmd.command("unshare <albumId>").description("Unshare an album").action(async (albumId) => {
-  try {
-    const photos = requireAuth();
-    await photos.albums.unshare(albumId);
-    success("Album unshared");
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-albumsCmd.command("contents <albumId>").description("List media items in an album").option("-n, --max <number>", "Maximum items to return", "25").action(async (albumId, opts) => {
-  try {
-    const photos = requireAuth();
-    const items = await photos.media.getInAlbum(albumId);
-    if (items.length === 0) {
-      info("No items in album");
-      return;
-    }
-    success(`Found ${items.length} item(s) in album:`);
-    const formatted = items.slice(0, parseInt(opts.max)).map((item) => ({
-      id: item.id,
-      filename: item.filename,
-      type: item.mediaMetadata.photo ? "Photo" : "Video",
-      created: item.mediaMetadata.creationTime,
-      size: `${item.mediaMetadata.width}x${item.mediaMetadata.height}`
-    }));
-    print(formatted, getFormat(albumsCmd));
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-var mediaCmd = program2.command("media").description("Media item commands");
-mediaCmd.command("list").description("List media items in your library").option("-n, --max <number>", "Maximum items to return", "25").action(async (opts) => {
-  try {
-    const photos = requireAuth();
-    const response = await photos.media.list({ pageSize: parseInt(opts.max) });
-    if (!response.mediaItems || response.mediaItems.length === 0) {
-      info("No media items found");
-      return;
-    }
-    success(`Found ${response.mediaItems.length} item(s):`);
-    const formatted = response.mediaItems.map((item) => ({
-      id: item.id,
-      filename: item.filename,
-      type: item.mediaMetadata.photo ? "Photo" : "Video",
-      created: item.mediaMetadata.creationTime,
-      size: `${item.mediaMetadata.width}x${item.mediaMetadata.height}`
-    }));
-    print(formatted, getFormat(mediaCmd));
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-mediaCmd.command("get <mediaItemId>").description("Get details of a specific media item").action(async (mediaItemId) => {
-  try {
-    const photos = requireAuth();
-    const item = await photos.media.get(mediaItemId);
-    print(item, getFormat(mediaCmd));
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-mediaCmd.command("search").description("Search for media items").option("--category <category>", "Filter by category (LANDSCAPES, SELFIES, PEOPLE, PETS, etc.)").option("--type <type>", "Filter by type (PHOTO, VIDEO)").option("--favorites", "Only show favorites").option("-n, --max <number>", "Maximum items to return", "25").action(async (opts) => {
-  try {
-    const photos = requireAuth();
-    let items;
-    if (opts.favorites) {
-      items = await photos.media.getFavorites({ pageSize: parseInt(opts.max) });
-    } else if (opts.category) {
-      items = await photos.media.searchByCategory([opts.category.toUpperCase()], { pageSize: parseInt(opts.max) });
-    } else if (opts.type) {
-      items = await photos.media.searchByMediaType([opts.type.toUpperCase()], { pageSize: parseInt(opts.max) });
-    } else {
-      const response = await photos.media.search({ pageSize: parseInt(opts.max) });
-      items = response.mediaItems || [];
-    }
-    if (items.length === 0) {
-      info("No media items found");
-      return;
-    }
-    success(`Found ${items.length} item(s):`);
-    const formatted = items.slice(0, parseInt(opts.max)).map((item) => ({
-      id: item.id,
-      filename: item.filename,
-      type: item.mediaMetadata.photo ? "Photo" : "Video",
-      created: item.mediaMetadata.creationTime
-    }));
-    print(formatted, getFormat(mediaCmd));
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-mediaCmd.command("download <mediaItemId>").description("Download a media item").option("-o, --output <path>", "Output file path").option("-w, --width <number>", "Width for photos").option("-h, --height <number>", "Height for photos").action(async (mediaItemId, opts) => {
-  try {
-    const photos = requireAuth();
-    const item = await photos.media.get(mediaItemId);
-    info(`Downloading: ${item.filename}`);
-    const buffer = await photos.media.download(item, opts.width ? parseInt(opts.width) : undefined, opts.height ? parseInt(opts.height) : undefined);
-    const outputPath = opts.output || join2(ensureDownloadsDir(), item.filename);
-    writeFileSync2(outputPath, buffer);
-    success(`Downloaded to: ${outputPath}`);
-    info(`Size: ${formatBytes(buffer.length)}`);
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-mediaCmd.command("url <mediaItemId>").description("Get download URL for a media item").option("-w, --width <number>", "Width for photos").option("-h, --height <number>", "Height for photos").action(async (mediaItemId, opts) => {
-  try {
-    const photos = requireAuth();
-    const item = await photos.media.get(mediaItemId);
-    const url = photos.media.getDownloadUrl(item, opts.width ? parseInt(opts.width) : undefined, opts.height ? parseInt(opts.height) : undefined);
-    info(`Filename: ${item.filename}`);
-    info(`URL: ${url}`);
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-var uploadCmd = program2.command("upload").description("Upload photos and videos");
-uploadCmd.command("file <path>").description("Upload a single file").option("-a, --album <albumId>", "Add to album").option("-d, --description <text>", "Description for the media item").action(async (filePath, opts) => {
-  try {
-    const photos = requireAuth();
-    if (!existsSync2(filePath)) {
-      error(`File not found: ${filePath}`);
-      process.exit(1);
-    }
-    if (!photos.upload.isSupported(filePath)) {
-      error(`Unsupported file type. Supported: ${photos.upload.getSupportedExtensions().join(", ")}`);
-      process.exit(1);
-    }
-    info(`Uploading: ${basename2(filePath)}`);
-    const item = await photos.upload.uploadAndCreate(filePath, {
-      description: opts.description,
-      albumId: opts.album
-    });
-    if (item) {
-      success("Upload complete!");
-      info(`Media ID: ${item.id}`);
-      info(`URL: ${item.productUrl}`);
-    } else {
-      warn("Upload succeeded but no media item returned");
-    }
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-uploadCmd.command("dir <path>").description("Upload all photos/videos from a directory").option("-a, --album <albumId>", "Add to album").option("-r, --recursive", "Include subdirectories").action(async (dirPath, opts) => {
-  try {
-    const photos = requireAuth();
-    if (!existsSync2(dirPath)) {
-      error(`Directory not found: ${dirPath}`);
-      process.exit(1);
-    }
-    info(`Scanning directory: ${dirPath}`);
-    const result = await photos.upload.uploadDirectory(dirPath, {
-      albumId: opts.album,
-      recursive: opts.recursive,
-      onProgress: (completed, total, filename) => {
-        if (completed < total) {
-          info(`[${completed + 1}/${total}] Uploading: ${filename}`);
-        }
-      }
-    });
-    const succeeded = result.newMediaItemResults.filter((r) => r.mediaItem).length;
-    const failed = result.newMediaItemResults.filter((r) => !r.mediaItem).length;
-    success(`Upload complete!`);
-    info(`Succeeded: ${succeeded}`);
-    if (failed > 0) {
-      warn(`Failed: ${failed}`);
-    }
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-uploadCmd.command("supported").description("List supported file types").action(() => {
-  const photos = GooglePhotos.create();
-  const extensions = photos.upload.getSupportedExtensions();
-  info("Supported file types:");
-  info(extensions.join(", "));
-});
-var bulkCmd = program2.command("bulk").description("Bulk operations on media items and albums");
-bulkCmd.command("preview").description("Preview media items matching filters").option("--album-id <albumId>", "Filter by album").option("--type <type>", "Filter by media type (PHOTO, VIDEO)").option("--favorites", "Only show favorites").option("-n, --max <number>", "Maximum results", "50").action(async (opts) => {
-  try {
-    const photos = requireAuth();
-    const bulk = new BulkApi(photos.getClient());
-    const result = await bulk.preview({
-      albumId: opts.albumId,
-      mediaType: opts.type,
-      favoritesOnly: opts.favorites,
-      maxResults: parseInt(opts.max)
-    });
-    success(`Found ${result.total} item(s):`);
-    print(result.items, getFormat(bulkCmd));
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-bulkCmd.command("add-to-album <albumId>").description("Bulk add media items to an album").option("--query-album-id <albumId>", "Filter by album to discover items").option("--type <type>", "Filter by media type").option("--favorites", "Only favorites").option("-n, --max <number>", "Maximum results", "100").option("--concurrency <number>", "Max concurrent operations", "10").option("--dry-run", "Preview without adding").action(async (albumId, opts) => {
-  try {
-    const photos = requireAuth();
-    const bulk = new BulkApi(photos.getClient());
-    const result = await bulk.addToAlbum({
-      targetAlbumId: albumId,
-      albumId: opts.queryAlbumId,
-      mediaType: opts.type,
-      favoritesOnly: opts.favorites,
-      maxResults: parseInt(opts.max),
-      concurrency: parseInt(opts.concurrency),
-      dryRun: opts.dryRun || false,
-      onProgress: (cur, total) => {
-        process.stdout.write(`\r  Progress: ${cur}/${total}`);
-      },
-      onError: (err, item) => {
-        warn(`Failed: ${item.filename} - ${err.message}`);
-      }
-    });
-    process.stdout.write(`
-`);
-    if (opts.dryRun) {
-      info(`Dry run: would add ${result.success} item(s) to album`);
-    } else {
-      success(`Added ${result.success} item(s) to album, ${result.failed} failed`);
-    }
-    if (result.errors.length > 0) {
-      print(result.errors, "pretty");
-    }
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-bulkCmd.command("remove-from-album <albumId>").description("Bulk remove media items from an album").option("--media-ids <ids>", "Comma-separated media item IDs").option("-n, --max <number>", "Maximum results", "100").option("--concurrency <number>", "Max concurrent operations", "10").option("--dry-run", "Preview without removing").action(async (albumId, opts) => {
-  try {
-    const photos = requireAuth();
-    const bulk = new BulkApi(photos.getClient());
-    const mediaItemIds = opts.mediaIds ? opts.mediaIds.split(",") : undefined;
-    const result = await bulk.removeFromAlbum({
-      albumId,
-      mediaItemIds,
-      maxResults: parseInt(opts.max),
-      concurrency: parseInt(opts.concurrency),
-      dryRun: opts.dryRun || false,
-      onProgress: (cur, total) => {
-        process.stdout.write(`\r  Progress: ${cur}/${total}`);
-      },
-      onError: (err, item) => {
-        warn(`Failed: ${item.filename} - ${err.message}`);
-      }
-    });
-    process.stdout.write(`
-`);
-    if (opts.dryRun) {
-      info(`Dry run: would remove ${result.success} item(s) from album`);
-    } else {
-      success(`Removed ${result.success} item(s) from album, ${result.failed} failed`);
-    }
-    if (result.errors.length > 0) {
-      print(result.errors, "pretty");
-    }
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-bulkCmd.command("create-albums").description("Bulk create albums from titles").option("--titles <titles>", "Comma-separated album titles").option("--titles-file <path>", "File with one title per line").option("--concurrency <number>", "Max concurrent operations", "10").option("--dry-run", "Preview without creating").action(async (opts) => {
-  let titles = [];
-  if (opts.titles) {
-    titles = opts.titles.split(",").map((t) => t.trim()).filter(Boolean);
-  } else if (opts.titlesFile) {
-    if (!existsSync2(opts.titlesFile)) {
-      error(`File not found: ${opts.titlesFile}`);
-      process.exit(1);
-    }
-    titles = __require("fs").readFileSync(opts.titlesFile, "utf-8").split(`
-`).map((t) => t.trim()).filter(Boolean);
-  }
-  if (titles.length === 0) {
-    error("Provide --titles or --titles-file");
-    process.exit(1);
-  }
-  try {
-    const photos = requireAuth();
-    const bulk = new BulkApi(photos.getClient());
-    const result = await bulk.createAlbums({
-      titles,
-      concurrency: parseInt(opts.concurrency),
-      dryRun: opts.dryRun || false,
-      onProgress: (cur, total) => {
-        process.stdout.write(`\r  Progress: ${cur}/${total}`);
-      },
-      onError: (err, title) => {
-        warn(`Failed: ${title} - ${err.message}`);
-      }
-    });
-    process.stdout.write(`
-`);
-    if (opts.dryRun) {
-      info(`Dry run: would create ${result.success} album(s)`);
-    } else {
-      success(`Created ${result.success} album(s), ${result.failed} failed`);
-    }
-    if (result.errors.length > 0) {
-      print(result.errors, "pretty");
-    }
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-bulkCmd.command("favorites").description("List favorite media items").option("-n, --max <number>", "Maximum results", "100").action(async (opts) => {
-  try {
-    const photos = requireAuth();
-    const bulk = new BulkApi(photos.getClient());
-    const result = await bulk.listFavorites({ maxResults: parseInt(opts.max) });
-    success(`Found ${result.total} favorite(s):`);
-    print(result.items, getFormat(bulkCmd));
-  } catch (err) {
-    error(String(err));
-    process.exit(1);
-  }
-});
-program2.parse();