@kubb/core 2.17.0 → 2.18.0

package/dist/chunk-T6TAUAYN.cjs

@@ -0,0 +1,2586 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunkOCUNVJPQcjs = require('./chunk-OCUNVJPQ.cjs');
+
+
+
+
+var _chunkXF35HUZ2cjs = require('./chunk-XF35HUZ2.cjs');
+
+
+var _chunk5T2QA53Bcjs = require('./chunk-5T2QA53B.cjs');
+
+
+
+
+
+
+var _chunkSU2W2A6Vcjs = require('./chunk-SU2W2A6V.cjs');
+
+
+
+
+
+var _chunk7HFYOZ7Fcjs = require('./chunk-7HFYOZ7F.cjs');
+
+
+var _chunk2H4XNW5Dcjs = require('./chunk-2H4XNW5D.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkOOZTXU7Fcjs = require('./chunk-OOZTXU7F.cjs');
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
+var require_eventemitter3 = _chunkOOZTXU7Fcjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    _chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__)
+        prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt])
+        emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn)
+        emitter._events[evt].push(listener);
+      else
+        emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0)
+        emitter._events = new Events();
+      else
+        delete emitter._events[evt];
+    }
+    function EventEmitter3() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter3.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0)
+        return names;
+      for (name in events = this._events) {
+        if (has.call(events, name))
+          names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter3.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers)
+        return [];
+      if (handlers.fn)
+        return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter3.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners)
+        return 0;
+      if (listeners.fn)
+        return 1;
+      return listeners.length;
+    };
+    EventEmitter3.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once)
+          this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once)
+            this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args)
+                for (j = 1, args = new Array(len - 1); j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter3.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter3.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter3.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length)
+          this._events[evt] = events.length === 1 ? events[0] : events;
+        else
+          clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter3.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt])
+          clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
+    EventEmitter3.prototype.addListener = EventEmitter3.prototype.on;
+    EventEmitter3.prefixed = prefix;
+    EventEmitter3.EventEmitter = EventEmitter3;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter3;
+    }
+  }
+});
+
+// src/index.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+// src/build.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+// src/FileManager.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var import_index = _chunkOOZTXU7Fcjs.__toESM.call(void 0, require_eventemitter3(), 1);
+
+// ../../node_modules/.pnpm/p-timeout@6.1.2/node_modules/p-timeout/index.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError(errorMessage) : new DOMException(errorMessage);
+var getAbortedReason = (signal) => {
+  const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
+  return reason instanceof Error ? reason : getDOMException(reason);
+};
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout }
+  } = options;
+  let timer;
+  const wrappedPromise = new Promise((resolve2, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (options.signal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        reject(getAbortedReason(signal));
+      }
+      signal.addEventListener("abort", () => {
+        reject(getAbortedReason(signal));
+      });
+    }
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      promise.then(resolve2, reject);
+      return;
+    }
+    const timeoutError = new TimeoutError();
+    timer = customTimers.setTimeout.call(void 0, () => {
+      if (fallback) {
+        try {
+          resolve2(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve2();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = _nullishCoalesce(message, () => ( `Promise timed out after ${milliseconds} milliseconds`));
+        reject(timeoutError);
+      }
+    }, milliseconds);
+    (async () => {
+      try {
+        resolve2(await promise);
+      } catch (error) {
+        reject(error);
+      }
+    })();
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(void 0, timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
+}
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/priority-queue.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/lower-bound.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/priority-queue.js
+var _queue;
+var PriorityQueue = class {
+  constructor() {
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _queue, []);
+  }
+  enqueue(run, options) {
+    options = {
+      priority: 0,
+      ...options
+    };
+    const element = {
+      priority: options.priority,
+      run
+    };
+    if (this.size && _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue)[this.size - 1].priority >= options.priority) {
+      _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue).push(element);
+      return;
+    }
+    const index = lowerBound(_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue), element, (a, b) => b.priority - a.priority);
+    _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue).splice(index, 0, element);
+  }
+  dequeue() {
+    const item = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue).shift();
+    return _optionalChain([item, 'optionalAccess', _2 => _2.run]);
+  }
+  filter(options) {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue).filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue).length;
+  }
+};
+_queue = new WeakMap();
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
+var _carryoverConcurrencyCount, _isIntervalIgnored, _intervalCount, _intervalCap, _interval, _intervalEnd, _intervalId, _timeoutId, _queue2, _queueClass, _pending, _concurrency, _isPaused, _throwOnTimeout, _doesIntervalAllowAnother, doesIntervalAllowAnother_get, _doesConcurrentAllowAnother, doesConcurrentAllowAnother_get, _next, next_fn, _onResumeInterval, onResumeInterval_fn, _isIntervalPaused, isIntervalPaused_get, _tryToStartAnother, tryToStartAnother_fn, _initializeIntervalIfNeeded, initializeIntervalIfNeeded_fn, _onInterval, onInterval_fn, _processQueue, processQueue_fn, _throwOnAbort, throwOnAbort_fn, _onEvent, onEvent_fn;
+var PQueue = class extends import_index.default {
+  // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
+  constructor(options) {
+    super();
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _doesIntervalAllowAnother);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _doesConcurrentAllowAnother);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _next);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _onResumeInterval);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _isIntervalPaused);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _tryToStartAnother);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _initializeIntervalIfNeeded);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _onInterval);
+    /**
+    Executes all queued functions until it reaches the limit.
+    */
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _processQueue);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _throwOnAbort);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _onEvent);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _carryoverConcurrencyCount, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _isIntervalIgnored, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _intervalCount, 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _intervalCap, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _interval, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _intervalEnd, 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _intervalId, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _timeoutId, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _queue2, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _queueClass, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _pending, 0);
+    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _concurrency, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _isPaused, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _throwOnTimeout, void 0);
+    /**
+        Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+    
+        Applies to each future operation.
+        */
+    _chunkOOZTXU7Fcjs.__publicField.call(void 0, this, "timeout");
+    options = {
+      carryoverConcurrencyCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _3 => _3.intervalCap, 'optionalAccess', _4 => _4.toString, 'call', _5 => _5()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _6 => _6.interval, 'optionalAccess', _7 => _7.toString, 'call', _8 => _8()]), () => ( ""))}\` (${typeof options.interval})`);
+    }
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _carryoverConcurrencyCount, options.carryoverConcurrencyCount);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _intervalCap, options.intervalCap);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _interval, options.interval);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _queue2, new options.queueClass());
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _queueClass, options.queueClass);
+    this.concurrency = options.concurrency;
+    this.timeout = options.timeout;
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _throwOnTimeout, options.throwOnTimeout === true);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _isPaused, options.autoStart === false);
+  }
+  get concurrency() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _concurrency);
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _concurrency, newConcurrency);
+    _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _processQueue, processQueue_fn).call(this);
+  }
+  async add(function_, options = {}) {
+    options = {
+      timeout: this.timeout,
+      throwOnTimeout: _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _throwOnTimeout),
+      ...options
+    };
+    return new Promise((resolve2, reject) => {
+      _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).enqueue(async () => {
+        _chunkOOZTXU7Fcjs.__privateWrapper.call(void 0, this, _pending)._++;
+        _chunkOOZTXU7Fcjs.__privateWrapper.call(void 0, this, _intervalCount)._++;
+        try {
+          _optionalChain([options, 'access', _9 => _9.signal, 'optionalAccess', _10 => _10.throwIfAborted, 'call', _11 => _11()]);
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _throwOnAbort, throwOnAbort_fn).call(this, options.signal)]);
+          }
+          const result = await operation;
+          resolve2(result);
+          this.emit("completed", result);
+        } catch (error) {
+          if (error instanceof TimeoutError && !options.throwOnTimeout) {
+            resolve2();
+            return;
+          }
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _next, next_fn).call(this);
+        }
+      }, options);
+      this.emit("add");
+      _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _tryToStartAnother, tryToStartAnother_fn).call(this);
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start() {
+    if (!_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _isPaused)) {
+      return this;
+    }
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _isPaused, false);
+    _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _processQueue, processQueue_fn).call(this);
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _isPaused, true);
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _queue2, new (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queueClass))());
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).size === 0) {
+      return;
+    }
+    await _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _onEvent, onEvent_fn).call(this, "empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(limit) {
+    if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).size < limit) {
+      return;
+    }
+    await _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _onEvent, onEvent_fn).call(this, "next", () => _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).size < limit);
+  }
+  /**
+      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+  
+      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+      */
+  async onIdle() {
+    if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _pending) === 0 && _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).size === 0) {
+      return;
+    }
+    await _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _onEvent, onEvent_fn).call(this, "idle");
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(options) {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _pending);
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _isPaused);
+  }
+};
+_carryoverConcurrencyCount = new WeakMap();
+_isIntervalIgnored = new WeakMap();
+_intervalCount = new WeakMap();
+_intervalCap = new WeakMap();
+_interval = new WeakMap();
+_intervalEnd = new WeakMap();
+_intervalId = new WeakMap();
+_timeoutId = new WeakMap();
+_queue2 = new WeakMap();
+_queueClass = new WeakMap();
+_pending = new WeakMap();
+_concurrency = new WeakMap();
+_isPaused = new WeakMap();
+_throwOnTimeout = new WeakMap();
+_doesIntervalAllowAnother = new WeakSet();
+doesIntervalAllowAnother_get = function() {
+  return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _isIntervalIgnored) || _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalCount) < _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalCap);
+};
+_doesConcurrentAllowAnother = new WeakSet();
+doesConcurrentAllowAnother_get = function() {
+  return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _pending) < _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _concurrency);
+};
+_next = new WeakSet();
+next_fn = function() {
+  _chunkOOZTXU7Fcjs.__privateWrapper.call(void 0, this, _pending)._--;
+  _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _tryToStartAnother, tryToStartAnother_fn).call(this);
+  this.emit("next");
+};
+_onResumeInterval = new WeakSet();
+onResumeInterval_fn = function() {
+  _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _onInterval, onInterval_fn).call(this);
+  _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _initializeIntervalIfNeeded, initializeIntervalIfNeeded_fn).call(this);
+  _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _timeoutId, void 0);
+};
+_isIntervalPaused = new WeakSet();
+isIntervalPaused_get = function() {
+  const now = Date.now();
+  if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalId) === void 0) {
+    const delay = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalEnd) - now;
+    if (delay < 0) {
+      _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _intervalCount, _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _carryoverConcurrencyCount) ? _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _pending) : 0);
+    } else {
+      if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _timeoutId) === void 0) {
+        _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _timeoutId, setTimeout(() => {
+          _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _onResumeInterval, onResumeInterval_fn).call(this);
+        }, delay));
+      }
+      return true;
+    }
+  }
+  return false;
+};
+_tryToStartAnother = new WeakSet();
+tryToStartAnother_fn = function() {
+  if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).size === 0) {
+    if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalId)) {
+      clearInterval(_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalId));
+    }
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _intervalId, void 0);
+    this.emit("empty");
+    if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _pending) === 0) {
+      this.emit("idle");
+    }
+    return false;
+  }
+  if (!_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _isPaused)) {
+    const canInitializeInterval = !_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _isIntervalPaused, isIntervalPaused_get);
+    if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _doesIntervalAllowAnother, doesIntervalAllowAnother_get) && _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _doesConcurrentAllowAnother, doesConcurrentAllowAnother_get)) {
+      const job = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue2).dequeue();
+      if (!job) {
+        return false;
+      }
+      this.emit("active");
+      job();
+      if (canInitializeInterval) {
+        _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _initializeIntervalIfNeeded, initializeIntervalIfNeeded_fn).call(this);
+      }
+      return true;
+    }
+  }
+  return false;
+};
+_initializeIntervalIfNeeded = new WeakSet();
+initializeIntervalIfNeeded_fn = function() {
+  if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _isIntervalIgnored) || _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalId) !== void 0) {
+    return;
+  }
+  _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _intervalId, setInterval(() => {
+    _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _onInterval, onInterval_fn).call(this);
+  }, _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _interval)));
+  _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _intervalEnd, Date.now() + _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _interval));
+};
+_onInterval = new WeakSet();
+onInterval_fn = function() {
+  if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalCount) === 0 && _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _pending) === 0 && _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalId)) {
+    clearInterval(_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _intervalId));
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _intervalId, void 0);
+  }
+  _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _intervalCount, _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _carryoverConcurrencyCount) ? _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _pending) : 0);
+  _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _processQueue, processQueue_fn).call(this);
+};
+_processQueue = new WeakSet();
+processQueue_fn = function() {
+  while (_chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _tryToStartAnother, tryToStartAnother_fn).call(this)) {
+  }
+};
+_throwOnAbort = new WeakSet();
+throwOnAbort_fn = async function(signal) {
+  return new Promise((_resolve, reject) => {
+    signal.addEventListener("abort", () => {
+      reject(signal.reason);
+    }, { once: true });
+  });
+};
+_onEvent = new WeakSet();
+onEvent_fn = async function(event, filter) {
+  return new Promise((resolve2) => {
+    const listener = () => {
+      if (filter && !filter()) {
+        return;
+      }
+      this.off(event, listener);
+      resolve2();
+    };
+    this.on(event, listener);
+  });
+};
+
+// src/FileManager.ts
+var _remeda = require('remeda');
+
+// src/BarrelManager.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var _tsparser = require('@kubb/ts-parser');
+
+
+// src/utils/TreeNode.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var _directorytree = require('directory-tree'); var _directorytree2 = _interopRequireDefault(_directorytree);
+var TreeNode = class _TreeNode {
+  constructor(data, parent) {
+    this.children = [];
+    this.data = data;
+    this.parent = parent;
+    return this;
+  }
+  addChild(data) {
+    const child = new _TreeNode(data, this);
+    if (!this.children) {
+      this.children = [];
+    }
+    this.children.push(child);
+    return child;
+  }
+  find(data) {
+    if (!data) {
+      return null;
+    }
+    if (data === this.data) {
+      return this;
+    }
+    if (_optionalChain([this, 'access', _12 => _12.children, 'optionalAccess', _13 => _13.length])) {
+      for (let i = 0, { length } = this.children, target = null; i < length; i++) {
+        target = this.children[i].find(data);
+        if (target) {
+          return target;
+        }
+      }
+    }
+    return null;
+  }
+  get leaves() {
+    if (!this.children || this.children.length === 0) {
+      return [this];
+    }
+    const leaves = [];
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        leaves.push.apply(leaves, this.children[i].leaves);
+      }
+    }
+    return leaves;
+  }
+  get root() {
+    if (!this.parent) {
+      return this;
+    }
+    return this.parent.root;
+  }
+  forEach(callback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("forEach() callback must be a function");
+    }
+    callback(this);
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        _optionalChain([this, 'access', _14 => _14.children, 'access', _15 => _15[i], 'optionalAccess', _16 => _16.forEach, 'call', _17 => _17(callback)]);
+      }
+    }
+    return this;
+  }
+  static build(path5, options = {}) {
+    try {
+      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
+      const filteredTree = _directorytree2.default.call(void 0, path5, {
+        extensions: options.extensions,
+        exclude: [/node_modules/, ...exclude]
+      });
+      if (!filteredTree) {
+        return null;
+      }
+      const treeNode = new _TreeNode({
+        name: filteredTree.name,
+        path: filteredTree.path,
+        type: FileManager.getMode(filteredTree.path)
+      });
+      const recurse = (node, item) => {
+        const subNode = node.addChild({
+          name: item.name,
+          path: item.path,
+          type: FileManager.getMode(item.path)
+        });
+        if (_optionalChain([item, 'access', _18 => _18.children, 'optionalAccess', _19 => _19.length])) {
+          _optionalChain([item, 'access', _20 => _20.children, 'optionalAccess', _21 => _21.forEach, 'call', _22 => _22((child) => {
+            recurse(subNode, child);
+          })]);
+        }
+      };
+      _optionalChain([filteredTree, 'access', _23 => _23.children, 'optionalAccess', _24 => _24.forEach, 'call', _25 => _25((child) => recurse(treeNode, child))]);
+      return treeNode;
+    } catch (e) {
+      throw new Error("Something went wrong with creating index files with the TreehNode class", { cause: e });
+    }
+  }
+};
+
+// src/BarrelManager.ts
+var _options;
+var BarrelManager = class {
+  constructor(options = {}) {
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _options, void 0);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _options, options);
+    return this;
+  }
+  getNamedExport(root, item) {
+    const exportedNames = _tsparser.getExports.call(void 0, _path2.default.resolve(root, item.path));
+    if (!exportedNames) {
+      return [item];
+    }
+    return exportedNames.reduce(
+      (prev, curr) => {
+        if (!_optionalChain([prev, 'access', _26 => _26[0], 'optionalAccess', _27 => _27.name]) || !_optionalChain([prev, 'access', _28 => _28[1], 'optionalAccess', _29 => _29.name])) {
+          return prev;
+        }
+        if (curr.isTypeOnly) {
+          prev[1] = { ...prev[1], name: [...prev[1].name, curr.name] };
+        } else {
+          prev[0] = { ...prev[0], name: [...prev[0].name, curr.name] };
+        }
+        return prev;
+      },
+      [
+        {
+          ...item,
+          name: [],
+          isTypeOnly: false
+        },
+        {
+          ...item,
+          name: [],
+          isTypeOnly: true
+        }
+      ]
+    );
+  }
+  getNamedExports(root, exports) {
+    return _optionalChain([exports, 'optionalAccess', _30 => _30.flatMap, 'call', _31 => _31((item) => {
+      return this.getNamedExport(root, item);
+    })]);
+  }
+  getIndexes(root) {
+    const { treeNode = {}, isTypeOnly, extName } = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _options);
+    const tree = TreeNode.build(root, treeNode);
+    if (!tree) {
+      return null;
+    }
+    const fileReducer = (files, treeNode2) => {
+      if (!treeNode2.children) {
+        return [];
+      }
+      if (treeNode2.children.length > 1) {
+        const indexPath = _path2.default.resolve(treeNode2.data.path, "index.ts");
+        const exports = treeNode2.children.filter(Boolean).map((file) => {
+          const importPath = file.data.type === "split" ? `./${file.data.name}/index` : `./${_chunkOCUNVJPQcjs.trimExtName.call(void 0, file.data.name)}`;
+          if (importPath.endsWith("index") && file.data.type === "single") {
+            return void 0;
+          }
+          return {
+            path: extName ? `${importPath}${extName}` : importPath,
+            isTypeOnly
+          };
+        }).filter(Boolean);
+        files.push({
+          path: indexPath,
+          baseName: "index.ts",
+          source: "",
+          exports,
+          exportable: true
+        });
+      } else if (treeNode2.children.length === 1) {
+        const [treeNodeChild] = treeNode2.children;
+        const indexPath = _path2.default.resolve(treeNode2.data.path, "index.ts");
+        const importPath = treeNodeChild.data.type === "split" ? `./${treeNodeChild.data.name}/index` : `./${_chunkOCUNVJPQcjs.trimExtName.call(void 0, treeNodeChild.data.name)}`;
+        const exports = [
+          {
+            path: extName ? `${importPath}${extName}` : importPath,
+            isTypeOnly
+          }
+        ];
+        files.push({
+          path: indexPath,
+          baseName: "index.ts",
+          source: "",
+          exports,
+          exportable: true
+        });
+      }
+      treeNode2.children.forEach((childItem) => {
+        fileReducer(files, childItem);
+      });
+      return files;
+    };
+    return fileReducer([], tree).reverse();
+  }
+};
+_options = new WeakMap();
+
+// src/FileManager.ts
+var KubbFile;
+((KubbFile2) => {
+})(KubbFile || (KubbFile = exports.KubbFile = {}));
+var _cache, _task, _queue3, _add, add_fn, _addOrAppend, addOrAppend_fn;
+var _FileManager = class _FileManager {
+  constructor({ task = async (file) => file, queue = new PQueue() } = {}) {
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _add);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _addOrAppend);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _cache, /* @__PURE__ */ new Map());
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _task, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _queue3, void 0);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _task, task);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _queue3, queue);
+    return this;
+  }
+  get files() {
+    const files = [];
+    _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cache).forEach((item) => {
+      files.push(...item.flat(1));
+    });
+    return files;
+  }
+  get isExecuting() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue3).size !== 0 && _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue3).pending !== 0;
+  }
+  async add(...files) {
+    const promises = combineFiles(files).map((file) => {
+      if (file.override) {
+        return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _add, add_fn).call(this, file);
+      }
+      return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _addOrAppend, addOrAppend_fn).call(this, file);
+    });
+    const resolvedFiles = await Promise.all(promises);
+    if (files.length > 1) {
+      return resolvedFiles;
+    }
+    return resolvedFiles[0];
+  }
+  async addIndexes({ root, output, meta, logger, options = {} }) {
+    const { exportType = "barrel" } = output;
+    if (exportType === false) {
+      return void 0;
+    }
+    const pathToBuildFrom = _path.resolve.call(void 0, root, output.path);
+    if (_chunkOCUNVJPQcjs.transformers_default.trimExtName(pathToBuildFrom).endsWith("index")) {
+      logger.emit("warning", "Output has the same fileName as the barrelFiles, please disable barrel generation");
+      return;
+    }
+    const exportPath = output.path.startsWith("./") ? _chunkOCUNVJPQcjs.trimExtName.call(void 0, output.path) : `./${_chunkOCUNVJPQcjs.trimExtName.call(void 0, output.path)}`;
+    const mode = _FileManager.getMode(output.path);
+    const barrelManager = new BarrelManager({
+      extName: output.extName,
+      ...options
+    });
+    let files = barrelManager.getIndexes(pathToBuildFrom);
+    if (!files) {
+      return void 0;
+    }
+    if (exportType === "barrelNamed") {
+      files = files.map((file) => {
+        if (file.exports) {
+          return {
+            ...file,
+            exports: barrelManager.getNamedExports(pathToBuildFrom, file.exports)
+          };
+        }
+        return file;
+      });
+    }
+    await Promise.all(
+      files.map((file) => {
+        return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _addOrAppend, addOrAppend_fn).call(this, {
+          ...file,
+          meta: meta ? meta : file.meta
+        });
+      })
+    );
+    const rootPath = mode === "split" ? `${exportPath}/index${output.extName || ""}` : `${exportPath}${output.extName || ""}`;
+    const rootFile = {
+      path: _path.resolve.call(void 0, root, "index.ts"),
+      baseName: "index.ts",
+      source: "",
+      exports: [
+        output.exportAs ? {
+          name: output.exportAs,
+          asAlias: true,
+          path: rootPath,
+          isTypeOnly: options.isTypeOnly
+        } : {
+          path: rootPath,
+          isTypeOnly: options.isTypeOnly
+        }
+      ],
+      exportable: true
+    };
+    if (exportType === "barrelNamed" && !output.exportAs && _optionalChain([rootFile, 'access', _32 => _32.exports, 'optionalAccess', _33 => _33[0]])) {
+      rootFile.exports = barrelManager.getNamedExport(root, rootFile.exports[0]);
+    }
+    await _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _addOrAppend, addOrAppend_fn).call(this, {
+      ...rootFile,
+      meta: meta ? meta : rootFile.meta
+    });
+  }
+  getCacheByUUID(UUID) {
+    let cache;
+    _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cache).forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
+    });
+    return cache;
+  }
+  get(path5) {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cache).get(path5);
+  }
+  remove(path5) {
+    const cacheItem = this.get(path5);
+    if (!cacheItem) {
+      return;
+    }
+    _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cache).delete(path5);
+  }
+  async write(...params) {
+    return _chunk2H4XNW5Dcjs.write.call(void 0, ...params);
+  }
+  async read(...params) {
+    return _chunk7HFYOZ7Fcjs.read.call(void 0, ...params);
+  }
+  // statics
+  static async getSource(file) {
+    return getSource(file);
+  }
+  static combineFiles(files) {
+    return combineFiles(files);
+  }
+  static getMode(path5) {
+    if (!path5) {
+      return "split";
+    }
+    return _path.extname.call(void 0, path5) ? "single" : "split";
+  }
+  static get extensions() {
+    return [".js", ".ts", ".tsx"];
+  }
+  static isJavascript(baseName) {
+    return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
+  }
+};
+_cache = new WeakMap();
+_task = new WeakMap();
+_queue3 = new WeakMap();
+_add = new WeakSet();
+add_fn = async function(file) {
+  const controller = new AbortController();
+  const resolvedFile = {
+    id: _crypto2.default.randomUUID(),
+    name: _chunkOCUNVJPQcjs.trimExtName.call(void 0, file.baseName),
+    ...file
+  };
+  if (_optionalChain([resolvedFile, 'access', _34 => _34.exports, 'optionalAccess', _35 => _35.length])) {
+    const folder = resolvedFile.path.replace(resolvedFile.baseName, "");
+    resolvedFile.exports = resolvedFile.exports.filter((exportItem) => {
+      const exportedFile = this.files.find((file2) => file2.path.includes(_path.resolve.call(void 0, folder, exportItem.path)));
+      if (exportedFile) {
+        return exportedFile.exportable;
+      }
+      return true;
+    });
+  }
+  _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
+  return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _queue3).add(
+    async () => {
+      var _a;
+      return (_a = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
+    },
+    { signal: controller.signal }
+  );
+};
+_addOrAppend = new WeakSet();
+addOrAppend_fn = async function(file) {
+  const previousCaches = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cache).get(file.path);
+  const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
+  if (previousCache) {
+    _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cache).delete(previousCache.path);
+    return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _add, add_fn).call(this, {
+      ...file,
+      source: previousCache.source && file.source ? `${previousCache.source}
+${file.source}` : "",
+      imports: [...previousCache.imports || [], ...file.imports || []],
+      exports: [...previousCache.exports || [], ...file.exports || []],
+      env: { ...previousCache.env || {}, ...file.env || {} }
+    });
+  }
+  return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _add, add_fn).call(this, file);
+};
+var FileManager = _FileManager;
+function 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;
+    },
+    []
+  );
+}
+async function getSource(file) {
+  if (file.language ? !["typescript", "javascript"].includes(file.language) : !FileManager.isJavascript(file.baseName)) {
+    return file.source;
+  }
+  const parser = await _chunkXF35HUZ2cjs.getParser.call(void 0, file.language);
+  const exports = file.exports ? combineExports(file.exports) : [];
+  const imports = file.imports && file.source ? combineImports(file.imports, exports, file.source) : [];
+  const importNodes = imports.filter((item) => {
+    const path5 = item.root ? _chunk7HFYOZ7Fcjs.getRelativePath.call(void 0, item.root, item.path) : item.path;
+    return path5 !== _chunkOCUNVJPQcjs.trimExtName.call(void 0, file.path);
+  }).map((item) => {
+    return parser.factory.createImportDeclaration({
+      name: item.name,
+      path: item.root ? _chunk7HFYOZ7Fcjs.getRelativePath.call(void 0, item.root, item.path) : item.path,
+      isTypeOnly: item.isTypeOnly
+    });
+  });
+  const exportNodes = exports.map(
+    (item) => parser.factory.createExportDeclaration({
+      name: item.name,
+      path: item.path,
+      isTypeOnly: item.isTypeOnly,
+      asAlias: item.asAlias
+    })
+  );
+  const source = [parser.print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
+  return parser.print([], { source, noEmitHelpers: false });
+}
+function combineExports(exports) {
+  const combinedExports = _chunk5T2QA53Bcjs.orderBy.call(void 0, 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 && _remeda.isDeepEqual.call(void 0, imp.name, name) && imp.isTypeOnly);
+      if (prevByPathAndIsTypeOnly) {
+        return prev;
+      }
+      const uniquePrev = prev.findLast(
+        (imp) => imp.path === curr.path && _remeda.isDeepEqual.call(void 0, imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
+      );
+      if (uniquePrev || Array.isArray(name) && !name.length || _optionalChain([prevByPath, 'optionalAccess', _36 => _36.asAlias]) && !curr.asAlias) {
+        return prev;
+      }
+      if (!prevByPath) {
+        return [
+          ...prev,
+          {
+            ...curr,
+            name: Array.isArray(name) ? [...new Set(name)] : name
+          }
+        ];
+      }
+      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+        prevByPath.name = [.../* @__PURE__ */ new Set([...prevByPath.name, ...curr.name])];
+        return prev;
+      }
+      return [...prev, curr];
+    },
+    []
+  );
+  return _chunk5T2QA53Bcjs.orderBy.call(void 0, combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
+}
+function combineImports(imports, exports, source) {
+  const combinedImports = _chunk5T2QA53Bcjs.orderBy.call(void 0, imports, [(v) => !v.isTypeOnly], ["asc"]).reduce(
+    (prev, curr) => {
+      let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
+      const hasImportInSource = (importName) => {
+        if (!source) {
+          return true;
+        }
+        const checker = (name2) => name2 && !!source.includes(name2);
+        return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
+      };
+      if (curr.path === curr.root) {
+        return prev;
+      }
+      if (Array.isArray(name)) {
+        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 && _remeda.isDeepEqual.call(void 0, imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+      const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && _remeda.isDeepEqual.call(void 0, imp.name, name) && imp.isTypeOnly);
+      if (prevByPathNameAndIsTypeOnly) {
+        return prev;
+      }
+      if (uniquePrev || Array.isArray(name) && !name.length) {
+        return prev;
+      }
+      if (!prevByPath) {
+        return [
+          ...prev,
+          {
+            ...curr,
+            name
+          }
+        ];
+      }
+      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
+        prevByPath.name = [.../* @__PURE__ */ new Set([...prevByPath.name, ...name])];
+        return prev;
+      }
+      if (!Array.isArray(name) && name && !hasImportInSource(name)) {
+        return prev;
+      }
+      return [...prev, curr];
+    },
+    []
+  );
+  return _chunk5T2QA53Bcjs.orderBy.call(void 0, combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
+}
+function getEnvSource(source, env) {
+  if (!env) {
+    return source;
+  }
+  const keys = Object.keys(env);
+  if (!keys.length) {
+    return source;
+  }
+  return keys.reduce((prev, key) => {
+    const environmentValue = env[key];
+    const replaceBy = environmentValue ? `'${_optionalChain([environmentValue, 'access', _37 => _37.replaceAll, 'call', _38 => _38('"', ""), 'optionalAccess', _39 => _39.replaceAll, 'call', _40 => _40("'", "")])}'` : "undefined";
+    if (key.toUpperCase() !== key) {
+      throw new TypeError(`Environment should be in upperCase for ${key}`);
+    }
+    if (typeof replaceBy === "string") {
+      prev = _chunkOCUNVJPQcjs.searchAndReplace.call(void 0, {
+        text: prev.replaceAll(`process.env.${key}`, replaceBy),
+        replaceBy,
+        prefix: "process.env",
+        key
+      });
+      prev = _chunkOCUNVJPQcjs.searchAndReplace.call(void 0, {
+        text: prev.replaceAll(/(declare const).*\n/gi, ""),
+        replaceBy,
+        key
+      });
+    }
+    return prev;
+  }, source);
+}
+
+// src/PluginManager.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+// src/PromiseManager.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+// src/utils/executeStrategies.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+function hookSeq(promises) {
+  return promises.filter(Boolean).reduce(
+    (promise, func) => {
+      if (typeof func !== "function") {
+        throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
+      }
+      return promise.then((state) => {
+        const calledFunc = func(state);
+        if (calledFunc) {
+          return calledFunc.then(Array.prototype.concat.bind(state));
+        }
+      });
+    },
+    Promise.resolve([])
+  );
+}
+function hookFirst(promises, nullCheck = (state) => state !== null) {
+  let promise = Promise.resolve(null);
+  for (const func of promises.filter(Boolean)) {
+    promise = promise.then((state) => {
+      if (nullCheck(state)) {
+        return state;
+      }
+      const calledFunc = func(state);
+      return calledFunc;
+    });
+  }
+  return promise;
+}
+function hookParallel(promises) {
+  return Promise.allSettled(promises.filter(Boolean).map((promise) => promise()));
+}
+
+// src/PromiseManager.ts
+var _options2;
+var PromiseManager = class {
+  constructor(options = {}) {
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _options2, {});
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _options2, options);
+    return this;
+  }
+  run(strategy, promises) {
+    if (strategy === "seq") {
+      return hookSeq(promises);
+    }
+    if (strategy === "first") {
+      return hookFirst(promises, _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _options2).nullCheck);
+    }
+    if (strategy === "parallel") {
+      return hookParallel(promises);
+    }
+    throw new Error(`${strategy} not implemented`);
+  }
+};
+_options2 = new WeakMap();
+function isPromise(result) {
+  return !!result && typeof _optionalChain([result, 'optionalAccess', _41 => _41.then]) === "function";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
+
+// src/errors.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var Warning = class extends Error {
+  constructor(message, options) {
+    super(message, { cause: _optionalChain([options, 'optionalAccess', _42 => _42.cause]) });
+    this.name = "Warning";
+  }
+};
+var ValidationPluginError = class extends Error {
+};
+
+// src/plugin.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+
+// src/utils/cache.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
+  return {
+    set(id, value) {
+      Store[id] = [0, value];
+    },
+    get(id) {
+      const item = Store[id];
+      if (!item) {
+        return null;
+      }
+      item[0] = 0;
+      return item[1];
+    },
+    has(id) {
+      const item = Store[id];
+      if (!item) {
+        return false;
+      }
+      item[0] = 0;
+      return true;
+    },
+    delete(id) {
+      return delete Store[id];
+    }
+  };
+}
+
+// src/plugin.ts
+function createPlugin(factory) {
+  return (options) => {
+    return factory(options);
+  };
+}
+var pluginName = "core";
+var definePlugin = createPlugin((options) => {
+  const { fileManager, pluginManager, resolvePath, resolveName, logger } = options;
+  return {
+    name: pluginName,
+    options,
+    key: ["core"],
+    api() {
+      return {
+        get config() {
+          return options.config;
+        },
+        get plugins() {
+          return options.getPlugins();
+        },
+        get plugin() {
+          return options.plugin;
+        },
+        logger,
+        fileManager,
+        pluginManager,
+        async addFile(...files) {
+          const resolvedFiles = await fileManager.add(...files);
+          if (!Array.isArray(resolvedFiles)) {
+            return [resolvedFiles];
+          }
+          return resolvedFiles;
+        },
+        resolvePath,
+        resolveName,
+        cache: createPluginCache()
+      };
+    },
+    resolvePath(baseName) {
+      const root = _path2.default.resolve(this.config.root, this.config.output.path);
+      return _path2.default.resolve(root, baseName);
+    },
+    resolveName(name) {
+      return name;
+    }
+  };
+});
+
+// src/PluginManager.ts
+var _core, _usedPluginNames, _promiseManager, _getSortedPlugins, getSortedPlugins_fn, _addExecutedToCallStack, addExecutedToCallStack_fn, _execute, execute_fn, _executeSync, executeSync_fn, _catcher, catcher_fn, _parse, parse_fn;
+var PluginManager = class {
+  constructor(config, options) {
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _getSortedPlugins);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _addExecutedToCallStack);
+    /**
+     * Run an async plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The actual pluginObject to run.
+     */
+    // Implementation signature
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _execute);
+    /**
+     * Run a sync plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The acutal plugin
+     * @param replaceContext When passed, the plugin context can be overridden.
+     */
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _executeSync);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _catcher);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _parse);
+    this.events = new (0, _chunkSU2W2A6Vcjs.EventEmitter)();
+    this.executed = [];
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _core, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _usedPluginNames, {});
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _promiseManager, void 0);
+    this.resolvePath = (params) => {
+      if (params.pluginKey) {
+        const paths = this.hookForPluginSync({
+          pluginKey: params.pluginKey,
+          hookName: "resolvePath",
+          parameters: [params.baseName, params.mode, params.options]
+        });
+        if (paths && _optionalChain([paths, 'optionalAccess', _43 => _43.length]) > 1) {
+          this.logger.emit("debug", [
+            `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
+
+Paths: ${JSON.stringify(paths, void 0, 2)}
+
+Falling back on the first item.
+`
+          ]);
+        }
+        return _optionalChain([paths, 'optionalAccess', _44 => _44.at, 'call', _45 => _45(0)]);
+      }
+      return this.hookFirstSync({
+        hookName: "resolvePath",
+        parameters: [params.baseName, params.mode, params.options]
+      }).result;
+    };
+    this.resolveName = (params) => {
+      if (params.pluginKey) {
+        const names = this.hookForPluginSync({
+          pluginKey: params.pluginKey,
+          hookName: "resolveName",
+          parameters: [params.name, params.type]
+        });
+        if (names && _optionalChain([names, 'optionalAccess', _46 => _46.length]) > 1) {
+          this.logger.emit("debug", [
+            `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
+
+Names: ${JSON.stringify(names, void 0, 2)}
+
+Falling back on the first item.
+`
+          ]);
+        }
+        return _chunkOCUNVJPQcjs.transformReservedWord.call(void 0, _optionalChain([names, 'optionalAccess', _47 => _47.at, 'call', _48 => _48(0)]) || params.name);
+      }
+      const name = this.hookFirstSync({
+        hookName: "resolveName",
+        parameters: [params.name, params.type]
+      }).result;
+      return _chunkOCUNVJPQcjs.transformReservedWord.call(void 0, name);
+    };
+    this.config = config;
+    this.logger = options.logger;
+    this.queue = new PQueue({ concurrency: 1 });
+    this.fileManager = new FileManager({
+      task: options.task,
+      queue: this.queue
+    });
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _promiseManager, new PromiseManager({
+      nullCheck: (state) => !!_optionalChain([state, 'optionalAccess', _49 => _49.result])
+    }));
+    const plugins = config.plugins || [];
+    const core = definePlugin({
+      config,
+      logger: this.logger,
+      pluginManager: this,
+      fileManager: this.fileManager,
+      resolvePath: this.resolvePath.bind(this),
+      resolveName: this.resolveName.bind(this),
+      getPlugins: _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _getSortedPlugins, getSortedPlugins_fn).bind(this)
+    });
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _core, _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _parse, parse_fn).call(this, core, this, core.api.call(null)));
+    this.plugins = [_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _core), ...plugins].map((plugin) => {
+      return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _parse, parse_fn).call(this, plugin, this, _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _core).api);
+    });
+    return this;
+  }
+  getFile({ name, mode, extName, pluginKey, options }) {
+    let source = "";
+    const baseName = `${name}${extName}`;
+    const path5 = this.resolvePath({ baseName, mode, pluginKey, options });
+    if (!path5) {
+      throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`);
+    }
+    try {
+      source = _chunk7HFYOZ7Fcjs.readSync.call(void 0, path5);
+    } catch (_e) {
+    }
+    return {
+      path: path5,
+      baseName,
+      meta: {
+        pluginKey
+      },
+      source
+    };
+  }
+  /**
+   * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
+   */
+  on(eventName, handler) {
+    this.events.on(eventName, handler);
+  }
+  /**
+   * Run a specific hookName for plugin x.
+   */
+  hookForPlugin({
+    pluginKey,
+    hookName,
+    parameters
+  }) {
+    const plugins = this.getPluginsByKey(hookName, pluginKey);
+    const promises = plugins.map((plugin) => {
+      return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _execute, execute_fn).call(this, {
+        strategy: "hookFirst",
+        hookName,
+        parameters,
+        plugin
+      });
+    }).filter(Boolean);
+    return Promise.all(promises);
+  }
+  /**
+   * Run a specific hookName for plugin x.
+   */
+  hookForPluginSync({
+    pluginKey,
+    hookName,
+    parameters
+  }) {
+    const plugins = this.getPluginsByKey(hookName, pluginKey);
+    return plugins.map((plugin) => {
+      return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _executeSync, executeSync_fn).call(this, {
+        strategy: "hookFirst",
+        hookName,
+        parameters,
+        plugin
+      });
+    }).filter(Boolean);
+  }
+  /**
+   * First non-null result stops and will return it's value.
+   */
+  async hookFirst({
+    hookName,
+    parameters,
+    skipped
+  }) {
+    const promises = _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _getSortedPlugins, getSortedPlugins_fn).call(this).filter((plugin) => {
+      return skipped ? skipped.has(plugin) : true;
+    }).map((plugin) => {
+      return async () => {
+        const value = await _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _execute, execute_fn).call(this, {
+          strategy: "hookFirst",
+          hookName,
+          parameters,
+          plugin
+        });
+        return Promise.resolve({
+          plugin,
+          result: value
+        });
+      };
+    });
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _promiseManager).run("first", promises);
+  }
+  /**
+   * First non-null result stops and will return it's value.
+   */
+  hookFirstSync({
+    hookName,
+    parameters,
+    skipped
+  }) {
+    let parseResult = null;
+    for (const plugin of _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
+      if (_optionalChain([skipped, 'optionalAccess', _50 => _50.has, 'call', _51 => _51(plugin)])) {
+        continue;
+      }
+      parseResult = {
+        result: _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _executeSync, executeSync_fn).call(this, {
+          strategy: "hookFirst",
+          hookName,
+          parameters,
+          plugin
+        }),
+        plugin
+      };
+      if (_optionalChain([parseResult, 'optionalAccess', _52 => _52.result]) != null) {
+        break;
+      }
+    }
+    return parseResult;
+  }
+  /**
+   * Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
+   */
+  async hookParallel({
+    hookName,
+    parameters
+  }) {
+    const promises = _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _execute, execute_fn).call(this, {
+        strategy: "hookParallel",
+        hookName,
+        parameters,
+        plugin
+      });
+    });
+    const results = await _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _promiseManager).run("parallel", promises);
+    results.forEach((result, index) => {
+      if (isPromiseRejectedResult(result)) {
+        const plugin = _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _getSortedPlugins, getSortedPlugins_fn).call(this)[index];
+        _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _catcher, catcher_fn).call(this, result.reason, plugin, hookName);
+      }
+    });
+    return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
+  }
+  /**
+   * 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,
+    parameters,
+    reduce
+  }) {
+    const [argument0, ...rest] = parameters;
+    let promise = Promise.resolve(argument0);
+    for (const plugin of _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
+      promise = promise.then((arg0) => {
+        const value = _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _execute, execute_fn).call(this, {
+          strategy: "hookReduceArg0",
+          hookName,
+          parameters: [arg0, ...rest],
+          plugin
+        });
+        return value;
+      }).then((result) => reduce.call(_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _core).api, argument0, result, plugin));
+    }
+    return promise;
+  }
+  /**
+   * Chains plugins
+   */
+  async hookSeq({ hookName, parameters }) {
+    const promises = _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _execute, execute_fn).call(this, {
+        strategy: "hookSeq",
+        hookName,
+        parameters,
+        plugin
+      });
+    });
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _promiseManager).run("seq", promises);
+  }
+  getPluginsByKey(hookName, pluginKey) {
+    const plugins = [...this.plugins];
+    const [searchPluginName, searchIdentifier] = pluginKey;
+    const pluginByPluginName = plugins.filter((plugin) => plugin[hookName]).filter((item) => {
+      const [name, identifier] = item.key;
+      const identifierCheck = _optionalChain([identifier, 'optionalAccess', _53 => _53.toString, 'call', _54 => _54()]) === _optionalChain([searchIdentifier, 'optionalAccess', _55 => _55.toString, 'call', _56 => _56()]);
+      const nameCheck = name === searchPluginName;
+      if (searchIdentifier) {
+        return identifierCheck && nameCheck;
+      }
+      return nameCheck;
+    });
+    if (!_optionalChain([pluginByPluginName, 'optionalAccess', _57 => _57.length])) {
+      const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
+      if (corePlugin) {
+        this.logger.emit("debug", [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`]);
+      } else {
+        this.logger.emit("debug", [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`]);
+      }
+      return corePlugin ? [corePlugin] : [];
+    }
+    return pluginByPluginName;
+  }
+  static getDependedPlugins(plugins, dependedPluginNames) {
+    let pluginNames = [];
+    if (typeof dependedPluginNames === "string") {
+      pluginNames = [dependedPluginNames];
+    } else {
+      pluginNames = dependedPluginNames;
+    }
+    return pluginNames.map((pluginName2) => {
+      const plugin = plugins.find((plugin2) => plugin2.name === pluginName2);
+      if (!plugin) {
+        throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
+      }
+      return plugin;
+    });
+  }
+  static get hooks() {
+    return ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
+  }
+};
+_core = new WeakMap();
+_usedPluginNames = new WeakMap();
+_promiseManager = new WeakMap();
+_getSortedPlugins = new WeakSet();
+getSortedPlugins_fn = function(hookName) {
+  const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
+  if (hookName) {
+    if (this.logger.logLevel === _chunkSU2W2A6Vcjs.LogLevel.info) {
+      const containsHookName = plugins.some((item) => item[hookName]);
+      if (!containsHookName) {
+        this.logger.emit("warning", `No hook ${hookName} found`);
+      }
+    }
+    return plugins.filter((item) => item[hookName]);
+  }
+  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 (_optionalChain([b, 'access', _58 => _58.pre, 'optionalAccess', _59 => _59.includes, 'call', _60 => _60(a.name)])) {
+      return 1;
+    }
+    if (_optionalChain([b, 'access', _61 => _61.post, 'optionalAccess', _62 => _62.includes, 'call', _63 => _63(a.name)])) {
+      return -1;
+    }
+    return 0;
+  });
+};
+_addExecutedToCallStack = new WeakSet();
+addExecutedToCallStack_fn = function(executer) {
+  if (executer) {
+    this.events.emit("executed", executer);
+    this.executed.push(executer);
+  }
+};
+_execute = new WeakSet();
+execute_fn = function({
+  strategy,
+  hookName,
+  parameters,
+  plugin
+}) {
+  const hook = plugin[hookName];
+  let output;
+  if (!hook) {
+    return null;
+  }
+  this.events.emit("execute", { strategy, hookName, parameters, plugin });
+  const task = Promise.resolve().then(() => {
+    if (typeof hook === "function") {
+      const possiblePromiseResult = hook.apply({ ..._chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _core).api, plugin }, parameters);
+      if (isPromise(possiblePromiseResult)) {
+        return Promise.resolve(possiblePromiseResult);
+      }
+      return possiblePromiseResult;
+    }
+    return hook;
+  }).then((result) => {
+    output = result;
+    _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
+      parameters,
+      output,
+      strategy,
+      hookName,
+      plugin
+    });
+    return result;
+  }).catch((e) => {
+    _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
+  });
+  return task;
+};
+_executeSync = new WeakSet();
+executeSync_fn = function({
+  strategy,
+  hookName,
+  parameters,
+  plugin
+}) {
+  const hook = plugin[hookName];
+  let output;
+  if (!hook) {
+    return null;
+  }
+  this.events.emit("execute", { strategy, hookName, parameters, plugin });
+  try {
+    if (typeof hook === "function") {
+      const fn = hook.apply({ ..._chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _core).api, plugin }, parameters);
+      output = fn;
+      return fn;
+    }
+    output = hook;
+    _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
+      parameters,
+      output,
+      strategy,
+      hookName,
+      plugin
+    });
+    return hook;
+  } catch (e) {
+    _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
+  }
+};
+_catcher = new WeakSet();
+catcher_fn = function(cause, plugin, hookName) {
+  const text = `${cause.message} (plugin: ${_optionalChain([plugin, 'optionalAccess', _64 => _64.name]) || "unknown"}, hook: ${hookName || "unknown"})`;
+  this.logger.emit("error", text, cause);
+  this.events.emit("error", cause);
+};
+_parse = new WeakSet();
+parse_fn = function(plugin, pluginManager, context) {
+  const usedPluginNames = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, pluginManager, _usedPluginNames);
+  _chunkXF35HUZ2cjs.setUniqueName.call(void 0, plugin.name, usedPluginNames);
+  const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
+  if (!plugin.transform) {
+    plugin.transform = function transform(code) {
+      return code;
+    };
+  }
+  if (plugin.api && typeof plugin.api === "function") {
+    const api = plugin.api.call(context);
+    return {
+      ...plugin,
+      key,
+      api
+    };
+  }
+  return {
+    ...plugin,
+    key
+  };
+};
+
+// src/config.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+function defineConfig(options) {
+  return options;
+}
+function isInputPath(result) {
+  return !!result && "path" in result;
+}
+
+// src/build.ts
+async function transformReducer(_previousCode, result, _plugin) {
+  return result;
+}
+async function setup(options) {
+  const { config, logger = _chunkSU2W2A6Vcjs.createLogger.call(void 0, { logLevel: _chunkSU2W2A6Vcjs.LogLevel.silent }) } = options;
+  let count = 0;
+  try {
+    if (isInputPath(config) && !new (0, _chunkXF35HUZ2cjs.URLPath)(config.input.path).isURL) {
+      await _chunk7HFYOZ7Fcjs.read.call(void 0, config.input.path);
+    }
+  } 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 ${_chunkSU2W2A6Vcjs.p.dim(config.input.path)}`,
+        {
+          cause: e
+        }
+      );
+    }
+  }
+  if (config.output.clean) {
+    await _chunk7HFYOZ7Fcjs.clean.call(void 0, config.output.path);
+  }
+  const task = async (file) => {
+    const { path: path5 } = file;
+    let source = await FileManager.getSource(file);
+    const { result: loadedResult } = await pluginManager.hookFirst({
+      hookName: "load",
+      parameters: [path5]
+    });
+    if (loadedResult && isPromise(loadedResult)) {
+      source = await loadedResult;
+    }
+    if (loadedResult && !isPromise(loadedResult)) {
+      source = loadedResult;
+    }
+    if (source) {
+      source = await pluginManager.hookReduceArg0({
+        hookName: "transform",
+        parameters: [source, path5],
+        reduce: transformReducer
+      });
+      if (config.output.write || config.output.write === void 0) {
+        if (_optionalChain([file, 'access', _65 => _65.meta, 'optionalAccess', _66 => _66.pluginKey])) {
+          await pluginManager.hookForPlugin({
+            pluginKey: _optionalChain([file, 'access', _67 => _67.meta, 'optionalAccess', _68 => _68.pluginKey]),
+            hookName: "writeFile",
+            parameters: [source, path5]
+          });
+        }
+        await pluginManager.hookFirst({
+          hookName: "writeFile",
+          parameters: [source, path5]
+        });
+      }
+    }
+    return {
+      ...file,
+      source: source || ""
+    };
+  };
+  const pluginManager = new PluginManager(config, { logger, task });
+  pluginManager.on("execute", (executer) => {
+    const { hookName, parameters, plugin } = executer;
+    if (hookName === "writeFile") {
+      const [code] = parameters;
+      logger.emit("debug", [`PluginKey ${_chunkSU2W2A6Vcjs.p.dim(JSON.stringify(plugin.key))} 
+with source
+
+${code}`]);
+    }
+  });
+  pluginManager.queue.on("add", () => {
+    if (logger.logLevel !== _chunkSU2W2A6Vcjs.LogLevel.info) {
+      return;
+    }
+    if (count === 0) {
+      logger.emit("start", "\u{1F4BE} Writing");
+    }
+  });
+  pluginManager.queue.on("active", () => {
+    if (logger.logLevel !== _chunkSU2W2A6Vcjs.LogLevel.info) {
+      return;
+    }
+    if (logger.spinner && pluginManager.queue.size > 0) {
+      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`;
+      logger.spinner.suffixText = _chunkSU2W2A6Vcjs.p.dim(text);
+    }
+    ++count;
+  });
+  pluginManager.queue.on("completed", () => {
+    if (logger.logLevel !== _chunkSU2W2A6Vcjs.LogLevel.info) {
+      return;
+    }
+    if (logger.spinner) {
+      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`;
+      logger.spinner.suffixText = _chunkSU2W2A6Vcjs.p.dim(text);
+    }
+  });
+  pluginManager.on("executed", (executer) => {
+    const { hookName, plugin, output, parameters } = executer;
+    const logs = [
+      `${_chunkSU2W2A6Vcjs.randomCliColour.call(void 0, plugin.name)} Executing ${hookName}`,
+      parameters && `${_chunkSU2W2A6Vcjs.p.bgWhite("Parameters")} ${_chunkSU2W2A6Vcjs.randomCliColour.call(void 0, plugin.name)} ${hookName}`,
+      JSON.stringify(parameters, void 0, 2),
+      output && `${_chunkSU2W2A6Vcjs.p.bgWhite("Output")} ${_chunkSU2W2A6Vcjs.randomCliColour.call(void 0, plugin.name)} ${hookName}`,
+      output
+    ].filter(Boolean);
+    logger.emit("debug", logs);
+  });
+  return pluginManager;
+}
+async function build(options) {
+  const pluginManager = await setup(options);
+  const { fileManager, logger } = pluginManager;
+  await pluginManager.hookParallel({
+    hookName: "buildStart",
+    parameters: [options.config]
+  });
+  await pluginManager.hookParallel({ hookName: "buildEnd" });
+  if (logger.logLevel === _chunkSU2W2A6Vcjs.LogLevel.info) {
+    logger.emit("end", "\u{1F4BE} Writing completed");
+  }
+  const files = await Promise.all(
+    fileManager.files.map(async (file) => ({
+      ...file,
+      source: await FileManager.getSource(file)
+    }))
+  );
+  return {
+    files,
+    pluginManager
+  };
+}
+async function safeBuild(options) {
+  const pluginManager = await setup(options);
+  const { fileManager, logger } = pluginManager;
+  try {
+    await pluginManager.hookParallel({
+      hookName: "buildStart",
+      parameters: [options.config]
+    });
+    await pluginManager.hookParallel({ hookName: "buildEnd" });
+    if (logger.logLevel === _chunkSU2W2A6Vcjs.LogLevel.info) {
+      logger.emit("end", "\u{1F4BE} Writing completed");
+    }
+  } catch (e) {
+    const files2 = await Promise.all(
+      fileManager.files.map(async (file) => ({
+        ...file,
+        source: await FileManager.getSource(file)
+      }))
+    );
+    return {
+      files: files2,
+      pluginManager,
+      error: e
+    };
+  }
+  const files = await Promise.all(
+    fileManager.files.map(async (file) => ({
+      ...file,
+      source: await FileManager.getSource(file)
+    }))
+  );
+  return {
+    files,
+    pluginManager
+  };
+}
+
+// src/Generator.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var _options3, _context;
+var Generator = class {
+  constructor(options, context) {
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _options3, {});
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _context, {});
+    if (context) {
+      _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _context, context);
+    }
+    if (options) {
+      _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _options3, options);
+    }
+    return this;
+  }
+  get options() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _options3);
+  }
+  get context() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _context);
+  }
+  set options(options) {
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _options3, { ..._chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _options3), ...options });
+  }
+};
+_options3 = new WeakMap();
+_context = new WeakMap();
+
+// src/PackageManager.ts
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var _module = require('module'); var _module2 = _interopRequireDefault(_module);
+var _os = require('os'); var _os2 = _interopRequireDefault(_os);
+var _url = require('url');
+
+// ../../node_modules/.pnpm/find-up@7.0.0/node_modules/find-up/index.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+
+// ../../node_modules/.pnpm/locate-path@7.2.0/node_modules/locate-path/index.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+
+
+// ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+// ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+// ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+var Node = class {
+  constructor(value) {
+    _chunkOOZTXU7Fcjs.__publicField.call(void 0, this, "value");
+    _chunkOOZTXU7Fcjs.__publicField.call(void 0, this, "next");
+    this.value = value;
+  }
+};
+var _head, _tail, _size;
+var Queue = class {
+  constructor() {
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _head, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _tail, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _size, void 0);
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _head)) {
+      _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _tail).next = node;
+      _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _tail, node);
+    } else {
+      _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _head, node);
+      _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _tail, node);
+    }
+    _chunkOOZTXU7Fcjs.__privateWrapper.call(void 0, this, _size)._++;
+  }
+  dequeue() {
+    const current = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _head);
+    if (!current) {
+      return;
+    }
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _head, _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _head).next);
+    _chunkOOZTXU7Fcjs.__privateWrapper.call(void 0, this, _size)._--;
+    return current.value;
+  }
+  clear() {
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _head, void 0);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _tail, void 0);
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _size, 0);
+  }
+  get size() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _size);
+  }
+  *[Symbol.iterator]() {
+    let current = _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _head);
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+_head = new WeakMap();
+_tail = new WeakMap();
+_size = new WeakMap();
+
+// ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (fn, resolve2, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve2(result);
+    try {
+      await result;
+    } catch (e2) {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve2, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve2, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve2) => {
+    enqueue(fn, resolve2, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
+var EndError = class extends Error {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+var testElement = async (element, tester) => tester(await element);
+var finder = async (element) => {
+  const values = await Promise.all(element);
+  if (values[1] === true) {
+    throw new EndError(values[0]);
+  }
+  return false;
+};
+async function pLocate(iterable, tester, {
+  concurrency = Number.POSITIVE_INFINITY,
+  preserveOrder = true
+} = {}) {
+  const limit = pLimit(concurrency);
+  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(items.map((element) => checkLimit(finder, element)));
+  } catch (error) {
+    if (error instanceof EndError) {
+      return error.value;
+    }
+    throw error;
+  }
+}
+
+// ../../node_modules/.pnpm/locate-path@7.2.0/node_modules/locate-path/index.js
+var typeMappings = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function checkType(type) {
+  if (Object.hasOwnProperty.call(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+var matchType = (type, stat) => stat[typeMappings[type]]();
+var toPath = (urlOrPath) => urlOrPath instanceof URL ? _url.fileURLToPath.call(void 0, urlOrPath) : urlOrPath;
+async function locatePath(paths, {
+  cwd = _process2.default.cwd(),
+  type = "file",
+  allowSymlinks = true,
+  concurrency,
+  preserveOrder
+} = {}) {
+  checkType(type);
+  cwd = toPath(cwd);
+  const statFunction = allowSymlinks ? _fs.promises.stat : _fs.promises.lstat;
+  return pLocate(paths, async (path_) => {
+    try {
+      const stat = await statFunction(_path2.default.resolve(cwd, path_));
+      return matchType(type, stat);
+    } catch (e3) {
+      return false;
+    }
+  }, { concurrency, preserveOrder });
+}
+function locatePathSync(paths, {
+  cwd = _process2.default.cwd(),
+  type = "file",
+  allowSymlinks = true
+} = {}) {
+  checkType(type);
+  cwd = toPath(cwd);
+  const statFunction = allowSymlinks ? _fs2.default.statSync : _fs2.default.lstatSync;
+  for (const path_ of paths) {
+    try {
+      const stat = statFunction(_path2.default.resolve(cwd, path_), {
+        throwIfNoEntry: false
+      });
+      if (!stat) {
+        continue;
+      }
+      if (matchType(type, stat)) {
+        return path_;
+      }
+    } catch (e4) {
+    }
+  }
+}
+
+// ../../node_modules/.pnpm/unicorn-magic@0.1.0/node_modules/unicorn-magic/node.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+function toPath2(urlOrPath) {
+  return urlOrPath instanceof URL ? _url.fileURLToPath.call(void 0, urlOrPath) : urlOrPath;
+}
+
+// ../../node_modules/.pnpm/path-exists@5.0.0/node_modules/path-exists/index.js
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+
+// ../../node_modules/.pnpm/find-up@7.0.0/node_modules/find-up/index.js
+var findUpStop = Symbol("findUpStop");
+async function findUpMultiple(name, options = {}) {
+  let directory = _path2.default.resolve(_nullishCoalesce(toPath2(options.cwd), () => ( "")));
+  const { root } = _path2.default.parse(directory);
+  const stopAt = _path2.default.resolve(directory, toPath2(_nullishCoalesce(options.stopAt, () => ( root))));
+  const limit = _nullishCoalesce(options.limit, () => ( Number.POSITIVE_INFINITY));
+  const paths = [name].flat();
+  const runMatcher = async (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePath(paths, locateOptions);
+    }
+    const foundPath = await name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePath([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = await runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(_path2.default.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = _path2.default.dirname(directory);
+  }
+  return matches;
+}
+function findUpMultipleSync(name, options = {}) {
+  let directory = _path2.default.resolve(_nullishCoalesce(toPath2(options.cwd), () => ( "")));
+  const { root } = _path2.default.parse(directory);
+  const stopAt = _path2.default.resolve(directory, _nullishCoalesce(toPath2(options.stopAt), () => ( root)));
+  const limit = _nullishCoalesce(options.limit, () => ( Number.POSITIVE_INFINITY));
+  const paths = [name].flat();
+  const runMatcher = (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePathSync(paths, locateOptions);
+    }
+    const foundPath = name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePathSync([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(_path2.default.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = _path2.default.dirname(directory);
+  }
+  return matches;
+}
+async function findUp(name, options = {}) {
+  const matches = await findUpMultiple(name, { ...options, limit: 1 });
+  return matches[0];
+}
+function findUpSync(name, options = {}) {
+  const matches = findUpMultipleSync(name, { ...options, limit: 1 });
+  return matches[0];
+}
+
+// src/PackageManager.ts
+var _semver = require('semver');
+var _cache2, _cwd, _SLASHES, _match, match_fn;
+var _PackageManager = class _PackageManager {
+  constructor(workspace) {
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _match);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _cwd, void 0);
+    _chunkOOZTXU7Fcjs.__privateAdd.call(void 0, this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
+    if (workspace) {
+      _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _cwd, workspace);
+    }
+    return this;
+  }
+  set workspace(workspace) {
+    _chunkOOZTXU7Fcjs.__privateSet.call(void 0, this, _cwd, workspace);
+  }
+  get workspace() {
+    return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cwd);
+  }
+  normalizeDirectory(directory) {
+    if (!_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _SLASHES).has(directory[directory.length - 1])) {
+      return `${directory}/`;
+    }
+    return directory;
+  }
+  getLocation(path5) {
+    let location = path5;
+    if (_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cwd)) {
+      const require2 = _module2.default.createRequire(this.normalizeDirectory(_chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cwd)));
+      location = require2.resolve(path5);
+    }
+    return location;
+  }
+  async import(path5) {
+    try {
+      let location = this.getLocation(path5);
+      if (_os2.default.platform() === "win32") {
+        location = _url.pathToFileURL.call(void 0, location).href;
+      }
+      const module = await Promise.resolve().then(() => _interopRequireWildcard(require(location)));
+      return _nullishCoalesce(_optionalChain([module, 'optionalAccess', _69 => _69.default]), () => ( module));
+    } catch (e) {
+      console.log(e);
+      return void 0;
+    }
+  }
+  async getPackageJSON() {
+    const pkgPath = await findUp(["package.json"], {
+      cwd: _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cwd)
+    });
+    if (!pkgPath) {
+      return void 0;
+    }
+    const json = await _chunk7HFYOZ7Fcjs.read.call(void 0, pkgPath);
+    return JSON.parse(json);
+  }
+  getPackageJSONSync() {
+    const pkgPath = findUpSync(["package.json"], {
+      cwd: _chunkOOZTXU7Fcjs.__privateGet.call(void 0, this, _cwd)
+    });
+    if (!pkgPath) {
+      return void 0;
+    }
+    const json = _chunk7HFYOZ7Fcjs.readSync.call(void 0, pkgPath);
+    return JSON.parse(json);
+  }
+  static setVersion(dependency, version) {
+    _chunkOOZTXU7Fcjs.__privateGet.call(void 0, _PackageManager, _cache2)[dependency] = version;
+  }
+  async getVersion(dependency) {
+    if (typeof dependency === "string" && _chunkOOZTXU7Fcjs.__privateGet.call(void 0, _PackageManager, _cache2)[dependency]) {
+      return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, _PackageManager, _cache2)[dependency];
+    }
+    const packageJSON = await this.getPackageJSON();
+    if (!packageJSON) {
+      return void 0;
+    }
+    return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _match, match_fn).call(this, packageJSON, dependency);
+  }
+  getVersionSync(dependency) {
+    if (typeof dependency === "string" && _chunkOOZTXU7Fcjs.__privateGet.call(void 0, _PackageManager, _cache2)[dependency]) {
+      return _chunkOOZTXU7Fcjs.__privateGet.call(void 0, _PackageManager, _cache2)[dependency];
+    }
+    const packageJSON = this.getPackageJSONSync();
+    if (!packageJSON) {
+      return void 0;
+    }
+    return _chunkOOZTXU7Fcjs.__privateMethod.call(void 0, this, _match, match_fn).call(this, packageJSON, dependency);
+  }
+  async isValid(dependency, version) {
+    const packageVersion = await this.getVersion(dependency);
+    if (!packageVersion) {
+      return false;
+    }
+    if (packageVersion === version) {
+      return true;
+    }
+    const semVer = _semver.coerce.call(void 0, packageVersion);
+    if (!semVer) {
+      throw new Error(`${packageVersion} is not valid`);
+    }
+    return _semver.satisfies.call(void 0, semVer, version);
+  }
+  isValidSync(dependency, version) {
+    const packageVersion = this.getVersionSync(dependency);
+    if (!packageVersion) {
+      return false;
+    }
+    const semVer = _semver.coerce.call(void 0, packageVersion);
+    if (!semVer) {
+      throw new Error(`${packageVersion} is not valid`);
+    }
+    return _semver.satisfies.call(void 0, semVer, version);
+  }
+};
+_cache2 = new WeakMap();
+_cwd = new WeakMap();
+_SLASHES = new WeakMap();
+_match = new WeakSet();
+match_fn = function(packageJSON, dependency) {
+  const dependencies = {
+    ...packageJSON["dependencies"] || {},
+    ...packageJSON["devDependencies"] || {}
+  };
+  if (typeof dependency === "string" && dependencies[dependency]) {
+    return dependencies[dependency];
+  }
+  const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
+  return matchedDependency ? dependencies[matchedDependency] : void 0;
+};
+_chunkOOZTXU7Fcjs.__privateAdd.call(void 0, _PackageManager, _cache2, {});
+var PackageManager = _PackageManager;
+
+// src/kubb.ts
+var kubb_exports = {};
+_chunkOOZTXU7Fcjs.init_cjs_shims.call(void 0, );
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.KubbFile = KubbFile; exports.FileManager = FileManager; exports.PromiseManager = PromiseManager; exports.Warning = Warning; exports.createPlugin = createPlugin; exports.pluginName = pluginName; exports.PluginManager = PluginManager; exports.defineConfig = defineConfig; exports.isInputPath = isInputPath; exports.build = build; exports.safeBuild = safeBuild; exports.Generator = Generator; exports.PackageManager = PackageManager; exports.kubb_exports = kubb_exports;
+//# sourceMappingURL=chunk-T6TAUAYN.cjs.map