@kubb/core 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/index.cjs

@@ -2,24 +2,22 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var pc3 = require('picocolors');
-var fs2 = require('fs-extra');
-var seedrandom = require('seedrandom');
+var pc2 = require('picocolors');
 var path4 = require('path');
 var jsRuntime = require('js-runtime');
 var changeCase = require('change-case');
 var crypto2 = require('crypto');
 var parser = require('@kubb/parser');
 var factory = require('@kubb/parser/factory');
-var isEqual = require('lodash.isequal');
 var naturalOrderby = require('natural-orderby');
 var dirTree = require('directory-tree');
+var seedrandom = require('seedrandom');
 var events = require('events');
 var perf_hooks = require('perf_hooks');
 var mod = require('module');
 var os = require('os');
 var url = require('url');
-var process = require('process');
+var process2 = require('process');
 var fs3 = require('fs');
 var semver = require('semver');
 
@@ -43,20 +41,23 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var pc3__default = /*#__PURE__*/_interopDefault(pc3);
-var fs2__default = /*#__PURE__*/_interopDefault(fs2);
-var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
+var pc2__default = /*#__PURE__*/_interopDefault(pc2);
 var path4__default = /*#__PURE__*/_interopDefault(path4);
 var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
 var factory__namespace = /*#__PURE__*/_interopNamespace(factory);
-var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
 var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
+var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
 var mod__default = /*#__PURE__*/_interopDefault(mod);
 var os__default = /*#__PURE__*/_interopDefault(os);
-var process__default = /*#__PURE__*/_interopDefault(process);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -65,6 +66,28 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod2) => function __require2() {
+  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
@@ -99,238 +122,3015 @@ var __privateMethod = (obj, member, method) => {
   __accessCheck(obj, member, "access private method");
   return method;
 };
-async function clean(path5) {
-  return fs2.remove(path5);
-}
-var LogLevel = {
-  silent: "silent",
-  info: "info",
-  debug: "debug"
-};
-function createLogger({ logLevel, name, spinner }) {
-  const logs = [];
-  const log = (message) => {
-    if (message && spinner) {
-      spinner.text = message;
-      logs.push(message);
-    }
-  };
-  const error = (message) => {
-    if (message) {
-      throw new Error(message || "Something went wrong");
-    }
-  };
-  const warn = (message) => {
-    if (message && spinner) {
-      spinner.warn(pc3__default.default.yellow(message));
-      logs.push(message);
-    }
-  };
-  const info = (message) => {
-    if (message && spinner && logLevel !== LogLevel.silent) {
-      spinner.info(message);
-      logs.push(message);
-    }
-  };
-  const logger = {
-    name,
-    logLevel,
-    log,
-    error,
-    warn,
-    info,
-    spinner,
-    logs
-  };
-  return logger;
-}
-var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
-function randomColour(text, colours = defaultColours) {
-  if (!text) {
-    return "white";
-  }
-  const random = seedrandom__default.default(text);
-  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
-  return colour;
-}
-function randomPicoColour(text, colors = defaultColours) {
-  const colours = pc3__default.default.createColors(true);
-  if (!text) {
-    return colours.white(text);
-  }
-  const colour = randomColour(text, colors);
-  const isDark = colour.includes("dark");
-  const key = colour.replace("dark", "").toLowerCase();
-  const formatter = colours[key];
-  if (isDark) {
-    return pc3__default.default.bold(formatter(text));
+
+// ../../node_modules/.pnpm/tsup@8.0.1_@microsoft+api-extractor@7.38.3_ts-node@10.9.1_typescript@5.3.2/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.0.1_@microsoft+api-extractor@7.38.3_ts-node@10.9.1_typescript@5.3.2/node_modules/tsup/assets/cjs_shims.js"() {
   }
-  if (typeof formatter !== "function") {
-    throw new Error("Formatter for picoColor is not of type function/Formatter");
+});
+
+// ../../node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js
+var require_universalify = __commonJS({
+  "../../node_modules/.pnpm/universalify@2.0.1/node_modules/universalify/index.js"(exports) {
+    init_cjs_shims();
+    exports.fromCallback = function(fn) {
+      return Object.defineProperty(function(...args) {
+        if (typeof args[args.length - 1] === "function")
+          fn.apply(this, args);
+        else {
+          return new Promise((resolve3, reject) => {
+            args.push((err, res) => err != null ? reject(err) : resolve3(res));
+            fn.apply(this, args);
+          });
+        }
+      }, "name", { value: fn.name });
+    };
+    exports.fromPromise = function(fn) {
+      return Object.defineProperty(function(...args) {
+        const cb = args[args.length - 1];
+        if (typeof cb !== "function")
+          return fn.apply(this, args);
+        else {
+          args.pop();
+          fn.apply(this, args).then((r) => cb(null, r), cb);
+        }
+      }, "name", { value: fn.name });
+    };
   }
-  return formatter(text);
-}
-var reader = jsRuntime.switcher(
-  {
-    node: async (path5) => {
-      return fs2__default.default.readFile(path5, { encoding: "utf8" });
-    },
-    bun: async (path5) => {
-      const file = Bun.file(path5);
-      return file.text();
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
+var require_polyfills = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
+    init_cjs_shims();
+    var constants = __require("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
     }
-  },
-  "node"
-);
-jsRuntime.switcher(
-  {
-    node: (path5) => {
-      return fs2__default.default.readFileSync(path5, { encoding: "utf8" });
-    },
-    bun: () => {
-      throw new Error("Bun cannot read sync");
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
+      };
+      if (Object.setPrototypeOf)
+        Object.setPrototypeOf(process.chdir, chdir);
     }
-  },
-  "node"
-);
-async function read(path5) {
-  return reader(path5);
-}
-var URLPath = class {
-  constructor(path5) {
-    this.path = path5;
-    return this;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  get URL() {
-    return this.toURLPath();
-  }
-  get isURL() {
-    try {
-      const url = new URL(this.path);
-      if (url?.href) {
-        return true;
+    var chdir;
+    module.exports = patch;
+    function patch(fs5) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs5);
+      }
+      if (!fs5.lutimes) {
+        patchLutimes(fs5);
+      }
+      fs5.chown = chownFix(fs5.chown);
+      fs5.fchown = chownFix(fs5.fchown);
+      fs5.lchown = chownFix(fs5.lchown);
+      fs5.chmod = chmodFix(fs5.chmod);
+      fs5.fchmod = chmodFix(fs5.fchmod);
+      fs5.lchmod = chmodFix(fs5.lchmod);
+      fs5.chownSync = chownFixSync(fs5.chownSync);
+      fs5.fchownSync = chownFixSync(fs5.fchownSync);
+      fs5.lchownSync = chownFixSync(fs5.lchownSync);
+      fs5.chmodSync = chmodFixSync(fs5.chmodSync);
+      fs5.fchmodSync = chmodFixSync(fs5.fchmodSync);
+      fs5.lchmodSync = chmodFixSync(fs5.lchmodSync);
+      fs5.stat = statFix(fs5.stat);
+      fs5.fstat = statFix(fs5.fstat);
+      fs5.lstat = statFix(fs5.lstat);
+      fs5.statSync = statFixSync(fs5.statSync);
+      fs5.fstatSync = statFixSync(fs5.fstatSync);
+      fs5.lstatSync = statFixSync(fs5.lstatSync);
+      if (fs5.chmod && !fs5.lchmod) {
+        fs5.lchmod = function(path5, mode, cb) {
+          if (cb)
+            process.nextTick(cb);
+        };
+        fs5.lchmodSync = function() {
+        };
+      }
+      if (fs5.chown && !fs5.lchown) {
+        fs5.lchown = function(path5, uid, gid, cb) {
+          if (cb)
+            process.nextTick(cb);
+        };
+        fs5.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs5.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb)
+                cb(er);
+            });
+          }
+          if (Object.setPrototypeOf)
+            Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        }(fs5.rename);
+      }
+      fs5.read = typeof fs5.read !== "function" ? fs5.read : function(fs$read) {
+        function read2(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs5, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs5, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf)
+          Object.setPrototypeOf(read2, fs$read);
+        return read2;
+      }(fs5.read);
+      fs5.readSync = typeof fs5.readSync !== "function" ? fs5.readSync : /* @__PURE__ */ function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs5, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      }(fs5.readSync);
+      function patchLchmod(fs6) {
+        fs6.lchmod = function(path5, mode, callback) {
+          fs6.open(
+            path5,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback)
+                  callback(err);
+                return;
+              }
+              fs6.fchmod(fd, mode, function(err2) {
+                fs6.close(fd, function(err22) {
+                  if (callback)
+                    callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs6.lchmodSync = function(path5, mode) {
+          var fd = fs6.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs6.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs6.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs6.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs6) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+          fs6.lutimes = function(path5, at, mt, cb) {
+            fs6.open(path5, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb)
+                  cb(er);
+                return;
+              }
+              fs6.futimes(fd, at, mt, function(er2) {
+                fs6.close(fd, function(er22) {
+                  if (cb)
+                    cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs6.lutimesSync = function(path5, at, mt) {
+            var fd = fs6.openSync(path5, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs6.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs6.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs6.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs6.futimes) {
+          fs6.lutimes = function(_a, _b, _c, cb) {
+            if (cb)
+              process.nextTick(cb);
+          };
+          fs6.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs5, target, mode, function(er) {
+            if (chownErOk(er))
+              er = null;
+            if (cb)
+              cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs5, target, mode);
+          } catch (er) {
+            if (!chownErOk(er))
+              throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs5, target, uid, gid, function(er) {
+            if (chownErOk(er))
+              er = null;
+            if (cb)
+              cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs5, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er))
+              throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig)
+          return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0)
+                stats.uid += 4294967296;
+              if (stats.gid < 0)
+                stats.gid += 4294967296;
+            }
+            if (cb)
+              cb.apply(this, arguments);
+          }
+          return options ? orig.call(fs5, target, options, callback) : orig.call(fs5, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig)
+          return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs5, target, options) : orig.call(fs5, target);
+          if (stats) {
+            if (stats.uid < 0)
+              stats.uid += 4294967296;
+            if (stats.gid < 0)
+              stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
       }
-    } catch (error) {
-      return false;
     }
-    return false;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  get template() {
-    return this.toTemplateString();
-  }
-  get object() {
-    return this.toObject();
-  }
-  get params() {
-    return this.getParams();
   }
-  toObject({ type = "path", replacer, stringify } = {}) {
-    const object = {
-      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
-      params: this.getParams()
-    };
-    if (stringify) {
-      if (type === "template") {
-        return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js"(exports, module) {
+    init_cjs_shims();
+    var Stream = __require("stream").Stream;
+    module.exports = legacy;
+    function legacy(fs5) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path5, options) {
+        if (!(this instanceof ReadStream))
+          return new ReadStream(path5, options);
+        Stream.call(this);
+        var self2 = this;
+        this.path = path5;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding)
+          this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self2._read();
+          });
+          return;
+        }
+        fs5.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self2.emit("error", err);
+            self2.readable = false;
+            return;
+          }
+          self2.fd = fd;
+          self2.emit("open", fd);
+          self2._read();
+        });
       }
-      if (object.params) {
-        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+      function WriteStream(path5, options) {
+        if (!(this instanceof WriteStream))
+          return new WriteStream(path5, options);
+        Stream.call(this);
+        this.path = path5;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs5.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
       }
-      return `{ url: '${object.url}' }`;
     }
-    return object;
   }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  toTemplateString(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    let newPath = this.path.replaceAll("{", "${");
-    if (found) {
-      newPath = found.reduce((prev, curr) => {
-        const pathParam = replacer ? replacer(changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-        const replacement = `\${${pathParam}}`;
-        return prev.replace(curr, replacement);
-      }, this.path);
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
+var require_clone = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js"(exports, module) {
+    init_cjs_shims();
+    module.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
     }
-    return `\`${newPath}\``;
   }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
-      return void 0;
+});
+
+// ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = __commonJS({
+  "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = __require("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = __require("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = Symbol.for("graceful-fs.queue");
+      previousSymbol = Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
     }
