@kubb/core 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/index.cjs

@@ -2,18 +2,20 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var chunkABFPJZJL_cjs = require('./chunk-ABFPJZJL.cjs');
-var chunk72O327DC_cjs = require('./chunk-72O327DC.cjs');
-require('./chunk-PY7I7OEN.cjs');
-var chunk77QZQ377_cjs = require('./chunk-77QZQ377.cjs');
-var chunkZ7XZQBAK_cjs = require('./chunk-Z7XZQBAK.cjs');
-var chunkI7UUR5MZ_cjs = require('./chunk-I7UUR5MZ.cjs');
+var chunkU4C2WTCI_cjs = require('./chunk-U4C2WTCI.cjs');
+var chunkLAS7UYTK_cjs = require('./chunk-LAS7UYTK.cjs');
+require('./chunk-ST7GHHSU.cjs');
+var chunkGBX7KRCX_cjs = require('./chunk-GBX7KRCX.cjs');
+var chunk35FDNG5F_cjs = require('./chunk-35FDNG5F.cjs');
+var chunkICRPOCV4_cjs = require('./chunk-ICRPOCV4.cjs');
+var chunkMM42A6GN_cjs = require('./chunk-MM42A6GN.cjs');
 var crypto = require('crypto');
 var path4 = require('path');
 var parser = require('@kubb/parser');
 var factory = require('@kubb/parser/factory');
 var naturalOrderby = require('natural-orderby');
 var dirTree = require('directory-tree');
+var events = require('events');
 var mod = require('module');
 var os = require('os');
 var url = require('url');
@@ -51,9 +53,9 @@ var process__default = /*#__PURE__*/_interopDefault(process);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
 
 // ../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js
