opencommit 3.1.1 → 3.2.1

package/out/cli.cjs

@@ -144,7 +144,7 @@ var require_windows = __commonJS({
   "node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     function checkPathExt(path5, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -169,12 +169,12 @@ var require_windows = __commonJS({
       return checkPathExt(path5, options);
     }
     function isexe(path5, options, cb) {
-      fs6.stat(path5, function(er2, stat) {
+      fs7.stat(path5, function(er2, stat) {
         cb(er2, er2 ? false : checkStat(stat, path5, options));
       });
     }
     function sync(path5, options) {
-      return checkStat(fs6.statSync(path5), path5, options);
+      return checkStat(fs7.statSync(path5), path5, options);
     }
   }
 });
@@ -184,14 +184,14 @@ var require_mode = __commonJS({
   "node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     function isexe(path5, options, cb) {
-      fs6.stat(path5, function(er2, stat) {
+      fs7.stat(path5, function(er2, stat) {
         cb(er2, er2 ? false : checkStat(stat, options));
       });
     }
     function sync(path5, options) {
-      return checkStat(fs6.statSync(path5), options);
+      return checkStat(fs7.statSync(path5), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -215,7 +215,7 @@ var require_mode = __commonJS({
 // node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "node_modules/isexe/index.js"(exports, module2) {
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -477,16 +477,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs6.openSync(command, "r");
-        fs6.readSync(fd, buffer, 0, size, 0);
-        fs6.closeSync(fd);
+        fd = fs7.openSync(command, "r");
+        fs7.readSync(fd, buffer, 0, size, 0);
+        fs7.closeSync(fd);
       } catch (e3) {
       }
       return shebangCommand(buffer.toString());
@@ -501,7 +501,7 @@ var require_parse = __commonJS({
     "use strict";
     var path5 = require("path");
     var resolveCommand = require_resolveCommand();
-    var escape = require_escape();
+    var escape2 = require_escape();
     var readShebang = require_readShebang();
     var isWin = process.platform === "win32";
     var isExecutableRegExp = /\.(?:com|exe)$/i;
@@ -525,8 +525,8 @@ var require_parse = __commonJS({
       if (parsed.options.forceShell || needsShell) {
         const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
         parsed.command = path5.normalize(parsed.command);
-        parsed.command = escape.command(parsed.command);
-        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        parsed.command = escape2.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
         const shellCommand = [parsed.command].concat(parsed.args).join(" ");
         parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
         parsed.command = process.env.comspec || "cmd.exe";
@@ -1040,7 +1040,7 @@ var require_package = __commonJS({
 // node_modules/dotenv/lib/main.js
 var require_main = __commonJS({
   "node_modules/dotenv/lib/main.js"(exports, module2) {
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var path5 = require("path");
     var os4 = require("os");
     var crypto2 = require("crypto");
@@ -1147,7 +1147,7 @@ var require_main = __commonJS({
       if (options && options.path && options.path.length > 0) {
         if (Array.isArray(options.path)) {
           for (const filepath of options.path) {
-            if (fs6.existsSync(filepath)) {
+            if (fs7.existsSync(filepath)) {
               possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
             }
           }
@@ -1157,7 +1157,7 @@ var require_main = __commonJS({
       } else {
         possibleVaultPath = path5.resolve(process.cwd(), ".env.vault");
       }
-      if (fs6.existsSync(possibleVaultPath)) {
+      if (fs7.existsSync(possibleVaultPath)) {
         return possibleVaultPath;
       }
       return null;
@@ -1201,7 +1201,7 @@ var require_main = __commonJS({
       const parsedAll = {};
       for (const path6 of optionPaths) {
         try {
-          const parsed = DotenvModule.parse(fs6.readFileSync(path6, { encoding }));
+          const parsed = DotenvModule.parse(fs7.readFileSync(path6, { encoding }));
           DotenvModule.populate(parsedAll, parsed, options);
         } catch (e3) {
           if (debug3) {
@@ -21024,7 +21024,7 @@ var require_form_data = __commonJS({
     var http3 = require("http");
     var https3 = require("https");
     var parseUrl = require("url").parse;
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var Stream3 = require("stream").Stream;
     var mime = require_mime_types();
     var asynckit = require_asynckit();
@@ -21089,7 +21089,7 @@ var require_form_data = __commonJS({
         if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
           callback(null, value.end + 1 - (value.start ? value.start : 0));
         } else {
-          fs6.stat(value.path, function(err, stat) {
+          fs7.stat(value.path, function(err, stat) {
             var fileSize;
             if (err) {
               callback(err);
@@ -22849,7 +22849,7 @@ var require_tiktoken = __commonJS({
     var imports = {};
     imports["./tiktoken_bg.js"] = wasm;
     var path5 = require("path");
-    var fs6 = require("fs");
+    var fs7 = require("fs");
     var candidates = __dirname.split(path5.sep).reduce((memo, _7, index, array) => {
       const prefix = array.slice(0, index + 1).join(path5.sep) + path5.sep;
       if (!prefix.includes("node_modules" + path5.sep)) {
@@ -22869,7 +22869,7 @@ var require_tiktoken = __commonJS({
     var bytes = null;
     for (const candidate of candidates) {
       try {
-        bytes = fs6.readFileSync(candidate);
+        bytes = fs7.readFileSync(candidate);
         break;
       } catch {
       }
@@ -24058,6 +24058,2144 @@ var require_state2 = __commonJS({
   }
 });
 
+// node_modules/es-errors/index.js
+var require_es_errors = __commonJS({
+  "node_modules/es-errors/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = Error;
+  }
+});
+
+// node_modules/es-errors/eval.js
+var require_eval = __commonJS({
+  "node_modules/es-errors/eval.js"(exports, module2) {
+    "use strict";
+    module2.exports = EvalError;
+  }
+});
+
+// node_modules/es-errors/range.js
+var require_range = __commonJS({
+  "node_modules/es-errors/range.js"(exports, module2) {
+    "use strict";
+    module2.exports = RangeError;
+  }
+});
+
+// node_modules/es-errors/ref.js
+var require_ref = __commonJS({
+  "node_modules/es-errors/ref.js"(exports, module2) {
+    "use strict";
+    module2.exports = ReferenceError;
+  }
+});
+
+// node_modules/es-errors/syntax.js
+var require_syntax = __commonJS({
+  "node_modules/es-errors/syntax.js"(exports, module2) {
+    "use strict";
+    module2.exports = SyntaxError;
+  }
+});
+
+// node_modules/es-errors/type.js
+var require_type = __commonJS({
+  "node_modules/es-errors/type.js"(exports, module2) {
+    "use strict";
+    module2.exports = TypeError;
+  }
+});
+
+// node_modules/es-errors/uri.js
+var require_uri = __commonJS({
+  "node_modules/es-errors/uri.js"(exports, module2) {
+    "use strict";
+    module2.exports = URIError;
+  }
+});
+
+// node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+  "node_modules/has-symbols/shams.js"(exports, module2) {
+    "use strict";
+    module2.exports = function hasSymbols() {
+      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+        return false;
+      }
+      if (typeof Symbol.iterator === "symbol") {
+        return true;
+      }
+      var obj = {};
+      var sym = Symbol("test");
+      var symObj = Object(sym);
+      if (typeof sym === "string") {
+        return false;
+      }
+      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+        return false;
+      }
+      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+        return false;
+      }
+      var symVal = 42;
+      obj[sym] = symVal;
+      for (sym in obj) {
+        return false;
+      }
+      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+        return false;
+      }
+      var syms = Object.getOwnPropertySymbols(obj);
+      if (syms.length !== 1 || syms[0] !== sym) {
+        return false;
+      }
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyDescriptor === "function") {
+        var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
+// node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+  "node_modules/has-symbols/index.js"(exports, module2) {
+    "use strict";
+    var origSymbol = typeof Symbol !== "undefined" && Symbol;
+    var hasSymbolSham = require_shams();
+    module2.exports = function hasNativeSymbols() {
+      if (typeof origSymbol !== "function") {
+        return false;
+      }
+      if (typeof Symbol !== "function") {
+        return false;
+      }
+      if (typeof origSymbol("foo") !== "symbol") {
+        return false;
+      }
+      if (typeof Symbol("bar") !== "symbol") {
+        return false;
+      }
+      return hasSymbolSham();
+    };
+  }
+});
+
+// node_modules/has-proto/index.js
+var require_has_proto = __commonJS({
+  "node_modules/has-proto/index.js"(exports, module2) {
+    "use strict";
+    var test2 = {
+      __proto__: null,
+      foo: {}
+    };
+    var $Object = Object;
+    module2.exports = function hasProto() {
+      return { __proto__: test2 }.foo === test2.foo && !(test2 instanceof $Object);
+    };
+  }
+});
+
+// node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+  "node_modules/function-bind/implementation.js"(exports, module2) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var toStr = Object.prototype.toString;
+    var max = Math.max;
+    var funcType = "[object Function]";
+    var concatty = function concatty2(a4, b7) {
+      var arr = [];
+      for (var i3 = 0; i3 < a4.length; i3 += 1) {
+        arr[i3] = a4[i3];
+      }
+      for (var j4 = 0; j4 < b7.length; j4 += 1) {
+        arr[j4 + a4.length] = b7[j4];
+      }
+      return arr;
+    };
+    var slicy = function slicy2(arrLike, offset) {
+      var arr = [];
+      for (var i3 = offset || 0, j4 = 0; i3 < arrLike.length; i3 += 1, j4 += 1) {
+        arr[j4] = arrLike[i3];
+      }
+      return arr;
+    };
+    var joiny = function(arr, joiner) {
+      var str2 = "";
+      for (var i3 = 0; i3 < arr.length; i3 += 1) {
+        str2 += arr[i3];
+        if (i3 + 1 < arr.length) {
+          str2 += joiner;
+        }
+      }
+      return str2;
+    };
+    module2.exports = function bind2(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.apply(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+      }
+      var args = slicy(arguments, 1);
+      var bound;
+      var binder = function() {
+        if (this instanceof bound) {
+          var result = target.apply(
+            this,
+            concatty(args, arguments)
+          );
+          if (Object(result) === result) {
+            return result;
+          }
+          return this;
+        }
+        return target.apply(
+          that,
+          concatty(args, arguments)
+        );
+      };
+      var boundLength = max(0, target.length - args.length);
+      var boundArgs = [];
+      for (var i3 = 0; i3 < boundLength; i3++) {
+        boundArgs[i3] = "$" + i3;
+      }
+      bound = Function("binder", "return function (" + joiny(boundArgs, ",") + "){ return binder.apply(this,arguments); }")(binder);
+      if (target.prototype) {
+        var Empty = function Empty2() {
+        };
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+      }
+      return bound;
+    };
+  }
+});
+
+// node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "node_modules/function-bind/index.js"(exports, module2) {
+    "use strict";
+    var implementation = require_implementation();
+    module2.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// node_modules/hasown/index.js
+var require_hasown = __commonJS({
+  "node_modules/hasown/index.js"(exports, module2) {
+    "use strict";
+    var call = Function.prototype.call;
+    var $hasOwn = Object.prototype.hasOwnProperty;
+    var bind2 = require_function_bind();
+    module2.exports = bind2.call(call, $hasOwn);
+  }
+});
+
+// node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+  "node_modules/get-intrinsic/index.js"(exports, module2) {
+    "use strict";
+    var undefined2;
+    var $Error = require_es_errors();
+    var $EvalError = require_eval();
+    var $RangeError = require_range();
+    var $ReferenceError = require_ref();
+    var $SyntaxError = require_syntax();
+    var $TypeError = require_type();
+    var $URIError = require_uri();
+    var $Function = Function;
+    var getEvalledConstructor = function(expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+      } catch (e3) {
+      }
+    };
+    var $gOPD = Object.getOwnPropertyDescriptor;
+    if ($gOPD) {
+      try {
+        $gOPD({}, "");
+      } catch (e3) {
+        $gOPD = null;
+      }
+    }
+    var throwTypeError = function() {
+      throw new $TypeError();
+    };
+    var ThrowTypeError = $gOPD ? function() {
+      try {
+        arguments.callee;
+        return throwTypeError;
+      } catch (calleeThrows) {
+        try {
+          return $gOPD(arguments, "callee").get;
+        } catch (gOPDthrows) {
+          return throwTypeError;
+        }
+      }
+    }() : throwTypeError;
+    var hasSymbols = require_has_symbols()();
+    var hasProto = require_has_proto()();
+    var getProto = Object.getPrototypeOf || (hasProto ? function(x5) {
+      return x5.__proto__;
+    } : null);
+    var needsEval = {};
+    var TypedArray = typeof Uint8Array === "undefined" || !getProto ? undefined2 : getProto(Uint8Array);
+    var INTRINSICS = {
+      __proto__: null,
+      "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+      "%Array%": Array,
+      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+      "%ArrayIteratorPrototype%": hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined2,
+      "%AsyncFromSyncIteratorPrototype%": undefined2,
+      "%AsyncFunction%": needsEval,
+      "%AsyncGenerator%": needsEval,
+      "%AsyncGeneratorFunction%": needsEval,
+      "%AsyncIteratorPrototype%": needsEval,
+      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+      "%BigInt64Array%": typeof BigInt64Array === "undefined" ? undefined2 : BigInt64Array,
+      "%BigUint64Array%": typeof BigUint64Array === "undefined" ? undefined2 : BigUint64Array,
+      "%Boolean%": Boolean,
+      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+      "%Date%": Date,
+      "%decodeURI%": decodeURI,
+      "%decodeURIComponent%": decodeURIComponent,
+      "%encodeURI%": encodeURI,
+      "%encodeURIComponent%": encodeURIComponent,
+      "%Error%": $Error,
+      "%eval%": eval,
+      "%EvalError%": $EvalError,
+      "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+      "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
+      "%Function%": $Function,
+      "%GeneratorFunction%": needsEval,
+      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+      "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+      "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+      "%isFinite%": isFinite,
+      "%isNaN%": isNaN,
+      "%IteratorPrototype%": hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined2,
+      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+      "%Math%": Math,
+      "%Number%": Number,
+      "%Object%": Object,
+      "%parseFloat%": parseFloat,
+      "%parseInt%": parseInt,
+      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+      "%RangeError%": $RangeError,
+      "%ReferenceError%": $ReferenceError,
+      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+      "%RegExp%": RegExp,
+      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols || !getProto ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
+      "%String%": String,
+      "%StringIteratorPrototype%": hasSymbols && getProto ? getProto(""[Symbol.iterator]()) : undefined2,
+      "%Symbol%": hasSymbols ? Symbol : undefined2,
+      "%SyntaxError%": $SyntaxError,
+      "%ThrowTypeError%": ThrowTypeError,
+      "%TypedArray%": TypedArray,
+      "%TypeError%": $TypeError,
+      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
+      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+      "%URIError%": $URIError,
+      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet
+    };
+    if (getProto) {
+      try {
+        null.error;
+      } catch (e3) {
+        errorProto = getProto(getProto(e3));
+        INTRINSICS["%Error.prototype%"] = errorProto;
+      }
+    }
+    var errorProto;
+    var doEval = function doEval2(name) {
+      var value;
+      if (name === "%AsyncFunction%") {
+        value = getEvalledConstructor("async function () {}");
+      } else if (name === "%GeneratorFunction%") {
+        value = getEvalledConstructor("function* () {}");
+      } else if (name === "%AsyncGeneratorFunction%") {
+        value = getEvalledConstructor("async function* () {}");
+      } else if (name === "%AsyncGenerator%") {
+        var fn = doEval2("%AsyncGeneratorFunction%");
+        if (fn) {
+          value = fn.prototype;
+        }
+      } else if (name === "%AsyncIteratorPrototype%") {
+        var gen = doEval2("%AsyncGenerator%");
+        if (gen && getProto) {
+          value = getProto(gen.prototype);
+        }
+      }
+      INTRINSICS[name] = value;
+      return value;
+    };
+    var LEGACY_ALIASES = {
+      __proto__: null,
+      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+      "%ArrayPrototype%": ["Array", "prototype"],
+      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+      "%ArrayProto_values%": ["Array", "prototype", "values"],
+      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+      "%BooleanPrototype%": ["Boolean", "prototype"],
+      "%DataViewPrototype%": ["DataView", "prototype"],
+      "%DatePrototype%": ["Date", "prototype"],
+      "%ErrorPrototype%": ["Error", "prototype"],
+      "%EvalErrorPrototype%": ["EvalError", "prototype"],
+      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+      "%FunctionPrototype%": ["Function", "prototype"],
+      "%Generator%": ["GeneratorFunction", "prototype"],
+      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+      "%JSONParse%": ["JSON", "parse"],
+      "%JSONStringify%": ["JSON", "stringify"],
+      "%MapPrototype%": ["Map", "prototype"],
+      "%NumberPrototype%": ["Number", "prototype"],
+      "%ObjectPrototype%": ["Object", "prototype"],
+      "%ObjProto_toString%": ["Object", "prototype", "toString"],
+      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+      "%PromisePrototype%": ["Promise", "prototype"],
+      "%PromiseProto_then%": ["Promise", "prototype", "then"],
+      "%Promise_all%": ["Promise", "all"],
+      "%Promise_reject%": ["Promise", "reject"],
+      "%Promise_resolve%": ["Promise", "resolve"],
+      "%RangeErrorPrototype%": ["RangeError", "prototype"],
+      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+      "%RegExpPrototype%": ["RegExp", "prototype"],
+      "%SetPrototype%": ["Set", "prototype"],
+      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+      "%StringPrototype%": ["String", "prototype"],
+      "%SymbolPrototype%": ["Symbol", "prototype"],
+      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+      "%TypeErrorPrototype%": ["TypeError", "prototype"],
+      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+      "%URIErrorPrototype%": ["URIError", "prototype"],
+      "%WeakMapPrototype%": ["WeakMap", "prototype"],
+      "%WeakSetPrototype%": ["WeakSet", "prototype"]
+    };
+    var bind2 = require_function_bind();
+    var hasOwn3 = require_hasown();
+    var $concat = bind2.call(Function.call, Array.prototype.concat);
+    var $spliceApply = bind2.call(Function.apply, Array.prototype.splice);
+    var $replace = bind2.call(Function.call, String.prototype.replace);
+    var $strSlice = bind2.call(Function.call, String.prototype.slice);
+    var $exec = bind2.call(Function.call, RegExp.prototype.exec);
+    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+    var reEscapeChar = /\\(\\)?/g;
+    var stringToPath = function stringToPath2(string) {
+      var first = $strSlice(string, 0, 1);
+      var last = $strSlice(string, -1);
+      if (first === "%" && last !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+      } else if (last === "%" && first !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+      }
+      var result = [];
+      $replace(string, rePropName, function(match, number, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+      });
+      return result;
+    };
+    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+      var intrinsicName = name;
+      var alias;
+      if (hasOwn3(LEGACY_ALIASES, intrinsicName)) {
+        alias = LEGACY_ALIASES[intrinsicName];
+        intrinsicName = "%" + alias[0] + "%";
+      }
+      if (hasOwn3(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName];
+        if (value === needsEval) {
+          value = doEval(intrinsicName);
+        }
+        if (typeof value === "undefined" && !allowMissing) {
+          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+        }
+        return {
+          alias,
+          name: intrinsicName,
+          value
+        };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module2.exports = function GetIntrinsic(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      }
+      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      }
+      if ($exec(/^%?[^%]*%?$/, name) === null) {
+        throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
+      }
+      var parts = stringToPath(name);
+      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+      var intrinsicRealName = intrinsic.name;
+      var value = intrinsic.value;
+      var skipFurtherCaching = false;
+      var alias = intrinsic.alias;
+      if (alias) {
+        intrinsicBaseName = alias[0];
+        $spliceApply(parts, $concat([0, 1], alias));
+      }
+      for (var i3 = 1, isOwn = true; i3 < parts.length; i3 += 1) {
+        var part = parts[i3];
+        var first = $strSlice(part, 0, 1);
+        var last = $strSlice(part, -1);
+        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+          throw new $SyntaxError("property names with quotes must have matching quotes");
+        }
+        if (part === "constructor" || !isOwn) {
+          skipFurtherCaching = true;
+        }
+        intrinsicBaseName += "." + part;
+        intrinsicRealName = "%" + intrinsicBaseName + "%";
+        if (hasOwn3(INTRINSICS, intrinsicRealName)) {
+          value = INTRINSICS[intrinsicRealName];
+        } else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing) {
+              throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+            }
+            return void 0;
+          }
+          if ($gOPD && i3 + 1 >= parts.length) {
+            var desc = $gOPD(value, part);
+            isOwn = !!desc;
+            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+              value = desc.get;
+            } else {
+              value = value[part];
+            }
+          } else {
+            isOwn = hasOwn3(value, part);
+            value = value[part];
+          }
+          if (isOwn && !skipFurtherCaching) {
+            INTRINSICS[intrinsicRealName] = value;
+          }
+        }
+      }
+      return value;
+    };
+  }
+});
+
+// node_modules/es-define-property/index.js
+var require_es_define_property = __commonJS({
+  "node_modules/es-define-property/index.js"(exports, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true) || false;
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e3) {
+        $defineProperty = false;
+      }
+    }
+    module2.exports = $defineProperty;
+  }
+});
+
+// node_modules/gopd/index.js
+var require_gopd = __commonJS({
+  "node_modules/gopd/index.js"(exports, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e3) {
+        $gOPD = null;
+      }
+    }
+    module2.exports = $gOPD;
+  }
+});
+
+// node_modules/define-data-property/index.js
+var require_define_data_property = __commonJS({
+  "node_modules/define-data-property/index.js"(exports, module2) {
+    "use strict";
+    var $defineProperty = require_es_define_property();
+    var $SyntaxError = require_syntax();
+    var $TypeError = require_type();
+    var gopd = require_gopd();
+    module2.exports = function defineDataProperty(obj, property, value) {
+      if (!obj || typeof obj !== "object" && typeof obj !== "function") {
+        throw new $TypeError("`obj` must be an object or a function`");
+      }
+      if (typeof property !== "string" && typeof property !== "symbol") {
+        throw new $TypeError("`property` must be a string or a symbol`");
+      }
+      if (arguments.length > 3 && typeof arguments[3] !== "boolean" && arguments[3] !== null) {
+        throw new $TypeError("`nonEnumerable`, if provided, must be a boolean or null");
+      }
+      if (arguments.length > 4 && typeof arguments[4] !== "boolean" && arguments[4] !== null) {
+        throw new $TypeError("`nonWritable`, if provided, must be a boolean or null");
+      }
+      if (arguments.length > 5 && typeof arguments[5] !== "boolean" && arguments[5] !== null) {
+        throw new $TypeError("`nonConfigurable`, if provided, must be a boolean or null");
+      }
+      if (arguments.length > 6 && typeof arguments[6] !== "boolean") {
+        throw new $TypeError("`loose`, if provided, must be a boolean");
+      }
+      var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
+      var nonWritable = arguments.length > 4 ? arguments[4] : null;
+      var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
+      var loose = arguments.length > 6 ? arguments[6] : false;
+      var desc = !!gopd && gopd(obj, property);
+      if ($defineProperty) {
+        $defineProperty(obj, property, {
+          configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
+          enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
+          value,
+          writable: nonWritable === null && desc ? desc.writable : !nonWritable
+        });
+      } else if (loose || !nonEnumerable && !nonWritable && !nonConfigurable) {
+        obj[property] = value;
+      } else {
+        throw new $SyntaxError("This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.");
+      }
+    };
+  }
+});
+
+// node_modules/has-property-descriptors/index.js
+var require_has_property_descriptors = __commonJS({
+  "node_modules/has-property-descriptors/index.js"(exports, module2) {
+    "use strict";
+    var $defineProperty = require_es_define_property();
+    var hasPropertyDescriptors = function hasPropertyDescriptors2() {
+      return !!$defineProperty;
+    };
+    hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {
+      if (!$defineProperty) {
+        return null;
+      }
+      try {
+        return $defineProperty([], "length", { value: 1 }).length !== 1;
+      } catch (e3) {
+        return true;
+      }
+    };
+    module2.exports = hasPropertyDescriptors;
+  }
+});
+
+// node_modules/set-function-length/index.js
+var require_set_function_length = __commonJS({
+  "node_modules/set-function-length/index.js"(exports, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var define2 = require_define_data_property();
+    var hasDescriptors = require_has_property_descriptors()();
+    var gOPD = require_gopd();
+    var $TypeError = require_type();
+    var $floor = GetIntrinsic("%Math.floor%");
+    module2.exports = function setFunctionLength(fn, length) {
+      if (typeof fn !== "function") {
+        throw new $TypeError("`fn` is not a function");
+      }
+      if (typeof length !== "number" || length < 0 || length > 4294967295 || $floor(length) !== length) {
+        throw new $TypeError("`length` must be a positive 32-bit integer");
+      }
+      var loose = arguments.length > 2 && !!arguments[2];
+      var functionLengthIsConfigurable = true;
+      var functionLengthIsWritable = true;
+      if ("length" in fn && gOPD) {
+        var desc = gOPD(fn, "length");
+        if (desc && !desc.configurable) {
+          functionLengthIsConfigurable = false;
+        }
+        if (desc && !desc.writable) {
+          functionLengthIsWritable = false;
+        }
+      }
+      if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
+        if (hasDescriptors) {
+          define2(fn, "length", length, true, true);
+        } else {
+          define2(fn, "length", length);
+        }
+      }
+      return fn;
+    };
+  }
+});
+
+// node_modules/call-bind/index.js
+var require_call_bind = __commonJS({
+  "node_modules/call-bind/index.js"(exports, module2) {
+    "use strict";
+    var bind2 = require_function_bind();
+    var GetIntrinsic = require_get_intrinsic();
+    var setFunctionLength = require_set_function_length();
+    var $TypeError = require_type();
+    var $apply = GetIntrinsic("%Function.prototype.apply%");
+    var $call = GetIntrinsic("%Function.prototype.call%");
+    var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind2.call($call, $apply);
+    var $defineProperty = require_es_define_property();
+    var $max = GetIntrinsic("%Math.max%");
+    module2.exports = function callBind(originalFunction) {
+      if (typeof originalFunction !== "function") {
+        throw new $TypeError("a function is required");
+      }
+      var func = $reflectApply(bind2, $call, arguments);
+      return setFunctionLength(
+        func,
+        1 + $max(0, originalFunction.length - (arguments.length - 1)),
+        true
+      );
+    };
+    var applyBind = function applyBind2() {
+      return $reflectApply(bind2, $apply, arguments);
+    };
+    if ($defineProperty) {
+      $defineProperty(module2.exports, "apply", { value: applyBind });
+    } else {
+      module2.exports.apply = applyBind;
+    }
+  }
+});
+
+// node_modules/call-bind/callBound.js
+var require_callBound = __commonJS({
+  "node_modules/call-bind/callBound.js"(exports, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var callBind = require_call_bind();
+    var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+    module2.exports = function callBoundIntrinsic(name, allowMissing) {
+      var intrinsic = GetIntrinsic(name, !!allowMissing);
+      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+        return callBind(intrinsic);
+      }
+      return intrinsic;
+    };
+  }
+});
+
+// node_modules/object-inspect/util.inspect.js
+var require_util_inspect = __commonJS({
+  "node_modules/object-inspect/util.inspect.js"(exports, module2) {
+    module2.exports = require("util").inspect;
+  }
+});
+
+// node_modules/object-inspect/index.js
+var require_object_inspect = __commonJS({
+  "node_modules/object-inspect/index.js"(exports, module2) {
+    var hasMap = typeof Map === "function" && Map.prototype;
+    var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
+    var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
+    var mapForEach = hasMap && Map.prototype.forEach;
+    var hasSet = typeof Set === "function" && Set.prototype;
+    var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
+    var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
+    var setForEach = hasSet && Set.prototype.forEach;
+    var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype;
+    var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
+    var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype;
+    var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
+    var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype;
+    var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
+    var booleanValueOf = Boolean.prototype.valueOf;
+    var objectToString = Object.prototype.toString;
+    var functionToString = Function.prototype.toString;
+    var $match = String.prototype.match;
+    var $slice = String.prototype.slice;
+    var $replace = String.prototype.replace;
+    var $toUpperCase = String.prototype.toUpperCase;
+    var $toLowerCase = String.prototype.toLowerCase;
+    var $test = RegExp.prototype.test;
+    var $concat = Array.prototype.concat;
+    var $join = Array.prototype.join;
+    var $arrSlice = Array.prototype.slice;
+    var $floor = Math.floor;
+    var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
+    var gOPS = Object.getOwnPropertySymbols;
+    var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
+    var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
+    var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
+    var isEnumerable = Object.prototype.propertyIsEnumerable;
+    var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O5) {
+      return O5.__proto__;
+    } : null);
+    function addNumericSeparator(num, str2) {
+      if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str2)) {
+        return str2;
+      }
+      var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
+      if (typeof num === "number") {
+        var int = num < 0 ? -$floor(-num) : $floor(num);
+        if (int !== num) {
+          var intStr = String(int);
+          var dec = $slice.call(str2, intStr.length + 1);
+          return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec, /([0-9]{3})/g, "$&_"), /_$/, "");
+        }
+      }
+      return $replace.call(str2, sepRegex, "$&_");
+    }
+    var utilInspect = require_util_inspect();
+    var inspectCustom = utilInspect.custom;
+    var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
+    module2.exports = function inspect_(obj, options, depth, seen) {
+      var opts = options || {};
+      if (has(opts, "quoteStyle") && (opts.quoteStyle !== "single" && opts.quoteStyle !== "double")) {
+        throw new TypeError('option "quoteStyle" must be "single" or "double"');
+      }
+      if (has(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {
+        throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
+      }
+      var customInspect = has(opts, "customInspect") ? opts.customInspect : true;
+      if (typeof customInspect !== "boolean" && customInspect !== "symbol") {
+        throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
+      }
+      if (has(opts, "indent") && opts.indent !== null && opts.indent !== "	" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {
+        throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
+      }
+      if (has(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") {
+        throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
+      }
+      var numericSeparator = opts.numericSeparator;
+      if (typeof obj === "undefined") {
+        return "undefined";
+      }
+      if (obj === null) {
+        return "null";
+      }
+      if (typeof obj === "boolean") {
+        return obj ? "true" : "false";
+      }
+      if (typeof obj === "string") {
+        return inspectString(obj, opts);
+      }
+      if (typeof obj === "number") {
+        if (obj === 0) {
+          return Infinity / obj > 0 ? "0" : "-0";
+        }
+        var str2 = String(obj);
+        return numericSeparator ? addNumericSeparator(obj, str2) : str2;
+      }
+      if (typeof obj === "bigint") {
+        var bigIntStr = String(obj) + "n";
+        return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
+      }
+      var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
+      if (typeof depth === "undefined") {
+        depth = 0;
+      }
+      if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") {
+        return isArray2(obj) ? "[Array]" : "[Object]";
+      }
+      var indent = getIndent(opts, depth);
+      if (typeof seen === "undefined") {
+        seen = [];
+      } else if (indexOf(seen, obj) >= 0) {
+        return "[Circular]";
+      }
+      function inspect3(value, from, noIndent) {
+        if (from) {
+          seen = $arrSlice.call(seen);
+          seen.push(from);
+        }
+        if (noIndent) {
+          var newOpts = {
+            depth: opts.depth
+          };
+          if (has(opts, "quoteStyle")) {
+            newOpts.quoteStyle = opts.quoteStyle;
+          }
+          return inspect_(value, newOpts, depth + 1, seen);
+        }
+        return inspect_(value, opts, depth + 1, seen);
+      }
+      if (typeof obj === "function" && !isRegExp2(obj)) {
+        var name = nameOf(obj);
+        var keys = arrObjKeys(obj, inspect3);
+        return "[Function" + (name ? ": " + name : " (anonymous)") + "]" + (keys.length > 0 ? " { " + $join.call(keys, ", ") + " }" : "");
+      }
+      if (isSymbol(obj)) {
+        var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
+        return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
+      }
+      if (isElement(obj)) {
+        var s2 = "<" + $toLowerCase.call(String(obj.nodeName));
+        var attrs = obj.attributes || [];
+        for (var i3 = 0; i3 < attrs.length; i3++) {
+          s2 += " " + attrs[i3].name + "=" + wrapQuotes(quote(attrs[i3].value), "double", opts);
+        }
+        s2 += ">";
+        if (obj.childNodes && obj.childNodes.length) {
+          s2 += "...";
+        }
+        s2 += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
+        return s2;
+      }
+      if (isArray2(obj)) {
+        if (obj.length === 0) {
+          return "[]";
+        }
+        var xs = arrObjKeys(obj, inspect3);
+        if (indent && !singleLineValues(xs)) {
+          return "[" + indentedJoin(xs, indent) + "]";
+        }
+        return "[ " + $join.call(xs, ", ") + " ]";
+      }
+      if (isError2(obj)) {
+        var parts = arrObjKeys(obj, inspect3);
+        if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
+          return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect3(obj.cause), parts), ", ") + " }";
+        }
+        if (parts.length === 0) {
+          return "[" + String(obj) + "]";
+        }
+        return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
+      }
+      if (typeof obj === "object" && customInspect) {
+        if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) {
+          return utilInspect(obj, { depth: maxDepth - depth });
+        } else if (customInspect !== "symbol" && typeof obj.inspect === "function") {
+          return obj.inspect();
+        }
+      }
+      if (isMap(obj)) {
+        var mapParts = [];
+        if (mapForEach) {
+          mapForEach.call(obj, function(value, key) {
+            mapParts.push(inspect3(key, obj, true) + " => " + inspect3(value, obj));
+          });
+        }
+        return collectionOf("Map", mapSize.call(obj), mapParts, indent);
+      }
+      if (isSet(obj)) {
+        var setParts = [];
+        if (setForEach) {
+          setForEach.call(obj, function(value) {
+            setParts.push(inspect3(value, obj));
+          });
+        }
+        return collectionOf("Set", setSize.call(obj), setParts, indent);
+      }
+      if (isWeakMap(obj)) {
+        return weakCollectionOf("WeakMap");
+      }
+      if (isWeakSet(obj)) {
+        return weakCollectionOf("WeakSet");
+      }
+      if (isWeakRef(obj)) {
+        return weakCollectionOf("WeakRef");
+      }
+      if (isNumber2(obj)) {
+        return markBoxed(inspect3(Number(obj)));
+      }
+      if (isBigInt(obj)) {
+        return markBoxed(inspect3(bigIntValueOf.call(obj)));
+      }
+      if (isBoolean2(obj)) {
+        return markBoxed(booleanValueOf.call(obj));
+      }
+      if (isString2(obj)) {
+        return markBoxed(inspect3(String(obj)));
+      }
+      if (typeof window !== "undefined" && obj === window) {
+        return "{ [object Window] }";
+      }
+      if (typeof globalThis !== "undefined" && obj === globalThis || typeof global !== "undefined" && obj === global) {
+        return "{ [object globalThis] }";
+      }
+      if (!isDate2(obj) && !isRegExp2(obj)) {
+        var ys = arrObjKeys(obj, inspect3);
+        var isPlainObject4 = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
+        var protoTag = obj instanceof Object ? "" : "null prototype";
+        var stringTag = !isPlainObject4 && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
+        var constructorTag = isPlainObject4 || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
+        var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
+        if (ys.length === 0) {
+          return tag + "{}";
+        }
+        if (indent) {
+          return tag + "{" + indentedJoin(ys, indent) + "}";
+        }
+        return tag + "{ " + $join.call(ys, ", ") + " }";
+      }
+      return String(obj);
+    };
+    function wrapQuotes(s2, defaultStyle, opts) {
+      var quoteChar = (opts.quoteStyle || defaultStyle) === "double" ? '"' : "'";
+      return quoteChar + s2 + quoteChar;
+    }
+    function quote(s2) {
+      return $replace.call(String(s2), /"/g, "&quot;");
+    }
+    function isArray2(obj) {
+      return toStr(obj) === "[object Array]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+    }
+    function isDate2(obj) {
+      return toStr(obj) === "[object Date]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+    }
+    function isRegExp2(obj) {
+      return toStr(obj) === "[object RegExp]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+    }
+    function isError2(obj) {
+      return toStr(obj) === "[object Error]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+    }
+    function isString2(obj) {
+      return toStr(obj) === "[object String]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+    }
+    function isNumber2(obj) {
+      return toStr(obj) === "[object Number]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+    }
+    function isBoolean2(obj) {
+      return toStr(obj) === "[object Boolean]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+    }
+    function isSymbol(obj) {
+      if (hasShammedSymbols) {
+        return obj && typeof obj === "object" && obj instanceof Symbol;
+      }
+      if (typeof obj === "symbol") {
+        return true;
+      }
+      if (!obj || typeof obj !== "object" || !symToString) {
+        return false;
+      }
+      try {
+        symToString.call(obj);
+        return true;
+      } catch (e3) {
+      }
+      return false;
+    }
+    function isBigInt(obj) {
+      if (!obj || typeof obj !== "object" || !bigIntValueOf) {
+        return false;
+      }
+      try {
+        bigIntValueOf.call(obj);
+        return true;
+      } catch (e3) {
+      }
+      return false;
+    }
+    var hasOwn3 = Object.prototype.hasOwnProperty || function(key) {
+      return key in this;
+    };
+    function has(obj, key) {
+      return hasOwn3.call(obj, key);
+    }
+    function toStr(obj) {
+      return objectToString.call(obj);
+    }
+    function nameOf(f4) {
+      if (f4.name) {
+        return f4.name;
+      }
+      var m5 = $match.call(functionToString.call(f4), /^function\s*([\w$]+)/);
+      if (m5) {
+        return m5[1];
+      }
+      return null;
+    }
+    function indexOf(xs, x5) {
+      if (xs.indexOf) {
+        return xs.indexOf(x5);
+      }
+      for (var i3 = 0, l3 = xs.length; i3 < l3; i3++) {
+        if (xs[i3] === x5) {
+          return i3;
+        }
+      }
+      return -1;
+    }
+    function isMap(x5) {
+      if (!mapSize || !x5 || typeof x5 !== "object") {
+        return false;
+      }
+      try {
+        mapSize.call(x5);
+        try {
+          setSize.call(x5);
+        } catch (s2) {
+          return true;
+        }
+        return x5 instanceof Map;
+      } catch (e3) {
+      }
+      return false;
+    }
+    function isWeakMap(x5) {
+      if (!weakMapHas || !x5 || typeof x5 !== "object") {
+        return false;
+      }
+      try {
+        weakMapHas.call(x5, weakMapHas);
+        try {
+          weakSetHas.call(x5, weakSetHas);
+        } catch (s2) {
+          return true;
+        }
+        return x5 instanceof WeakMap;
+      } catch (e3) {
+      }
+      return false;
+    }
+    function isWeakRef(x5) {
+      if (!weakRefDeref || !x5 || typeof x5 !== "object") {
+        return false;
+      }
+      try {
+        weakRefDeref.call(x5);
+        return true;
+      } catch (e3) {
+      }
+      return false;
+    }
+    function isSet(x5) {
+      if (!setSize || !x5 || typeof x5 !== "object") {
+        return false;
+      }
+      try {
+        setSize.call(x5);
+        try {
+          mapSize.call(x5);
+        } catch (m5) {
+          return true;
+        }
+        return x5 instanceof Set;
+      } catch (e3) {
+      }
+      return false;
+    }
+    function isWeakSet(x5) {
+      if (!weakSetHas || !x5 || typeof x5 !== "object") {
+        return false;
+      }
+      try {
+        weakSetHas.call(x5, weakSetHas);
+        try {
+          weakMapHas.call(x5, weakMapHas);
+        } catch (s2) {
+          return true;
+        }
+        return x5 instanceof WeakSet;
+      } catch (e3) {
+      }
+      return false;
+    }
+    function isElement(x5) {
+      if (!x5 || typeof x5 !== "object") {
+        return false;
+      }
+      if (typeof HTMLElement !== "undefined" && x5 instanceof HTMLElement) {
+        return true;
+      }
+      return typeof x5.nodeName === "string" && typeof x5.getAttribute === "function";
+    }
+    function inspectString(str2, opts) {
+      if (str2.length > opts.maxStringLength) {
+        var remaining = str2.length - opts.maxStringLength;
+        var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
+        return inspectString($slice.call(str2, 0, opts.maxStringLength), opts) + trailer;
+      }
+      var s2 = $replace.call($replace.call(str2, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, lowbyte);
+      return wrapQuotes(s2, "single", opts);
+    }
+    function lowbyte(c3) {
+      var n2 = c3.charCodeAt(0);
+      var x5 = {
+        8: "b",
+        9: "t",
+        10: "n",
+        12: "f",
+        13: "r"
+      }[n2];
+      if (x5) {
+        return "\\" + x5;
+      }
+      return "\\x" + (n2 < 16 ? "0" : "") + $toUpperCase.call(n2.toString(16));
+    }
+    function markBoxed(str2) {
+      return "Object(" + str2 + ")";
+    }
+    function weakCollectionOf(type2) {
+      return type2 + " { ? }";
+    }
+    function collectionOf(type2, size, entries, indent) {
+      var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
+      return type2 + " (" + size + ") {" + joinedEntries + "}";
+    }
+    function singleLineValues(xs) {
+      for (var i3 = 0; i3 < xs.length; i3++) {
+        if (indexOf(xs[i3], "\n") >= 0) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function getIndent(opts, depth) {
+      var baseIndent;
+      if (opts.indent === "	") {
+        baseIndent = "	";
+      } else if (typeof opts.indent === "number" && opts.indent > 0) {
+        baseIndent = $join.call(Array(opts.indent + 1), " ");
+      } else {
+        return null;
+      }
+      return {
+        base: baseIndent,
+        prev: $join.call(Array(depth + 1), baseIndent)
+      };
+    }
+    function indentedJoin(xs, indent) {
+      if (xs.length === 0) {
+        return "";
+      }
+      var lineJoiner = "\n" + indent.prev + indent.base;
+      return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
+    }
+    function arrObjKeys(obj, inspect3) {
+      var isArr = isArray2(obj);
+      var xs = [];
+      if (isArr) {
+        xs.length = obj.length;
+        for (var i3 = 0; i3 < obj.length; i3++) {
+          xs[i3] = has(obj, i3) ? inspect3(obj[i3], obj) : "";
+        }
+      }
+      var syms = typeof gOPS === "function" ? gOPS(obj) : [];
+      var symMap;
+      if (hasShammedSymbols) {
+        symMap = {};
+        for (var k7 = 0; k7 < syms.length; k7++) {
+          symMap["$" + syms[k7]] = syms[k7];
+        }
+      }
+      for (var key in obj) {
+        if (!has(obj, key)) {
+          continue;
+        }
+        if (isArr && String(Number(key)) === key && key < obj.length) {
+          continue;
+        }
+        if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) {
+          continue;
+        } else if ($test.call(/[^\w$]/, key)) {
+          xs.push(inspect3(key, obj) + ": " + inspect3(obj[key], obj));
+        } else {
+          xs.push(key + ": " + inspect3(obj[key], obj));
+        }
+      }
+      if (typeof gOPS === "function") {
+        for (var j4 = 0; j4 < syms.length; j4++) {
+          if (isEnumerable.call(obj, syms[j4])) {
+            xs.push("[" + inspect3(syms[j4]) + "]: " + inspect3(obj[syms[j4]], obj));
+          }
+        }
+      }
+      return xs;
+    }
+  }
+});
+
+// node_modules/side-channel/index.js
+var require_side_channel = __commonJS({
+  "node_modules/side-channel/index.js"(exports, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var callBound = require_callBound();
+    var inspect3 = require_object_inspect();
+    var $TypeError = require_type();
+    var $WeakMap = GetIntrinsic("%WeakMap%", true);
+    var $Map = GetIntrinsic("%Map%", true);
+    var $weakMapGet = callBound("WeakMap.prototype.get", true);
+    var $weakMapSet = callBound("WeakMap.prototype.set", true);
+    var $weakMapHas = callBound("WeakMap.prototype.has", true);
+    var $mapGet = callBound("Map.prototype.get", true);
+    var $mapSet = callBound("Map.prototype.set", true);
+    var $mapHas = callBound("Map.prototype.has", true);
+    var listGetNode = function(list, key) {
+      var prev = list;
+      var curr;
+      for (; (curr = prev.next) !== null; prev = curr) {
+        if (curr.key === key) {
+          prev.next = curr.next;
+          curr.next = list.next;
+          list.next = curr;
+          return curr;
+        }
+      }
+    };
+    var listGet = function(objects, key) {
+      var node = listGetNode(objects, key);
+      return node && node.value;
+    };
+    var listSet = function(objects, key, value) {
+      var node = listGetNode(objects, key);
+      if (node) {
+        node.value = value;
+      } else {
+        objects.next = {
+          key,
+          next: objects.next,
+          value
+        };
+      }
+    };
+    var listHas = function(objects, key) {
+      return !!listGetNode(objects, key);
+    };
+    module2.exports = function getSideChannel() {
+      var $wm;
+      var $m;
+      var $o;
+      var channel = {
+        assert: function(key) {
+          if (!channel.has(key)) {
+            throw new $TypeError("Side channel does not contain " + inspect3(key));
+          }
+        },
+        get: function(key) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if ($wm) {
+              return $weakMapGet($wm, key);
+            }
+          } else if ($Map) {
+            if ($m) {
+              return $mapGet($m, key);
+            }
+          } else {
+            if ($o) {
+              return listGet($o, key);
+            }
+          }
+        },
+        has: function(key) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if ($wm) {
+              return $weakMapHas($wm, key);
+            }
+          } else if ($Map) {
+            if ($m) {
+              return $mapHas($m, key);
+            }
+          } else {
+            if ($o) {
+              return listHas($o, key);
+            }
+          }
+          return false;
+        },
+        set: function(key, value) {
+          if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+            if (!$wm) {
+              $wm = new $WeakMap();
+            }
+            $weakMapSet($wm, key, value);
+          } else if ($Map) {
+            if (!$m) {
+              $m = new $Map();
+            }
+            $mapSet($m, key, value);
+          } else {
+            if (!$o) {
+              $o = { key: {}, next: null };
+            }
+            listSet($o, key, value);
+          }
+        }
+      };
+      return channel;
+    };
+  }
+});
+
+// node_modules/qs/lib/formats.js
+var require_formats = __commonJS({
+  "node_modules/qs/lib/formats.js"(exports, module2) {
+    "use strict";
+    var replace = String.prototype.replace;
+    var percentTwenties = /%20/g;
+    var Format = {
+      RFC1738: "RFC1738",
+      RFC3986: "RFC3986"
+    };
+    module2.exports = {
+      "default": Format.RFC3986,
+      formatters: {
+        RFC1738: function(value) {
+          return replace.call(value, percentTwenties, "+");
+        },
+        RFC3986: function(value) {
+          return String(value);
+        }
+      },
+      RFC1738: Format.RFC1738,
+      RFC3986: Format.RFC3986
+    };
+  }
+});
+
+// node_modules/qs/lib/utils.js
+var require_utils2 = __commonJS({
+  "node_modules/qs/lib/utils.js"(exports, module2) {
+    "use strict";
+    var formats = require_formats();
+    var has = Object.prototype.hasOwnProperty;
+    var isArray2 = Array.isArray;
+    var hexTable = function() {
+      var array = [];
+      for (var i3 = 0; i3 < 256; ++i3) {
+        array.push("%" + ((i3 < 16 ? "0" : "") + i3.toString(16)).toUpperCase());
+      }
+      return array;
+    }();
+    var compactQueue = function compactQueue2(queue) {
+      while (queue.length > 1) {
+        var item = queue.pop();
+        var obj = item.obj[item.prop];
+        if (isArray2(obj)) {
+          var compacted = [];
+          for (var j4 = 0; j4 < obj.length; ++j4) {
+            if (typeof obj[j4] !== "undefined") {
+              compacted.push(obj[j4]);
+            }
+          }
+          item.obj[item.prop] = compacted;
+        }
+      }
+    };
+    var arrayToObject2 = function arrayToObject3(source, options) {
+      var obj = options && options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+      for (var i3 = 0; i3 < source.length; ++i3) {
+        if (typeof source[i3] !== "undefined") {
+          obj[i3] = source[i3];
+        }
+      }
+      return obj;
+    };
+    var merge2 = function merge3(target, source, options) {
+      if (!source) {
+        return target;
+      }
+      if (typeof source !== "object") {
+        if (isArray2(target)) {
+          target.push(source);
+        } else if (target && typeof target === "object") {
+          if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
+            target[source] = true;
+          }
+        } else {
+          return [target, source];
+        }
+        return target;
+      }
+      if (!target || typeof target !== "object") {
+        return [target].concat(source);
+      }
+      var mergeTarget = target;
+      if (isArray2(target) && !isArray2(source)) {
+        mergeTarget = arrayToObject2(target, options);
+      }
+      if (isArray2(target) && isArray2(source)) {
+        source.forEach(function(item, i3) {
+          if (has.call(target, i3)) {
+            var targetItem = target[i3];
+            if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
+              target[i3] = merge3(targetItem, item, options);
+            } else {
+              target.push(item);
+            }
+          } else {
+            target[i3] = item;
+          }
+        });
+        return target;
+      }
+      return Object.keys(source).reduce(function(acc, key) {
+        var value = source[key];
+        if (has.call(acc, key)) {
+          acc[key] = merge3(acc[key], value, options);
+        } else {
+          acc[key] = value;
+        }
+        return acc;
+      }, mergeTarget);
+    };
+    var assign = function assignSingleSource(target, source) {
+      return Object.keys(source).reduce(function(acc, key) {
+        acc[key] = source[key];
+        return acc;
+      }, target);
+    };
+    var decode = function(str2, decoder, charset) {
+      var strWithoutPlus = str2.replace(/\+/g, " ");
+      if (charset === "iso-8859-1") {
+        return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+      }
+      try {
+        return decodeURIComponent(strWithoutPlus);
+      } catch (e3) {
+        return strWithoutPlus;
+      }
+    };
+    var limit = 1024;
+    var encode3 = function encode4(str2, defaultEncoder, charset, kind3, format) {
+      if (str2.length === 0) {
+        return str2;
+      }
+      var string = str2;
+      if (typeof str2 === "symbol") {
+        string = Symbol.prototype.toString.call(str2);
+      } else if (typeof str2 !== "string") {
+        string = String(str2);
+      }
+      if (charset === "iso-8859-1") {
+        return escape(string).replace(/%u[0-9a-f]{4}/gi, function($0) {
+          return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
+        });
+      }
+      var out = "";
+      for (var j4 = 0; j4 < string.length; j4 += limit) {
+        var segment = string.length >= limit ? string.slice(j4, j4 + limit) : string;
+        var arr = [];
+        for (var i3 = 0; i3 < segment.length; ++i3) {
+          var c3 = segment.charCodeAt(i3);
+          if (c3 === 45 || c3 === 46 || c3 === 95 || c3 === 126 || c3 >= 48 && c3 <= 57 || c3 >= 65 && c3 <= 90 || c3 >= 97 && c3 <= 122 || format === formats.RFC1738 && (c3 === 40 || c3 === 41)) {
+            arr[arr.length] = segment.charAt(i3);
+            continue;
+          }
+          if (c3 < 128) {
+            arr[arr.length] = hexTable[c3];
+            continue;
+          }
+          if (c3 < 2048) {
+            arr[arr.length] = hexTable[192 | c3 >> 6] + hexTable[128 | c3 & 63];
+            continue;
+          }
+          if (c3 < 55296 || c3 >= 57344) {
+            arr[arr.length] = hexTable[224 | c3 >> 12] + hexTable[128 | c3 >> 6 & 63] + hexTable[128 | c3 & 63];
+            continue;
+          }
+          i3 += 1;
+          c3 = 65536 + ((c3 & 1023) << 10 | segment.charCodeAt(i3) & 1023);
+          arr[arr.length] = hexTable[240 | c3 >> 18] + hexTable[128 | c3 >> 12 & 63] + hexTable[128 | c3 >> 6 & 63] + hexTable[128 | c3 & 63];
+        }
+        out += arr.join("");
+      }
+      return out;
+    };
+    var compact = function compact2(value) {
+      var queue = [{ obj: { o: value }, prop: "o" }];
+      var refs = [];
+      for (var i3 = 0; i3 < queue.length; ++i3) {
+        var item = queue[i3];
+        var obj = item.obj[item.prop];
+        var keys = Object.keys(obj);
+        for (var j4 = 0; j4 < keys.length; ++j4) {
+          var key = keys[j4];
+          var val = obj[key];
+          if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
+            queue.push({ obj, prop: key });
+            refs.push(val);
+          }
+        }
+      }
+      compactQueue(queue);
+      return value;
+    };
+    var isRegExp2 = function isRegExp3(obj) {
+      return Object.prototype.toString.call(obj) === "[object RegExp]";
+    };
+    var isBuffer2 = function isBuffer3(obj) {
+      if (!obj || typeof obj !== "object") {
+        return false;
+      }
+      return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+    };
+    var combine = function combine2(a4, b7) {
+      return [].concat(a4, b7);
+    };
+    var maybeMap = function maybeMap2(val, fn) {
+      if (isArray2(val)) {
+        var mapped = [];
+        for (var i3 = 0; i3 < val.length; i3 += 1) {
+          mapped.push(fn(val[i3]));
+        }
+        return mapped;
+      }
+      return fn(val);
+    };
+    module2.exports = {
+      arrayToObject: arrayToObject2,
+      assign,
+      combine,
+      compact,
+      decode,
+      encode: encode3,
+      isBuffer: isBuffer2,
+      isRegExp: isRegExp2,
+      maybeMap,
+      merge: merge2
+    };
+  }
+});
+
+// node_modules/qs/lib/stringify.js
+var require_stringify = __commonJS({
+  "node_modules/qs/lib/stringify.js"(exports, module2) {
+    "use strict";
+    var getSideChannel = require_side_channel();
+    var utils = require_utils2();
+    var formats = require_formats();
+    var has = Object.prototype.hasOwnProperty;
+    var arrayPrefixGenerators = {
+      brackets: function brackets(prefix) {
+        return prefix + "[]";
+      },
+      comma: "comma",
+      indices: function indices(prefix, key) {
+        return prefix + "[" + key + "]";
+      },
+      repeat: function repeat(prefix) {
+        return prefix;
+      }
+    };
+    var isArray2 = Array.isArray;
+    var push = Array.prototype.push;
+    var pushToArray = function(arr, valueOrArray) {
+      push.apply(arr, isArray2(valueOrArray) ? valueOrArray : [valueOrArray]);
+    };
+    var toISO = Date.prototype.toISOString;
+    var defaultFormat = formats["default"];
+    var defaults2 = {
+      addQueryPrefix: false,
+      allowDots: false,
+      allowEmptyArrays: false,
+      arrayFormat: "indices",
+      charset: "utf-8",
+      charsetSentinel: false,
+      delimiter: "&",
+      encode: true,
+      encodeDotInKeys: false,
+      encoder: utils.encode,
+      encodeValuesOnly: false,
+      format: defaultFormat,
+      formatter: formats.formatters[defaultFormat],
+      indices: false,
+      serializeDate: function serializeDate(date) {
+        return toISO.call(date);
+      },
+      skipNulls: false,
+      strictNullHandling: false
+    };
+    var isNonNullishPrimitive = function isNonNullishPrimitive2(v5) {
+      return typeof v5 === "string" || typeof v5 === "number" || typeof v5 === "boolean" || typeof v5 === "symbol" || typeof v5 === "bigint";
+    };
+    var sentinel = {};
+    var stringify2 = function stringify3(object, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter2, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {
+      var obj = object;
+      var tmpSc = sideChannel;
+      var step = 0;
+      var findFlag = false;
+      while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
+        var pos = tmpSc.get(object);
+        step += 1;
+        if (typeof pos !== "undefined") {
+          if (pos === step) {
+            throw new RangeError("Cyclic object value");
+          } else {
+            findFlag = true;
+          }
+        }
+        if (typeof tmpSc.get(sentinel) === "undefined") {
+          step = 0;
+        }
+      }
+      if (typeof filter2 === "function") {
+        obj = filter2(prefix, obj);
+      } else if (obj instanceof Date) {
+        obj = serializeDate(obj);
+      } else if (generateArrayPrefix === "comma" && isArray2(obj)) {
+        obj = utils.maybeMap(obj, function(value2) {
+          if (value2 instanceof Date) {
+            return serializeDate(value2);
+          }
+          return value2;
+        });
+      }
+      if (obj === null) {
+        if (strictNullHandling) {
+          return encoder && !encodeValuesOnly ? encoder(prefix, defaults2.encoder, charset, "key", format) : prefix;
+        }
+        obj = "";
+      }
+      if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
+        if (encoder) {
+          var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults2.encoder, charset, "key", format);
+          return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults2.encoder, charset, "value", format))];
+        }
+        return [formatter(prefix) + "=" + formatter(String(obj))];
+      }
+      var values = [];
+      if (typeof obj === "undefined") {
+        return values;
+      }
+      var objKeys;
+      if (generateArrayPrefix === "comma" && isArray2(obj)) {
+        if (encodeValuesOnly && encoder) {
+          obj = utils.maybeMap(obj, encoder);
+        }
+        objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
+      } else if (isArray2(filter2)) {
+        objKeys = filter2;
+      } else {
+        var keys = Object.keys(obj);
+        objKeys = sort ? keys.sort(sort) : keys;
+      }
+      var encodedPrefix = encodeDotInKeys ? prefix.replace(/\./g, "%2E") : prefix;
+      var adjustedPrefix = commaRoundTrip && isArray2(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
+      if (allowEmptyArrays && isArray2(obj) && obj.length === 0) {
+        return adjustedPrefix + "[]";
+      }
+      for (var j4 = 0; j4 < objKeys.length; ++j4) {
+        var key = objKeys[j4];
+        var value = typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key];
+        if (skipNulls && value === null) {
+          continue;
+        }
+        var encodedKey = allowDots && encodeDotInKeys ? key.replace(/\./g, "%2E") : key;
+        var keyPrefix = isArray2(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, encodedKey) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + encodedKey : "[" + encodedKey + "]");
+        sideChannel.set(object, step);
+        var valueSideChannel = getSideChannel();
+        valueSideChannel.set(sentinel, sideChannel);
+        pushToArray(values, stringify3(
+          value,
+          keyPrefix,
+          generateArrayPrefix,
+          commaRoundTrip,
+          allowEmptyArrays,
+          strictNullHandling,
+          skipNulls,
+          encodeDotInKeys,
+          generateArrayPrefix === "comma" && encodeValuesOnly && isArray2(obj) ? null : encoder,
+          filter2,
+          sort,
+          allowDots,
+          serializeDate,
+          format,
+          formatter,
+          encodeValuesOnly,
+          charset,
+          valueSideChannel
+        ));
+      }
+      return values;
+    };
+    var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) {
+      if (!opts) {
+        return defaults2;
+      }
+      if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
+        throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+      }
+      if (typeof opts.encodeDotInKeys !== "undefined" && typeof opts.encodeDotInKeys !== "boolean") {
+        throw new TypeError("`encodeDotInKeys` option can only be `true` or `false`, when provided");
+      }
+      if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
+        throw new TypeError("Encoder has to be a function.");
+      }
+      var charset = opts.charset || defaults2.charset;
+      if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+        throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+      }
+      var format = formats["default"];
+      if (typeof opts.format !== "undefined") {
+        if (!has.call(formats.formatters, opts.format)) {
+          throw new TypeError("Unknown format option provided.");
+        }
+        format = opts.format;
+      }
+      var formatter = formats.formatters[format];
+      var filter2 = defaults2.filter;
+      if (typeof opts.filter === "function" || isArray2(opts.filter)) {
+        filter2 = opts.filter;
+      }
+      var arrayFormat;
+      if (opts.arrayFormat in arrayPrefixGenerators) {
+        arrayFormat = opts.arrayFormat;
+      } else if ("indices" in opts) {
+        arrayFormat = opts.indices ? "indices" : "repeat";
+      } else {
+        arrayFormat = defaults2.arrayFormat;
+      }
+      if ("commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
+        throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
+      }
+      var allowDots = typeof opts.allowDots === "undefined" ? opts.encodeDotInKeys === true ? true : defaults2.allowDots : !!opts.allowDots;
+      return {
+        addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults2.addQueryPrefix,
+        allowDots,
+        allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults2.allowEmptyArrays,
+        arrayFormat,
+        charset,
+        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults2.charsetSentinel,
+        commaRoundTrip: opts.commaRoundTrip,
+        delimiter: typeof opts.delimiter === "undefined" ? defaults2.delimiter : opts.delimiter,
+        encode: typeof opts.encode === "boolean" ? opts.encode : defaults2.encode,
+        encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults2.encodeDotInKeys,
+        encoder: typeof opts.encoder === "function" ? opts.encoder : defaults2.encoder,
+        encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults2.encodeValuesOnly,
+        filter: filter2,
+        format,
+        formatter,
+        serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults2.serializeDate,
+        skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults2.skipNulls,
+        sort: typeof opts.sort === "function" ? opts.sort : null,
+        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults2.strictNullHandling
+      };
+    };
+    module2.exports = function(object, opts) {
+      var obj = object;
+      var options = normalizeStringifyOptions(opts);
+      var objKeys;
+      var filter2;
+      if (typeof options.filter === "function") {
+        filter2 = options.filter;
+        obj = filter2("", obj);
+      } else if (isArray2(options.filter)) {
+        filter2 = options.filter;
+        objKeys = filter2;
+      }
+      var keys = [];
+      if (typeof obj !== "object" || obj === null) {
+        return "";
+      }
+      var generateArrayPrefix = arrayPrefixGenerators[options.arrayFormat];
+      var commaRoundTrip = generateArrayPrefix === "comma" && options.commaRoundTrip;
+      if (!objKeys) {
+        objKeys = Object.keys(obj);
+      }
+      if (options.sort) {
+        objKeys.sort(options.sort);
+      }
+      var sideChannel = getSideChannel();
+      for (var i3 = 0; i3 < objKeys.length; ++i3) {
+        var key = objKeys[i3];
+        if (options.skipNulls && obj[key] === null) {
+          continue;
+        }
+        pushToArray(keys, stringify2(
+          obj[key],
+          key,
+          generateArrayPrefix,
+          commaRoundTrip,
+          options.allowEmptyArrays,
+          options.strictNullHandling,
+          options.skipNulls,
+          options.encodeDotInKeys,
+          options.encode ? options.encoder : null,
+          options.filter,
+          options.sort,
+          options.allowDots,
+          options.serializeDate,
+          options.format,
+          options.formatter,
+          options.encodeValuesOnly,
+          options.charset,
+          sideChannel
+        ));
+      }
+      var joined = keys.join(options.delimiter);
+      var prefix = options.addQueryPrefix === true ? "?" : "";
+      if (options.charsetSentinel) {
+        if (options.charset === "iso-8859-1") {
+          prefix += "utf8=%26%2310003%3B&";
+        } else {
+          prefix += "utf8=%E2%9C%93&";
+        }
+      }
+      return joined.length > 0 ? prefix + joined : "";
+    };
+  }
+});
+
+// node_modules/qs/lib/parse.js
+var require_parse2 = __commonJS({
+  "node_modules/qs/lib/parse.js"(exports, module2) {
+    "use strict";
+    var utils = require_utils2();
+    var has = Object.prototype.hasOwnProperty;
+    var isArray2 = Array.isArray;
+    var defaults2 = {
+      allowDots: false,
+      allowEmptyArrays: false,
+      allowPrototypes: false,
+      allowSparse: false,
+      arrayLimit: 20,
+      charset: "utf-8",
+      charsetSentinel: false,
+      comma: false,
+      decodeDotInKeys: false,
+      decoder: utils.decode,
+      delimiter: "&",
+      depth: 5,
+      duplicates: "combine",
+      ignoreQueryPrefix: false,
+      interpretNumericEntities: false,
+      parameterLimit: 1e3,
+      parseArrays: true,
+      plainObjects: false,
+      strictDepth: false,
+      strictNullHandling: false
+    };
+    var interpretNumericEntities = function(str2) {
+      return str2.replace(/&#(\d+);/g, function($0, numberStr) {
+        return String.fromCharCode(parseInt(numberStr, 10));
+      });
+    };
+    var parseArrayValue = function(val, options) {
+      if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) {
+        return val.split(",");
+      }
+      return val;
+    };
+    var isoSentinel = "utf8=%26%2310003%3B";
+    var charsetSentinel = "utf8=%E2%9C%93";
+    var parseValues = function parseQueryStringValues(str2, options) {
+      var obj = { __proto__: null };
+      var cleanStr = options.ignoreQueryPrefix ? str2.replace(/^\?/, "") : str2;
+      cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+      var limit = options.parameterLimit === Infinity ? void 0 : options.parameterLimit;
+      var parts = cleanStr.split(options.delimiter, limit);
+      var skipIndex = -1;
+      var i3;
+      var charset = options.charset;
+      if (options.charsetSentinel) {
+        for (i3 = 0; i3 < parts.length; ++i3) {
+          if (parts[i3].indexOf("utf8=") === 0) {
+            if (parts[i3] === charsetSentinel) {
+              charset = "utf-8";
+            } else if (parts[i3] === isoSentinel) {
+              charset = "iso-8859-1";
+            }
+            skipIndex = i3;
+            i3 = parts.length;
+          }
+        }
+      }
+      for (i3 = 0; i3 < parts.length; ++i3) {
+        if (i3 === skipIndex) {
+          continue;
+        }
+        var part = parts[i3];
+        var bracketEqualsPos = part.indexOf("]=");
+        var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1;
+        var key, val;
+        if (pos === -1) {
+          key = options.decoder(part, defaults2.decoder, charset, "key");
+          val = options.strictNullHandling ? null : "";
+        } else {
+          key = options.decoder(part.slice(0, pos), defaults2.decoder, charset, "key");
+          val = utils.maybeMap(
+            parseArrayValue(part.slice(pos + 1), options),
+            function(encodedVal) {
+              return options.decoder(encodedVal, defaults2.decoder, charset, "value");
+            }
+          );
+        }
+        if (val && options.interpretNumericEntities && charset === "iso-8859-1") {
+          val = interpretNumericEntities(val);
+        }
+        if (part.indexOf("[]=") > -1) {
+          val = isArray2(val) ? [val] : val;
+        }
+        var existing = has.call(obj, key);
+        if (existing && options.duplicates === "combine") {
+          obj[key] = utils.combine(obj[key], val);
+        } else if (!existing || options.duplicates === "last") {
+          obj[key] = val;
+        }
+      }
+      return obj;
+    };
+    var parseObject = function(chain, val, options, valuesParsed) {
+      var leaf = valuesParsed ? val : parseArrayValue(val, options);
+      for (var i3 = chain.length - 1; i3 >= 0; --i3) {
+        var obj;
+        var root = chain[i3];
+        if (root === "[]" && options.parseArrays) {
+          obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : [].concat(leaf);
+        } else {
+          obj = options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+          var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
+          var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot;
+          var index = parseInt(decodedRoot, 10);
+          if (!options.parseArrays && decodedRoot === "") {
+            obj = { 0: leaf };
+          } else if (!isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && (options.parseArrays && index <= options.arrayLimit)) {
+            obj = [];
+            obj[index] = leaf;
+          } else if (decodedRoot !== "__proto__") {
+            obj[decodedRoot] = leaf;
+          }
+        }
+        leaf = obj;
+      }
+      return leaf;
+    };
+    var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+      if (!givenKey) {
+        return;
+      }
+      var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
+      var brackets = /(\[[^[\]]*])/;
+      var child = /(\[[^[\]]*])/g;
+      var segment = options.depth > 0 && brackets.exec(key);
+      var parent = segment ? key.slice(0, segment.index) : key;
+      var keys = [];
+      if (parent) {
+        if (!options.plainObjects && has.call(Object.prototype, parent)) {
+          if (!options.allowPrototypes) {
+            return;
+          }
+        }
+        keys.push(parent);
+      }
+      var i3 = 0;
+      while (options.depth > 0 && (segment = child.exec(key)) !== null && i3 < options.depth) {
+        i3 += 1;
+        if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
+          if (!options.allowPrototypes) {
+            return;
+          }
+        }
+        keys.push(segment[1]);
+      }
+      if (segment) {
+        if (options.strictDepth === true) {
+          throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
+        }
+        keys.push("[" + key.slice(segment.index) + "]");
+      }
+      return parseObject(keys, val, options, valuesParsed);
+    };
+    var normalizeParseOptions = function normalizeParseOptions2(opts) {
+      if (!opts) {
+        return defaults2;
+      }
+      if (typeof opts.allowEmptyArrays !== "undefined" && typeof opts.allowEmptyArrays !== "boolean") {
+        throw new TypeError("`allowEmptyArrays` option can only be `true` or `false`, when provided");
+      }
+      if (typeof opts.decodeDotInKeys !== "undefined" && typeof opts.decodeDotInKeys !== "boolean") {
+        throw new TypeError("`decodeDotInKeys` option can only be `true` or `false`, when provided");
+      }
+      if (opts.decoder !== null && typeof opts.decoder !== "undefined" && typeof opts.decoder !== "function") {
+        throw new TypeError("Decoder has to be a function.");
+      }
+      if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+        throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+      }
+      var charset = typeof opts.charset === "undefined" ? defaults2.charset : opts.charset;
+      var duplicates = typeof opts.duplicates === "undefined" ? defaults2.duplicates : opts.duplicates;
+      if (duplicates !== "combine" && duplicates !== "first" && duplicates !== "last") {
+        throw new TypeError("The duplicates option must be either combine, first, or last");
+      }
+      var allowDots = typeof opts.allowDots === "undefined" ? opts.decodeDotInKeys === true ? true : defaults2.allowDots : !!opts.allowDots;
+      return {
+        allowDots,
+        allowEmptyArrays: typeof opts.allowEmptyArrays === "boolean" ? !!opts.allowEmptyArrays : defaults2.allowEmptyArrays,
+        allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults2.allowPrototypes,
+        allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults2.allowSparse,
+        arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults2.arrayLimit,
+        charset,
+        charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults2.charsetSentinel,
+        comma: typeof opts.comma === "boolean" ? opts.comma : defaults2.comma,
+        decodeDotInKeys: typeof opts.decodeDotInKeys === "boolean" ? opts.decodeDotInKeys : defaults2.decodeDotInKeys,
+        decoder: typeof opts.decoder === "function" ? opts.decoder : defaults2.decoder,
+        delimiter: typeof opts.delimiter === "string" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults2.delimiter,
+        depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults2.depth,
+        duplicates,
+        ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
+        interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults2.interpretNumericEntities,
+        parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults2.parameterLimit,
+        parseArrays: opts.parseArrays !== false,
+        plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults2.plainObjects,
+        strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults2.strictDepth,
+        strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults2.strictNullHandling
+      };
+    };
+    module2.exports = function(str2, opts) {
+      var options = normalizeParseOptions(opts);
+      if (str2 === "" || str2 === null || typeof str2 === "undefined") {
+        return options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+      }
+      var tempObj = typeof str2 === "string" ? parseValues(str2, options) : str2;
+      var obj = options.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+      var keys = Object.keys(tempObj);
+      for (var i3 = 0; i3 < keys.length; ++i3) {
+        var key = keys[i3];
+        var newObj = parseKeys(key, tempObj[key], options, typeof str2 === "string");
+        obj = utils.merge(obj, newObj, options);
+      }
+      if (options.allowSparse === true) {
+        return obj;
+      }
+      return utils.compact(obj);
+    };
+  }
+});
+
+// node_modules/qs/lib/index.js
+var require_lib3 = __commonJS({
+  "node_modules/qs/lib/index.js"(exports, module2) {
+    "use strict";
+    var stringify2 = require_stringify();
+    var parse = require_parse2();
+    var formats = require_formats();
+    module2.exports = {
+      formats,
+      parse,
+      stringify: stringify2
+    };
+  }
+});
+
 // node_modules/@commitlint/types/lib/ensure.js
 var require_ensure = __commonJS({
   "node_modules/@commitlint/types/lib/ensure.js"(exports) {
@@ -24099,7 +26237,7 @@ var require_load = __commonJS({
 });
 
 // node_modules/@commitlint/types/lib/parse.js
-var require_parse2 = __commonJS({
+var require_parse3 = __commonJS({
   "node_modules/@commitlint/types/lib/parse.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -24135,7 +26273,7 @@ var require_rules = __commonJS({
 });
 
 // node_modules/@commitlint/types/lib/index.js
-var require_lib3 = __commonJS({
+var require_lib4 = __commonJS({
   "node_modules/@commitlint/types/lib/index.js"(exports) {
     "use strict";
     var __createBinding2 = exports && exports.__createBinding || (Object.create ? function(o3, m5, k7, k22) {
@@ -24164,7 +26302,7 @@ var require_lib3 = __commonJS({
     __exportStar2(require_is_ignored(), exports);
     __exportStar2(require_lint(), exports);
     __exportStar2(require_load(), exports);
-    __exportStar2(require_parse2(), exports);
+    __exportStar2(require_parse3(), exports);
     __exportStar2(require_prompt(), exports);
     __exportStar2(require_rules(), exports);
   }
@@ -25193,7 +27331,7 @@ function G3(t2, e3) {
 // package.json
 var package_default = {
   name: "opencommit",
-  version: "3.1.1",
+  version: "3.2.1",
   description: "Auto-generate impressive commits in 1 second. Killing lame commits with AI \u{1F92F}\u{1F52B}",
   keywords: [
     "git",
@@ -25239,8 +27377,9 @@ var package_default = {
     "dev:gemini": "OCO_AI_PROVIDER='gemini' ts-node ./src/cli.ts",
     build: "rimraf out && node esbuild.config.js",
     "build:push": "npm run build && git add . && git commit -m 'build' && git push",
-    deploy: "npm run build:push && git push --tags && npm publish --tag latest",
-    "deploy:patch": "npm version patch && npm run deploy",
+    deploy: "npm publish --tag latest",
+    "deploy:build": "npm run build:push && git push --tags && npm run deploy",
+    "deploy:patch": "npm version patch && npm run deploy:build",
     lint: "eslint src --ext ts && tsc --noEmit",
     format: "prettier --write src",
     test: "node --no-warnings --experimental-vm-modules $( [ -f ./node_modules/.bin/jest ] && echo ./node_modules/.bin/jest || which jest ) test/unit",
@@ -25281,7 +27420,6 @@ var package_default = {
     "@google/generative-ai": "^0.11.4",
     "@octokit/webhooks-schemas": "^6.11.0",
     "@octokit/webhooks-types": "^6.11.0",
-    ai: "^2.2.14",
     axios: "^1.3.4",
     chalk: "^5.2.0",
     cleye: "^1.3.2",
@@ -25290,7 +27428,7 @@ var package_default = {
     ignore: "^5.2.4",
     ini: "^3.0.1",
     inquirer: "^9.1.4",
-    openai: "^4.56.0"
+    openai: "^4.57.0"
   }
 };
 
@@ -27739,33 +29877,6 @@ function getI18nLocal(value) {
 }
 
 // src/commands/config.ts
-var CONFIG_KEYS = /* @__PURE__ */ ((CONFIG_KEYS2) => {
-  CONFIG_KEYS2["OCO_OPENAI_API_KEY"] = "OCO_OPENAI_API_KEY";
-  CONFIG_KEYS2["OCO_ANTHROPIC_API_KEY"] = "OCO_ANTHROPIC_API_KEY";
-  CONFIG_KEYS2["OCO_AZURE_API_KEY"] = "OCO_AZURE_API_KEY";
-  CONFIG_KEYS2["OCO_GEMINI_API_KEY"] = "OCO_GEMINI_API_KEY";
-  CONFIG_KEYS2["OCO_GEMINI_BASE_PATH"] = "OCO_GEMINI_BASE_PATH";
-  CONFIG_KEYS2["OCO_TOKENS_MAX_INPUT"] = "OCO_TOKENS_MAX_INPUT";
-  CONFIG_KEYS2["OCO_TOKENS_MAX_OUTPUT"] = "OCO_TOKENS_MAX_OUTPUT";
-  CONFIG_KEYS2["OCO_OPENAI_BASE_PATH"] = "OCO_OPENAI_BASE_PATH";
-  CONFIG_KEYS2["OCO_DESCRIPTION"] = "OCO_DESCRIPTION";
-  CONFIG_KEYS2["OCO_EMOJI"] = "OCO_EMOJI";
-  CONFIG_KEYS2["OCO_MODEL"] = "OCO_MODEL";
-  CONFIG_KEYS2["OCO_LANGUAGE"] = "OCO_LANGUAGE";
-  CONFIG_KEYS2["OCO_WHY"] = "OCO_WHY";
-  CONFIG_KEYS2["OCO_MESSAGE_TEMPLATE_PLACEHOLDER"] = "OCO_MESSAGE_TEMPLATE_PLACEHOLDER";
-  CONFIG_KEYS2["OCO_PROMPT_MODULE"] = "OCO_PROMPT_MODULE";
-  CONFIG_KEYS2["OCO_AI_PROVIDER"] = "OCO_AI_PROVIDER";
-  CONFIG_KEYS2["OCO_GITPUSH"] = "OCO_GITPUSH";
-  CONFIG_KEYS2["OCO_ONE_LINE_COMMIT"] = "OCO_ONE_LINE_COMMIT";
-  CONFIG_KEYS2["OCO_AZURE_ENDPOINT"] = "OCO_AZURE_ENDPOINT";
-  CONFIG_KEYS2["OCO_TEST_MOCK_TYPE"] = "OCO_TEST_MOCK_TYPE";
-  CONFIG_KEYS2["OCO_API_URL"] = "OCO_API_URL";
-  CONFIG_KEYS2["OCO_OLLAMA_API_URL"] = "OCO_OLLAMA_API_URL";
-  CONFIG_KEYS2["OCO_FLOWISE_ENDPOINT"] = "OCO_FLOWISE_ENDPOINT";
-  CONFIG_KEYS2["OCO_FLOWISE_API_KEY"] = "OCO_FLOWISE_API_KEY";
-  return CONFIG_KEYS2;
-})(CONFIG_KEYS || {});
 var MODEL_LIST = {
   openai: [
     "gpt-4o-mini",
@@ -27831,56 +29942,18 @@ var validateConfig = (key, condition, validationMessage) => {
   }
 };
 var configValidators = {
-  ["OCO_OPENAI_API_KEY" /* OCO_OPENAI_API_KEY */](value, config7 = {}) {
+  ["OCO_API_KEY" /* OCO_API_KEY */](value, config7 = {}) {
     if (config7.OCO_AI_PROVIDER !== "openai")
       return value;
     validateConfig(
-      "OCO_OPENAI_API_KEY",
+      "OCO_API_KEY",
       typeof value === "string" && value.length > 0,
       "Empty value is not allowed"
     );
     validateConfig(
-      "OCO_OPENAI_API_KEY",
+      "OCO_API_KEY",
       value,
-      'You need to provide the OCO_OPENAI_API_KEY when OCO_AI_PROVIDER is set to "openai" (default). Run `oco config set OCO_OPENAI_API_KEY=your_key`'
-    );
-    return value;
-  },
-  ["OCO_AZURE_API_KEY" /* OCO_AZURE_API_KEY */](value, config7 = {}) {
-    if (config7.OCO_AI_PROVIDER !== "azure")
-      return value;
-    validateConfig(
-      "OCO_AZURE_API_KEY",
-      !!value,
-      'You need to provide the OCO_AZURE_API_KEY when OCO_AI_PROVIDER is set to "azure". Run: `oco config set OCO_AZURE_API_KEY=your_key`'
-    );
-    return value;
-  },
-  ["OCO_GEMINI_API_KEY" /* OCO_GEMINI_API_KEY */](value, config7 = {}) {
-    if (config7.OCO_AI_PROVIDER !== "gemini")
-      return value;
-    validateConfig(
-      "OCO_GEMINI_API_KEY",
-      value || config7.OCO_GEMINI_API_KEY || config7.OCO_AI_PROVIDER === "test",
-      'You need to provide the OCO_GEMINI_API_KEY when OCO_AI_PROVIDER is set to "gemini". Run: `oco config set OCO_GEMINI_API_KEY=your_key`'
-    );
-    return value;
-  },
-  ["OCO_ANTHROPIC_API_KEY" /* OCO_ANTHROPIC_API_KEY */](value, config7 = {}) {
-    if (config7.OCO_AI_PROVIDER !== "anthropic")
-      return value;
-    validateConfig(
-      "ANTHROPIC_API_KEY",
-      !!value,
-      'You need to provide the OCO_ANTHROPIC_API_KEY key when OCO_AI_PROVIDER is set to "anthropic". Run: `oco config set OCO_ANTHROPIC_API_KEY=your_key`'
-    );
-    return value;
-  },
-  ["OCO_FLOWISE_API_KEY" /* OCO_FLOWISE_API_KEY */](value, config7 = {}) {
-    validateConfig(
-      "OCO_FLOWISE_API_KEY" /* OCO_FLOWISE_API_KEY */,
-      value || config7.OCO_AI_PROVIDER !== "flowise",
-      'You need to provide the OCO_FLOWISE_API_KEY when OCO_AI_PROVIDER is set to "flowise". Run: `oco config set OCO_FLOWISE_API_KEY=your_key`'
+      'You need to provide the OCO_API_KEY when OCO_AI_PROVIDER set to "openai" (default) or "ollama" or "azure" or "gemini" or "flowise" or "anthropic". Run `oco config set OCO_API_KEY=your_key OCO_AI_PROVIDER=openai`'
     );
     return value;
   },
@@ -27927,11 +30000,11 @@ var configValidators = {
     );
     return getI18nLocal(value);
   },
-  ["OCO_OPENAI_BASE_PATH" /* OCO_OPENAI_BASE_PATH */](value) {
+  ["OCO_API_URL" /* OCO_API_URL */](value) {
     validateConfig(
-      "OCO_OPENAI_BASE_PATH" /* OCO_OPENAI_BASE_PATH */,
+      "OCO_API_URL" /* OCO_API_URL */,
       typeof value === "string",
-      "Must be string"
+      `${value} is not a valid URL. It should start with 'http://' or 'https://'.`
     );
     return value;
   },
@@ -27993,22 +30066,6 @@ var configValidators = {
     );
     return value;
   },
-  ["OCO_AZURE_ENDPOINT" /* OCO_AZURE_ENDPOINT */](value) {
-    validateConfig(
-      "OCO_AZURE_ENDPOINT" /* OCO_AZURE_ENDPOINT */,
-      value.includes("openai.azure.com"),
-      'Must be in format "https://<resource name>.openai.azure.com/"'
-    );
-    return value;
-  },
-  ["OCO_FLOWISE_ENDPOINT" /* OCO_FLOWISE_ENDPOINT */](value) {
-    validateConfig(
-      "OCO_FLOWISE_ENDPOINT" /* OCO_FLOWISE_ENDPOINT */,
-      typeof value === "string" && value.includes(":"),
-      "Value must be string and should include both I.P. and port number"
-    );
-    return value;
-  },
   ["OCO_TEST_MOCK_TYPE" /* OCO_TEST_MOCK_TYPE */](value) {
     validateConfig(
       "OCO_TEST_MOCK_TYPE" /* OCO_TEST_MOCK_TYPE */,
@@ -28019,15 +30076,25 @@ var configValidators = {
     );
     return value;
   },
-  ["OCO_OLLAMA_API_URL" /* OCO_OLLAMA_API_URL */](value) {
+  ["OCO_WHY" /* OCO_WHY */](value) {
     validateConfig(
-      "OCO_OLLAMA_API_URL" /* OCO_OLLAMA_API_URL */,
-      typeof value === "string" && value.startsWith("http"),
-      `${value} is not a valid URL. It should start with 'http://' or 'https://'.`
+      "OCO_WHY" /* OCO_WHY */,
+      typeof value === "boolean",
+      "Must be true or false"
     );
     return value;
   }
 };
+var OCO_AI_PROVIDER_ENUM = /* @__PURE__ */ ((OCO_AI_PROVIDER_ENUM2) => {
+  OCO_AI_PROVIDER_ENUM2["OLLAMA"] = "ollama";
+  OCO_AI_PROVIDER_ENUM2["OPENAI"] = "openai";
+  OCO_AI_PROVIDER_ENUM2["ANTHROPIC"] = "anthropic";
+  OCO_AI_PROVIDER_ENUM2["GEMINI"] = "gemini";
+  OCO_AI_PROVIDER_ENUM2["AZURE"] = "azure";
+  OCO_AI_PROVIDER_ENUM2["TEST"] = "test";
+  OCO_AI_PROVIDER_ENUM2["FLOWISE"] = "flowise";
+  return OCO_AI_PROVIDER_ENUM2;
+})(OCO_AI_PROVIDER_ENUM || {});
 var defaultConfigPath = (0, import_path.join)((0, import_os.homedir)(), ".opencommit");
 var defaultEnvPath = (0, import_path.resolve)(process.cwd(), ".env");
 var DEFAULT_CONFIG = {
@@ -28050,7 +30117,7 @@ var initGlobalConfig = (configPath = defaultConfigPath) => {
   (0, import_fs.writeFileSync)(configPath, (0, import_ini.stringify)(DEFAULT_CONFIG), "utf8");
   return DEFAULT_CONFIG;
 };
-var parseEnvVarValue = (value) => {
+var parseConfigVarValue = (value) => {
   try {
     return JSON.parse(value);
   } catch (error) {
@@ -28061,32 +30128,32 @@ var getEnvConfig = (envPath) => {
   dotenv.config({ path: envPath });
   return {
     OCO_MODEL: process.env.OCO_MODEL,
-    OCO_OPENAI_API_KEY: process.env.OCO_OPENAI_API_KEY,
-    OCO_ANTHROPIC_API_KEY: process.env.OCO_ANTHROPIC_API_KEY,
-    OCO_AZURE_API_KEY: process.env.OCO_AZURE_API_KEY,
-    OCO_GEMINI_API_KEY: process.env.OCO_GEMINI_API_KEY,
-    OCO_FLOWISE_API_KEY: process.env.OCO_FLOWISE_API_KEY,
-    OCO_TOKENS_MAX_INPUT: parseEnvVarValue(process.env.OCO_TOKENS_MAX_INPUT),
-    OCO_TOKENS_MAX_OUTPUT: parseEnvVarValue(process.env.OCO_TOKENS_MAX_OUTPUT),
-    OCO_OPENAI_BASE_PATH: process.env.OCO_OPENAI_BASE_PATH,
-    OCO_GEMINI_BASE_PATH: process.env.OCO_GEMINI_BASE_PATH,
-    OCO_AZURE_ENDPOINT: process.env.OCO_AZURE_ENDPOINT,
-    OCO_FLOWISE_ENDPOINT: process.env.OCO_FLOWISE_ENDPOINT,
-    OCO_OLLAMA_API_URL: process.env.OCO_OLLAMA_API_URL,
-    OCO_DESCRIPTION: parseEnvVarValue(process.env.OCO_DESCRIPTION),
-    OCO_EMOJI: parseEnvVarValue(process.env.OCO_EMOJI),
+    OCO_API_URL: process.env.OCO_API_URL,
+    OCO_API_KEY: process.env.OCO_API_KEY,
+    OCO_AI_PROVIDER: process.env.OCO_AI_PROVIDER,
+    OCO_TOKENS_MAX_INPUT: parseConfigVarValue(process.env.OCO_TOKENS_MAX_INPUT),
+    OCO_TOKENS_MAX_OUTPUT: parseConfigVarValue(
+      process.env.OCO_TOKENS_MAX_OUTPUT
+    ),
+    OCO_DESCRIPTION: parseConfigVarValue(process.env.OCO_DESCRIPTION),
+    OCO_EMOJI: parseConfigVarValue(process.env.OCO_EMOJI),
     OCO_LANGUAGE: process.env.OCO_LANGUAGE,
     OCO_MESSAGE_TEMPLATE_PLACEHOLDER: process.env.OCO_MESSAGE_TEMPLATE_PLACEHOLDER,
     OCO_PROMPT_MODULE: process.env.OCO_PROMPT_MODULE,
-    OCO_AI_PROVIDER: process.env.OCO_AI_PROVIDER,
-    OCO_ONE_LINE_COMMIT: parseEnvVarValue(process.env.OCO_ONE_LINE_COMMIT),
+    OCO_ONE_LINE_COMMIT: parseConfigVarValue(process.env.OCO_ONE_LINE_COMMIT),
     OCO_TEST_MOCK_TYPE: process.env.OCO_TEST_MOCK_TYPE,
-    OCO_GITPUSH: parseEnvVarValue(process.env.OCO_GITPUSH)
+    OCO_GITPUSH: parseConfigVarValue(process.env.OCO_GITPUSH)
   };
 };
-var getGlobalConfig = (configPath) => {
+var setGlobalConfig = (config7, configPath = defaultConfigPath) => {
+  (0, import_fs.writeFileSync)(configPath, (0, import_ini.stringify)(config7), "utf8");
+};
+var getIsGlobalConfigFileExist = (configPath = defaultConfigPath) => {
+  return (0, import_fs.existsSync)(configPath);
+};
+var getGlobalConfig = (configPath = defaultConfigPath) => {
   let globalConfig;
-  const isGlobalConfigFileExist = (0, import_fs.existsSync)(configPath);
+  const isGlobalConfigFileExist = getIsGlobalConfigFileExist(configPath);
   if (!isGlobalConfigFileExist)
     globalConfig = initGlobalConfig(configPath);
   else {
@@ -28095,10 +30162,13 @@ var getGlobalConfig = (configPath) => {
   }
   return globalConfig;
 };
-var mergeConfigs = (main, fallback) => Object.keys(CONFIG_KEYS).reduce((acc, key) => {
-  acc[key] = parseEnvVarValue(main[key] ?? fallback[key]);
-  return acc;
-}, {});
+var mergeConfigs = (main, fallback) => {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(main), ...Object.keys(fallback)]);
+  return Array.from(allKeys).reduce((acc, key) => {
+    acc[key] = parseConfigVarValue(main[key] ?? fallback[key]);
+    return acc;
+  }, {});
+};
 var getConfig = ({
   envPath = defaultEnvPath,
   globalPath = defaultConfigPath
@@ -28112,6 +30182,7 @@ var setConfig = (keyValues, globalConfigPath = defaultConfigPath) => {
   const config7 = getConfig({
     globalPath: globalConfigPath
   });
+  const configToSet = {};
   for (let [key, value] of keyValues) {
     if (!configValidators.hasOwnProperty(key)) {
       const supportedKeys = Object.keys(configValidators).join("\n");
@@ -28125,7 +30196,10 @@ For more help refer to our docs: https://github.com/di-sukharev/opencommit`
     }
     let parsedConfigValue;
     try {
-      parsedConfigValue = JSON.parse(value);
+      if (typeof value === "string")
+        parsedConfigValue = JSON.parse(value);
+      else
+        parsedConfigValue = value;
     } catch (error) {
       parsedConfigValue = value;
     }
@@ -28133,9 +30207,9 @@ For more help refer to our docs: https://github.com/di-sukharev/opencommit`
       parsedConfigValue,
       config7
     );
-    config7[key] = validValue;
+    configToSet[key] = validValue;
   }
-  (0, import_fs.writeFileSync)(globalConfigPath, (0, import_ini.stringify)(config7), "utf8");
+  setGlobalConfig(mergeConfigs(configToSet, config7), globalConfigPath);
   ce(`${source_default.green("\u2714")} config successfully set`);
 };
 var configCommand = G3(
@@ -37221,7 +39295,7 @@ var AzureEngine = class {
 };
 
 // src/engine/flowise.ts
-var FlowiseAi = class {
+var FlowiseEngine = class {
   constructor(config7) {
     this.config = config7;
     this.client = axios_default.create({
@@ -38016,7 +40090,7 @@ var GoogleGenerativeAI = class {
 };
 
 // src/engine/gemini.ts
-var Gemini = class {
+var GeminiEngine = class {
   constructor(config7) {
     this.client = new GoogleGenerativeAI(config7.apiKey);
     this.config = config7;
@@ -38074,7 +40148,7 @@ var Gemini = class {
 };
 
 // src/engine/ollama.ts
-var OllamaAi = class {
+var OllamaEngine = class {
   constructor(config7) {
     this.config = config7;
     this.client = axios_default.create({
@@ -38090,7 +40164,10 @@ var OllamaAi = class {
       stream: false
     };
     try {
-      const response = await this.client.post("", params);
+      const response = await this.client.post(
+        this.client.getUri(this.config),
+        params
+      );
       const message = response.data.message;
       return message?.content;
     } catch (err) {
@@ -38121,7 +40198,7 @@ __export(error_exports2, {
 });
 
 // node_modules/openai/version.mjs
-var VERSION4 = "4.56.0";
+var VERSION4 = "4.57.0";
 
 // node_modules/openai/_shims/registry.mjs
 var auto2 = false;
@@ -39414,6 +41491,9 @@ var ContentFilterFinishReasonError = class extends OpenAIError {
   }
 };
 
+// node_modules/openai/index.mjs
+var qs = __toESM(require_lib3(), 1);
+
 // node_modules/openai/pagination.mjs
 var Page = class extends AbstractPage2 {
   constructor(client, response, body, options) {
@@ -41591,8 +43671,12 @@ var MessagesPage = class extends CursorPage {
 
 // node_modules/openai/resources/beta/threads/runs/steps.mjs
 var Steps = class extends APIResource2 {
-  retrieve(threadId, runId, stepId, options) {
+  retrieve(threadId, runId, stepId, query = {}, options) {
+    if (isRequestOptions(query)) {
+      return this.retrieve(threadId, runId, stepId, {}, query);
+    }
     return this._client.get(`/threads/${threadId}/runs/${runId}/steps/${stepId}`, {
+      query,
       ...options,
       headers: { "OpenAI-Beta": "assistants=v2", ...options?.headers }
     });
@@ -41620,12 +43704,14 @@ var Runs = class extends APIResource2 {
     super(...arguments);
     this.steps = new Steps(this._client);
   }
-  create(threadId, body, options) {
+  create(threadId, params, options) {
+    const { include, ...body } = params;
     return this._client.post(`/threads/${threadId}/runs`, {
+      query: { include },
       body,
       ...options,
       headers: { "OpenAI-Beta": "assistants=v2", ...options?.headers },
-      stream: body.stream ?? false
+      stream: params.stream ?? false
     });
   }
   retrieve(threadId, runId, options) {
@@ -42313,6 +44399,9 @@ var OpenAI = class extends APIClient2 {
   authHeaders(opts) {
     return { Authorization: `Bearer ${this.apiKey}` };
   }
+  stringifyQuery(query) {
+    return qs.stringify(query, { arrayFormat: "brackets" });
+  }
 };
 _a4 = OpenAI;
 OpenAI.OpenAI = _a4;
@@ -42394,44 +44483,24 @@ function getEngine() {
     model: config7.OCO_MODEL,
     maxTokensOutput: config7.OCO_TOKENS_MAX_OUTPUT,
     maxTokensInput: config7.OCO_TOKENS_MAX_INPUT,
-    baseURL: config7.OCO_OPENAI_BASE_PATH
+    baseURL: config7.OCO_API_URL,
+    apiKey: config7.OCO_API_KEY
   };
   switch (provider) {
     case "ollama" /* OLLAMA */:
-      return new OllamaAi({
-        ...DEFAULT_CONFIG2,
-        apiKey: "",
-        baseURL: config7.OCO_OLLAMA_API_URL
-      });
+      return new OllamaEngine(DEFAULT_CONFIG2);
     case "anthropic" /* ANTHROPIC */:
-      return new AnthropicEngine({
-        ...DEFAULT_CONFIG2,
-        apiKey: config7.OCO_ANTHROPIC_API_KEY
-      });
+      return new AnthropicEngine(DEFAULT_CONFIG2);
     case "test" /* TEST */:
       return new TestAi(config7.OCO_TEST_MOCK_TYPE);
     case "gemini" /* GEMINI */:
-      return new Gemini({
-        ...DEFAULT_CONFIG2,
-        apiKey: config7.OCO_GEMINI_API_KEY,
-        baseURL: config7.OCO_GEMINI_BASE_PATH
-      });
+      return new GeminiEngine(DEFAULT_CONFIG2);
     case "azure" /* AZURE */:
-      return new AzureEngine({
-        ...DEFAULT_CONFIG2,
-        apiKey: config7.OCO_AZURE_API_KEY
-      });
+      return new AzureEngine(DEFAULT_CONFIG2);
     case "flowise" /* FLOWISE */:
-      return new FlowiseAi({
-        ...DEFAULT_CONFIG2,
-        baseURL: config7.OCO_FLOWISE_ENDPOINT || DEFAULT_CONFIG2.baseURL,
-        apiKey: config7.OCO_FLOWISE_API_KEY
-      });
+      return new FlowiseEngine(DEFAULT_CONFIG2);
     default:
-      return new OpenAiEngine({
-        ...DEFAULT_CONFIG2,
-        apiKey: config7.OCO_OPENAI_API_KEY
-      });
+      return new OpenAiEngine(DEFAULT_CONFIG2);
   }
 }
 
@@ -42452,7 +44521,7 @@ var computeHash = async (content, algorithm = "sha256") => {
 };
 
 // src/modules/commitlint/prompts.ts
-var import_types = __toESM(require_lib3(), 1);
+var import_types = __toESM(require_lib4(), 1);
 var config2 = getConfig();
 var translation = i18n[config2.OCO_LANGUAGE || "en"];
 var getTypeRuleExtraDescription = (type2, prompt) => prompt?.questions?.type?.enum?.[type2]?.description;
@@ -42915,8 +44984,8 @@ function mergeDiffs(arr, maxStringLength) {
 
 // src/generateCommitMessageFromGitDiff.ts
 var config5 = getConfig();
-var MAX_TOKENS_INPUT = config5.OCO_TOKENS_MAX_INPUT || 40960 /* DEFAULT_MAX_TOKENS_INPUT */;
-var MAX_TOKENS_OUTPUT = config5.OCO_TOKENS_MAX_OUTPUT || 4096 /* DEFAULT_MAX_TOKENS_OUTPUT */;
+var MAX_TOKENS_INPUT = config5.OCO_TOKENS_MAX_INPUT;
+var MAX_TOKENS_OUTPUT = config5.OCO_TOKENS_MAX_OUTPUT;
 var generateCommitMessageChatCompletionPrompt = async (diff, fullGitMojiSpec) => {
   const INIT_MESSAGES_PROMPT = await getMainCommitPrompt(fullGitMojiSpec);
   const chatContextAsCompletionRequest = [...INIT_MESSAGES_PROMPT];
@@ -43209,13 +45278,15 @@ ${source_default.grey("\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2
       );
       ce(stdout);
       const remotes = await getGitRemotes();
+      if (config6.OCO_GITPUSH === false)
+        return;
       if (!remotes.length) {
         const { stdout: stdout2 } = await execa("git", ["push"]);
         if (stdout2)
           ce(stdout2);
         process.exit(0);
       }
-      if (remotes.length === 1 && config6.OCO_GITPUSH !== true) {
+      if (remotes.length === 1) {
         const isPushConfirmedByUser = await Q3({
           message: "Do you want to run `git push`?"
         });
@@ -43248,13 +45319,13 @@ ${source_default.grey("\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2014\u2
         const pushSpinner = le();
         pushSpinner.start(`Running 'git push ${selectedRemote}'`);
         const { stdout: stdout2 } = await execa("git", ["push", selectedRemote]);
+        if (stdout2)
+          ce(stdout2);
         pushSpinner.stop(
           `${source_default.green(
             "\u2714"
-          )} Successfully pushed all commits to ${selectedRemote}`
+          )} successfully pushed all commits to ${selectedRemote}`
         );
-        if (stdout2)
-          ce(stdout2);
       }
     } else {
       const regenerateMessage = await Q3({
@@ -43482,10 +45553,11 @@ var prepareCommitMessageHook = async (isStageAllFlag = false) => {
       return;
     ae("opencommit");
     const config7 = getConfig();
-    if (!config7.OCO_OPENAI_API_KEY && !config7.OCO_ANTHROPIC_API_KEY && !config7.OCO_AZURE_API_KEY) {
-      throw new Error(
-        "No OPEN_AI_API or OCO_ANTHROPIC_API_KEY or OCO_AZURE_API_KEY exists. Set your key in ~/.opencommit"
+    if (!config7.OCO_API_KEY) {
+      ce(
+        "No OCO_API_KEY is set. Set your key via `oco config set OCO_API_KEY=<value>. For more info see https://github.com/di-sukharev/opencommit"
       );
+      return;
     }
     const spin = le();
     spin.start("Generating commit message");
@@ -43534,6 +45606,152 @@ Current version: ${currentVersion}. Latest version: ${latestVersion}.
   }
 };
 
+// src/migrations/_run.ts
+var import_fs5 = __toESM(require("fs"), 1);
+var import_os2 = require("os");
+var import_path5 = require("path");
+
+// src/migrations/00_use_single_api_key_and_url.ts
+function use_single_api_key_and_url_default() {
+  const config7 = getConfig({ setDefaultValues: false });
+  const aiProvider = config7.OCO_AI_PROVIDER;
+  let apiKey;
+  let apiUrl;
+  if (aiProvider === "ollama" /* OLLAMA */) {
+    apiKey = config7["OCO_OLLAMA_API_KEY"];
+    apiUrl = config7["OCO_OLLAMA_API_URL"];
+  } else if (aiProvider === "anthropic" /* ANTHROPIC */) {
+    apiKey = config7["OCO_ANTHROPIC_API_KEY"];
+    apiUrl = config7["OCO_ANTHROPIC_BASE_PATH"];
+  } else if (aiProvider === "openai" /* OPENAI */) {
+    apiKey = config7["OCO_OPENAI_API_KEY"];
+    apiUrl = config7["OCO_OPENAI_BASE_PATH"];
+  } else if (aiProvider === "azure" /* AZURE */) {
+    apiKey = config7["OCO_AZURE_API_KEY"];
+    apiUrl = config7["OCO_AZURE_ENDPOINT"];
+  } else if (aiProvider === "gemini" /* GEMINI */) {
+    apiKey = config7["OCO_GEMINI_API_KEY"];
+    apiUrl = config7["OCO_GEMINI_BASE_PATH"];
+  } else if (aiProvider === "flowise" /* FLOWISE */) {
+    apiKey = config7["OCO_FLOWISE_API_KEY"];
+    apiUrl = config7["OCO_FLOWISE_ENDPOINT"];
+  } else {
+    throw new Error(
+      `Migration failed, set AI provider first. Run "oco config set OCO_AI_PROVIDER=<provider>", where <provider> is one of: ${Object.values(
+        OCO_AI_PROVIDER_ENUM
+      ).join(", ")}`
+    );
+  }
+  if (apiKey)
+    setConfig([["OCO_API_KEY" /* OCO_API_KEY */, apiKey]]);
+  if (apiUrl)
+    setConfig([["OCO_API_URL" /* OCO_API_URL */, apiUrl]]);
+}
+
+// src/migrations/01_remove_obsolete_config_keys_from_global_file.ts
+function remove_obsolete_config_keys_from_global_file_default() {
+  const obsoleteKeys = [
+    "OCO_OLLAMA_API_KEY",
+    "OCO_OLLAMA_API_URL",
+    "OCO_ANTHROPIC_API_KEY",
+    "OCO_ANTHROPIC_BASE_PATH",
+    "OCO_OPENAI_API_KEY",
+    "OCO_OPENAI_BASE_PATH",
+    "OCO_AZURE_API_KEY",
+    "OCO_AZURE_ENDPOINT",
+    "OCO_GEMINI_API_KEY",
+    "OCO_GEMINI_BASE_PATH",
+    "OCO_FLOWISE_API_KEY",
+    "OCO_FLOWISE_ENDPOINT"
+  ];
+  const globalConfig = getGlobalConfig();
+  const configToOverride = { ...globalConfig };
+  for (const key of obsoleteKeys)
+    delete configToOverride[key];
+  setGlobalConfig(configToOverride);
+}
+
+// src/migrations/02_set_missing_default_values.ts
+function set_missing_default_values_default() {
+  const setDefaultConfigValues = (config7) => {
+    const entriesToSet = [];
+    for (const entry of Object.entries(DEFAULT_CONFIG)) {
+      const [key, _value] = entry;
+      if (config7[key] === "undefined")
+        entriesToSet.push(entry);
+    }
+    if (entriesToSet.length > 0)
+      setConfig(entriesToSet);
+  };
+  setDefaultConfigValues(getGlobalConfig());
+}
+
+// src/migrations/_migrations.ts
+var migrations = [
+  {
+    name: "00_use_single_api_key_and_url",
+    run: use_single_api_key_and_url_default
+  },
+  {
+    name: "01_remove_obsolete_config_keys_from_global_file",
+    run: remove_obsolete_config_keys_from_global_file_default
+  },
+  {
+    name: "02_set_missing_default_values",
+    run: set_missing_default_values_default
+  }
+];
+
+// src/migrations/_run.ts
+var migrationsFile = (0, import_path5.join)((0, import_os2.homedir)(), ".opencommit_migrations");
+var getCompletedMigrations = () => {
+  if (!import_fs5.default.existsSync(migrationsFile)) {
+    return [];
+  }
+  const data = import_fs5.default.readFileSync(migrationsFile, "utf-8");
+  return data ? JSON.parse(data) : [];
+};
+var saveCompletedMigration = (migrationName) => {
+  const completedMigrations = getCompletedMigrations();
+  completedMigrations.push(migrationName);
+  import_fs5.default.writeFileSync(
+    migrationsFile,
+    JSON.stringify(completedMigrations, null, 2)
+  );
+};
+var runMigrations = async () => {
+  if (!getIsGlobalConfigFileExist())
+    return;
+  const config7 = getConfig();
+  if (config7.OCO_AI_PROVIDER === "test" /* TEST */)
+    return;
+  const completedMigrations = getCompletedMigrations();
+  let isMigrated = false;
+  for (const migration of migrations) {
+    if (!completedMigrations.includes(migration.name)) {
+      try {
+        console.log("Applying migration", migration.name);
+        migration.run();
+        console.log("Migration applied successfully", migration.name);
+        saveCompletedMigration(migration.name);
+      } catch (error) {
+        ce(
+          `${source_default.red("Failed to apply migration")} ${migration.name}: ${error}`
+        );
+      }
+      isMigrated = true;
+    }
+  }
+  if (isMigrated) {
+    ce(
+      `${source_default.green(
+        "\u2714"
+      )} Migrations to your config were applied successfully. Please rerun.`
+    );
+    process.exit(0);
+  }
+};
+
 // src/cli.ts
 var extraArgs = process.argv.slice(2);
 Z2(
@@ -43554,6 +45772,7 @@ Z2(
     help: { description: package_default.description }
   },
   async ({ flags }) => {
+    await runMigrations();
     await checkIsLatestVersion();
     if (await isHookCalled()) {
       prepareCommitMessageHook();