-    const params = {};
-    found.forEach((item) => {
-      item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
+    function noop() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug = noop;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs5[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs5, queue);
+      fs5.close = function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs5, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      }(fs5.close);
+      fs5.closeSync = function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs5, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      }(fs5.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs5[gracefulQueue]);
+          __require("assert").equal(fs5[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs5[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs5));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs5.__patched) {
+      module.exports = patch(fs5);
+      fs5.__patched = true;
+    }
+    function patch(fs6) {
+      polyfills(fs6);
+      fs6.gracefulify = patch;
+      fs6.createReadStream = createReadStream;
+      fs6.createWriteStream = createWriteStream;
+      var fs$readFile = fs6.readFile;
+      fs6.readFile = readFile;
+      function readFile(path5, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path5, options, cb);
+        function go$readFile(path6, options2, cb2, startTime) {
+          return fs$readFile(path6, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path6, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs6.writeFile;
+      fs6.writeFile = writeFile;
+      function writeFile(path5, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path5, data, options, cb);
+        function go$writeFile(path6, data2, options2, cb2, startTime) {
+          return fs$writeFile(path6, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs6.appendFile;
+      if (fs$appendFile)
+        fs6.appendFile = appendFile;
+      function appendFile(path5, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path5, data, options, cb);
+        function go$appendFile(path6, data2, options2, cb2, startTime) {
+          return fs$appendFile(path6, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs6.copyFile;
+      if (fs$copyFile)
+        fs6.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs6.readdir;
+      fs6.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path5, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path6, options2, cb2, startTime) {
+          return fs$readdir(path6, fs$readdirCallback(
+            path6,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path6, options2, cb2, startTime) {
+          return fs$readdir(path6, options2, fs$readdirCallback(
+            path6,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path5, options, cb);
+        function fs$readdirCallback(path6, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path6, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs6);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs6.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs6.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs6, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs6, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs6, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs6, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path5, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path5, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path5, options) {
+        return new fs6.ReadStream(path5, options);
+      }
+      function createWriteStream(path5, options) {
+        return new fs6.WriteStream(path5, options);
+      }
+      var fs$open = fs6.open;
+      fs6.open = open;
+      function open(path5, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path5, flags, mode, cb);
+        function go$open(path6, flags2, mode2, cb2, startTime) {
+          return fs$open(path6, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path6, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs6;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs5[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs5[gracefulQueue].length; ++i) {
+        if (fs5[gracefulQueue][i].length > 2) {
+          fs5[gracefulQueue][i][3] = now;
+          fs5[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs5[gracefulQueue].length === 0)
+        return;
+      var elem = fs5[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs5[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/fs/index.js
+var require_fs = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
+    init_cjs_shims();
+    var u = require_universalify().fromCallback;
+    var fs5 = require_graceful_fs();
+    var api = [
+      "access",
+      "appendFile",
+      "chmod",
+      "chown",
+      "close",
+      "copyFile",
+      "fchmod",
+      "fchown",
+      "fdatasync",
+      "fstat",
+      "fsync",
+      "ftruncate",
+      "futimes",
+      "lchmod",
+      "lchown",
+      "link",
+      "lstat",
+      "mkdir",
+      "mkdtemp",
+      "open",
+      "opendir",
+      "readdir",
+      "readFile",
+      "readlink",
+      "realpath",
+      "rename",
+      "rm",
+      "rmdir",
+      "stat",
+      "symlink",
+      "truncate",
+      "unlink",
+      "utimes",
+      "writeFile"
+    ].filter((key) => {
+      return typeof fs5[key] === "function";
+    });
+    Object.assign(exports, fs5);
+    api.forEach((method) => {
+      exports[method] = u(fs5[method]);
+    });
+    exports.exists = function(filename, callback) {
+      if (typeof callback === "function") {
+        return fs5.exists(filename, callback);
+      }
+      return new Promise((resolve3) => {
+        return fs5.exists(filename, resolve3);
+      });
+    };
+    exports.read = function(fd, buffer, offset, length, position, callback) {
+      if (typeof callback === "function") {
+        return fs5.read(fd, buffer, offset, length, position, callback);
+      }
+      return new Promise((resolve3, reject) => {
+        fs5.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+          if (err)
+            return reject(err);
+          resolve3({ bytesRead, buffer: buffer2 });
+        });
+      });
+    };
+    exports.write = function(fd, buffer, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs5.write(fd, buffer, ...args);
+      }
+      return new Promise((resolve3, reject) => {
+        fs5.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+          if (err)
+            return reject(err);
+          resolve3({ bytesWritten, buffer: buffer2 });
+        });
+      });
+    };
+    exports.readv = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs5.readv(fd, buffers, ...args);
+      }
+      return new Promise((resolve3, reject) => {
+        fs5.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve3({ bytesRead, buffers: buffers2 });
+        });
+      });
+    };
+    exports.writev = function(fd, buffers, ...args) {
+      if (typeof args[args.length - 1] === "function") {
+        return fs5.writev(fd, buffers, ...args);
+      }
+      return new Promise((resolve3, reject) => {
+        fs5.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+          if (err)
+            return reject(err);
+          resolve3({ bytesWritten, buffers: buffers2 });
+        });
+      });
+    };
+    if (typeof fs5.realpath.native === "function") {
+      exports.realpath.native = u(fs5.realpath.native);
+    } else {
+      process.emitWarning(
+        "fs.realpath.native is not a function. Is fs being monkey-patched?",
+        "Warning",
+        "fs-extra-WARN0003"
+      );
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js
+var require_utils = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/utils.js"(exports, module) {
+    init_cjs_shims();
+    var path5 = __require("path");
+    module.exports.checkPath = function checkPath(pth) {
+      if (process.platform === "win32") {
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path5.parse(pth).root, ""));
+        if (pathHasInvalidWinCharacters) {
+          const error = new Error(`Path contains invalid characters: ${pth}`);
+          error.code = "EINVAL";
+          throw error;
+        }
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/make-dir.js
+var require_make_dir = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_fs();
+    var { checkPath } = require_utils();
+    var getMode = (options) => {
+      const defaults = { mode: 511 };
+      if (typeof options === "number")
+        return options;
+      return { ...defaults, ...options }.mode;
+    };
+    module.exports.makeDir = async (dir, options) => {
+      checkPath(dir);
+      return fs5.mkdir(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+    module.exports.makeDirSync = (dir, options) => {
+      checkPath(dir);
+      return fs5.mkdirSync(dir, {
+        mode: getMode(options),
+        recursive: true
+      });
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/index.js
+var require_mkdirs = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/mkdirs/index.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    var { makeDir: _makeDir, makeDirSync } = require_make_dir();
+    var makeDir = u(_makeDir);
+    module.exports = {
+      mkdirs: makeDir,
+      mkdirsSync: makeDirSync,
+      // alias
+      mkdirp: makeDir,
+      mkdirpSync: makeDirSync,
+      ensureDir: makeDir,
+      ensureDirSync: makeDirSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/path-exists/index.js
+var require_path_exists = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    var fs5 = require_fs();
+    function pathExists2(path5) {
+      return fs5.access(path5).then(() => true).catch(() => false);
+    }
+    module.exports = {
+      pathExists: u(pathExists2),
+      pathExistsSync: fs5.existsSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/utimes.js
+var require_utimes = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function utimesMillis(path5, atime, mtime) {
+      const fd = await fs5.open(path5, "r+");
+      let closeErr = null;
+      try {
+        await fs5.futimes(fd, atime, mtime);
+      } finally {
+        try {
+          await fs5.close(fd);
+        } catch (e) {
+          closeErr = e;
+        }
+      }
+      if (closeErr) {
+        throw closeErr;
+      }
+    }
+    function utimesMillisSync(path5, atime, mtime) {
+      const fd = fs5.openSync(path5, "r+");
+      fs5.futimesSync(fd, atime, mtime);
+      return fs5.closeSync(fd);
+    }
+    module.exports = {
+      utimesMillis: u(utimesMillis),
+      utimesMillisSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js
+var require_stat = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_fs();
+    var path5 = __require("path");
+    var u = require_universalify().fromPromise;
+    function getStats(src, dest, opts) {
+      const statFunc = opts.dereference ? (file) => fs5.stat(file, { bigint: true }) : (file) => fs5.lstat(file, { bigint: true });
+      return Promise.all([
+        statFunc(src),
+        statFunc(dest).catch((err) => {
+          if (err.code === "ENOENT")
+            return null;
+          throw err;
+        })
+      ]).then(([srcStat, destStat]) => ({ srcStat, destStat }));
+    }
+    function getStatsSync(src, dest, opts) {
+      let destStat;
+      const statFunc = opts.dereference ? (file) => fs5.statSync(file, { bigint: true }) : (file) => fs5.lstatSync(file, { bigint: true });
+      const srcStat = statFunc(src);
+      try {
+        destStat = statFunc(dest);
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return { srcStat, destStat: null };
+        throw err;
+      }
+      return { srcStat, destStat };
+    }
+    async function checkPaths(src, dest, funcName, opts) {
+      const { srcStat, destStat } = await getStats(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path5.basename(src);
+          const destBaseName = path5.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    function checkPathsSync(src, dest, funcName, opts) {
+      const { srcStat, destStat } = getStatsSync(src, dest, opts);
+      if (destStat) {
+        if (areIdentical(srcStat, destStat)) {
+          const srcBaseName = path5.basename(src);
+          const destBaseName = path5.basename(dest);
+          if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
+            return { srcStat, destStat, isChangingCase: true };
+          }
+          throw new Error("Source and destination must not be the same.");
+        }
+        if (srcStat.isDirectory() && !destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`);
+        }
+        if (!srcStat.isDirectory() && destStat.isDirectory()) {
+          throw new Error(`Cannot overwrite directory '${dest}' with non-directory '${src}'.`);
+        }
+      }
+      if (srcStat.isDirectory() && isSrcSubdir(src, dest)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return { srcStat, destStat };
+    }
+    async function checkParentPaths(src, srcStat, dest, funcName) {
+      const srcParent = path5.resolve(path5.dirname(src));
+      const destParent = path5.resolve(path5.dirname(dest));
+      if (destParent === srcParent || destParent === path5.parse(destParent).root)
+        return;
+      let destStat;
+      try {
+        destStat = await fs5.stat(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPaths(src, srcStat, destParent, funcName);
+    }
+    function checkParentPathsSync(src, srcStat, dest, funcName) {
+      const srcParent = path5.resolve(path5.dirname(src));
+      const destParent = path5.resolve(path5.dirname(dest));
+      if (destParent === srcParent || destParent === path5.parse(destParent).root)
+        return;
+      let destStat;
+      try {
+        destStat = fs5.statSync(destParent, { bigint: true });
+      } catch (err) {
+        if (err.code === "ENOENT")
+          return;
+        throw err;
+      }
+      if (areIdentical(srcStat, destStat)) {
+        throw new Error(errMsg(src, dest, funcName));
+      }
+      return checkParentPathsSync(src, srcStat, destParent, funcName);
+    }
+    function areIdentical(srcStat, destStat) {
+      return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
+    }
+    function isSrcSubdir(src, dest) {
+      const srcArr = path5.resolve(src).split(path5.sep).filter((i) => i);
+      const destArr = path5.resolve(dest).split(path5.sep).filter((i) => i);
+      return srcArr.every((cur, i) => destArr[i] === cur);
+    }
+    function errMsg(src, dest, funcName) {
+      return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.`;
+    }
+    module.exports = {
+      // checkPaths
+      checkPaths: u(checkPaths),
+      checkPathsSync,
+      // checkParent
+      checkParentPaths: u(checkParentPaths),
+      checkParentPathsSync,
+      // Misc
+      isSrcSubdir,
+      areIdentical
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js
+var require_copy = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_fs();
+    var path5 = __require("path");
+    var { mkdirs } = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var { utimesMillis } = require_utimes();
+    var stat = require_stat();
+    async function copy(src, dest, opts = {}) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0001"
+        );
+      }
+      const { srcStat, destStat } = await stat.checkPaths(src, dest, "copy", opts);
+      await stat.checkParentPaths(src, srcStat, dest, "copy");
+      const include = await runFilter(src, dest, opts);
+      if (!include)
+        return;
+      const destParent = path5.dirname(dest);
+      const dirExists = await pathExists2(destParent);
+      if (!dirExists) {
+        await mkdirs(destParent);
+      }
+      await getStatsAndPerformCopy(destStat, src, dest, opts);
+    }
+    async function runFilter(src, dest, opts) {
+      if (!opts.filter)
+        return true;
+      return opts.filter(src, dest);
+    }
+    async function getStatsAndPerformCopy(destStat, src, dest, opts) {
+      const statFn = opts.dereference ? fs5.stat : fs5.lstat;
+      const srcStat = await statFn(src);
+      if (srcStat.isDirectory())
+        return onDir(srcStat, destStat, src, dest, opts);
+      if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
+        return onFile(srcStat, destStat, src, dest, opts);
+      if (srcStat.isSymbolicLink())
+        return onLink(destStat, src, dest, opts);
+      if (srcStat.isSocket())
+        throw new Error(`Cannot copy a socket file: ${src}`);
+      if (srcStat.isFIFO())
+        throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    async function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return copyFile(srcStat, src, dest, opts);
+      if (opts.overwrite) {
+        await fs5.unlink(dest);
+        return copyFile(srcStat, src, dest, opts);
+      }
+      if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    async function copyFile(srcStat, src, dest, opts) {
+      await fs5.copyFile(src, dest);
+      if (opts.preserveTimestamps) {
+        if (fileIsNotWritable(srcStat.mode)) {
+          await makeFileWritable(dest, srcStat.mode);
+        }
+        const updatedSrcStat = await fs5.stat(src);
+        await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+      }
+      return fs5.chmod(dest, srcStat.mode);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return fs5.chmod(dest, srcMode | 128);
+    }
+    async function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat) {
+        await fs5.mkdir(dest);
+      }
+      const items = await fs5.readdir(src);
+      await Promise.all(items.map(async (item) => {
+        const srcItem = path5.join(src, item);
+        const destItem = path5.join(dest, item);
+        const include = await runFilter(srcItem, destItem, opts);
+        if (!include)
+          return;
+        const { destStat: destStat2 } = await stat.checkPaths(srcItem, destItem, "copy", opts);
+        return getStatsAndPerformCopy(destStat2, srcItem, destItem, opts);
+      }));
+      if (!destStat) {
+        await fs5.chmod(dest, srcStat.mode);
+      }
+    }
+    async function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = await fs5.readlink(src);
+      if (opts.dereference) {
+        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs5.symlink(resolvedSrc, dest);
+      }
+      let resolvedDest = null;
+      try {
+        resolvedDest = await fs5.readlink(dest);
+      } catch (e) {
+        if (e.code === "EINVAL" || e.code === "UNKNOWN")
+          return fs5.symlink(resolvedSrc, dest);
+        throw e;
+      }
+      if (opts.dereference) {
+        resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+      }
+      if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+        throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+      }
+      if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+        throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+      }
+      await fs5.unlink(dest);
+      return fs5.symlink(resolvedSrc, dest);
+    }
+    module.exports = copy;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js
+var require_copy_sync = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_graceful_fs();
+    var path5 = __require("path");
+    var mkdirsSync = require_mkdirs().mkdirsSync;
+    var utimesMillisSync = require_utimes().utimesMillisSync;
+    var stat = require_stat();
+    function copySync(src, dest, opts) {
+      if (typeof opts === "function") {
+        opts = { filter: opts };
+      }
+      opts = opts || {};
+      opts.clobber = "clobber" in opts ? !!opts.clobber : true;
+      opts.overwrite = "overwrite" in opts ? !!opts.overwrite : opts.clobber;
+      if (opts.preserveTimestamps && process.arch === "ia32") {
+        process.emitWarning(
+          "Using the preserveTimestamps option in 32-bit node is not recommended;\n\n	see https://github.com/jprichardson/node-fs-extra/issues/269",
+          "Warning",
+          "fs-extra-WARN0002"
+        );
+      }
+      const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
+      stat.checkParentPathsSync(src, srcStat, dest, "copy");
+      if (opts.filter && !opts.filter(src, dest))
+        return;
+      const destParent = path5.dirname(dest);
+      if (!fs5.existsSync(destParent))
+        mkdirsSync(destParent);
+      return getStats(destStat, src, dest, opts);
+    }
+    function getStats(destStat, src, dest, opts) {
+      const statSync = opts.dereference ? fs5.statSync : fs5.lstatSync;
+      const srcStat = statSync(src);
+      if (srcStat.isDirectory())
+        return onDir(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice())
+        return onFile(srcStat, destStat, src, dest, opts);
+      else if (srcStat.isSymbolicLink())
+        return onLink(destStat, src, dest, opts);
+      else if (srcStat.isSocket())
+        throw new Error(`Cannot copy a socket file: ${src}`);
+      else if (srcStat.isFIFO())
+        throw new Error(`Cannot copy a FIFO pipe: ${src}`);
+      throw new Error(`Unknown file: ${src}`);
+    }
+    function onFile(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return copyFile(srcStat, src, dest, opts);
+      return mayCopyFile(srcStat, src, dest, opts);
+    }
+    function mayCopyFile(srcStat, src, dest, opts) {
+      if (opts.overwrite) {
+        fs5.unlinkSync(dest);
+        return copyFile(srcStat, src, dest, opts);
+      } else if (opts.errorOnExist) {
+        throw new Error(`'${dest}' already exists`);
+      }
+    }
+    function copyFile(srcStat, src, dest, opts) {
+      fs5.copyFileSync(src, dest);
+      if (opts.preserveTimestamps)
+        handleTimestamps(srcStat.mode, src, dest);
+      return setDestMode(dest, srcStat.mode);
+    }
+    function handleTimestamps(srcMode, src, dest) {
+      if (fileIsNotWritable(srcMode))
+        makeFileWritable(dest, srcMode);
+      return setDestTimestamps(src, dest);
+    }
+    function fileIsNotWritable(srcMode) {
+      return (srcMode & 128) === 0;
+    }
+    function makeFileWritable(dest, srcMode) {
+      return setDestMode(dest, srcMode | 128);
+    }
+    function setDestMode(dest, srcMode) {
+      return fs5.chmodSync(dest, srcMode);
+    }
+    function setDestTimestamps(src, dest) {
+      const updatedSrcStat = fs5.statSync(src);
+      return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
+    }
+    function onDir(srcStat, destStat, src, dest, opts) {
+      if (!destStat)
+        return mkDirAndCopy(srcStat.mode, src, dest, opts);
+      return copyDir(src, dest, opts);
+    }
+    function mkDirAndCopy(srcMode, src, dest, opts) {
+      fs5.mkdirSync(dest);
+      copyDir(src, dest, opts);
+      return setDestMode(dest, srcMode);
+    }
+    function copyDir(src, dest, opts) {
+      fs5.readdirSync(src).forEach((item) => copyDirItem(item, src, dest, opts));
+    }
+    function copyDirItem(item, src, dest, opts) {
+      const srcItem = path5.join(src, item);
+      const destItem = path5.join(dest, item);
+      if (opts.filter && !opts.filter(srcItem, destItem))
+        return;
+      const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
+      return getStats(destStat, srcItem, destItem, opts);
+    }
+    function onLink(destStat, src, dest, opts) {
+      let resolvedSrc = fs5.readlinkSync(src);
+      if (opts.dereference) {
+        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+      }
+      if (!destStat) {
+        return fs5.symlinkSync(resolvedSrc, dest);
+      } else {
+        let resolvedDest;
+        try {
+          resolvedDest = fs5.readlinkSync(dest);
+        } catch (err) {
+          if (err.code === "EINVAL" || err.code === "UNKNOWN")
+            return fs5.symlinkSync(resolvedSrc, dest);
+          throw err;
+        }
+        if (opts.dereference) {
+          resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+        }
+        if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
+          throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
+        }
+        if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
+          throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
+        }
+        return copyLink(resolvedSrc, dest);
+      }
+    }
+    function copyLink(resolvedSrc, dest) {
+      fs5.unlinkSync(dest);
+      return fs5.symlinkSync(resolvedSrc, dest);
+    }
+    module.exports = copySync;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/index.js
+var require_copy2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/copy/index.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    module.exports = {
+      copy: u(require_copy()),
+      copySync: require_copy_sync()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/remove/index.js
+var require_remove = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_graceful_fs();
+    var u = require_universalify().fromCallback;
+    function remove2(path5, callback) {
+      fs5.rm(path5, { recursive: true, force: true }, callback);
+    }
+    function removeSync(path5) {
+      fs5.rmSync(path5, { recursive: true, force: true });
+    }
+    module.exports = {
+      remove: u(remove2),
+      removeSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/empty/index.js
+var require_empty = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    var fs5 = require_fs();
+    var path5 = __require("path");
+    var mkdir = require_mkdirs();
+    var remove2 = require_remove();
+    var emptyDir = u(async function emptyDir2(dir) {
+      let items;
+      try {
+        items = await fs5.readdir(dir);
+      } catch {
+        return mkdir.mkdirs(dir);
+      }
+      return Promise.all(items.map((item) => remove2.remove(path5.join(dir, item))));
+    });
+    function emptyDirSync(dir) {
+      let items;
+      try {
+        items = fs5.readdirSync(dir);
+      } catch {
+        return mkdir.mkdirsSync(dir);
+      }
+      items.forEach((item) => {
+        item = path5.join(dir, item);
+        remove2.removeSync(item);
+      });
+    }
+    module.exports = {
+      emptyDirSync,
+      emptydirSync: emptyDirSync,
+      emptyDir,
+      emptydir: emptyDir
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js
+var require_file = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    var path5 = __require("path");
+    var fs5 = require_fs();
+    var mkdir = require_mkdirs();
+    async function createFile(file) {
+      let stats;
+      try {
+        stats = await fs5.stat(file);
+      } catch {
+      }
+      if (stats && stats.isFile())
+        return;
+      const dir = path5.dirname(file);
+      let dirStats = null;
+      try {
+        dirStats = await fs5.stat(dir);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          await mkdir.mkdirs(dir);
+          await fs5.writeFile(file, "");
+          return;
+        } else {
+          throw err;
+        }
+      }
+      if (dirStats.isDirectory()) {
+        await fs5.writeFile(file, "");
+      } else {
+        await fs5.readdir(dir);
+      }
+    }
+    function createFileSync(file) {
+      let stats;
+      try {
+        stats = fs5.statSync(file);
+      } catch {
+      }
+      if (stats && stats.isFile())
+        return;
+      const dir = path5.dirname(file);
+      try {
+        if (!fs5.statSync(dir).isDirectory()) {
+          fs5.readdirSync(dir);
+        }
+      } catch (err) {
+        if (err && err.code === "ENOENT")
+          mkdir.mkdirsSync(dir);
+        else
+          throw err;
+      }
+      fs5.writeFileSync(file, "");
+    }
+    module.exports = {
+      createFile: u(createFile),
+      createFileSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js
+var require_link = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    var path5 = __require("path");
+    var fs5 = require_fs();
+    var mkdir = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createLink(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = await fs5.lstat(dstpath);
+      } catch {
+      }
+      let srcStat;
+      try {
+        srcStat = await fs5.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      if (dstStat && areIdentical(srcStat, dstStat))
+        return;
+      const dir = path5.dirname(dstpath);
+      const dirExists = await pathExists2(dir);
+      if (!dirExists) {
+        await mkdir.mkdirs(dir);
+      }
+      await fs5.link(srcpath, dstpath);
+    }
+    function createLinkSync(srcpath, dstpath) {
+      let dstStat;
+      try {
+        dstStat = fs5.lstatSync(dstpath);
+      } catch {
+      }
+      try {
+        const srcStat = fs5.lstatSync(srcpath);
+        if (dstStat && areIdentical(srcStat, dstStat))
+          return;
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureLink");
+        throw err;
+      }
+      const dir = path5.dirname(dstpath);
+      const dirExists = fs5.existsSync(dir);
+      if (dirExists)
+        return fs5.linkSync(srcpath, dstpath);
+      mkdir.mkdirsSync(dir);
+      return fs5.linkSync(srcpath, dstpath);
+    }
+    module.exports = {
+      createLink: u(createLink),
+      createLinkSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js
+var require_symlink_paths = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports, module) {
+    init_cjs_shims();
+    var path5 = __require("path");
+    var fs5 = require_fs();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var u = require_universalify().fromPromise;
+    async function symlinkPaths(srcpath, dstpath) {
+      if (path5.isAbsolute(srcpath)) {
+        try {
+          await fs5.lstat(srcpath);
+        } catch (err) {
+          err.message = err.message.replace("lstat", "ensureSymlink");
+          throw err;
+        }
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path5.dirname(dstpath);
+      const relativeToDst = path5.join(dstdir, srcpath);
+      const exists = await pathExists2(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      try {
+        await fs5.lstat(srcpath);
+      } catch (err) {
+        err.message = err.message.replace("lstat", "ensureSymlink");
+        throw err;
+      }
+      return {
+        toCwd: srcpath,
+        toDst: path5.relative(dstdir, srcpath)
+      };
+    }
+    function symlinkPathsSync(srcpath, dstpath) {
+      if (path5.isAbsolute(srcpath)) {
+        const exists2 = fs5.existsSync(srcpath);
+        if (!exists2)
+          throw new Error("absolute srcpath does not exist");
+        return {
+          toCwd: srcpath,
+          toDst: srcpath
+        };
+      }
+      const dstdir = path5.dirname(dstpath);
+      const relativeToDst = path5.join(dstdir, srcpath);
+      const exists = fs5.existsSync(relativeToDst);
+      if (exists) {
+        return {
+          toCwd: relativeToDst,
+          toDst: srcpath
+        };
+      }
+      const srcExists = fs5.existsSync(srcpath);
+      if (!srcExists)
+        throw new Error("relative srcpath does not exist");
+      return {
+        toCwd: srcpath,
+        toDst: path5.relative(dstdir, srcpath)
+      };
+    }
+    module.exports = {
+      symlinkPaths: u(symlinkPaths),
+      symlinkPathsSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-type.js
+var require_symlink_type = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_fs();
+    var u = require_universalify().fromPromise;
+    async function symlinkType(srcpath, type) {
+      if (type)
+        return type;
+      let stats;
+      try {
+        stats = await fs5.lstat(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    function symlinkTypeSync(srcpath, type) {
+      if (type)
+        return type;
+      let stats;
+      try {
+        stats = fs5.lstatSync(srcpath);
+      } catch {
+        return "file";
+      }
+      return stats && stats.isDirectory() ? "dir" : "file";
+    }
+    module.exports = {
+      symlinkType: u(symlinkType),
+      symlinkTypeSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js
+var require_symlink = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    var path5 = __require("path");
+    var fs5 = require_fs();
+    var { mkdirs, mkdirsSync } = require_mkdirs();
+    var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
+    var { symlinkType, symlinkTypeSync } = require_symlink_type();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var { areIdentical } = require_stat();
+    async function createSymlink(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = await fs5.lstat(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const [srcStat, dstStat] = await Promise.all([
+          fs5.stat(srcpath),
+          fs5.stat(dstpath)
+        ]);
+        if (areIdentical(srcStat, dstStat))
+          return;
+      }
+      const relative2 = await symlinkPaths(srcpath, dstpath);
+      srcpath = relative2.toDst;
+      const toType = await symlinkType(relative2.toCwd, type);
+      const dir = path5.dirname(dstpath);
+      if (!await pathExists2(dir)) {
+        await mkdirs(dir);
+      }
+      return fs5.symlink(srcpath, dstpath, toType);
+    }
+    function createSymlinkSync(srcpath, dstpath, type) {
+      let stats;
+      try {
+        stats = fs5.lstatSync(dstpath);
+      } catch {
+      }
+      if (stats && stats.isSymbolicLink()) {
+        const srcStat = fs5.statSync(srcpath);
+        const dstStat = fs5.statSync(dstpath);
+        if (areIdentical(srcStat, dstStat))
+          return;
+      }
+      const relative2 = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative2.toDst;
+      type = symlinkTypeSync(relative2.toCwd, type);
+      const dir = path5.dirname(dstpath);
+      const exists = fs5.existsSync(dir);
+      if (exists)
+        return fs5.symlinkSync(srcpath, dstpath, type);
+      mkdirsSync(dir);
+      return fs5.symlinkSync(srcpath, dstpath, type);
+    }
+    module.exports = {
+      createSymlink: u(createSymlink),
+      createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/index.js
+var require_ensure = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/ensure/index.js"(exports, module) {
+    init_cjs_shims();
+    var { createFile, createFileSync } = require_file();
+    var { createLink, createLinkSync } = require_link();
+    var { createSymlink, createSymlinkSync } = require_symlink();
+    module.exports = {
+      // file
+      createFile,
+      createFileSync,
+      ensureFile: createFile,
+      ensureFileSync: createFileSync,
+      // link
+      createLink,
+      createLinkSync,
+      ensureLink: createLink,
+      ensureLinkSync: createLinkSync,
+      // symlink
+      createSymlink,
+      createSymlinkSync,
+      ensureSymlink: createSymlink,
+      ensureSymlinkSync: createSymlinkSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js
+var require_utils2 = __commonJS({
+  "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/utils.js"(exports, module) {
+    init_cjs_shims();
+    function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+      const EOF = finalEOL ? EOL : "";
+      const str = JSON.stringify(obj, replacer, spaces);
+      return str.replace(/\n/g, EOL) + EOF;
+    }
+    function stripBom(content) {
+      if (Buffer.isBuffer(content))
+        content = content.toString("utf8");
+      return content.replace(/^\uFEFF/, "");
+    }
+    module.exports = { stringify, stripBom };
+  }
+});
+
+// ../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js
+var require_jsonfile = __commonJS({
+  "../../node_modules/.pnpm/jsonfile@6.1.0/node_modules/jsonfile/index.js"(exports, module) {
+    init_cjs_shims();
+    var _fs;
+    try {
+      _fs = require_graceful_fs();
+    } catch (_) {
+      _fs = __require("fs");
+    }
+    var universalify = require_universalify();
+    var { stringify, stripBom } = require_utils2();
+    async function _readFile(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs5 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      let data = await universalify.fromCallback(fs5.readFile)(file, options);
+      data = stripBom(data);
+      let obj;
+      try {
+        obj = JSON.parse(data, options ? options.reviver : null);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+      return obj;
+    }
+    var readFile = universalify.fromPromise(_readFile);
+    function readFileSync(file, options = {}) {
+      if (typeof options === "string") {
+        options = { encoding: options };
+      }
+      const fs5 = options.fs || _fs;
+      const shouldThrow = "throws" in options ? options.throws : true;
+      try {
+        let content = fs5.readFileSync(file, options);
+        content = stripBom(content);
+        return JSON.parse(content, options.reviver);
+      } catch (err) {
+        if (shouldThrow) {
+          err.message = `${file}: ${err.message}`;
+          throw err;
+        } else {
+          return null;
+        }
+      }
+    }
+    async function _writeFile(file, obj, options = {}) {
+      const fs5 = options.fs || _fs;
+      const str = stringify(obj, options);
+      await universalify.fromCallback(fs5.writeFile)(file, str, options);
+    }
+    var writeFile = universalify.fromPromise(_writeFile);
+    function writeFileSync(file, obj, options = {}) {
+      const fs5 = options.fs || _fs;
+      const str = stringify(obj, options);
+      return fs5.writeFileSync(file, str, options);
+    }
+    var jsonfile = {
+      readFile,
+      readFileSync,
+      writeFile,
+      writeFileSync
+    };
+    module.exports = jsonfile;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/jsonfile.js
+var require_jsonfile2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/jsonfile.js"(exports, module) {
+    init_cjs_shims();
+    var jsonFile = require_jsonfile();
+    module.exports = {
+      // jsonfile exports
+      readJson: jsonFile.readFile,
+      readJsonSync: jsonFile.readFileSync,
+      writeJson: jsonFile.writeFile,
+      writeJsonSync: jsonFile.writeFileSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/output-file/index.js
+var require_output_file = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    var fs5 = require_fs();
+    var path5 = __require("path");
+    var mkdir = require_mkdirs();
+    var pathExists2 = require_path_exists().pathExists;
+    async function outputFile(file, data, encoding = "utf-8") {
+      const dir = path5.dirname(file);
+      if (!await pathExists2(dir)) {
+        await mkdir.mkdirs(dir);
+      }
+      return fs5.writeFile(file, data, encoding);
+    }
+    function outputFileSync(file, ...args) {
+      const dir = path5.dirname(file);
+      if (!fs5.existsSync(dir)) {
+        mkdir.mkdirsSync(dir);
+      }
+      fs5.writeFileSync(file, ...args);
+    }
+    module.exports = {
+      outputFile: u(outputFile),
+      outputFileSync
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json.js
+var require_output_json = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json.js"(exports, module) {
+    init_cjs_shims();
+    var { stringify } = require_utils2();
+    var { outputFile } = require_output_file();
+    async function outputJson(file, data, options = {}) {
+      const str = stringify(data, options);
+      await outputFile(file, str, options);
+    }
+    module.exports = outputJson;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json-sync.js
+var require_output_json_sync = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/output-json-sync.js"(exports, module) {
+    init_cjs_shims();
+    var { stringify } = require_utils2();
+    var { outputFileSync } = require_output_file();
+    function outputJsonSync(file, data, options) {
+      const str = stringify(data, options);
+      outputFileSync(file, str, options);
+    }
+    module.exports = outputJsonSync;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/index.js
+var require_json = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/json/index.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    var jsonFile = require_jsonfile2();
+    jsonFile.outputJson = u(require_output_json());
+    jsonFile.outputJsonSync = require_output_json_sync();
+    jsonFile.outputJSON = jsonFile.outputJson;
+    jsonFile.outputJSONSync = jsonFile.outputJsonSync;
+    jsonFile.writeJSON = jsonFile.writeJson;
+    jsonFile.writeJSONSync = jsonFile.writeJsonSync;
+    jsonFile.readJSON = jsonFile.readJson;
+    jsonFile.readJSONSync = jsonFile.readJsonSync;
+    module.exports = jsonFile;
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js
+var require_move = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_fs();
+    var path5 = __require("path");
+    var { copy } = require_copy2();
+    var { remove: remove2 } = require_remove();
+    var { mkdirp } = require_mkdirs();
+    var { pathExists: pathExists2 } = require_path_exists();
+    var stat = require_stat();
+    async function move(src, dest, opts = {}) {
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
+      await stat.checkParentPaths(src, srcStat, dest, "move");
+      const destParent = path5.dirname(dest);
+      const parsedParentPath = path5.parse(destParent);
+      if (parsedParentPath.root !== destParent) {
+        await mkdirp(destParent);
+      }
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    async function doRename(src, dest, overwrite, isChangingCase) {
+      if (!isChangingCase) {
+        if (overwrite) {
+          await remove2(dest);
+        } else if (await pathExists2(dest)) {
+          throw new Error("dest already exists.");
+        }
+      }
+      try {
+        await fs5.rename(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV") {
+          throw err;
+        }
+        await moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    async function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      await copy(src, dest, opts);
+      return remove2(src);
+    }
+    module.exports = move;
   }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath() {
-    return this.path.replaceAll("{", ":").replaceAll("}", "");
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js
+var require_move_sync = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
+    init_cjs_shims();
+    var fs5 = require_graceful_fs();
+    var path5 = __require("path");
+    var copySync = require_copy2().copySync;
+    var removeSync = require_remove().removeSync;
+    var mkdirpSync = require_mkdirs().mkdirpSync;
+    var stat = require_stat();
+    function moveSync(src, dest, opts) {
+      opts = opts || {};
+      const overwrite = opts.overwrite || opts.clobber || false;
+      const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
+      stat.checkParentPathsSync(src, srcStat, dest, "move");
+      if (!isParentRoot(dest))
+        mkdirpSync(path5.dirname(dest));
+      return doRename(src, dest, overwrite, isChangingCase);
+    }
+    function isParentRoot(dest) {
+      const parent = path5.dirname(dest);
+      const parsedPath = path5.parse(parent);
+      return parsedPath.root === parent;
+    }
+    function doRename(src, dest, overwrite, isChangingCase) {
+      if (isChangingCase)
+        return rename(src, dest, overwrite);
+      if (overwrite) {
+        removeSync(dest);
+        return rename(src, dest, overwrite);
+      }
+      if (fs5.existsSync(dest))
+        throw new Error("dest already exists.");
+      return rename(src, dest, overwrite);
+    }
+    function rename(src, dest, overwrite) {
+      try {
+        fs5.renameSync(src, dest);
+      } catch (err) {
+        if (err.code !== "EXDEV")
+          throw err;
+        return moveAcrossDevice(src, dest, overwrite);
+      }
+    }
+    function moveAcrossDevice(src, dest, overwrite) {
+      const opts = {
+        overwrite,
+        errorOnExist: true,
+        preserveTimestamps: true
+      };
+      copySync(src, dest, opts);
+      return removeSync(src);
+    }
+    module.exports = moveSync;
   }
-};
+});
 
-// src/config.ts
-function defineConfig(options) {
-  return options;
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/index.js
+var require_move2 = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/move/index.js"(exports, module) {
+    init_cjs_shims();
+    var u = require_universalify().fromPromise;
+    module.exports = {
+      move: u(require_move()),
+      moveSync: require_move_sync()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/fs-extra@11.2.0/node_modules/fs-extra/lib/index.js"(exports, module) {
+    init_cjs_shims();
+    module.exports = {
+      // Export promiseified graceful-fs:
+      ...require_fs(),
+      // Export extra methods:
+      ...require_copy2(),
+      ...require_empty(),
+      ...require_ensure(),
+      ...require_json(),
+      ...require_mkdirs(),
+      ...require_move2(),
+      ...require_output_file(),
+      ...require_path_exists(),
+      ...require_remove()
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js
+var require_lodash = __commonJS({
+  "../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js"(exports, module) {
+    init_cjs_shims();
+    var LARGE_ARRAY_SIZE = 200;
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    var COMPARE_PARTIAL_FLAG = 1;
+    var COMPARE_UNORDERED_FLAG = 2;
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    var argsTag = "[object Arguments]";
+    var arrayTag = "[object Array]";
+    var asyncTag = "[object AsyncFunction]";
+    var boolTag = "[object Boolean]";
+    var dateTag = "[object Date]";
+    var errorTag = "[object Error]";
+    var funcTag = "[object Function]";
+    var genTag = "[object GeneratorFunction]";
+    var mapTag = "[object Map]";
+    var numberTag = "[object Number]";
+    var nullTag = "[object Null]";
+    var objectTag = "[object Object]";
+    var promiseTag = "[object Promise]";
+    var proxyTag = "[object Proxy]";
+    var regexpTag = "[object RegExp]";
+    var setTag = "[object Set]";
+    var stringTag = "[object String]";
+    var symbolTag = "[object Symbol]";
+    var undefinedTag = "[object Undefined]";
+    var weakMapTag = "[object WeakMap]";
+    var arrayBufferTag = "[object ArrayBuffer]";
+    var dataViewTag = "[object DataView]";
+    var float32Tag = "[object Float32Array]";
+    var float64Tag = "[object Float64Array]";
+    var int8Tag = "[object Int8Array]";
+    var int16Tag = "[object Int16Array]";
+    var int32Tag = "[object Int32Array]";
+    var uint8Tag = "[object Uint8Array]";
+    var uint8ClampedTag = "[object Uint8ClampedArray]";
+    var uint16Tag = "[object Uint16Array]";
+    var uint32Tag = "[object Uint32Array]";
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+    var reIsUint = /^(?:0|[1-9]\d*)$/;
+    var typedArrayTags = {};
+    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+    var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var freeProcess = moduleExports && freeGlobal.process;
+    var nodeUtil = function() {
+      try {
+        return freeProcess && freeProcess.binding && freeProcess.binding("util");
+      } catch (e) {
+      }
+    }();
+    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+    function arrayFilter(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+      while (++index < length) {
+        var value = array[index];
+        if (predicate(value, index, array)) {
+          result[resIndex++] = value;
+        }
+      }
+      return result;
+    }
+    function arrayPush(array, values) {
+      var index = -1, length = values.length, offset = array.length;
+      while (++index < length) {
+        array[offset + index] = values[index];
+      }
+      return array;
+    }
+    function arraySome(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length;
+      while (++index < length) {
+        if (predicate(array[index], index, array)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function baseTimes(n, iteratee) {
+      var index = -1, result = Array(n);
+      while (++index < n) {
+        result[index] = iteratee(index);
+      }
+      return result;
+    }
+    function baseUnary(func) {
+      return function(value) {
+        return func(value);
+      };
+    }
+    function cacheHas(cache, key) {
+      return cache.has(key);
+    }
+    function getValue(object, key) {
+      return object == null ? void 0 : object[key];
+    }
+    function mapToArray(map) {
+      var index = -1, result = Array(map.size);
+      map.forEach(function(value, key) {
+        result[++index] = [key, value];
+      });
+      return result;
+    }
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
+      };
+    }
+    function setToArray(set) {
+      var index = -1, result = Array(set.size);
+      set.forEach(function(value) {
+        result[++index] = value;
+      });
+      return result;
+    }
+    var arrayProto = Array.prototype;
+    var funcProto = Function.prototype;
+    var objectProto = Object.prototype;
+    var coreJsData = root["__core-js_shared__"];
+    var funcToString = funcProto.toString;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var maskSrcKey = function() {
+      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+      return uid ? "Symbol(src)_1." + uid : "";
+    }();
+    var nativeObjectToString = objectProto.toString;
+    var reIsNative = RegExp(
+      "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+    );
+    var Buffer2 = moduleExports ? root.Buffer : void 0;
+    var Symbol2 = root.Symbol;
+    var Uint8Array2 = root.Uint8Array;
+    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+    var splice = arrayProto.splice;
+    var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+    var nativeGetSymbols = Object.getOwnPropertySymbols;
+    var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+    var nativeKeys = overArg(Object.keys, Object);
+    var DataView = getNative(root, "DataView");
+    var Map2 = getNative(root, "Map");
+    var Promise2 = getNative(root, "Promise");
+    var Set2 = getNative(root, "Set");
+    var WeakMap2 = getNative(root, "WeakMap");
+    var nativeCreate = getNative(Object, "create");
+    var dataViewCtorString = toSource(DataView);
+    var mapCtorString = toSource(Map2);
+    var promiseCtorString = toSource(Promise2);
+    var setCtorString = toSource(Set2);
+    var weakMapCtorString = toSource(WeakMap2);
+    var symbolProto = Symbol2 ? Symbol2.prototype : void 0;
+    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+    function Hash(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function hashClear() {
+      this.__data__ = nativeCreate ? nativeCreate(null) : {};
+      this.size = 0;
+    }
+    function hashDelete(key) {
+      var result = this.has(key) && delete this.__data__[key];
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function hashGet(key) {
+      var data = this.__data__;
+      if (nativeCreate) {
+        var result = data[key];
+        return result === HASH_UNDEFINED ? void 0 : result;
+      }
+      return hasOwnProperty.call(data, key) ? data[key] : void 0;
+    }
+    function hashHas(key) {
+      var data = this.__data__;
+      return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+    }
+    function hashSet(key, value) {
+      var data = this.__data__;
+      this.size += this.has(key) ? 0 : 1;
+      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+      return this;
+    }
+    Hash.prototype.clear = hashClear;
+    Hash.prototype["delete"] = hashDelete;
+    Hash.prototype.get = hashGet;
+    Hash.prototype.has = hashHas;
+    Hash.prototype.set = hashSet;
+    function ListCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function listCacheClear() {
+      this.__data__ = [];
+      this.size = 0;
+    }
+    function listCacheDelete(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        return false;
+      }
+      var lastIndex = data.length - 1;
+      if (index == lastIndex) {
+        data.pop();
+      } else {
+        splice.call(data, index, 1);
+      }
+      --this.size;
+      return true;
+    }
+    function listCacheGet(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      return index < 0 ? void 0 : data[index][1];
+    }
+    function listCacheHas(key) {
+      return assocIndexOf(this.__data__, key) > -1;
+    }
+    function listCacheSet(key, value) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        ++this.size;
+        data.push([key, value]);
+      } else {
+        data[index][1] = value;
+      }
+      return this;
+    }
+    ListCache.prototype.clear = listCacheClear;
+    ListCache.prototype["delete"] = listCacheDelete;
+    ListCache.prototype.get = listCacheGet;
+    ListCache.prototype.has = listCacheHas;
+    ListCache.prototype.set = listCacheSet;
+    function MapCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function mapCacheClear() {
+      this.size = 0;
+      this.__data__ = {
+        "hash": new Hash(),
+        "map": new (Map2 || ListCache)(),
+        "string": new Hash()
+      };
+    }
+    function mapCacheDelete(key) {
+      var result = getMapData(this, key)["delete"](key);
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function mapCacheGet(key) {
+      return getMapData(this, key).get(key);
+    }
+    function mapCacheHas(key) {
+      return getMapData(this, key).has(key);
+    }
+    function mapCacheSet(key, value) {
+      var data = getMapData(this, key), size = data.size;
+      data.set(key, value);
+      this.size += data.size == size ? 0 : 1;
+      return this;
+    }
+    MapCache.prototype.clear = mapCacheClear;
+    MapCache.prototype["delete"] = mapCacheDelete;
+    MapCache.prototype.get = mapCacheGet;
+    MapCache.prototype.has = mapCacheHas;
+    MapCache.prototype.set = mapCacheSet;
+    function SetCache(values) {
+      var index = -1, length = values == null ? 0 : values.length;
+      this.__data__ = new MapCache();
+      while (++index < length) {
+        this.add(values[index]);
+      }
+    }
+    function setCacheAdd(value) {
+      this.__data__.set(value, HASH_UNDEFINED);
+      return this;
+    }
+    function setCacheHas(value) {
+      return this.__data__.has(value);
+    }
+    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+    SetCache.prototype.has = setCacheHas;
+    function Stack(entries) {
+      var data = this.__data__ = new ListCache(entries);
+      this.size = data.size;
+    }
+    function stackClear() {
+      this.__data__ = new ListCache();
+      this.size = 0;
+    }
+    function stackDelete(key) {
+      var data = this.__data__, result = data["delete"](key);
+      this.size = data.size;
+      return result;
+    }
+    function stackGet(key) {
+      return this.__data__.get(key);
+    }
+    function stackHas(key) {
+      return this.__data__.has(key);
+    }
+    function stackSet(key, value) {
+      var data = this.__data__;
+      if (data instanceof ListCache) {
+        var pairs = data.__data__;
+        if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+          pairs.push([key, value]);
+          this.size = ++data.size;
+          return this;
+        }
+        data = this.__data__ = new MapCache(pairs);
+      }
+      data.set(key, value);
+      this.size = data.size;
+      return this;
+    }
+    Stack.prototype.clear = stackClear;
+    Stack.prototype["delete"] = stackDelete;
+    Stack.prototype.get = stackGet;
+    Stack.prototype.has = stackHas;
+    Stack.prototype.set = stackSet;
+    function arrayLikeKeys(value, inherited) {
+      var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+      for (var key in value) {
+        if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+        isIndex(key, length)))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function assocIndexOf(array, key) {
+      var length = array.length;
+      while (length--) {
+        if (eq(array[length][0], key)) {
+          return length;
+        }
+      }
+      return -1;
+    }
+    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+      var result = keysFunc(object);
+      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+    }
+    function baseGetTag(value) {
+      if (value == null) {
+        return value === void 0 ? undefinedTag : nullTag;
+      }
+      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+    }
+    function baseIsArguments(value) {
+      return isObjectLike(value) && baseGetTag(value) == argsTag;
+    }
+    function baseIsEqual(value, other, bitmask, customizer, stack) {
+      if (value === other) {
+        return true;
+      }
+      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+        return value !== value && other !== other;
+      }
+      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+    }
+    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+      var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+      objTag = objTag == argsTag ? objectTag : objTag;
+      othTag = othTag == argsTag ? objectTag : othTag;
+      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+      if (isSameTag && isBuffer(object)) {
+        if (!isBuffer(other)) {
+          return false;
+        }
+        objIsArr = true;
+        objIsObj = false;
+      }
+      if (isSameTag && !objIsObj) {
+        stack || (stack = new Stack());
+        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+      }
+      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+        var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+        if (objIsWrapped || othIsWrapped) {
+          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+          stack || (stack = new Stack());
+          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+        }
+      }
+      if (!isSameTag) {
+        return false;
+      }
+      stack || (stack = new Stack());
+      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+    }
+    function baseIsNative(value) {
+      if (!isObject(value) || isMasked(value)) {
+        return false;
+      }
+      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+      return pattern.test(toSource(value));
+    }
+    function baseIsTypedArray(value) {
+      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+    }
+    function baseKeys(object) {
+      if (!isPrototype(object)) {
+        return nativeKeys(object);
+      }
+      var result = [];
+      for (var key in Object(object)) {
+        if (hasOwnProperty.call(object, key) && key != "constructor") {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+      }
+      var stacked = stack.get(array);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+      stack.set(array, other);
+      stack.set(other, array);
+      while (++index < arrLength) {
+        var arrValue = array[index], othValue = other[index];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+        }
+        if (compared !== void 0) {
+          if (compared) {
+            continue;
+          }
+          result = false;
+          break;
+        }
+        if (seen) {
+          if (!arraySome(other, function(othValue2, othIndex) {
+            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+            result = false;
+            break;
+          }
+        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+          result = false;
+          break;
+        }
+      }
+      stack["delete"](array);
+      stack["delete"](other);
+      return result;
+    }
+    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+      switch (tag) {
+        case dataViewTag:
+          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+            return false;
+          }
+          object = object.buffer;
+          other = other.buffer;
+        case arrayBufferTag:
+          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+            return false;
+          }
+          return true;
+        case boolTag:
+        case dateTag:
+        case numberTag:
+          return eq(+object, +other);
+        case errorTag:
+          return object.name == other.name && object.message == other.message;
+        case regexpTag:
+        case stringTag:
+          return object == other + "";
+        case mapTag:
+          var convert = mapToArray;
+        case setTag:
+          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+          convert || (convert = setToArray);
+          if (object.size != other.size && !isPartial) {
+            return false;
+          }
+          var stacked = stack.get(object);
+          if (stacked) {
+            return stacked == other;
+          }
+          bitmask |= COMPARE_UNORDERED_FLAG;
+          stack.set(object, other);
+          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+          stack["delete"](object);
+          return result;
+        case symbolTag:
+          if (symbolValueOf) {
+            return symbolValueOf.call(object) == symbolValueOf.call(other);
+          }
+      }
+      return false;
+    }
+    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+      if (objLength != othLength && !isPartial) {
+        return false;
+      }
+      var index = objLength;
+      while (index--) {
+        var key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+          return false;
+        }
+      }
+      var stacked = stack.get(object);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var result = true;
+      stack.set(object, other);
+      stack.set(other, object);
+      var skipCtor = isPartial;
+      while (++index < objLength) {
+        key = objProps[index];
+        var objValue = object[key], othValue = other[key];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+        }
+        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+          result = false;
+          break;
+        }
+        skipCtor || (skipCtor = key == "constructor");
+      }
+      if (result && !skipCtor) {
+        var objCtor = object.constructor, othCtor = other.constructor;
+        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+          result = false;
+        }
+      }
+      stack["delete"](object);
+      stack["delete"](other);
+      return result;
+    }
+    function getAllKeys(object) {
+      return baseGetAllKeys(object, keys, getSymbols);
+    }
+    function getMapData(map, key) {
+      var data = map.__data__;
+      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+    }
+    function getNative(object, key) {
+      var value = getValue(object, key);
+      return baseIsNative(value) ? value : void 0;
+    }
+    function getRawTag(value) {
+      var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+      try {
+        value[symToStringTag] = void 0;
+        var unmasked = true;
+      } catch (e) {
+      }
+      var result = nativeObjectToString.call(value);
+      if (unmasked) {
+        if (isOwn) {
+          value[symToStringTag] = tag;
+        } else {
+          delete value[symToStringTag];
+        }
+      }
+      return result;
+    }
+    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+      if (object == null) {
+        return [];
+      }
+      object = Object(object);
+      return arrayFilter(nativeGetSymbols(object), function(symbol) {
+        return propertyIsEnumerable.call(object, symbol);
+      });
+    };
+    var getTag = baseGetTag;
+    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
+      getTag = function(value) {
+        var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+        if (ctorString) {
+          switch (ctorString) {
+            case dataViewCtorString:
+              return dataViewTag;
+            case mapCtorString:
+              return mapTag;
+            case promiseCtorString:
+              return promiseTag;
+            case setCtorString:
+              return setTag;
+            case weakMapCtorString:
+              return weakMapTag;
+          }
+        }
+        return result;
+      };
+    }
+    function isIndex(value, length) {
+      length = length == null ? MAX_SAFE_INTEGER : length;
+      return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+    }
+    function isKeyable(value) {
+      var type = typeof value;
+      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+    }
+    function isMasked(func) {
+      return !!maskSrcKey && maskSrcKey in func;
+    }
+    function isPrototype(value) {
+      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+      return value === proto;
+    }
+    function objectToString(value) {
+      return nativeObjectToString.call(value);
+    }
+    function toSource(func) {
+      if (func != null) {
+        try {
+          return funcToString.call(func);
+        } catch (e) {
+        }
+        try {
+          return func + "";
+        } catch (e) {
+        }
+      }
+      return "";
+    }
+    function eq(value, other) {
+      return value === other || value !== value && other !== other;
+    }
+    var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+      return arguments;
+    }()) ? baseIsArguments : function(value) {
+      return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+    };
+    var isArray = Array.isArray;
+    function isArrayLike(value) {
+      return value != null && isLength(value.length) && !isFunction(value);
+    }
+    var isBuffer = nativeIsBuffer || stubFalse;
+    function isEqual2(value, other) {
+      return baseIsEqual(value, other);
+    }
+    function isFunction(value) {
+      if (!isObject(value)) {
+        return false;
+      }
+      var tag = baseGetTag(value);
+      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
+    function isLength(value) {
+      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    }
+    function isObject(value) {
+      var type = typeof value;
+      return value != null && (type == "object" || type == "function");
+    }
+    function isObjectLike(value) {
+      return value != null && typeof value == "object";
+    }
+    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+    function keys(object) {
+      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+    }
+    function stubArray() {
+      return [];
+    }
+    function stubFalse() {
+      return false;
+    }
+    module.exports = isEqual2;
+  }
+});
+
+// src/index.ts
+init_cjs_shims();
+
+// src/build.ts
+init_cjs_shims();
+
+// src/fs/clean.ts
+init_cjs_shims();
+var import_fs_extra = __toESM(require_lib(), 1);
+async function clean(path5) {
+  return (0, import_fs_extra.remove)(path5);
 }
-function isInputPath(result) {
-  return !!result && "path" in result;
+
+// src/fs/read.ts
+init_cjs_shims();
+var import_fs_extra2 = __toESM(require_lib(), 1);
+function slash(path5, platform = "linux") {
+  const isWindowsPath = /^\\\\\?\\/.test(path5);
+  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
+    return path5.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+  }
+  return path5.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
+}
+function getRelativePath(rootDir, filePath, platform = "linux") {
+  if (!rootDir || !filePath) {
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
+  }
+  const relativePath = path4.relative(rootDir, filePath);
+  const slashedPath = slash(relativePath, platform);
+  if (slashedPath.startsWith("../")) {
+    return slashedPath.replace(path4.basename(slashedPath), path4.basename(slashedPath, path4.extname(filePath)));
+  }
+  return `./${slashedPath.replace(path4.basename(slashedPath), path4.basename(slashedPath, path4.extname(filePath)))}`;
+}
+var reader = jsRuntime.switcher(
+  {
+    node: async (path5) => {
+      return import_fs_extra2.default.readFile(path5, { encoding: "utf8" });
+    },
+    bun: async (path5) => {
+      const file = Bun.file(path5);
+      return file.text();
+    }
+  },
+  "node"
+);
+jsRuntime.switcher(
+  {
+    node: (path5) => {
+      return import_fs_extra2.default.readFileSync(path5, { encoding: "utf8" });
+    },
+    bun: () => {
+      throw new Error("Bun cannot read sync");
+    }
+  },
+  "node"
+);
+async function read(path5) {
+  return reader(path5);
 }
 
-// src/utils/timeout.ts
-async function timeout(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(() => {
-      resolve2(true);
-    }, ms);
-  });
+// src/utils/URLPath.ts
+init_cjs_shims();
+
+// src/transformers/index.ts
+init_cjs_shims();
+
+// src/transformers/casing.ts
+init_cjs_shims();
+function camelCase(text) {
+  return changeCase.camelCase(text, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: changeCase.camelCaseTransformMerge });
+}
+function pascalCase(text) {
+  return changeCase.pascalCase(text, { delimiter: "", stripRegexp: /[^A-Z0-9$]/gi, transform: changeCase.pascalCaseTransformMerge });
 }
 
-// src/utils/transformers/combineCodes.ts
+// src/transformers/combineCodes.ts
+init_cjs_shims();
 function combineCodes(codes) {
   return codes.join("\n");
 }
 
-// src/utils/transformers/createJSDocBlockText.ts
-function createJSDocBlockText({ comments, newLine }) {
+// src/transformers/createJSDocBlockText.ts
+init_cjs_shims();
+function createJSDocBlockText({ comments }) {
   const filteredComments = comments.filter(Boolean);
   if (!filteredComments.length) {
     return "";
   }
-  const source = `/**
+  return `/**
  * ${filteredComments.join("\n * ")}
  */`;
-  if (newLine) {
-    return `${source}
-`;
-  }
-  return source;
 }
 
-// src/utils/transformers/escape.ts
+// src/transformers/escape.ts
+init_cjs_shims();
 function escape(text) {
   return text ? text.replaceAll("`", "\\`") : "";
 }
@@ -355,12 +3155,14 @@ function jsStringEscape(input) {
   });
 }
 
-// src/utils/transformers/indent.ts
+// src/transformers/indent.ts
+init_cjs_shims();
 function createIndent(size) {
   return Array.from({ length: size + 1 }).join(" ");
 }
 
-// src/utils/transformers/nameSorter.ts
+// src/transformers/nameSorter.ts
+init_cjs_shims();
 function nameSorter(a, b) {
   if (a.name < b.name) {
     return -1;
@@ -371,7 +3173,8 @@ function nameSorter(a, b) {
   return 0;
 }
 
-// src/utils/transformers/searchAndReplace.ts
+// src/transformers/searchAndReplace.ts
+init_cjs_shims();
 function searchAndReplace(options) {
   const { text, replaceBy, prefix = "", key } = options;
   const searchValues = options.searchValues?.(prefix, key) || [
@@ -388,7 +3191,8 @@ function searchAndReplace(options) {
   }, text);
 }
 
-// src/utils/transformers/transformReservedWord.ts
+// src/transformers/transformReservedWord.ts
+init_cjs_shims();
 var reservedWords = [
   "abstract",
   "arguments",
@@ -481,13 +3285,17 @@ function transformReservedWord(word) {
   return word;
 }
 
-// src/utils/transformers/trim.ts
+// src/transformers/trim.ts
+init_cjs_shims();
 function trim(text) {
   return text.replaceAll(/\n/g, "").trim();
 }
+function trimExtName(text) {
+  return text.replace(/\.[^/.]+$/, "");
+}
 
-// src/utils/transformers/index.ts
-var transformers = {
+// src/transformers/index.ts
+var transformers_default = {
   combineCodes,
   escape,
   jsStringEscape,
@@ -496,28 +3304,145 @@ var transformers = {
   nameSorter,
   searchAndReplace,
   trim,
+  trimExtName,
   JSDoc: {
     createJSDocBlockText
+  },
+  camelCase,
+  pascalCase
+};
+
+// src/utils/URLPath.ts
+var URLPath = class {
+  constructor(path5) {
+    this.path = path5;
+    return this;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  get URL() {
+    return this.toURLPath();
+  }
+  get isURL() {
+    try {
+      const url = new URL(this.path);
+      if (url?.href) {
+        return true;
+      }
+    } catch (error) {
+      return false;
+    }
+    return false;
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  get template() {
+    return this.toTemplateString();
+  }
+  get object() {
+    return this.toObject();
+  }
+  get params() {
+    return this.getParams();
+  }
+  toObject({ type = "path", replacer, stringify } = {}) {
+    const object = {
+      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams()
+    };
+    if (stringify) {
+      if (type === "template") {
+        return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      }
+      if (object.params) {
+        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+      }
+      return `{ url: '${object.url}' }`;
+    }
+    return object;
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  toTemplateString(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    let newPath = this.path.replaceAll("{", "${");
+    if (found) {
+      newPath = found.reduce((prev, curr) => {
+        const pathParam = replacer ? replacer(transformers_default.camelCase(curr)) : transformers_default.camelCase(curr);
+        const replacement = `\${${pathParam}}`;
+        return prev.replace(curr, replacement);
+      }, this.path);
+    }
+    return `\`${newPath}\``;
+  }
+  getParams(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    if (!found) {
+      return void 0;
+    }
+    const params = {};
+    found.forEach((item) => {
+      item = item.replaceAll("{", "").replaceAll("}", "");
+      const pathParam = replacer ? replacer(transformers_default.camelCase(item)) : transformers_default.camelCase(item);
+      params[pathParam] = pathParam;
+    }, this.path);
+    return params;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath() {
+    return this.path.replaceAll("{", ":").replaceAll("}", "");
   }
 };
+
+// src/config.ts
+init_cjs_shims();
+function defineConfig(options) {
+  return options;
+}
+function isInputPath(result) {
+  return !!result && "path" in result;
+}
+
+// src/FileManager.ts
+init_cjs_shims();
+var import_lodash = __toESM(require_lodash(), 1);
+
+// src/fs/write.ts
+init_cjs_shims();
+var import_fs_extra3 = __toESM(require_lib(), 1);
 async function saveCreateDirectory(path5) {
   const passedPath = path4.dirname(path4.resolve(path5));
-  await fs2__default.default.mkdir(passedPath, { recursive: true });
+  await import_fs_extra3.default.mkdir(passedPath, { recursive: true });
 }
 var writer = jsRuntime.switcher(
   {
     node: async (path5, data) => {
       try {
-        await fs2__default.default.stat(path4.resolve(path5));
-        const oldContent = await fs2__default.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
+        await import_fs_extra3.default.stat(path4.resolve(path5));
+        const oldContent = await import_fs_extra3.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
         if (oldContent?.toString() === data?.toString()) {
           return;
         }
       } catch (_err) {
       }
       await saveCreateDirectory(path5);
-      await fs2__default.default.writeFile(path4.resolve(path5), data, { encoding: "utf-8" });
-      const savedData = await fs2__default.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
+      await import_fs_extra3.default.writeFile(path4.resolve(path5), data, { encoding: "utf-8" });
+      const savedData = await import_fs_extra3.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
       if (savedData?.toString() !== data?.toString()) {
         throw new Error(`Sanity check failed for ${path5}
 
@@ -560,6 +3485,22 @@ async function write(data, path5) {
   }
   return writer(path5, data.trim());
 }
+
+// src/utils/timeout.ts
+init_cjs_shims();
+async function timeout(ms) {
+  return new Promise((resolve3) => {
+    setTimeout(() => {
+      resolve3(true);
+    }, ms);
+  });
+}
+
+// src/BarrelManager.ts
+init_cjs_shims();
+
+// src/utils/TreeNode.ts
+init_cjs_shims();
 var TreeNode = class _TreeNode {
   constructor(data, parent) {
     this.children = [];
@@ -650,78 +3591,67 @@ var TreeNode = class _TreeNode {
 var _options;
 var BarrelManager = class {
   constructor(options = {}) {
-    __privateAdd(this, _options, {});
+    __privateAdd(this, _options, void 0);
     __privateSet(this, _options, options);
     return this;
   }
-  getIndexes(root, extName) {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = __privateGet(this, _options);
-    const extMapper = {
-      ".ts": {
-        extensions: /\.ts/,
-        exclude: [/schemas/, /json/]
-      },
-      ".json": {
-        extensions: /\.json/,
-        exclude: []
-      }
-    };
-    const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
+  getIndexes(pathToBuild) {
+    const { treeNode = {}, isTypeOnly, extName } = __privateGet(this, _options);
+    const tree = TreeNode.build(pathToBuild, treeNode);
     if (!tree) {
       return null;
     }
-    const fileReducer = (files2, currentTree) => {
-      if (!currentTree.children) {
+    const fileReducer = (files, treeNode2) => {
+      if (!treeNode2.children) {
         return [];
       }
-      if (currentTree.children?.length > 1) {
-        const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
-        const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && file.data.type === "file") {
+      if (treeNode2.children.length > 1) {
+        const indexPath = path4__default.default.resolve(treeNode2.data.path, "index.ts");
+        const exports = treeNode2.children.filter(Boolean).map((file) => {
+          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${transformers_default.trimExtName(file.data.name)}`;
+          if (importPath.endsWith("index") && file.data.type === "file") {
             return void 0;
           }
           return {
-            path: includeExt ? `${importPath}${extName}` : importPath,
+            path: extName ? `${importPath}${extName}` : importPath,
             isTypeOnly
           };
         }).filter(Boolean);
-        files2.push({
+        files.push({
           path: indexPath,
           baseName: "index.ts",
           source: "",
-          exports: output ? exports?.filter((item) => {
-            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-          }) : exports
+          exports,
+          meta: {
+            treeNode: treeNode2
+          }
         });
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}/index` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-          const exports = [
-            {
-              path: includeExt ? `${importPath}${extName}` : importPath,
-              isTypeOnly
-            }
-          ];
-          files2.push({
-            path: indexPath,
-            baseName: "index.ts",
-            source: "",
-            exports: output ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-            }) : exports
-          });
+      } else if (treeNode2.children.length === 1) {
+        const [treeNodeChild] = treeNode2.children;
+        const indexPath = path4__default.default.resolve(treeNode2.data.path, "index.ts");
+        const importPath = treeNodeChild.data.type === "directory" ? `./${treeNodeChild.data.name}/index` : `./${transformers_default.trimExtName(treeNodeChild.data.name)}`;
+        const exports = [
+          {
+            path: extName ? `${importPath}${extName}` : importPath,
+            isTypeOnly
+          }
+        ];
+        files.push({
+          path: indexPath,
+          baseName: "index.ts",
+          source: "",
+          exports,
+          meta: {
+            treeNode: treeNode2
+          }
         });
       }
-      currentTree.children.forEach((childItem) => {
-        fileReducer(files2, childItem);
+      treeNode2.children.forEach((childItem) => {
+        fileReducer(files, childItem);
       });
-      return files2;
+      return files;
     };
-    const files = fileReducer([], tree).reverse();
-    const filteredFiles = filter ? files.filter(filter) : files;
-    return map ? filteredFiles.map(map) : filteredFiles;
+    return fileReducer([], tree).reverse();
   }
 };
 _options = new WeakMap();
@@ -730,7 +3660,7 @@ _options = new WeakMap();
 exports.KubbFile = void 0;
 ((KubbFile2) => {
 })(exports.KubbFile || (exports.KubbFile = {}));
-var _cache, _task, _isWriting, _timeout, _queue, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
+var _cache, _task, _isWriting, _timeout, _queue, _validate, _add, add_fn, _addOrAppend, addOrAppend_fn;
 var _FileManager = class _FileManager {
   constructor(options) {
     __privateAdd(this, _validate);
@@ -763,7 +3693,6 @@ var _FileManager = class _FileManager {
   }
   async add(...files) {
     const promises = files.map((file) => {
-      __privateMethod(this, _validate, validate_fn).call(this, file);
       if (file.override) {
         return __privateMethod(this, _add, add_fn).call(this, file);
       }
@@ -775,12 +3704,37 @@ var _FileManager = class _FileManager {
     }
     return resolvedFiles[0];
   }
-  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
-    const barrelManager = new BarrelManager(options);
-    const files = barrelManager.getIndexes(root, extName);
+  async addIndexes({ root, output, meta, options = {} }) {
+    const { exportType = "barrel" } = output;
+    if (!exportType) {
+      return void 0;
+    }
+    const exportPath = output.path.startsWith("./") ? output.path : `./${output.path}`;
+    const barrelManager = new BarrelManager({ extName: output.extName, ...options });
+    const files = barrelManager.getIndexes(path4.resolve(root, output.path));
     if (!files) {
       return void 0;
     }
+    const rootFile = {
+      path: path4.resolve(root, "index.ts"),
+      baseName: "index.ts",
+      source: "",
+      exports: [
+        output.exportAs ? {
+          name: output.exportAs,
+          asAlias: true,
+          path: exportPath,
+          isTypeOnly: options.isTypeOnly
+        } : {
+          path: exportPath,
+          isTypeOnly: options.isTypeOnly
+        }
+      ]
+    };
+    await __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
+      ...rootFile,
+      meta: meta ? meta : rootFile.meta
+    });
     return await Promise.all(
       files.map((file) => {
         return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
@@ -822,44 +3776,7 @@ var _FileManager = class _FileManager {
   }
   // statics
   static getSource(file) {
-    if (!_FileManager.isExtensionAllowed(file.baseName)) {
-      return file.source;
-    }
-    const exports = file.exports ? combineExports(file.exports) : [];
-    const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
-    const importNodes = imports.map((item) => factory__namespace.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-    const exportNodes = exports.map(
-      (item) => factory__namespace.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
-    );
-    return [parser.print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
-  }
-  static combineFiles(files) {
-    return files.filter(Boolean).reduce((acc, file) => {
-      const prevIndex = acc.findIndex((item) => item.path === file.path);
-      if (prevIndex === -1) {
-        return [...acc, file];
-      }
-      const prev = acc[prevIndex];
-      if (prev && file.override) {
-        acc[prevIndex] = {
-          imports: [],
-          exports: [],
-          ...file
-        };
-        return acc;
-      }
-      if (prev) {
-        acc[prevIndex] = {
-          ...file,
-          source: prev.source && file.source ? `${prev.source}
-${file.source}` : "",
-          imports: [...prev.imports || [], ...file.imports || []],
-          exports: [...prev.exports || [], ...file.exports || []],
-          env: { ...prev.env || {}, ...file.env || {} }
-        };
-      }
-      return acc;
-    }, []);
+    return getSource(file);
   }
   static getMode(path5) {
     if (!path5) {
@@ -880,18 +3797,10 @@ _isWriting = new WeakMap();
 _timeout = new WeakMap();
 _queue = new WeakMap();
 _validate = new WeakSet();
-validate_fn = function(file) {
-  if (!file.validate) {
-    return;
-  }
-  if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
-    throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
-  }
-};
 _add = new WeakSet();
 add_fn = async function(file) {
   const controller = new AbortController();
-  const resolvedFile = { id: crypto2__default.default.randomUUID(), ...file };
+  const resolvedFile = { id: crypto2__default.default.randomUUID(), name: transformers_default.trimExtName(file.baseName), ...file };
   __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
   if (__privateGet(this, _queue)) {
     await __privateGet(this, _queue).run(
@@ -922,16 +3831,41 @@ ${file.source}` : "",
   return __privateMethod(this, _add, add_fn).call(this, file);
 };
 var FileManager = _FileManager;
+function getSource(file) {
+  if (!FileManager.isExtensionAllowed(file.baseName)) {
+    return file.source;
+  }
+  const exports = file.exports ? combineExports(file.exports) : [];
+  const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
+  const importNodes = imports.filter((item) => {
+    return item.path !== transformers_default.trimExtName(file.path);
+  }).map((item) => {
+    return factory__namespace.createImportDeclaration({
+      name: item.name,
+      path: item.root ? getRelativePath(item.root, item.path) : item.path,
+      isTypeOnly: item.isTypeOnly
+    });
+  });
+  const exportNodes = exports.map(
+    (item) => factory__namespace.createExportDeclaration({
+      name: item.name,
+      path: item.path,
+      isTypeOnly: item.isTypeOnly,
+      asAlias: item.asAlias
+    })
+  );
+  return [parser.print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
+}
 function combineExports(exports) {
   const combinedExports = naturalOrderby.orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     const name = curr.name;
     const prevByPath = prev.findLast((imp) => imp.path === curr.path);
-    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
+    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && (0, import_lodash.default)(imp.name, name) && imp.isTypeOnly);
     if (prevByPathAndIsTypeOnly) {
       return prev;
     }
     const uniquePrev = prev.findLast(
-      (imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
+      (imp) => imp.path === curr.path && (0, import_lodash.default)(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
     );
     if (uniquePrev || Array.isArray(name) && !name.length || prevByPath?.asAlias && !curr.asAlias) {
       return prev;
@@ -964,11 +3898,11 @@ function combineImports(imports, exports, source) {
       return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
     };
     if (Array.isArray(name)) {
-      name = name.filter((item) => hasImportInSource(item));
+      name = name.filter((item) => typeof item === "string" ? hasImportInSource(item) : hasImportInSource(item.propertyName));
     }
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
-    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
-    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
+    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && (0, import_lodash.default)(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && (0, import_lodash.default)(imp.name, name) && imp.isTypeOnly);
     if (prevByPathNameAndIsTypeOnly) {
       return prev;
     }
@@ -1010,13 +3944,90 @@ function getEnvSource(source, env) {
       throw new TypeError(`Environment should be in upperCase for ${key}`);
     }
     if (typeof replaceBy === "string") {
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+      prev = transformers_default.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
+      prev = transformers_default.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
 `, "ig"), ""), replaceBy, key });
     }
     return prev;
   }, source);
 }
+
+// src/logger.ts
+init_cjs_shims();
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
+};
+function createLogger({ logLevel, name, spinner }) {
+  const logs = [];
+  const log = (message) => {
+    if (message && spinner) {
+      spinner.text = message;
+      logs.push(message);
+    }
+  };
+  const error = (message) => {
+    if (message) {
+      throw new Error(message || "Something went wrong");
+    }
+  };
+  const warn = (message) => {
+    if (message && spinner) {
+      spinner.warn(pc2__default.default.yellow(message));
+      logs.push(message);
+    }
+  };
+  const info = (message) => {
+    if (message && spinner && logLevel !== LogLevel.silent) {
+      spinner.info(message);
+      logs.push(message);
+    }
+  };
+  const logger = {
+    name,
+    logLevel,
+    log,
+    error,
+    warn,
+    info,
+    spinner,
+    logs
+  };
+  return logger;
+}
+var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
+function randomColour(text, colours = defaultColours) {
+  if (!text) {
+    return "white";
+  }
+  const random = seedrandom__default.default(text);
+  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
+  return colour;
+}
+function randomPicoColour(text, colors = defaultColours) {
+  const colours = pc2__default.default.createColors(true);
+  if (!text) {
+    return colours.white(text);
+  }
+  const colour = randomColour(text, colors);
+  const isDark = colour.includes("dark");
+  const key = colour.replace("dark", "").toLowerCase();
+  const formatter = colours[key];
+  if (isDark) {
+    return pc2__default.default.bold(formatter(text));
+  }
+  if (typeof formatter !== "function") {
+    throw new Error("Formatter for picoColor is not of type function/Formatter");
+  }
+  return formatter(text);
+}
+
+// src/PluginManager.ts
+init_cjs_shims();
+
+// src/utils/EventEmitter.ts
+init_cjs_shims();
 var _emitter;
 var EventEmitter = class {
   constructor() {
@@ -1037,6 +4048,9 @@ var EventEmitter = class {
   }
 };
 _emitter = new WeakMap();
+
+// src/utils/Queue.ts
+init_cjs_shims();
 var _queue2, _workerCount, _maxParallel, _debug, _work, work_fn;
 var Queue = class {
   constructor(maxParallel, debug = false) {
@@ -1050,8 +4064,8 @@ var Queue = class {
     __privateSet(this, _debug, debug);
   }
   run(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
-    return new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
+    return new Promise((resolve3, reject) => {
+      const item = { reject, resolve: resolve3, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
         __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
         reject("Aborted");
@@ -1061,8 +4075,8 @@ var Queue = class {
     });
   }
   runSync(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
-    new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
+    new Promise((resolve3, reject) => {
+      const item = { reject, resolve: resolve3, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
         __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
       });
@@ -1089,13 +4103,13 @@ work_fn = function() {
   __privateWrapper(this, _workerCount)._++;
   let entry;
   while (entry = __privateGet(this, _queue2).shift()) {
-    const { reject, resolve: resolve2, job, name, description } = entry;
+    const { reject, resolve: resolve3, job, name, description } = entry;
     if (__privateGet(this, _debug)) {
       perf_hooks.performance.mark(name + "_start");
     }
     job().then((result) => {
       this.eventEmitter.emit("jobDone", result);
-      resolve2(result);
+      resolve3(result);
       if (__privateGet(this, _debug)) {
         perf_hooks.performance.mark(name + "_stop");
         perf_hooks.performance.measure(description, name + "_start", name + "_stop");
@@ -1109,6 +4123,7 @@ work_fn = function() {
 };
 
 // src/utils/uniqueName.ts
+init_cjs_shims();
 function setUniqueName(originalName, data) {
   let used = data[originalName] || 0;
   if (used) {
@@ -1120,6 +4135,7 @@ function setUniqueName(originalName, data) {
 }
 
 // src/errors.ts
+init_cjs_shims();
 var Warning = class extends Error {
   constructor(message, options) {
     super(message, { cause: options?.cause });
@@ -1129,7 +4145,11 @@ var Warning = class extends Error {
 var ValidationPluginError = class extends Error {
 };
 
+// src/plugin.ts
+init_cjs_shims();
+
 // src/utils/cache.ts
+init_cjs_shims();
 function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
   return {
     set(id, value) {
@@ -1169,8 +4189,7 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
-    key: ["controller", "core"],
-    kind: "controller",
+    key: ["core"],
     api() {
       return {
         get config() {
@@ -1207,7 +4226,11 @@ var definePlugin = createPlugin((options) => {
   };
 });
 
+// src/PromiseManager.ts
+init_cjs_shims();
+
 // src/utils/executeStrategies.ts
+init_cjs_shims();
 function hookSeq(promises) {
   return promises.filter(Boolean).reduce(
     (promise, func) => {
@@ -1294,7 +4317,7 @@ var PluginManager = class {
     __privateAdd(this, _executeSync);
     __privateAdd(this, _catcher);
     __privateAdd(this, _parse);
-    this.eventEmitter = new EventEmitter();
+    this.events = new EventEmitter();
     this.executed = [];
     __privateAdd(this, _core, void 0);
     __privateAdd(this, _usedPluginNames, {});
@@ -1306,11 +4329,14 @@ var PluginManager = class {
           hookName: "resolvePath",
           parameters: [params.baseName, params.directory, params.options]
         });
-        if (paths && paths?.length > 1) {
-          throw new Error(
+        if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+          this.logger.warn(
             `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
 
-Paths: ${JSON.stringify(paths, void 0, 2)}`
+Paths: ${JSON.stringify(paths, void 0, 2)}
+
+Falling back on the first item.
+`
           );
         }
         return paths?.at(0);
@@ -1327,11 +4353,14 @@ Paths: ${JSON.stringify(paths, void 0, 2)}`
           hookName: "resolveName",
           parameters: [params.name, params.type]
         });
-        if (names && names?.length > 1) {
-          throw new Error(
+        if (names && names?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+          this.logger.warn(
             `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
 
-Names: ${JSON.stringify(names, void 0, 2)}`
+Names: ${JSON.stringify(names, void 0, 2)}
+
+Falling back on the first item.
+`
           );
         }
         return transformReservedWord(names?.at(0) || params.name);
@@ -1363,11 +4392,14 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     });
     return this;
   }
+  /**
+   * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
+   */
   on(eventName, handler) {
-    this.eventEmitter.on(eventName, handler);
+    this.events.on(eventName, handler);
   }
   /**
-   * Run only hook for a specific plugin name
+   * Run a specific hookName for plugin x.
    */
   hookForPlugin({
     pluginKey,
@@ -1385,6 +4417,9 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     }).filter(Boolean);
     return Promise.all(promises);
   }
+  /**
+   * Run a specific hookName for plugin x.
+   */
   hookForPluginSync({
     pluginKey,
     hookName,
@@ -1401,7 +4436,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     }).filter(Boolean);
   }
   /**
-   * Chains, first non-null result stops and returns
+   * First non-null result stops and will return it's value.
    */
   async hookFirst({
     hookName,
@@ -1429,7 +4464,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     return __privateGet(this, _promiseManager).run("first", promises);
   }
   /**
-   * Chains, first non-null result stops and returns
+   * First non-null result stops and will return it's value.
    */
   hookFirstSync({
     hookName,
@@ -1457,7 +4492,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     return parseResult;
   }
   /**
-   * Parallel, runs all plugins
+   * Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
    */
   async hookParallel({
     hookName,
@@ -1476,7 +4511,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
   /**
-   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   * Chain all plugins, `reduce` can be passed through to handle every returned value. The return value of the first plugin will be used as the first parameter for the plugin after that.
    */
   hookReduceArg0({
     hookName,
@@ -1514,20 +4549,19 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }
   getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
-    const [searchKind, searchPluginName, searchIdentifier] = pluginKey;
+    const [searchPluginName, searchIdentifier] = pluginKey;
     const pluginByPluginName = plugins.filter((plugin) => plugin[hookName]).filter((item) => {
-      const [kind, name, identifier] = item.key;
+      const [name, identifier] = item.key;
       const identifierCheck = identifier?.toString() === searchIdentifier?.toString();
-      const kindCheck = kind === searchKind;
       const nameCheck = name === searchPluginName;
       if (searchIdentifier) {
-        return identifierCheck && kindCheck && nameCheck;
+        return identifierCheck && nameCheck;
       }
-      return kindCheck && nameCheck;
+      return nameCheck;
     });
     if (!pluginByPluginName?.length) {
       const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
-      if (this.logger.logLevel === "info") {
+      if (this.logger.logLevel === LogLevel.debug) {
         if (corePlugin) {
           this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`);
         } else {
@@ -1555,7 +4589,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   static get hooks() {
-    return ["validate", "buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
+    return ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
   }
 };
 _core = new WeakMap();
@@ -1565,7 +4599,7 @@ _getSortedPlugins = new WeakSet();
 getSortedPlugins_fn = function(hookName) {
   const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
   if (hookName) {
-    if (this.logger.logLevel === "info") {
+    if (this.logger.logLevel === LogLevel.info) {
       const containsHookName = plugins.some((item) => item[hookName]);
       if (!containsHookName) {
         this.logger.warn(`No hook ${hookName} found`);
@@ -1573,12 +4607,28 @@ getSortedPlugins_fn = function(hookName) {
     }
     return plugins.filter((item) => item[hookName]);
   }
-  return plugins;
+  return plugins.map((plugin) => {
+    if (plugin.pre) {
+      const isValid = plugin.pre.every((pluginName2) => plugins.find((pluginToFind) => pluginToFind.name === pluginName2));
+      if (!isValid) {
+        throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, void 0, 2)})`);
+      }
+    }
+    return plugin;
+  }).sort((a, b) => {
+    if (b.pre?.includes(a.name)) {
+      return 1;
+    }
+    if (b.post?.includes(a.name)) {
+      return -1;
+    }
+    return 0;
+  });
 };
 _addExecutedToCallStack = new WeakSet();
 addExecutedToCallStack_fn = function(executer) {
   if (executer) {
-    this.eventEmitter.emit("executed", executer);
+    this.events.emit("executed", executer);
     this.executed.push(executer);
   }
 };
@@ -1594,7 +4644,7 @@ execute_fn = function({
   if (!hook) {
     return null;
   }
-  this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+  this.events.emit("execute", { strategy, hookName, parameters, plugin });
   const task = Promise.resolve().then(() => {
     if (typeof hook === "function") {
       const possiblePromiseResult = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
@@ -1632,7 +4682,7 @@ executeSync_fn = function({
   if (!hook) {
     return null;
   }
-  this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+  this.events.emit("execute", { strategy, hookName, parameters, plugin });
   try {
     if (typeof hook === "function") {
       const fn = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
@@ -1658,13 +4708,13 @@ catcher_fn = function(e, plugin, hookName) {
   const text = `${e.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})
 `;
   this.logger.error(text);
-  this.eventEmitter.emit("error", e);
+  this.events.emit("error", e);
 };
 _parse = new WeakSet();
 parse_fn = function(plugin, pluginManager, context) {
   const usedPluginNames = __privateGet(pluginManager, _usedPluginNames);
   setUniqueName(plugin.name, usedPluginNames);
-  const key = plugin.key || [plugin.kind, plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
+  const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
   if (plugin.name !== "core" && usedPluginNames[plugin.name] >= 2) {
     pluginManager.logger.warn("Using multiple of the same plugin is an experimental feature");
   }
@@ -1700,7 +4750,7 @@ async function setup(options) {
   } catch (e) {
     if (isInputPath(config)) {
       throw new Error(
-        "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3__default.default.dim(config.input.path),
+        "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc2__default.default.dim(config.input.path),
         {
           cause: e
         }
@@ -1752,8 +4802,8 @@ async function setup(options) {
       if (logger.logLevel === LogLevel.info) {
         logger.spinner.start(`\u{1F4BE} Writing`);
       }
-      if (logger.logLevel === "debug") {
-        logger.info(`PluginKey ${pc3__default.default.dim(JSON.stringify(plugin.key))} 
+      if (logger.logLevel === LogLevel.debug) {
+        logger.info(`PluginKey ${pc2__default.default.dim(JSON.stringify(plugin.key))} 
 with source
 
 ${code}`);
@@ -1766,7 +4816,7 @@ ${code}`);
     if (logger.logLevel === LogLevel.info && logger.spinner) {
       if (hookName === "writeFile") {
         const [_code, path5] = parameters;
-        logger.spinner.suffixText = pc3__default.default.dim(path5);
+        logger.spinner.suffixText = pc2__default.default.dim(path5);
       } else {
         logger.spinner.suffixText = messsage;
       }
@@ -1774,9 +4824,9 @@ ${code}`);
     if (logger.logLevel === LogLevel.debug) {
       logger.info(messsage);
       const logs = [
-        parameters && `${pc3__default.default.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        parameters && `${pc2__default.default.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
         JSON.stringify(parameters, void 0, 2),
-        output && `${pc3__default.default.bgWhite("Output")} ${randomPicoColour(plugin.name)} ${hookName}`,
+        output && `${pc2__default.default.bgWhite("Output")} ${randomPicoColour(plugin.name)} ${hookName}`,
         output
       ].filter(Boolean);
       console.log(logs.join("\n"));
@@ -1787,10 +4837,6 @@ ${code}`);
 async function build(options) {
   const pluginManager = await setup(options);
   const { fileManager, logger } = pluginManager;
-  await pluginManager.hookParallel({
-    hookName: "validate",
-    parameters: [pluginManager.plugins]
-  });
   await pluginManager.hookParallel({
     hookName: "buildStart",
     parameters: [options.config]
@@ -1806,10 +4852,6 @@ async function safeBuild(options) {
   const pluginManager = await setup(options);
   const { fileManager, logger } = pluginManager;
   try {
-    await pluginManager.hookParallel({
-      hookName: "validate",
-      parameters: [pluginManager.plugins]
-    });
     await pluginManager.hookParallel({
       hookName: "buildStart",
       parameters: [options.config]
@@ -1826,6 +4868,7 @@ async function safeBuild(options) {
 }
 
 // src/Generator.ts
+init_cjs_shims();
 var _options3, _context;
 var Generator = class {
   constructor(options, context) {
@@ -1852,7 +4895,23 @@ var Generator = class {
 _options3 = new WeakMap();
 _context = new WeakMap();
 
+// src/PackageManager.ts
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/find-up@6.3.0/node_modules/find-up/index.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/locate-path@7.2.0/node_modules/locate-path/index.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
+init_cjs_shims();
+
+// ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
+init_cjs_shims();
+
 // ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
+init_cjs_shims();
 var Node = class {
   constructor(value) {
     __publicField(this, "value");
@@ -1921,18 +4980,18 @@ function pLimit(concurrency) {
       queue.dequeue()();
     }
   };
-  const run = async (fn, resolve2, args) => {
+  const run = async (fn, resolve3, args) => {
     activeCount++;
     const result = (async () => fn(...args))();
-    resolve2(result);
+    resolve3(result);
     try {
       await result;
     } catch {
     }
     next();
   };
-  const enqueue = (fn, resolve2, args) => {
-    queue.enqueue(run.bind(void 0, fn, resolve2, args));
+  const enqueue = (fn, resolve3, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve3, args));
     (async () => {
       await Promise.resolve();
       if (activeCount < concurrency && queue.size > 0) {
@@ -1940,8 +4999,8 @@ function pLimit(concurrency) {
       }
     })();
   };
-  const generator = (fn, ...args) => new Promise((resolve2) => {
-    enqueue(fn, resolve2, args);
+  const generator = (fn, ...args) => new Promise((resolve3) => {
+    enqueue(fn, resolve3, args);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -2005,7 +5064,7 @@ function checkType(type) {
 var matchType = (type, stat) => stat[typeMappings[type]]();
 var toPath = (urlOrPath) => urlOrPath instanceof URL ? url.fileURLToPath(urlOrPath) : urlOrPath;
 async function locatePath(paths, {
-  cwd = process__default.default.cwd(),
+  cwd = process2__default.default.cwd(),
   type = "file",
   allowSymlinks = true,
   concurrency,
@@ -2024,7 +5083,7 @@ async function locatePath(paths, {
   }, { concurrency, preserveOrder });
 }
 function locatePathSync(paths, {
-  cwd = process__default.default.cwd(),
+  cwd = process2__default.default.cwd(),
   type = "file",
   allowSymlinks = true
 } = {}) {
@@ -2047,6 +5106,9 @@ function locatePathSync(paths, {
   }
 }
 
+// ../../node_modules/.pnpm/path-exists@5.0.0/node_modules/path-exists/index.js
+init_cjs_shims();
+
 // ../../node_modules/.pnpm/find-up@6.3.0/node_modules/find-up/index.js
 var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? url.fileURLToPath(urlOrPath) : urlOrPath;
 var findUpStop = Symbol("findUpStop");
@@ -2251,10 +5313,6 @@ match_fn = function(packageJSON, dependency) {
 __privateAdd(_PackageManager, _cache2, {});
 var PackageManager = _PackageManager;
 
-// src/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
-
 // src/index.ts
 var src_default = build;
 
@@ -2263,12 +5321,8 @@ exports.Generator = Generator;
 exports.PackageManager = PackageManager;
 exports.PluginManager = PluginManager;
 exports.PromiseManager = PromiseManager;
-exports.SchemaGenerator = SchemaGenerator;
-exports.ValidationPluginError = ValidationPluginError;
 exports.Warning = Warning;
 exports.build = build;
-exports.combineExports = combineExports;
-exports.combineImports = combineImports;
 exports.createPlugin = createPlugin;
 exports.default = src_default;
 exports.defineConfig = defineConfig;