-var require_lodash = chunkI7UUR5MZ_cjs.__commonJS({
+var require_lodash = chunkMM42A6GN_cjs.__commonJS({
   "../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js"(exports, module) {
-    chunkI7UUR5MZ_cjs.init_cjs_shims();
+    chunkMM42A6GN_cjs.init_cjs_shims();
     var LARGE_ARRAY_SIZE = 200;
     var HASH_UNDEFINED = "__lodash_hash_undefined__";
     var COMPARE_PARTIAL_FLAG = 1;
@@ -752,14 +754,196 @@ var require_lodash = chunkI7UUR5MZ_cjs.__commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
+var require_eventemitter3 = chunkMM42A6GN_cjs.__commonJS({
+  "../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js"(exports, module) {
+    chunkMM42A6GN_cjs.init_cjs_shims();
+    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
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // src/build.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // src/config.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 function defineConfig(options) {
   return options;
 }
@@ -768,14 +952,492 @@ function isInputPath(result) {
 }
 
 // src/FileManager.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
-var import_lodash = chunkI7UUR5MZ_cjs.__toESM(require_lodash(), 1);
+chunkMM42A6GN_cjs.init_cjs_shims();
+var import_lodash = chunkMM42A6GN_cjs.__toESM(require_lodash(), 1);
+
+// ../../node_modules/.pnpm/p-queue@7.4.1/node_modules/p-queue/dist/index.js
+chunkMM42A6GN_cjs.init_cjs_shims();
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
+chunkMM42A6GN_cjs.init_cjs_shims();
+var import_index = chunkMM42A6GN_cjs.__toESM(require_eventemitter3(), 1);
+
+// ../../node_modules/.pnpm/p-timeout@5.1.0/node_modules/p-timeout/index.js
+chunkMM42A6GN_cjs.init_cjs_shims();
+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, milliseconds, fallback, options) {
+  let timer;
+  const cancelablePromise = 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 (milliseconds === Number.POSITIVE_INFINITY) {
+      resolve2(promise);
+      return;
+    }
+    options = {
+      customTimers: { setTimeout, clearTimeout },
+      ...options
+    };
+    if (options.signal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        reject(getAbortedReason(signal));
+      }
+      signal.addEventListener("abort", () => {
+        reject(getAbortedReason(signal));
+      });
+    }
+    timer = options.customTimers.setTimeout.call(void 0, () => {
+      if (typeof fallback === "function") {
+        try {
+          resolve2(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
+      const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      reject(timeoutError);
+    }, milliseconds);
+    (async () => {
+      try {
+        resolve2(await promise);
+      } catch (error) {
+        reject(error);
+      } finally {
+        options.customTimers.clearTimeout.call(void 0, timer);
+      }
+    })();
+  });
+  cancelablePromise.clear = () => {
+    clearTimeout(timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
+}
+
+// ../../node_modules/.pnpm/p-queue@7.4.1/node_modules/p-queue/dist/priority-queue.js
+chunkMM42A6GN_cjs.init_cjs_shims();
+
+// ../../node_modules/.pnpm/p-queue@7.4.1/node_modules/p-queue/dist/lower-bound.js
+chunkMM42A6GN_cjs.init_cjs_shims();
+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@7.4.1/node_modules/p-queue/dist/priority-queue.js
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PriorityQueue_queue;
+var PriorityQueue = class {
+  constructor() {
+    _PriorityQueue_queue.set(this, []);
+  }
+  enqueue(run, options) {
+    options = {
+      priority: 0,
+      ...options
+    };
+    const element = {
+      priority: options.priority,
+      run
+    };
+    if (this.size && __classPrivateFieldGet(this, _PriorityQueue_queue, "f")[this.size - 1].priority >= options.priority) {
+      __classPrivateFieldGet(this, _PriorityQueue_queue, "f").push(element);
+      return;
+    }
+    const index = lowerBound(__classPrivateFieldGet(this, _PriorityQueue_queue, "f"), element, (a, b) => b.priority - a.priority);
+    __classPrivateFieldGet(this, _PriorityQueue_queue, "f").splice(index, 0, element);
+  }
+  dequeue() {
+    const item = __classPrivateFieldGet(this, _PriorityQueue_queue, "f").shift();
+    return item === null || item === void 0 ? void 0 : item.run;
+  }
+  filter(options) {
+    return __classPrivateFieldGet(this, _PriorityQueue_queue, "f").filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return __classPrivateFieldGet(this, _PriorityQueue_queue, "f").length;
+  }
+};
+_PriorityQueue_queue = /* @__PURE__ */ new WeakMap();
+var priority_queue_default = PriorityQueue;
+
+// ../../node_modules/.pnpm/p-queue@7.4.1/node_modules/p-queue/dist/index.js
+var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+  if (kind === "m")
+    throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet2 = function(receiver, state, kind, f) {
+  if (kind === "a" && !f)
+    throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+    throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PQueue_instances;
+var _PQueue_carryoverConcurrencyCount;
+var _PQueue_isIntervalIgnored;
+var _PQueue_intervalCount;
+var _PQueue_intervalCap;
+var _PQueue_interval;
+var _PQueue_intervalEnd;
+var _PQueue_intervalId;
+var _PQueue_timeoutId;
+var _PQueue_queue;
+var _PQueue_queueClass;
+var _PQueue_pending;
+var _PQueue_concurrency;
+var _PQueue_isPaused;
+var _PQueue_throwOnTimeout;
+var _PQueue_doesIntervalAllowAnother_get;
+var _PQueue_doesConcurrentAllowAnother_get;
+var _PQueue_next;
+var _PQueue_onResumeInterval;
+var _PQueue_isIntervalPaused_get;
+var _PQueue_tryToStartAnother;
+var _PQueue_initializeIntervalIfNeeded;
+var _PQueue_onInterval;
+var _PQueue_processQueue;
+var _PQueue_throwOnAbort;
+var _PQueue_onEvent;
+var AbortError2 = class extends Error {
+};
+var PQueue = class extends import_index.default {
+  // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
+  constructor(options) {
+    var _a, _b, _c, _d;
+    super();
+    _PQueue_instances.add(this);
+    _PQueue_carryoverConcurrencyCount.set(this, void 0);
+    _PQueue_isIntervalIgnored.set(this, void 0);
+    _PQueue_intervalCount.set(this, 0);
+    _PQueue_intervalCap.set(this, void 0);
+    _PQueue_interval.set(this, void 0);
+    _PQueue_intervalEnd.set(this, 0);
+    _PQueue_intervalId.set(this, void 0);
+    _PQueue_timeoutId.set(this, void 0);
+    _PQueue_queue.set(this, void 0);
+    _PQueue_queueClass.set(this, void 0);
+    _PQueue_pending.set(this, 0);
+    _PQueue_concurrency.set(this, void 0);
+    _PQueue_isPaused.set(this, void 0);
+    _PQueue_throwOnTimeout.set(this, void 0);
+    Object.defineProperty(this, "timeout", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    options = {
+      carryoverConcurrencyCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: priority_queue_default,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}\` (${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 \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options.interval})`);
+    }
+    __classPrivateFieldSet(this, _PQueue_carryoverConcurrencyCount, options.carryoverConcurrencyCount, "f");
+    __classPrivateFieldSet(this, _PQueue_isIntervalIgnored, options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0, "f");
+    __classPrivateFieldSet(this, _PQueue_intervalCap, options.intervalCap, "f");
+    __classPrivateFieldSet(this, _PQueue_interval, options.interval, "f");
+    __classPrivateFieldSet(this, _PQueue_queue, new options.queueClass(), "f");
+    __classPrivateFieldSet(this, _PQueue_queueClass, options.queueClass, "f");
+    this.concurrency = options.concurrency;
+    this.timeout = options.timeout;
+    __classPrivateFieldSet(this, _PQueue_throwOnTimeout, options.throwOnTimeout === true, "f");
+    __classPrivateFieldSet(this, _PQueue_isPaused, options.autoStart === false, "f");
+  }
+  get concurrency() {
+    return __classPrivateFieldGet2(this, _PQueue_concurrency, "f");
+  }
+  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})`);
+    }
+    __classPrivateFieldSet(this, _PQueue_concurrency, newConcurrency, "f");
+    __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
+  }
+  async add(function_, options = {}) {
+    options = {
+      timeout: this.timeout,
+      throwOnTimeout: __classPrivateFieldGet2(this, _PQueue_throwOnTimeout, "f"),
+      ...options
+    };
+    return new Promise((resolve2, reject) => {
+      __classPrivateFieldGet2(this, _PQueue_queue, "f").enqueue(async () => {
+        var _a;
+        var _b, _c;
+        __classPrivateFieldSet(this, _PQueue_pending, (_b = __classPrivateFieldGet2(this, _PQueue_pending, "f"), _b++, _b), "f");
+        __classPrivateFieldSet(this, _PQueue_intervalCount, (_c = __classPrivateFieldGet2(this, _PQueue_intervalCount, "f"), _c++, _c), "f");
+        try {
+          if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            throw new AbortError2("The task was aborted.");
+          }
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), options.timeout);
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_throwOnAbort).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 {
+          __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_next).call(this);
+        }
+      }, options);
+      this.emit("add");
+      __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).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 (!__classPrivateFieldGet2(this, _PQueue_isPaused, "f")) {
+      return this;
+    }
+    __classPrivateFieldSet(this, _PQueue_isPaused, false, "f");
+    __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    __classPrivateFieldSet(this, _PQueue_isPaused, true, "f");
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    __classPrivateFieldSet(this, _PQueue_queue, new (__classPrivateFieldGet2(this, _PQueue_queueClass, "f"))(), "f");
+  }
+  /**
+      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 (__classPrivateFieldGet2(this, _PQueue_queue, "f").size === 0) {
+      return;
+    }
+    await __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_onEvent).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 (__classPrivateFieldGet2(this, _PQueue_queue, "f").size < limit) {
+      return;
+    }
+    await __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, "next", () => __classPrivateFieldGet2(this, _PQueue_queue, "f").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 (__classPrivateFieldGet2(this, _PQueue_pending, "f") === 0 && __classPrivateFieldGet2(this, _PQueue_queue, "f").size === 0) {
+      return;
+    }
+    await __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_onEvent).call(this, "idle");
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return __classPrivateFieldGet2(this, _PQueue_queue, "f").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 __classPrivateFieldGet2(this, _PQueue_queue, "f").filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return __classPrivateFieldGet2(this, _PQueue_pending, "f");
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return __classPrivateFieldGet2(this, _PQueue_isPaused, "f");
+  }
+};
+_PQueue_carryoverConcurrencyCount = /* @__PURE__ */ new WeakMap(), _PQueue_isIntervalIgnored = /* @__PURE__ */ new WeakMap(), _PQueue_intervalCount = /* @__PURE__ */ new WeakMap(), _PQueue_intervalCap = /* @__PURE__ */ new WeakMap(), _PQueue_interval = /* @__PURE__ */ new WeakMap(), _PQueue_intervalEnd = /* @__PURE__ */ new WeakMap(), _PQueue_intervalId = /* @__PURE__ */ new WeakMap(), _PQueue_timeoutId = /* @__PURE__ */ new WeakMap(), _PQueue_queue = /* @__PURE__ */ new WeakMap(), _PQueue_queueClass = /* @__PURE__ */ new WeakMap(), _PQueue_pending = /* @__PURE__ */ new WeakMap(), _PQueue_concurrency = /* @__PURE__ */ new WeakMap(), _PQueue_isPaused = /* @__PURE__ */ new WeakMap(), _PQueue_throwOnTimeout = /* @__PURE__ */ new WeakMap(), _PQueue_instances = /* @__PURE__ */ new WeakSet(), _PQueue_doesIntervalAllowAnother_get = function _PQueue_doesIntervalAllowAnother_get2() {
+  return __classPrivateFieldGet2(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet2(this, _PQueue_intervalCount, "f") < __classPrivateFieldGet2(this, _PQueue_intervalCap, "f");
+}, _PQueue_doesConcurrentAllowAnother_get = function _PQueue_doesConcurrentAllowAnother_get2() {
+  return __classPrivateFieldGet2(this, _PQueue_pending, "f") < __classPrivateFieldGet2(this, _PQueue_concurrency, "f");
+}, _PQueue_next = function _PQueue_next2() {
+  var _a;
+  __classPrivateFieldSet(this, _PQueue_pending, (_a = __classPrivateFieldGet2(this, _PQueue_pending, "f"), _a--, _a), "f");
+  __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this);
+  this.emit("next");
+}, _PQueue_onResumeInterval = function _PQueue_onResumeInterval2() {
+  __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
+  __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
+  __classPrivateFieldSet(this, _PQueue_timeoutId, void 0, "f");
+}, _PQueue_isIntervalPaused_get = function _PQueue_isIntervalPaused_get2() {
+  const now = Date.now();
+  if (__classPrivateFieldGet2(this, _PQueue_intervalId, "f") === void 0) {
+    const delay = __classPrivateFieldGet2(this, _PQueue_intervalEnd, "f") - now;
+    if (delay < 0) {
+      __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet2(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet2(this, _PQueue_pending, "f") : 0, "f");
+    } else {
+      if (__classPrivateFieldGet2(this, _PQueue_timeoutId, "f") === void 0) {
+        __classPrivateFieldSet(this, _PQueue_timeoutId, setTimeout(() => {
+          __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_onResumeInterval).call(this);
+        }, delay), "f");
+      }
+      return true;
+    }
+  }
+  return false;
+}, _PQueue_tryToStartAnother = function _PQueue_tryToStartAnother2() {
+  if (__classPrivateFieldGet2(this, _PQueue_queue, "f").size === 0) {
+    if (__classPrivateFieldGet2(this, _PQueue_intervalId, "f")) {
+      clearInterval(__classPrivateFieldGet2(this, _PQueue_intervalId, "f"));
+    }
+    __classPrivateFieldSet(this, _PQueue_intervalId, void 0, "f");
+    this.emit("empty");
+    if (__classPrivateFieldGet2(this, _PQueue_pending, "f") === 0) {
+      this.emit("idle");
+    }
+    return false;
+  }
+  if (!__classPrivateFieldGet2(this, _PQueue_isPaused, "f")) {
+    const canInitializeInterval = !__classPrivateFieldGet2(this, _PQueue_instances, "a", _PQueue_isIntervalPaused_get);
+    if (__classPrivateFieldGet2(this, _PQueue_instances, "a", _PQueue_doesIntervalAllowAnother_get) && __classPrivateFieldGet2(this, _PQueue_instances, "a", _PQueue_doesConcurrentAllowAnother_get)) {
+      const job = __classPrivateFieldGet2(this, _PQueue_queue, "f").dequeue();
+      if (!job) {
+        return false;
+      }
+      this.emit("active");
+      job();
+      if (canInitializeInterval) {
+        __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_initializeIntervalIfNeeded).call(this);
+      }
+      return true;
+    }
+  }
+  return false;
+}, _PQueue_initializeIntervalIfNeeded = function _PQueue_initializeIntervalIfNeeded2() {
+  if (__classPrivateFieldGet2(this, _PQueue_isIntervalIgnored, "f") || __classPrivateFieldGet2(this, _PQueue_intervalId, "f") !== void 0) {
+    return;
+  }
+  __classPrivateFieldSet(this, _PQueue_intervalId, setInterval(() => {
+    __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_onInterval).call(this);
+  }, __classPrivateFieldGet2(this, _PQueue_interval, "f")), "f");
+  __classPrivateFieldSet(this, _PQueue_intervalEnd, Date.now() + __classPrivateFieldGet2(this, _PQueue_interval, "f"), "f");
+}, _PQueue_onInterval = function _PQueue_onInterval2() {
+  if (__classPrivateFieldGet2(this, _PQueue_intervalCount, "f") === 0 && __classPrivateFieldGet2(this, _PQueue_pending, "f") === 0 && __classPrivateFieldGet2(this, _PQueue_intervalId, "f")) {
+    clearInterval(__classPrivateFieldGet2(this, _PQueue_intervalId, "f"));
+    __classPrivateFieldSet(this, _PQueue_intervalId, void 0, "f");
+  }
+  __classPrivateFieldSet(this, _PQueue_intervalCount, __classPrivateFieldGet2(this, _PQueue_carryoverConcurrencyCount, "f") ? __classPrivateFieldGet2(this, _PQueue_pending, "f") : 0, "f");
+  __classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_processQueue).call(this);
+}, _PQueue_processQueue = function _PQueue_processQueue2() {
+  while (__classPrivateFieldGet2(this, _PQueue_instances, "m", _PQueue_tryToStartAnother).call(this)) {
+  }
+}, _PQueue_throwOnAbort = async function _PQueue_throwOnAbort2(signal) {
+  return new Promise((_resolve, reject) => {
+    signal.addEventListener("abort", () => {
+      reject(new AbortError2("The task was aborted."));
+    }, { once: true });
+  });
+}, _PQueue_onEvent = async function _PQueue_onEvent2(event, filter) {
+  return new Promise((resolve2) => {
+    const listener = () => {
+      if (filter && !filter()) {
+        return;
+      }
+      this.off(event, listener);
+      resolve2();
+    };
+    this.on(event, listener);
+  });
+};
+var dist_default = PQueue;
 
 // src/BarrelManager.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // src/utils/TreeNode.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 var TreeNode = class _TreeNode {
   constructor(data, parent) {
     this.children = [];
@@ -866,12 +1528,12 @@ var TreeNode = class _TreeNode {
 var _options;
 var BarrelManager = class {
   constructor(options = {}) {
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _options, void 0);
-    chunkI7UUR5MZ_cjs.__privateSet(this, _options, options);
+    chunkMM42A6GN_cjs.__privateAdd(this, _options, void 0);
+    chunkMM42A6GN_cjs.__privateSet(this, _options, options);
     return this;
   }
   getIndexes(pathToBuild) {
-    const { treeNode = {}, isTypeOnly, extName } = chunkI7UUR5MZ_cjs.__privateGet(this, _options);
+    const { treeNode = {}, isTypeOnly, extName } = chunkMM42A6GN_cjs.__privateGet(this, _options);
     const tree = TreeNode.build(pathToBuild, treeNode);
     if (!tree) {
       return null;
@@ -883,7 +1545,7 @@ var BarrelManager = class {
       if (treeNode2.children.length > 1) {
         const indexPath = path4__default.default.resolve(treeNode2.data.path, "index.ts");
         const exports = treeNode2.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${chunkABFPJZJL_cjs.trimExtName(file.data.name)}`;
+          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${chunkU4C2WTCI_cjs.trimExtName(file.data.name)}`;
           if (importPath.endsWith("index") && file.data.type === "file") {
             return void 0;
           }
@@ -904,7 +1566,7 @@ var BarrelManager = class {
       } else if (treeNode2.children.length === 1) {
         const [treeNodeChild] = treeNode2.children;
         const indexPath = path4__default.default.resolve(treeNode2.data.path, "index.ts");
-        const importPath = treeNodeChild.data.type === "directory" ? `./${treeNodeChild.data.name}/index` : `./${chunkABFPJZJL_cjs.trimExtName(treeNodeChild.data.name)}`;
+        const importPath = treeNodeChild.data.type === "directory" ? `./${treeNodeChild.data.name}/index` : `./${chunkU4C2WTCI_cjs.trimExtName(treeNodeChild.data.name)}`;
         const exports = [
           {
             path: extName ? `${importPath}${extName}` : importPath,
@@ -935,43 +1597,34 @@ _options = new WeakMap();
 exports.KubbFile = void 0;
 ((KubbFile2) => {
 })(exports.KubbFile || (exports.KubbFile = {}));
-var _cache, _task, _isWriting, _timeout, _queue, _validate, _add, add_fn, _addOrAppend, addOrAppend_fn;
+var _cache, _task, _queue, _add, add_fn, _addOrAppend, addOrAppend_fn;
 var _FileManager = class _FileManager {
-  constructor(options) {
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _validate);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _add);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _addOrAppend);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _cache, /* @__PURE__ */ new Map());
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _task, void 0);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _isWriting, false);
-    /**
-     * Timeout between writes
-     */
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _timeout, 0);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _queue, void 0);
-    if (options) {
-      chunkI7UUR5MZ_cjs.__privateSet(this, _task, options.task);
-      chunkI7UUR5MZ_cjs.__privateSet(this, _queue, options.queue);
-      chunkI7UUR5MZ_cjs.__privateSet(this, _timeout, options.timeout || 0);
-    }
+  constructor({ task = async (file) => file, queue = new dist_default() } = {}) {
+    chunkMM42A6GN_cjs.__privateAdd(this, _add);
+    chunkMM42A6GN_cjs.__privateAdd(this, _addOrAppend);
+    chunkMM42A6GN_cjs.__privateAdd(this, _cache, /* @__PURE__ */ new Map());
+    chunkMM42A6GN_cjs.__privateAdd(this, _task, void 0);
+    chunkMM42A6GN_cjs.__privateAdd(this, _queue, void 0);
+    chunkMM42A6GN_cjs.__privateSet(this, _task, task);
+    chunkMM42A6GN_cjs.__privateSet(this, _queue, queue);
     return this;
   }
   get files() {
     const files = [];
-    chunkI7UUR5MZ_cjs.__privateGet(this, _cache).forEach((item) => {
+    chunkMM42A6GN_cjs.__privateGet(this, _cache).forEach((item) => {
       files.push(...item.flat(1));
     });
     return files;
   }
   get isExecuting() {
-    return chunkI7UUR5MZ_cjs.__privateGet(this, _queue)?.hasJobs ?? chunkI7UUR5MZ_cjs.__privateGet(this, _isWriting) ?? false;
+    return chunkMM42A6GN_cjs.__privateGet(this, _queue).size !== 0 && chunkMM42A6GN_cjs.__privateGet(this, _queue).pending !== 0;
   }
   async add(...files) {
-    const promises = files.map((file) => {
+    const promises = combineFiles(files).map((file) => {
       if (file.override) {
-        return chunkI7UUR5MZ_cjs.__privateMethod(this, _add, add_fn).call(this, file);
+        return chunkMM42A6GN_cjs.__privateMethod(this, _add, add_fn).call(this, file);
       }
-      return chunkI7UUR5MZ_cjs.__privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
+      return chunkMM42A6GN_cjs.__privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
     });
     const resolvedFiles = await Promise.all(promises);
     if (files.length > 1) {
@@ -984,7 +1637,7 @@ var _FileManager = class _FileManager {
     if (!exportType) {
       return void 0;
     }
-    const exportPath = output.path.startsWith("./") ? output.path : `./${output.path}`;
+    const exportPath = output.path.startsWith("./") ? chunkU4C2WTCI_cjs.trimExtName(output.path) : `./${chunkU4C2WTCI_cjs.trimExtName(output.path)}`;
     const barrelManager = new BarrelManager({ extName: output.extName, ...options });
     const files = barrelManager.getIndexes(path4.resolve(root, output.path));
     if (!files) {
@@ -998,21 +1651,21 @@ var _FileManager = class _FileManager {
         output.exportAs ? {
           name: output.exportAs,
           asAlias: true,
-          path: exportPath,
+          path: output.extName ? `${exportPath}${output.extName}` : exportPath,
           isTypeOnly: options.isTypeOnly
         } : {
-          path: exportPath,
+          path: output.extName ? `${exportPath}${output.extName}` : exportPath,
           isTypeOnly: options.isTypeOnly
         }
       ]
     };
-    await chunkI7UUR5MZ_cjs.__privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
+    await chunkMM42A6GN_cjs.__privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
       ...rootFile,
       meta: meta ? meta : rootFile.meta
     });
     return await Promise.all(
       files.map((file) => {
-        return chunkI7UUR5MZ_cjs.__privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
+        return chunkMM42A6GN_cjs.__privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
           ...file,
           meta: meta ? meta : file.meta
         });
@@ -1021,38 +1674,34 @@ var _FileManager = class _FileManager {
   }
   getCacheByUUID(UUID) {
     let cache;
-    chunkI7UUR5MZ_cjs.__privateGet(this, _cache).forEach((files) => {
+    chunkMM42A6GN_cjs.__privateGet(this, _cache).forEach((files) => {
       cache = files.find((item) => item.id === UUID);
     });
     return cache;
   }
   get(path5) {
-    return chunkI7UUR5MZ_cjs.__privateGet(this, _cache).get(path5);
+    return chunkMM42A6GN_cjs.__privateGet(this, _cache).get(path5);
   }
   remove(path5) {
     const cacheItem = this.get(path5);
     if (!cacheItem) {
       return;
     }
-    chunkI7UUR5MZ_cjs.__privateGet(this, _cache).delete(path5);
+    chunkMM42A6GN_cjs.__privateGet(this, _cache).delete(path5);
   }
   async write(...params) {
-    if (!chunkI7UUR5MZ_cjs.__privateGet(this, _isWriting)) {
-      chunkI7UUR5MZ_cjs.__privateSet(this, _isWriting, true);
-      const text = await chunkZ7XZQBAK_cjs.write(...params);
-      chunkI7UUR5MZ_cjs.__privateSet(this, _isWriting, false);
-      return text;
-    }
-    await chunk72O327DC_cjs.timeout(chunkI7UUR5MZ_cjs.__privateGet(this, _timeout));
-    return this.write(...params);
+    return chunkICRPOCV4_cjs.write(...params);
   }
   async read(...params) {
-    return chunkZ7XZQBAK_cjs.read(...params);
+    return chunk35FDNG5F_cjs.read(...params);
   }
   // statics
   static getSource(file) {
     return getSource(file);
   }
+  static combineFiles(files) {
+    return combineFiles(files);
+  }
   static getMode(path5) {
     if (!path5) {
       return "directory";
@@ -1068,33 +1717,27 @@ var _FileManager = class _FileManager {
 };
 _cache = new WeakMap();
 _task = new WeakMap();
-_isWriting = new WeakMap();
-_timeout = new WeakMap();
 _queue = new WeakMap();
-_validate = new WeakSet();
 _add = new WeakSet();
 add_fn = async function(file) {
   const controller = new AbortController();
-  const resolvedFile = { id: crypto__default.default.randomUUID(), name: chunkABFPJZJL_cjs.trimExtName(file.baseName), ...file };
-  chunkI7UUR5MZ_cjs.__privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-  if (chunkI7UUR5MZ_cjs.__privateGet(this, _queue)) {
-    await chunkI7UUR5MZ_cjs.__privateGet(this, _queue).run(
-      async () => {
-        var _a;
-        return (_a = chunkI7UUR5MZ_cjs.__privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
-      },
-      { controller }
-    );
-  }
-  return resolvedFile;
+  const resolvedFile = { id: crypto__default.default.randomUUID(), name: chunkU4C2WTCI_cjs.trimExtName(file.baseName), ...file };
+  chunkMM42A6GN_cjs.__privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
+  return chunkMM42A6GN_cjs.__privateGet(this, _queue).add(
+    async () => {
+      var _a;
+      return (_a = chunkMM42A6GN_cjs.__privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
+    },
+    { signal: controller.signal }
+  );
 };
 _addOrAppend = new WeakSet();
 addOrAppend_fn = async function(file) {
-  const previousCaches = chunkI7UUR5MZ_cjs.__privateGet(this, _cache).get(file.path);
+  const previousCaches = chunkMM42A6GN_cjs.__privateGet(this, _cache).get(file.path);
   const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
   if (previousCache) {
-    chunkI7UUR5MZ_cjs.__privateGet(this, _cache).delete(previousCache.path);
-    return chunkI7UUR5MZ_cjs.__privateMethod(this, _add, add_fn).call(this, {
+    chunkMM42A6GN_cjs.__privateGet(this, _cache).delete(previousCache.path);
+    return chunkMM42A6GN_cjs.__privateMethod(this, _add, add_fn).call(this, {
       ...file,
       source: previousCache.source && file.source ? `${previousCache.source}
 ${file.source}` : "",
@@ -1103,9 +1746,37 @@ ${file.source}` : "",
       env: { ...previousCache.env || {}, ...file.env || {} }
     });
   }
-  return chunkI7UUR5MZ_cjs.__privateMethod(this, _add, add_fn).call(this, file);
+  return chunkMM42A6GN_cjs.__privateMethod(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;
+  }, []);
+}
 function getSource(file) {
   if (!FileManager.isExtensionAllowed(file.baseName)) {
     return file.source;
@@ -1113,11 +1784,11 @@ function getSource(file) {
   const exports = file.exports ? combineExports(file.exports) : [];
   const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
   const importNodes = imports.filter((item) => {
-    return item.path !== chunkABFPJZJL_cjs.trimExtName(file.path);
+    return item.path !== chunkU4C2WTCI_cjs.trimExtName(file.path);
   }).map((item) => {
     return factory__namespace.createImportDeclaration({
       name: item.name,
-      path: item.root ? chunkZ7XZQBAK_cjs.getRelativePath(item.root, item.path) : item.path,
+      path: item.root ? chunk35FDNG5F_cjs.getRelativePath(item.root, item.path) : item.path,
       isTypeOnly: item.isTypeOnly
     });
   });
@@ -1219,8 +1890,8 @@ function getEnvSource(source, env) {
       throw new TypeError(`Environment should be in upperCase for ${key}`);
     }
     if (typeof replaceBy === "string") {
-      prev = chunkABFPJZJL_cjs.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = chunkABFPJZJL_cjs.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+      prev = chunkU4C2WTCI_cjs.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
+      prev = chunkU4C2WTCI_cjs.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
 `, "ig"), ""), replaceBy, key });
     }
     return prev;
@@ -1228,10 +1899,33 @@ function getEnvSource(source, env) {
 }
 
 // src/PluginManager.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
+
+// src/utils/EventEmitter.ts
+chunkMM42A6GN_cjs.init_cjs_shims();
+var _emitter;
+var EventEmitter2 = class {
+  constructor() {
+    chunkMM42A6GN_cjs.__privateAdd(this, _emitter, new events.EventEmitter());
+    chunkMM42A6GN_cjs.__privateGet(this, _emitter).setMaxListeners(100);
+  }
+  emit(eventName, ...eventArg) {
+    chunkMM42A6GN_cjs.__privateGet(this, _emitter).emit(eventName, ...eventArg);
+  }
+  on(eventName, handler) {
+    chunkMM42A6GN_cjs.__privateGet(this, _emitter).on(eventName, handler);
+  }
+  off(eventName, handler) {
+    chunkMM42A6GN_cjs.__privateGet(this, _emitter).off(eventName, handler);
+  }
+  removeAll() {
+    chunkMM42A6GN_cjs.__privateGet(this, _emitter).removeAllListeners();
+  }
+};
+_emitter = new WeakMap();
 
 // src/errors.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 var Warning = class extends Error {
   constructor(message, options) {
     super(message, { cause: options?.cause });
@@ -1242,10 +1936,10 @@ var ValidationPluginError = class extends Error {
 };
 
 // src/plugin.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // src/utils/cache.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
   return {
     set(id, value) {
@@ -1323,10 +2017,10 @@ var definePlugin = createPlugin((options) => {
 });
 
 // src/PromiseManager.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // src/utils/executeStrategies.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 function hookSeq(promises) {
   return promises.filter(Boolean).reduce(
     (promise, func) => {
@@ -1364,8 +2058,8 @@ function hookParallel(promises) {
 var _options2;
 var PromiseManager = class {
   constructor(options = {}) {
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _options2, {});
-    chunkI7UUR5MZ_cjs.__privateSet(this, _options2, options);
+    chunkMM42A6GN_cjs.__privateAdd(this, _options2, {});
+    chunkMM42A6GN_cjs.__privateSet(this, _options2, options);
     return this;
   }
   run(strategy, promises) {
@@ -1373,7 +2067,7 @@ var PromiseManager = class {
       return hookSeq(promises);
     }
     if (strategy === "first") {
-      return hookFirst(promises, chunkI7UUR5MZ_cjs.__privateGet(this, _options2).nullCheck);
+      return hookFirst(promises, chunkMM42A6GN_cjs.__privateGet(this, _options2).nullCheck);
     }
     if (strategy === "parallel") {
       return hookParallel(promises);
@@ -1393,8 +2087,8 @@ function isPromiseRejectedResult(result) {
 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) {
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _getSortedPlugins);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _addExecutedToCallStack);
+    chunkMM42A6GN_cjs.__privateAdd(this, _getSortedPlugins);
+    chunkMM42A6GN_cjs.__privateAdd(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`.
@@ -1402,7 +2096,7 @@ var PluginManager = class {
      * @param plugin The actual pluginObject to run.
      */
     // Implementation signature
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _execute);
+    chunkMM42A6GN_cjs.__privateAdd(this, _execute);
     /**
      * Run a sync plugin hook and return the result.
      * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
@@ -1410,14 +2104,14 @@ var PluginManager = class {
      * @param plugin The acutal plugin
      * @param replaceContext When passed, the plugin context can be overridden.
      */
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _executeSync);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _catcher);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _parse);
-    this.events = new chunk72O327DC_cjs.EventEmitter();
+    chunkMM42A6GN_cjs.__privateAdd(this, _executeSync);
+    chunkMM42A6GN_cjs.__privateAdd(this, _catcher);
+    chunkMM42A6GN_cjs.__privateAdd(this, _parse);
+    this.events = new EventEmitter2();
     this.executed = [];
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _core, void 0);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _usedPluginNames, {});
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _promiseManager, void 0);
+    chunkMM42A6GN_cjs.__privateAdd(this, _core, void 0);
+    chunkMM42A6GN_cjs.__privateAdd(this, _usedPluginNames, {});
+    chunkMM42A6GN_cjs.__privateAdd(this, _promiseManager, void 0);
     this.resolvePath = (params) => {
       if (params.pluginKey) {
         const paths = this.hookForPluginSync({
@@ -1425,8 +2119,8 @@ var PluginManager = class {
           hookName: "resolvePath",
           parameters: [params.baseName, params.directory, params.options]
         });
-        if (paths && paths?.length > 1 && this.logger.logLevel === chunk77QZQ377_cjs.LogLevel.debug) {
-          this.logger.warn(
+        if (paths && paths?.length > 1 && this.logger.logLevel === chunkGBX7KRCX_cjs.LogLevel.debug) {
+          this.logger.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)}
@@ -1449,8 +2143,8 @@ Falling back on the first item.
           hookName: "resolveName",
           parameters: [params.name, params.type]
         });
-        if (names && names?.length > 1 && this.logger.logLevel === chunk77QZQ377_cjs.LogLevel.debug) {
-          this.logger.warn(
+        if (names && names?.length > 1 && this.logger.logLevel === chunkGBX7KRCX_cjs.LogLevel.debug) {
+          this.logger.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)}
@@ -1459,19 +2153,19 @@ Falling back on the first item.
 `
           );
         }
-        return chunkABFPJZJL_cjs.transformReservedWord(names?.at(0) || params.name);
+        return chunkU4C2WTCI_cjs.transformReservedWord(names?.at(0) || params.name);
       }
       const name = this.hookFirstSync({
         hookName: "resolveName",
         parameters: [params.name, params.type]
       }).result;
-      return chunkABFPJZJL_cjs.transformReservedWord(name);
+      return chunkU4C2WTCI_cjs.transformReservedWord(name);
     };
     this.config = config;
     this.logger = options.logger;
-    this.queue = new chunk72O327DC_cjs.Queue(100, this.logger.logLevel === chunk77QZQ377_cjs.LogLevel.debug);
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue, timeout: options.writeTimeout });
-    chunkI7UUR5MZ_cjs.__privateSet(this, _promiseManager, new PromiseManager({ nullCheck: (state) => !!state?.result }));
+    this.queue = new dist_default({ concurrency: 1 });
+    this.fileManager = new FileManager({ task: options.task, queue: this.queue });
+    chunkMM42A6GN_cjs.__privateSet(this, _promiseManager, new PromiseManager({ nullCheck: (state) => !!state?.result }));
     const plugins = config.plugins || [];
     const core = definePlugin({
       config,
@@ -1480,11 +2174,11 @@ Falling back on the first item.
       fileManager: this.fileManager,
       resolvePath: this.resolvePath.bind(this),
       resolveName: this.resolveName.bind(this),
-      getPlugins: chunkI7UUR5MZ_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).bind(this)
+      getPlugins: chunkMM42A6GN_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).bind(this)
     });
-    chunkI7UUR5MZ_cjs.__privateSet(this, _core, chunkI7UUR5MZ_cjs.__privateMethod(this, _parse, parse_fn).call(this, core, this, core.api.call(null)));
-    this.plugins = [chunkI7UUR5MZ_cjs.__privateGet(this, _core), ...plugins].map((plugin) => {
-      return chunkI7UUR5MZ_cjs.__privateMethod(this, _parse, parse_fn).call(this, plugin, this, chunkI7UUR5MZ_cjs.__privateGet(this, _core).api);
+    chunkMM42A6GN_cjs.__privateSet(this, _core, chunkMM42A6GN_cjs.__privateMethod(this, _parse, parse_fn).call(this, core, this, core.api.call(null)));
+    this.plugins = [chunkMM42A6GN_cjs.__privateGet(this, _core), ...plugins].map((plugin) => {
+      return chunkMM42A6GN_cjs.__privateMethod(this, _parse, parse_fn).call(this, plugin, this, chunkMM42A6GN_cjs.__privateGet(this, _core).api);
     });
     return this;
   }
@@ -1504,7 +2198,7 @@ Falling back on the first item.
   }) {
     const plugins = this.getPluginsByKey(hookName, pluginKey);
     const promises = plugins.map((plugin) => {
-      return chunkI7UUR5MZ_cjs.__privateMethod(this, _execute, execute_fn).call(this, {
+      return chunkMM42A6GN_cjs.__privateMethod(this, _execute, execute_fn).call(this, {
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -1523,7 +2217,7 @@ Falling back on the first item.
   }) {
     const plugins = this.getPluginsByKey(hookName, pluginKey);
     return plugins.map((plugin) => {
-      return chunkI7UUR5MZ_cjs.__privateMethod(this, _executeSync, executeSync_fn).call(this, {
+      return chunkMM42A6GN_cjs.__privateMethod(this, _executeSync, executeSync_fn).call(this, {
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -1539,11 +2233,11 @@ Falling back on the first item.
     parameters,
     skipped
   }) {
-    const promises = chunkI7UUR5MZ_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).filter((plugin) => {
+    const promises = chunkMM42A6GN_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).filter((plugin) => {
       return skipped ? skipped.has(plugin) : true;
     }).map((plugin) => {
       return async () => {
-        const value = await chunkI7UUR5MZ_cjs.__privateMethod(this, _execute, execute_fn).call(this, {
+        const value = await chunkMM42A6GN_cjs.__privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1557,7 +2251,7 @@ Falling back on the first item.
         );
       };
     });
-    return chunkI7UUR5MZ_cjs.__privateGet(this, _promiseManager).run("first", promises);
+    return chunkMM42A6GN_cjs.__privateGet(this, _promiseManager).run("first", promises);
   }
   /**
    * First non-null result stops and will return it's value.
@@ -1568,12 +2262,12 @@ Falling back on the first item.
     skipped
   }) {
     let parseResult = null;
-    for (const plugin of chunkI7UUR5MZ_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
+    for (const plugin of chunkMM42A6GN_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       if (skipped && skipped.has(plugin)) {
         continue;
       }
       parseResult = {
-        result: chunkI7UUR5MZ_cjs.__privateMethod(this, _executeSync, executeSync_fn).call(this, {
+        result: chunkMM42A6GN_cjs.__privateMethod(this, _executeSync, executeSync_fn).call(this, {
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1594,14 +2288,14 @@ Falling back on the first item.
     hookName,
     parameters
   }) {
-    const promises = chunkI7UUR5MZ_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
-      return () => chunkI7UUR5MZ_cjs.__privateMethod(this, _execute, execute_fn).call(this, { strategy: "hookParallel", hookName, parameters, plugin });
+    const promises = chunkMM42A6GN_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => chunkMM42A6GN_cjs.__privateMethod(this, _execute, execute_fn).call(this, { strategy: "hookParallel", hookName, parameters, plugin });
     });
-    const results = await chunkI7UUR5MZ_cjs.__privateGet(this, _promiseManager).run("parallel", promises);
+    const results = await chunkMM42A6GN_cjs.__privateGet(this, _promiseManager).run("parallel", promises);
     results.forEach((result, index) => {
       if (isPromiseRejectedResult(result)) {
-        const plugin = chunkI7UUR5MZ_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)[index];
-        chunkI7UUR5MZ_cjs.__privateMethod(this, _catcher, catcher_fn).call(this, result.reason, plugin, hookName);
+        const plugin = chunkMM42A6GN_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)[index];
+        chunkMM42A6GN_cjs.__privateMethod(this, _catcher, catcher_fn).call(this, result.reason, plugin, hookName);
       }
     });
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
@@ -1616,16 +2310,16 @@ Falling back on the first item.
   }) {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
-    for (const plugin of chunkI7UUR5MZ_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
+    for (const plugin of chunkMM42A6GN_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       promise = promise.then((arg0) => {
-        const value = chunkI7UUR5MZ_cjs.__privateMethod(this, _execute, execute_fn).call(this, {
+        const value = chunkMM42A6GN_cjs.__privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookReduceArg0",
           hookName,
           parameters: [arg0, ...rest],
           plugin
         });
         return value;
-      }).then((result) => reduce.call(chunkI7UUR5MZ_cjs.__privateGet(this, _core).api, argument0, result, plugin));
+      }).then((result) => reduce.call(chunkMM42A6GN_cjs.__privateGet(this, _core).api, argument0, result, plugin));
     }
     return promise;
   }
@@ -1633,15 +2327,15 @@ Falling back on the first item.
    * Chains plugins
    */
   async hookSeq({ hookName, parameters }) {
-    const promises = chunkI7UUR5MZ_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
-      return () => chunkI7UUR5MZ_cjs.__privateMethod(this, _execute, execute_fn).call(this, {
+    const promises = chunkMM42A6GN_cjs.__privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => chunkMM42A6GN_cjs.__privateMethod(this, _execute, execute_fn).call(this, {
         strategy: "hookSeq",
         hookName,
         parameters,
         plugin
       });
     });
-    return chunkI7UUR5MZ_cjs.__privateGet(this, _promiseManager).run("seq", promises);
+    return chunkMM42A6GN_cjs.__privateGet(this, _promiseManager).run("seq", promises);
   }
   getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
@@ -1657,11 +2351,11 @@ Falling back on the first item.
     });
     if (!pluginByPluginName?.length) {
       const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
-      if (this.logger.logLevel === chunk77QZQ377_cjs.LogLevel.debug) {
+      if (this.logger.logLevel === chunkGBX7KRCX_cjs.LogLevel.debug) {
         if (corePlugin) {
-          this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`);
+          this.logger.debug(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`);
         } else {
-          this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`);
+          this.logger.debug(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`);
         }
       }
       return corePlugin ? [corePlugin] : [];
@@ -1695,7 +2389,7 @@ _getSortedPlugins = new WeakSet();
 getSortedPlugins_fn = function(hookName) {
   const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
   if (hookName) {
-    if (this.logger.logLevel === chunk77QZQ377_cjs.LogLevel.info) {
+    if (this.logger.logLevel === chunkGBX7KRCX_cjs.LogLevel.info) {
       const containsHookName = plugins.some((item) => item[hookName]);
       if (!containsHookName) {
         this.logger.warn(`No hook ${hookName} found`);
@@ -1743,7 +2437,7 @@ execute_fn = function({
   this.events.emit("execute", { strategy, hookName, parameters, plugin });
   const task = Promise.resolve().then(() => {
     if (typeof hook === "function") {
-      const possiblePromiseResult = hook.apply({ ...chunkI7UUR5MZ_cjs.__privateGet(this, _core).api, plugin }, parameters);
+      const possiblePromiseResult = hook.apply({ ...chunkMM42A6GN_cjs.__privateGet(this, _core).api, plugin }, parameters);
       if (isPromise(possiblePromiseResult)) {
         return Promise.resolve(possiblePromiseResult);
       }
@@ -1752,7 +2446,7 @@ execute_fn = function({
     return hook;
   }).then((result) => {
     output = result;
-    chunkI7UUR5MZ_cjs.__privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
+    chunkMM42A6GN_cjs.__privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
       parameters,
       output,
       strategy,
@@ -1761,7 +2455,7 @@ execute_fn = function({
     });
     return result;
   }).catch((e) => {
-    chunkI7UUR5MZ_cjs.__privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    chunkMM42A6GN_cjs.__privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
     return null;
   });
   return task;
@@ -1781,12 +2475,12 @@ executeSync_fn = function({
   this.events.emit("execute", { strategy, hookName, parameters, plugin });
   try {
     if (typeof hook === "function") {
-      const fn = hook.apply({ ...chunkI7UUR5MZ_cjs.__privateGet(this, _core).api, plugin }, parameters);
+      const fn = hook.apply({ ...chunkMM42A6GN_cjs.__privateGet(this, _core).api, plugin }, parameters);
       output = fn;
       return fn;
     }
     output = hook;
-    chunkI7UUR5MZ_cjs.__privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
+    chunkMM42A6GN_cjs.__privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
       parameters,
       output,
       strategy,
@@ -1795,7 +2489,7 @@ executeSync_fn = function({
     });
     return hook;
   } catch (e) {
-    chunkI7UUR5MZ_cjs.__privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    chunkMM42A6GN_cjs.__privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
     return null;
   }
 };
@@ -1808,12 +2502,9 @@ catcher_fn = function(e, plugin, hookName) {
 };
 _parse = new WeakSet();
 parse_fn = function(plugin, pluginManager, context) {
-  const usedPluginNames = chunkI7UUR5MZ_cjs.__privateGet(pluginManager, _usedPluginNames);
-  chunk72O327DC_cjs.setUniqueName(plugin.name, usedPluginNames);
+  const usedPluginNames = chunkMM42A6GN_cjs.__privateGet(pluginManager, _usedPluginNames);
+  chunkLAS7UYTK_cjs.setUniqueName(plugin.name, usedPluginNames);
   const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
-  if (plugin.name !== "core" && usedPluginNames[plugin.name] >= 2) {
-    pluginManager.logger.warn("Using multiple of the same plugin is an experimental feature");
-  }
   if (!plugin.transform) {
     plugin.transform = function transform(code) {
       return code;
@@ -1838,15 +2529,16 @@ async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
 async function setup(options) {
-  const { config, logger = chunk77QZQ377_cjs.createLogger({ logLevel: chunk77QZQ377_cjs.LogLevel.silent }) } = options;
+  const { config, logger = chunkGBX7KRCX_cjs.createLogger({ logLevel: chunkGBX7KRCX_cjs.LogLevel.silent }) } = options;
+  let count = 0;
   try {
-    if (isInputPath(config) && !new chunk72O327DC_cjs.URLPath(config.input.path).isURL) {
-      await chunkZ7XZQBAK_cjs.read(config.input.path);
+    if (isInputPath(config) && !new chunkLAS7UYTK_cjs.URLPath(config.input.path).isURL) {
+      await chunk35FDNG5F_cjs.read(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 " + chunk77QZQ377_cjs.p.dim(config.input.path),
+        "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + chunkGBX7KRCX_cjs.p.dim(config.input.path),
         {
           cause: e
         }
@@ -1854,78 +2546,97 @@ async function setup(options) {
     }
   }
   if (config.output.clean) {
-    await chunkZ7XZQBAK_cjs.clean(config.output.path);
+    await chunk35FDNG5F_cjs.clean(config.output.path);
   }
-  const queueTask = async (file) => {
+  const task = async (file) => {
     const { path: path5 } = file;
-    let code = FileManager.getSource(file);
+    let source = FileManager.getSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
       parameters: [path5]
     });
     if (loadedResult && isPromise(loadedResult)) {
-      code = await loadedResult;
+      source = await loadedResult;
     }
     if (loadedResult && !isPromise(loadedResult)) {
-      code = loadedResult;
+      source = loadedResult;
     }
-    if (code) {
-      const transformedCode = await pluginManager.hookReduceArg0({
+    if (source) {
+      source = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path5],
+        parameters: [source, path5],
         reduce: transformReducer
       });
       if (config.output.write || config.output.write === void 0) {
         if (file.meta?.pluginKey) {
-          return pluginManager.hookForPlugin({
+          await pluginManager.hookForPlugin({
             pluginKey: file.meta?.pluginKey,
             hookName: "writeFile",
-            parameters: [transformedCode, path5]
+            parameters: [source, path5]
           });
         }
-        return pluginManager.hookFirst({
+        await pluginManager.hookFirst({
           hookName: "writeFile",
-          parameters: [transformedCode, path5]
+          parameters: [source, path5]
         });
       }
     }
+    return {
+      ...file,
+      source: source || ""
+    };
   };
-  const pluginManager = new PluginManager(config, { logger, task: queueTask, writeTimeout: 0 });
+  const pluginManager = new PluginManager(config, { logger, task });
   pluginManager.on("execute", (executer) => {
     const { hookName, parameters, plugin } = executer;
     if (hookName === "writeFile" && logger.spinner) {
       const [code] = parameters;
-      if (logger.logLevel === chunk77QZQ377_cjs.LogLevel.info) {
-        logger.spinner.start(`\u{1F4BE} Writing`);
-      }
-      if (logger.logLevel === chunk77QZQ377_cjs.LogLevel.debug) {
-        logger.info(`PluginKey ${chunk77QZQ377_cjs.p.dim(JSON.stringify(plugin.key))} 
+      if (logger.logLevel === chunkGBX7KRCX_cjs.LogLevel.debug) {
+        logger.debug(`PluginKey ${chunkGBX7KRCX_cjs.p.dim(JSON.stringify(plugin.key))} 
 with source
 
 ${code}`);
       }
     }
   });
+  pluginManager.queue.on("add", () => {
+    if (logger.logLevel !== chunkGBX7KRCX_cjs.LogLevel.info) {
+      return;
+    }
+    if (logger.spinner && count === 0) {
+      logger.spinner?.start(`\u{1F4BE} Writing`);
+    }
+  });
+  pluginManager.queue.on("active", () => {
+    if (logger.logLevel !== chunkGBX7KRCX_cjs.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 = chunkGBX7KRCX_cjs.p.dim(text);
+    }
+    ++count;
+  });
+  pluginManager.queue.on("completed", () => {
+    if (logger.logLevel !== chunkGBX7KRCX_cjs.LogLevel.info) {
+      return;
+    }
+    if (logger.spinner) {
+      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`;
+      logger.spinner.suffixText = chunkGBX7KRCX_cjs.p.dim(text);
+    }
+  });
   pluginManager.on("executed", (executer) => {
     const { hookName, plugin, output, parameters } = executer;
-    const messsage = `${chunk77QZQ377_cjs.randomCliColour(plugin.name)} Executing ${hookName}`;
-    if (logger.logLevel === chunk77QZQ377_cjs.LogLevel.info && logger.spinner) {
-      if (hookName === "writeFile") {
-        const [_code, path5] = parameters;
-        logger.spinner.suffixText = chunk77QZQ377_cjs.p.dim(path5);
-      } else {
-        logger.spinner.suffixText = messsage;
-      }
-    }
-    if (logger.logLevel === chunk77QZQ377_cjs.LogLevel.debug) {
-      logger.info(messsage);
+    if (logger.logLevel === chunkGBX7KRCX_cjs.LogLevel.debug) {
       const logs = [
-        parameters && `${chunk77QZQ377_cjs.p.bgWhite(`Parameters`)} ${chunk77QZQ377_cjs.randomCliColour(plugin.name)} ${hookName}`,
+        `${chunkGBX7KRCX_cjs.randomCliColour(plugin.name)} Executing ${hookName}`,
+        parameters && `${chunkGBX7KRCX_cjs.p.bgWhite(`Parameters`)} ${chunkGBX7KRCX_cjs.randomCliColour(plugin.name)} ${hookName}`,
         JSON.stringify(parameters, void 0, 2),
-        output && `${chunk77QZQ377_cjs.p.bgWhite("Output")} ${chunk77QZQ377_cjs.randomCliColour(plugin.name)} ${hookName}`,
+        output && `${chunkGBX7KRCX_cjs.p.bgWhite("Output")} ${chunkGBX7KRCX_cjs.randomCliColour(plugin.name)} ${hookName}`,
         output
       ].filter(Boolean);
-      console.log(logs.join("\n"));
+      logger.debug(logs.join("\n"));
     }
   });
   return pluginManager;
@@ -1938,7 +2649,7 @@ async function build(options) {
     parameters: [options.config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  if (!fileManager.isExecuting && logger.spinner) {
+  if (logger.logLevel === chunkGBX7KRCX_cjs.LogLevel.info && logger.spinner) {
     logger.spinner.suffixText = "";
     logger.spinner.succeed(`\u{1F4BE} Writing completed`);
   }
@@ -1953,7 +2664,7 @@ async function safeBuild(options) {
       parameters: [options.config]
     });
     await pluginManager.hookParallel({ hookName: "buildEnd" });
-    if (!fileManager.isExecuting && logger.spinner) {
+    if (logger.logLevel === chunkGBX7KRCX_cjs.LogLevel.info && logger.spinner) {
       logger.spinner.suffixText = "";
       logger.spinner.succeed(`\u{1F4BE} Writing completed`);
     }
@@ -1964,95 +2675,95 @@ async function safeBuild(options) {
 }
 
 // src/Generator.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 var _options3, _context;
 var Generator = class {
   constructor(options, context) {
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _options3, {});
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _context, {});
+    chunkMM42A6GN_cjs.__privateAdd(this, _options3, {});
+    chunkMM42A6GN_cjs.__privateAdd(this, _context, {});
     if (context) {
-      chunkI7UUR5MZ_cjs.__privateSet(this, _context, context);
+      chunkMM42A6GN_cjs.__privateSet(this, _context, context);
     }
     if (options) {
-      chunkI7UUR5MZ_cjs.__privateSet(this, _options3, options);
+      chunkMM42A6GN_cjs.__privateSet(this, _options3, options);
     }
     return this;
   }
   get options() {
-    return chunkI7UUR5MZ_cjs.__privateGet(this, _options3);
+    return chunkMM42A6GN_cjs.__privateGet(this, _options3);
   }
   get context() {
-    return chunkI7UUR5MZ_cjs.__privateGet(this, _context);
+    return chunkMM42A6GN_cjs.__privateGet(this, _context);
   }
   set options(options) {
-    chunkI7UUR5MZ_cjs.__privateSet(this, _options3, { ...chunkI7UUR5MZ_cjs.__privateGet(this, _options3), ...options });
+    chunkMM42A6GN_cjs.__privateSet(this, _options3, { ...chunkMM42A6GN_cjs.__privateGet(this, _options3), ...options });
   }
 };
 _options3 = new WeakMap();
 _context = new WeakMap();
 
 // src/PackageManager.ts
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // ../../node_modules/.pnpm/find-up@7.0.0/node_modules/find-up/index.js
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // ../../node_modules/.pnpm/locate-path@7.2.0/node_modules/locate-path/index.js
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // ../../node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 var Node = class {
   constructor(value) {
-    chunkI7UUR5MZ_cjs.__publicField(this, "value");
-    chunkI7UUR5MZ_cjs.__publicField(this, "next");
+    chunkMM42A6GN_cjs.__publicField(this, "value");
+    chunkMM42A6GN_cjs.__publicField(this, "next");
     this.value = value;
   }
 };
 var _head, _tail, _size;
-var Queue2 = class {
+var Queue = class {
   constructor() {
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _head, void 0);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _tail, void 0);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _size, void 0);
+    chunkMM42A6GN_cjs.__privateAdd(this, _head, void 0);
+    chunkMM42A6GN_cjs.__privateAdd(this, _tail, void 0);
+    chunkMM42A6GN_cjs.__privateAdd(this, _size, void 0);
     this.clear();
   }
   enqueue(value) {
     const node = new Node(value);
-    if (chunkI7UUR5MZ_cjs.__privateGet(this, _head)) {
-      chunkI7UUR5MZ_cjs.__privateGet(this, _tail).next = node;
-      chunkI7UUR5MZ_cjs.__privateSet(this, _tail, node);
+    if (chunkMM42A6GN_cjs.__privateGet(this, _head)) {
+      chunkMM42A6GN_cjs.__privateGet(this, _tail).next = node;
+      chunkMM42A6GN_cjs.__privateSet(this, _tail, node);
     } else {
-      chunkI7UUR5MZ_cjs.__privateSet(this, _head, node);
-      chunkI7UUR5MZ_cjs.__privateSet(this, _tail, node);
+      chunkMM42A6GN_cjs.__privateSet(this, _head, node);
+      chunkMM42A6GN_cjs.__privateSet(this, _tail, node);
     }
-    chunkI7UUR5MZ_cjs.__privateWrapper(this, _size)._++;
+    chunkMM42A6GN_cjs.__privateWrapper(this, _size)._++;
   }
   dequeue() {
-    const current = chunkI7UUR5MZ_cjs.__privateGet(this, _head);
+    const current = chunkMM42A6GN_cjs.__privateGet(this, _head);
     if (!current) {
       return;
     }
-    chunkI7UUR5MZ_cjs.__privateSet(this, _head, chunkI7UUR5MZ_cjs.__privateGet(this, _head).next);
-    chunkI7UUR5MZ_cjs.__privateWrapper(this, _size)._--;
+    chunkMM42A6GN_cjs.__privateSet(this, _head, chunkMM42A6GN_cjs.__privateGet(this, _head).next);
+    chunkMM42A6GN_cjs.__privateWrapper(this, _size)._--;
     return current.value;
   }
   clear() {
-    chunkI7UUR5MZ_cjs.__privateSet(this, _head, void 0);
-    chunkI7UUR5MZ_cjs.__privateSet(this, _tail, void 0);
-    chunkI7UUR5MZ_cjs.__privateSet(this, _size, 0);
+    chunkMM42A6GN_cjs.__privateSet(this, _head, void 0);
+    chunkMM42A6GN_cjs.__privateSet(this, _tail, void 0);
+    chunkMM42A6GN_cjs.__privateSet(this, _size, 0);
   }
   get size() {
-    return chunkI7UUR5MZ_cjs.__privateGet(this, _size);
+    return chunkMM42A6GN_cjs.__privateGet(this, _size);
   }
   *[Symbol.iterator]() {
-    let current = chunkI7UUR5MZ_cjs.__privateGet(this, _head);
+    let current = chunkMM42A6GN_cjs.__privateGet(this, _head);
     while (current) {
       yield current.value;
       current = current.next;
@@ -2068,7 +2779,7 @@ 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 Queue2();
+  const queue = new Queue();
   let activeCount = 0;
   const next = () => {
     activeCount--;
@@ -2203,13 +2914,13 @@ function locatePathSync(paths, {
 }
 
 // ../../node_modules/.pnpm/unicorn-magic@0.1.0/node_modules/unicorn-magic/node.js
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 function toPath2(urlOrPath) {
   return urlOrPath instanceof URL ? url.fileURLToPath(urlOrPath) : urlOrPath;
 }
 
 // ../../node_modules/.pnpm/path-exists@5.0.0/node_modules/path-exists/index.js
-chunkI7UUR5MZ_cjs.init_cjs_shims();
+chunkMM42A6GN_cjs.init_cjs_shims();
 
 // ../../node_modules/.pnpm/find-up@7.0.0/node_modules/find-up/index.js
 var findUpStop = Symbol("findUpStop");
@@ -2288,30 +2999,30 @@ function findUpSync(name, options = {}) {
 var _cache2, _cwd, _SLASHES, _match, match_fn;
 var _PackageManager = class _PackageManager {
   constructor(workspace) {
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _match);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _cwd, void 0);
-    chunkI7UUR5MZ_cjs.__privateAdd(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
+    chunkMM42A6GN_cjs.__privateAdd(this, _match);
+    chunkMM42A6GN_cjs.__privateAdd(this, _cwd, void 0);
+    chunkMM42A6GN_cjs.__privateAdd(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
     if (workspace) {
-      chunkI7UUR5MZ_cjs.__privateSet(this, _cwd, workspace);
+      chunkMM42A6GN_cjs.__privateSet(this, _cwd, workspace);
     }
     return this;
   }
   set workspace(workspace) {
-    chunkI7UUR5MZ_cjs.__privateSet(this, _cwd, workspace);
+    chunkMM42A6GN_cjs.__privateSet(this, _cwd, workspace);
   }
   get workspace() {
-    return chunkI7UUR5MZ_cjs.__privateGet(this, _cwd);
+    return chunkMM42A6GN_cjs.__privateGet(this, _cwd);
   }
   normalizeDirectory(directory) {
-    if (!chunkI7UUR5MZ_cjs.__privateGet(this, _SLASHES).has(directory[directory.length - 1])) {
+    if (!chunkMM42A6GN_cjs.__privateGet(this, _SLASHES).has(directory[directory.length - 1])) {
       return `${directory}/`;
     }
     return directory;
   }
   getLocation(path5) {
     let location = path5;
-    if (chunkI7UUR5MZ_cjs.__privateGet(this, _cwd)) {
-      const require2 = mod__default.default.createRequire(this.normalizeDirectory(chunkI7UUR5MZ_cjs.__privateGet(this, _cwd)));
+    if (chunkMM42A6GN_cjs.__privateGet(this, _cwd)) {
+      const require2 = mod__default.default.createRequire(this.normalizeDirectory(chunkMM42A6GN_cjs.__privateGet(this, _cwd)));
       location = require2.resolve(path5);
     }
     return location;
@@ -2331,44 +3042,44 @@ var _PackageManager = class _PackageManager {
   }
   async getPackageJSON() {
     const pkgPath = await findUp(["package.json"], {
-      cwd: chunkI7UUR5MZ_cjs.__privateGet(this, _cwd)
+      cwd: chunkMM42A6GN_cjs.__privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
     }
-    return chunkI7UUR5MZ_cjs.__require(pkgPath);
+    return chunkMM42A6GN_cjs.__require(pkgPath);
   }
   getPackageJSONSync() {
     const pkgPath = findUpSync(["package.json"], {
-      cwd: chunkI7UUR5MZ_cjs.__privateGet(this, _cwd)
+      cwd: chunkMM42A6GN_cjs.__privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
     }
-    return chunkI7UUR5MZ_cjs.__require(pkgPath);
+    return chunkMM42A6GN_cjs.__require(pkgPath);
   }
   static setVersion(dependency, version) {
-    chunkI7UUR5MZ_cjs.__privateGet(_PackageManager, _cache2)[dependency] = version;
+    chunkMM42A6GN_cjs.__privateGet(_PackageManager, _cache2)[dependency] = version;
   }
   async getVersion(dependency) {
-    if (typeof dependency === "string" && chunkI7UUR5MZ_cjs.__privateGet(_PackageManager, _cache2)[dependency]) {
-      return chunkI7UUR5MZ_cjs.__privateGet(_PackageManager, _cache2)[dependency];
+    if (typeof dependency === "string" && chunkMM42A6GN_cjs.__privateGet(_PackageManager, _cache2)[dependency]) {
+      return chunkMM42A6GN_cjs.__privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = await this.getPackageJSON();
     if (!packageJSON) {
       return void 0;
     }
-    return chunkI7UUR5MZ_cjs.__privateMethod(this, _match, match_fn).call(this, packageJSON, dependency);
+    return chunkMM42A6GN_cjs.__privateMethod(this, _match, match_fn).call(this, packageJSON, dependency);
   }
   getVersionSync(dependency) {
-    if (typeof dependency === "string" && chunkI7UUR5MZ_cjs.__privateGet(_PackageManager, _cache2)[dependency]) {
-      return chunkI7UUR5MZ_cjs.__privateGet(_PackageManager, _cache2)[dependency];
+    if (typeof dependency === "string" && chunkMM42A6GN_cjs.__privateGet(_PackageManager, _cache2)[dependency]) {
+      return chunkMM42A6GN_cjs.__privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = this.getPackageJSONSync();
     if (!packageJSON) {
       return void 0;
     }
-    return chunkI7UUR5MZ_cjs.__privateMethod(this, _match, match_fn).call(this, packageJSON, dependency);
+    return chunkMM42A6GN_cjs.__privateMethod(this, _match, match_fn).call(this, packageJSON, dependency);
   }
   async isValid(dependency, version) {
     const packageVersion = await this.getVersion(dependency);
@@ -2411,7 +3122,7 @@ match_fn = function(packageJSON, dependency) {
   const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
   return matchedDependency ? dependencies[matchedDependency] : void 0;
 };
-chunkI7UUR5MZ_cjs.__privateAdd(_PackageManager, _cache2, {});
+chunkMM42A6GN_cjs.__privateAdd(_PackageManager, _cache2, {});
 var PackageManager = _PackageManager;
 
 // src/index.ts