@kubb/core 2.0.0-canary.20231030T124950 → 2.0.0

package/dist/index.js

@@ -1,253 +1,736 @@
 import mod, { createRequire } from 'module';
-import pc3 from 'picocolors';
-import fs2, { remove } from 'fs-extra';
-import seedrandom from 'seedrandom';
-import { switcher } from 'js-runtime';
-import { camelCase, camelCaseTransformMerge } from 'change-case';
-import crypto2 from 'crypto';
-import path, { resolve, dirname, extname } from 'path';
+import { transformReservedWord, trimExtName, searchAndReplace } from './chunk-HIE46T3F.js';
+import { setUniqueName, URLPath } from './chunk-4A7WG6IA.js';
+import './chunk-XPOF4D5N.js';
+import { LogLevel, createLogger, p, randomCliColour } from './chunk-K2H7BYQB.js';
+import { read, getRelativePath, clean } from './chunk-NAWI7UXW.js';
+import { write } from './chunk-7S67BJXQ.js';
+import { __commonJS, init_esm_shims, __toESM, __privateAdd, __privateSet, __privateGet, __privateMethod, __require } from './chunk-54P4AWHI.js';
+import crypto from 'crypto';
+import path, { resolve, extname } from 'path';
 import { print } from '@kubb/parser';
 import * as factory from '@kubb/parser/factory';
-import isEqual from 'lodash.isequal';
 import { orderBy } from 'natural-orderby';
+import PQueue from 'p-queue';
 import dirTree from 'directory-tree';
 import { EventEmitter as EventEmitter$1 } from 'events';
-import { performance } from 'perf_hooks';
 import os from 'os';
 import { pathToFileURL } from 'url';
 import { findUp, findUpSync } from 'find-up';
 import { coerce, satisfies } from 'semver';
 
-const require = createRequire(import.meta.url);
-  
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value, setter);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-async function clean(path3) {
-  return remove(path3);
-}
-var LogLevel = {
-  silent: "silent",
-  info: "info",
-  debug: "debug"
-};
-function createLogger({ logLevel, name, spinner }) {
-  const logs = [];
-  const log = (message) => {
-    if (message && spinner) {
-      spinner.text = message;
-      logs.push(message);
+createRequire(import.meta.url);
+
+// ../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js
+var require_lodash = __commonJS({
+  "../../node_modules/.pnpm/lodash.isequal@4.5.0/node_modules/lodash.isequal/index.js"(exports, module) {
+    init_esm_shims();
+    var LARGE_ARRAY_SIZE = 200;
+    var HASH_UNDEFINED = "__lodash_hash_undefined__";
+    var COMPARE_PARTIAL_FLAG = 1;
+    var COMPARE_UNORDERED_FLAG = 2;
+    var MAX_SAFE_INTEGER = 9007199254740991;
+    var argsTag = "[object Arguments]";
+    var arrayTag = "[object Array]";
+    var asyncTag = "[object AsyncFunction]";
+    var boolTag = "[object Boolean]";
+    var dateTag = "[object Date]";
+    var errorTag = "[object Error]";
+    var funcTag = "[object Function]";
+    var genTag = "[object GeneratorFunction]";
+    var mapTag = "[object Map]";
+    var numberTag = "[object Number]";
+    var nullTag = "[object Null]";
+    var objectTag = "[object Object]";
+    var promiseTag = "[object Promise]";
+    var proxyTag = "[object Proxy]";
+    var regexpTag = "[object RegExp]";
+    var setTag = "[object Set]";
+    var stringTag = "[object String]";
+    var symbolTag = "[object Symbol]";
+    var undefinedTag = "[object Undefined]";
+    var weakMapTag = "[object WeakMap]";
+    var arrayBufferTag = "[object ArrayBuffer]";
+    var dataViewTag = "[object DataView]";
+    var float32Tag = "[object Float32Array]";
+    var float64Tag = "[object Float64Array]";
+    var int8Tag = "[object Int8Array]";
+    var int16Tag = "[object Int16Array]";
+    var int32Tag = "[object Int32Array]";
+    var uint8Tag = "[object Uint8Array]";
+    var uint8ClampedTag = "[object Uint8ClampedArray]";
+    var uint16Tag = "[object Uint16Array]";
+    var uint32Tag = "[object Uint32Array]";
+    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+    var reIsHostCtor = /^\[object .+?Constructor\]$/;
+    var reIsUint = /^(?:0|[1-9]\d*)$/;
+    var typedArrayTags = {};
+    typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+    var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+    var moduleExports = freeModule && freeModule.exports === freeExports;
+    var freeProcess = moduleExports && freeGlobal.process;
+    var nodeUtil = function() {
+      try {
+        return freeProcess && freeProcess.binding && freeProcess.binding("util");
+      } catch (e) {
+      }
+    }();
+    var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+    function arrayFilter(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+      while (++index < length) {
+        var value = array[index];
+        if (predicate(value, index, array)) {
+          result[resIndex++] = value;
+        }
+      }
+      return result;
     }
-  };
-  const error = (message) => {
-    if (message) {
-      throw new Error(message || "Something went wrong");
+    function arrayPush(array, values) {
+      var index = -1, length = values.length, offset = array.length;
+      while (++index < length) {
+        array[offset + index] = values[index];
+      }
+      return array;
     }
-  };
-  const warn = (message) => {
-    if (message && spinner) {
-      spinner.warn(pc3.yellow(message));
-      logs.push(message);
+    function arraySome(array, predicate) {
+      var index = -1, length = array == null ? 0 : array.length;
+      while (++index < length) {
+        if (predicate(array[index], index, array)) {
+          return true;
+        }
+      }
+      return false;
     }
-  };
-  const info = (message) => {
-    if (message && spinner) {
-      spinner.info(message);
-      logs.push(message);
+    function baseTimes(n, iteratee) {
+      var index = -1, result = Array(n);
+      while (++index < n) {
+        result[index] = iteratee(index);
+      }
+      return result;
     }
-  };
-  const logger = {
-    name,
-    logLevel,
-    log,
-    error,
-    warn,
-    info,
-    spinner,
-    logs
-  };
-  return logger;
-}
-var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
-function randomColour(text, colours = defaultColours) {
-  if (!text) {
-    return "white";
-  }
-  const random = seedrandom(text);
-  const colour = colours.at(Math.floor(random() * colours.length)) || "white";
-  return colour;
-}
-function randomPicoColour(text, colors = defaultColours) {
-  const colours = pc3.createColors(true);
-  if (!text) {
-    return colours.white(text);
-  }
-  const colour = randomColour(text, colors);
-  const isDark = colour.includes("dark");
-  const key = colour.replace("dark", "").toLowerCase();
-  const formatter = colours[key];
-  if (isDark) {
-    return pc3.bold(formatter(text));
-  }
-  if (typeof formatter !== "function") {
-    throw new Error("Formatter for picoColor is not of type function/Formatter");
-  }
-  return formatter(text);
-}
-var reader = switcher(
-  {
-    node: async (path3) => {
-      return fs2.readFile(path3, { encoding: "utf8" });
-    },
-    bun: async (path3) => {
-      const file = Bun.file(path3);
-      return file.text();
-    }
-  },
-  "node"
-);
-switcher(
-  {
-    node: (path3) => {
-      return fs2.readFileSync(path3, { encoding: "utf8" });
-    },
-    bun: () => {
-      throw new Error("Bun cannot read sync");
-    }
-  },
-  "node"
-);
-async function read(path3) {
-  return reader(path3);
-}
-var URLPath = class {
-  constructor(path3) {
-    this.path = path3;
-    return this;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  get URL() {
-    return this.toURLPath();
-  }
-  get isURL() {
-    try {
-      const url = new URL(this.path);
-      if (url?.href) {
+    function baseUnary(func) {
+      return function(value) {
+        return func(value);
+      };
+    }
+    function cacheHas(cache, key) {
+      return cache.has(key);
+    }
+    function getValue(object, key) {
+      return object == null ? void 0 : object[key];
+    }
+    function mapToArray(map) {
+      var index = -1, result = Array(map.size);
+      map.forEach(function(value, key) {
+        result[++index] = [key, value];
+      });
+      return result;
+    }
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
+      };
+    }
+    function setToArray(set) {
+      var index = -1, result = Array(set.size);
+      set.forEach(function(value) {
+        result[++index] = value;
+      });
+      return result;
+    }
+    var arrayProto = Array.prototype;
+    var funcProto = Function.prototype;
+    var objectProto = Object.prototype;
+    var coreJsData = root["__core-js_shared__"];
+    var funcToString = funcProto.toString;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var maskSrcKey = function() {
+      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+      return uid ? "Symbol(src)_1." + uid : "";
+    }();
+    var nativeObjectToString = objectProto.toString;
+    var reIsNative = RegExp(
+      "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+    );
+    var Buffer = moduleExports ? root.Buffer : void 0;
+    var Symbol = root.Symbol;
+    var Uint8Array = root.Uint8Array;
+    var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+    var splice = arrayProto.splice;
+    var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+    var nativeGetSymbols = Object.getOwnPropertySymbols;
+    var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+    var nativeKeys = overArg(Object.keys, Object);
+    var DataView = getNative(root, "DataView");
+    var Map2 = getNative(root, "Map");
+    var Promise2 = getNative(root, "Promise");
+    var Set2 = getNative(root, "Set");
+    var WeakMap2 = getNative(root, "WeakMap");
+    var nativeCreate = getNative(Object, "create");
+    var dataViewCtorString = toSource(DataView);
+    var mapCtorString = toSource(Map2);
+    var promiseCtorString = toSource(Promise2);
+    var setCtorString = toSource(Set2);
+    var weakMapCtorString = toSource(WeakMap2);
+    var symbolProto = Symbol ? Symbol.prototype : void 0;
+    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+    function Hash(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function hashClear() {
+      this.__data__ = nativeCreate ? nativeCreate(null) : {};
+      this.size = 0;
+    }
+    function hashDelete(key) {
+      var result = this.has(key) && delete this.__data__[key];
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function hashGet(key) {
+      var data = this.__data__;
+      if (nativeCreate) {
+        var result = data[key];
+        return result === HASH_UNDEFINED ? void 0 : result;
+      }
+      return hasOwnProperty.call(data, key) ? data[key] : void 0;
+    }
+    function hashHas(key) {
+      var data = this.__data__;
+      return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+    }
+    function hashSet(key, value) {
+      var data = this.__data__;
+      this.size += this.has(key) ? 0 : 1;
+      data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+      return this;
+    }
+    Hash.prototype.clear = hashClear;
+    Hash.prototype["delete"] = hashDelete;
+    Hash.prototype.get = hashGet;
+    Hash.prototype.has = hashHas;
+    Hash.prototype.set = hashSet;
+    function ListCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function listCacheClear() {
+      this.__data__ = [];
+      this.size = 0;
+    }
+    function listCacheDelete(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        return false;
+      }
+      var lastIndex = data.length - 1;
+      if (index == lastIndex) {
+        data.pop();
+      } else {
+        splice.call(data, index, 1);
+      }
+      --this.size;
+      return true;
+    }
+    function listCacheGet(key) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      return index < 0 ? void 0 : data[index][1];
+    }
+    function listCacheHas(key) {
+      return assocIndexOf(this.__data__, key) > -1;
+    }
+    function listCacheSet(key, value) {
+      var data = this.__data__, index = assocIndexOf(data, key);
+      if (index < 0) {
+        ++this.size;
+        data.push([key, value]);
+      } else {
+        data[index][1] = value;
+      }
+      return this;
+    }
+    ListCache.prototype.clear = listCacheClear;
+    ListCache.prototype["delete"] = listCacheDelete;
+    ListCache.prototype.get = listCacheGet;
+    ListCache.prototype.has = listCacheHas;
+    ListCache.prototype.set = listCacheSet;
+    function MapCache(entries) {
+      var index = -1, length = entries == null ? 0 : entries.length;
+      this.clear();
+      while (++index < length) {
+        var entry = entries[index];
+        this.set(entry[0], entry[1]);
+      }
+    }
+    function mapCacheClear() {
+      this.size = 0;
+      this.__data__ = {
+        "hash": new Hash(),
+        "map": new (Map2 || ListCache)(),
+        "string": new Hash()
+      };
+    }
+    function mapCacheDelete(key) {
+      var result = getMapData(this, key)["delete"](key);
+      this.size -= result ? 1 : 0;
+      return result;
+    }
+    function mapCacheGet(key) {
+      return getMapData(this, key).get(key);
+    }
+    function mapCacheHas(key) {
+      return getMapData(this, key).has(key);
+    }
+    function mapCacheSet(key, value) {
+      var data = getMapData(this, key), size = data.size;
+      data.set(key, value);
+      this.size += data.size == size ? 0 : 1;
+      return this;
+    }
+    MapCache.prototype.clear = mapCacheClear;
+    MapCache.prototype["delete"] = mapCacheDelete;
+    MapCache.prototype.get = mapCacheGet;
+    MapCache.prototype.has = mapCacheHas;
+    MapCache.prototype.set = mapCacheSet;
+    function SetCache(values) {
+      var index = -1, length = values == null ? 0 : values.length;
+      this.__data__ = new MapCache();
+      while (++index < length) {
+        this.add(values[index]);
+      }
+    }
+    function setCacheAdd(value) {
+      this.__data__.set(value, HASH_UNDEFINED);
+      return this;
+    }
+    function setCacheHas(value) {
+      return this.__data__.has(value);
+    }
+    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+    SetCache.prototype.has = setCacheHas;
+    function Stack(entries) {
+      var data = this.__data__ = new ListCache(entries);
+      this.size = data.size;
+    }
+    function stackClear() {
+      this.__data__ = new ListCache();
+      this.size = 0;
+    }
+    function stackDelete(key) {
+      var data = this.__data__, result = data["delete"](key);
+      this.size = data.size;
+      return result;
+    }
+    function stackGet(key) {
+      return this.__data__.get(key);
+    }
+    function stackHas(key) {
+      return this.__data__.has(key);
+    }
+    function stackSet(key, value) {
+      var data = this.__data__;
+      if (data instanceof ListCache) {
+        var pairs = data.__data__;
+        if (!Map2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+          pairs.push([key, value]);
+          this.size = ++data.size;
+          return this;
+        }
+        data = this.__data__ = new MapCache(pairs);
+      }
+      data.set(key, value);
+      this.size = data.size;
+      return this;
+    }
+    Stack.prototype.clear = stackClear;
+    Stack.prototype["delete"] = stackDelete;
+    Stack.prototype.get = stackGet;
+    Stack.prototype.has = stackHas;
+    Stack.prototype.set = stackSet;
+    function arrayLikeKeys(value, inherited) {
+      var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+      for (var key in value) {
+        if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+        (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+        isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+        isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+        isIndex(key, length)))) {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function assocIndexOf(array, key) {
+      var length = array.length;
+      while (length--) {
+        if (eq(array[length][0], key)) {
+          return length;
+        }
+      }
+      return -1;
+    }
+    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+      var result = keysFunc(object);
+      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+    }
+    function baseGetTag(value) {
+      if (value == null) {
+        return value === void 0 ? undefinedTag : nullTag;
+      }
+      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+    }
+    function baseIsArguments(value) {
+      return isObjectLike(value) && baseGetTag(value) == argsTag;
+    }
+    function baseIsEqual(value, other, bitmask, customizer, stack) {
+      if (value === other) {
         return true;
       }
-    } catch (error) {
+      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+        return value !== value && other !== other;
+      }
+      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+    }
+    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+      var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+      objTag = objTag == argsTag ? objectTag : objTag;
+      othTag = othTag == argsTag ? objectTag : othTag;
+      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+      if (isSameTag && isBuffer(object)) {
+        if (!isBuffer(other)) {
+          return false;
+        }
+        objIsArr = true;
+        objIsObj = false;
+      }
+      if (isSameTag && !objIsObj) {
+        stack || (stack = new Stack());
+        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+      }
+      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+        var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+        if (objIsWrapped || othIsWrapped) {
+          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+          stack || (stack = new Stack());
+          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+        }
+      }
+      if (!isSameTag) {
+        return false;
+      }
+      stack || (stack = new Stack());
+      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+    }
+    function baseIsNative(value) {
+      if (!isObject(value) || isMasked(value)) {
+        return false;
+      }
+      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+      return pattern.test(toSource(value));
+    }
+    function baseIsTypedArray(value) {
+      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+    }
+    function baseKeys(object) {
+      if (!isPrototype(object)) {
+        return nativeKeys(object);
+      }
+      var result = [];
+      for (var key in Object(object)) {
+        if (hasOwnProperty.call(object, key) && key != "constructor") {
+          result.push(key);
+        }
+      }
+      return result;
+    }
+    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+        return false;
+      }
+      var stacked = stack.get(array);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
+      stack.set(array, other);
+      stack.set(other, array);
+      while (++index < arrLength) {
+        var arrValue = array[index], othValue = other[index];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+        }
+        if (compared !== void 0) {
+          if (compared) {
+            continue;
+          }
+          result = false;
+          break;
+        }
+        if (seen) {
+          if (!arraySome(other, function(othValue2, othIndex) {
+            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+              return seen.push(othIndex);
+            }
+          })) {
+            result = false;
+            break;
+          }
+        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+          result = false;
+          break;
+        }
+      }
+      stack["delete"](array);
+      stack["delete"](other);
+      return result;
+    }
+    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+      switch (tag) {
+        case dataViewTag:
+          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+            return false;
+          }
+          object = object.buffer;
+          other = other.buffer;
+        case arrayBufferTag:
+          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+            return false;
+          }
+          return true;
+        case boolTag:
+        case dateTag:
+        case numberTag:
+          return eq(+object, +other);
+        case errorTag:
+          return object.name == other.name && object.message == other.message;
+        case regexpTag:
+        case stringTag:
+          return object == other + "";
+        case mapTag:
+          var convert = mapToArray;
+        case setTag:
+          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+          convert || (convert = setToArray);
+          if (object.size != other.size && !isPartial) {
+            return false;
+          }
+          var stacked = stack.get(object);
+          if (stacked) {
+            return stacked == other;
+          }
+          bitmask |= COMPARE_UNORDERED_FLAG;
+          stack.set(object, other);
+          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+          stack["delete"](object);
+          return result;
+        case symbolTag:
+          if (symbolValueOf) {
+            return symbolValueOf.call(object) == symbolValueOf.call(other);
+          }
+      }
       return false;
     }
-    return false;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  get template() {
-    return this.toTemplateString();
-  }
-  get object() {
-    return this.toObject();
-  }
-  get params() {
-    return this.getParams();
-  }
-  toObject({ type = "path", replacer, stringify } = {}) {
-    const object = {
-      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
-      params: this.getParams()
+    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+      if (objLength != othLength && !isPartial) {
+        return false;
+      }
+      var index = objLength;
+      while (index--) {
+        var key = objProps[index];
+        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+          return false;
+        }
+      }
+      var stacked = stack.get(object);
+      if (stacked && stack.get(other)) {
+        return stacked == other;
+      }
+      var result = true;
+      stack.set(object, other);
+      stack.set(other, object);
+      var skipCtor = isPartial;
+      while (++index < objLength) {
+        key = objProps[index];
+        var objValue = object[key], othValue = other[key];
+        if (customizer) {
+          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+        }
+        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+          result = false;
+          break;
+        }
+        skipCtor || (skipCtor = key == "constructor");
+      }
+      if (result && !skipCtor) {
+        var objCtor = object.constructor, othCtor = other.constructor;
+        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+          result = false;
+        }
+      }
+      stack["delete"](object);
+      stack["delete"](other);
+      return result;
+    }
+    function getAllKeys(object) {
+      return baseGetAllKeys(object, keys, getSymbols);
+    }
+    function getMapData(map, key) {
+      var data = map.__data__;
+      return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+    }
+    function getNative(object, key) {
+      var value = getValue(object, key);
+      return baseIsNative(value) ? value : void 0;
+    }
+    function getRawTag(value) {
+      var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+      try {
+        value[symToStringTag] = void 0;
+        var unmasked = true;
+      } catch (e) {
+      }
+      var result = nativeObjectToString.call(value);
+      if (unmasked) {
+        if (isOwn) {
+          value[symToStringTag] = tag;
+        } else {
+          delete value[symToStringTag];
+        }
+      }
+      return result;
+    }
+    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+      if (object == null) {
+        return [];
+      }
+      object = Object(object);
+      return arrayFilter(nativeGetSymbols(object), function(symbol) {
+        return propertyIsEnumerable.call(object, symbol);
+      });
     };
-    if (stringify) {
-      if (type !== "template") {
-        throw new Error("Type should be `template` when using stringiyf");
+    var getTag = baseGetTag;
+    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map2 && getTag(new Map2()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap2 && getTag(new WeakMap2()) != weakMapTag) {
+      getTag = function(value) {
+        var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+        if (ctorString) {
+          switch (ctorString) {
+            case dataViewCtorString:
+              return dataViewTag;
+            case mapCtorString:
+              return mapTag;
+            case promiseCtorString:
+              return promiseTag;
+            case setCtorString:
+              return setTag;
+            case weakMapCtorString:
+              return weakMapTag;
+          }
+        }
+        return result;
+      };
+    }
+    function isIndex(value, length) {
+      length = length == null ? MAX_SAFE_INTEGER : length;
+      return !!length && (typeof value == "number" || reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+    }
+    function isKeyable(value) {
+      var type = typeof value;
+      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+    }
+    function isMasked(func) {
+      return !!maskSrcKey && maskSrcKey in func;
+    }
+    function isPrototype(value) {
+      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+      return value === proto;
+    }
+    function objectToString(value) {
+      return nativeObjectToString.call(value);
+    }
+    function toSource(func) {
+      if (func != null) {
+        try {
+          return funcToString.call(func);
+        } catch (e) {
+        }
+        try {
+          return func + "";
+        } catch (e) {
+        }
       }
-      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      return "";
     }
-    return object;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  toTemplateString(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    let newPath = this.path.replaceAll("{", "${");
-    if (found) {
-      newPath = found.reduce((prev, curr) => {
-        const pathParam = replacer ? replacer(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge });
-        const replacement = `\${${pathParam}}`;
-        return prev.replace(curr, replacement);
-      }, this.path);
-    }
-    return `\`${newPath}\``;
-  }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
-      return void 0;
+    function eq(value, other) {
+      return value === other || value !== value && other !== other;
     }
-    const params = {};
-    found.forEach((item) => {
-      item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
-  }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath() {
-    return this.path.replaceAll("{", ":").replaceAll("}", "");
+    var isArguments = baseIsArguments(/* @__PURE__ */ function() {
+      return arguments;
+    }()) ? baseIsArguments : function(value) {
+      return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+    };
+    var isArray = Array.isArray;
+    function isArrayLike(value) {
+      return value != null && isLength(value.length) && !isFunction(value);
+    }
+    var isBuffer = nativeIsBuffer || stubFalse;
+    function isEqual2(value, other) {
+      return baseIsEqual(value, other);
+    }
+    function isFunction(value) {
+      if (!isObject(value)) {
+        return false;
+      }
+      var tag = baseGetTag(value);
+      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+    }
+    function isLength(value) {
+      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    }
+    function isObject(value) {
+      var type = typeof value;
+      return value != null && (type == "object" || type == "function");
+    }
+    function isObjectLike(value) {
+      return value != null && typeof value == "object";
+    }
+    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+    function keys(object) {
+      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+    }
+    function stubArray() {
+      return [];
+    }
+    function stubFalse() {
+      return false;
+    }
+    module.exports = isEqual2;
   }
-};
+});
+
+// src/index.ts
+init_esm_shims();
+
+// src/build.ts
+init_esm_shims();
 
 // src/config.ts
+init_esm_shims();
 function defineConfig(options) {
   return options;
 }
@@ -255,255 +738,15 @@ function isInputPath(result) {
   return !!result && "path" in result;
 }
 
-// src/utils/timeout.ts
-async function timeout(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(() => {
-      resolve2(true);
-    }, ms);
-  });
-}
-
-// src/utils/transformers/combineCodes.ts
-function combineCodes(codes) {
-  return codes.join("\n");
-}
-
-// src/utils/transformers/createJSDocBlockText.ts
-function createJSDocBlockText({ comments }) {
-  const filteredComments = comments.filter(Boolean);
-  if (!filteredComments.length) {
-    return "";
-  }
-  return `/**
- * ${filteredComments.join("\n * ")}
- */`;
-}
-
-// src/utils/transformers/escape.ts
-function escape(text) {
-  return text ? text.replaceAll("`", "\\`") : "";
-}
-function jsStringEscape(input) {
-  return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
-    switch (character) {
-      case '"':
-      case "'":
-      case "\\":
-        return "\\" + character;
-      case "\n":
-        return "\\n";
-      case "\r":
-        return "\\r";
-      case "\u2028":
-        return "\\u2028";
-      case "\u2029":
-        return "\\u2029";
-      default:
-        return "";
-    }
-  });
-}
-
-// src/utils/transformers/indent.ts
-function createIndent(size) {
-  return Array.from({ length: size + 1 }).join(" ");
-}
-
-// src/utils/transformers/nameSorter.ts
-function nameSorter(a, b) {
-  if (a.name < b.name) {
-    return -1;
-  }
-  if (a.name > b.name) {
-    return 1;
-  }
-  return 0;
-}
-
-// src/utils/transformers/searchAndReplace.ts
-function searchAndReplace(options) {
-  const { text, replaceBy, prefix = "", key } = options;
-  const searchValues = options.searchValues?.(prefix, key) || [
-    `${prefix}["${key}"]`,
-    `${prefix}['${key}']`,
-    `${prefix}[\`${key}\`]`,
-    `${prefix}"${key}"`,
-    `${prefix}'${key}'`,
-    `${prefix}\`${key}\``,
-    new RegExp(`${prefix}${key}`, "g")
-  ];
-  return searchValues.reduce((prev, searchValue) => {
-    return prev.toString().replaceAll(searchValue, replaceBy);
-  }, text);
-}
-
-// src/utils/transformers/transformReservedWord.ts
-var reservedWords = [
-  "abstract",
-  "arguments",
-  "boolean",
-  "break",
-  "byte",
-  "case",
-  "catch",
-  "char",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "double",
-  "else",
-  "enum",
-  "eval",
-  "export",
-  "extends",
-  "false",
-  "final",
-  "finally",
-  "float",
-  "for",
-  "function",
-  "goto",
-  "if",
-  "implements",
-  "import",
-  "in",
-  "instanceof",
-  "int",
-  "interface",
-  "let",
-  "long",
-  "native",
-  "new",
-  "null",
-  "package",
-  "private",
-  "protected",
-  "public",
-  "return",
-  "short",
-  "static",
-  "super",
-  "switch",
-  "synchronized",
-  "this",
-  "throw",
-  "throws",
-  "transient",
-  "true",
-  "try",
-  "typeof",
-  "var",
-  "void",
-  "volatile",
-  "while",
-  "with",
-  "yield",
-  "Array",
-  "Date",
-  "eval",
-  "function",
-  "hasOwnProperty",
-  "Infinity",
-  "isFinite",
-  "isNaN",
-  "isPrototypeOf",
-  "length",
-  "Math",
-  "name",
-  "NaN",
-  "Number",
-  "Object",
-  "prototype",
-  "String",
-  "toString",
-  "undefined",
-  "valueOf"
-];
-function transformReservedWord(word) {
-  if (word && reservedWords.includes(word) || word?.match(/^\d/)) {
-    return `_${word}`;
-  }
-  return word;
-}
-
-// src/utils/transformers/index.ts
-var transformers = {
-  combineCodes,
-  escape,
-  jsStringEscape,
-  createIndent,
-  transformReservedWord,
-  nameSorter,
-  searchAndReplace,
-  JSDoc: {
-    createJSDocBlockText
-  }
-};
-async function saveCreateDirectory(path3) {
-  const passedPath = dirname(resolve(path3));
-  await fs2.mkdir(passedPath, { recursive: true });
-}
-var writer = switcher(
-  {
-    node: async (path3, data) => {
-      try {
-        await fs2.stat(resolve(path3));
-        const oldContent = await fs2.readFile(resolve(path3), { encoding: "utf-8" });
-        if (oldContent?.toString() === data?.toString()) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path3);
-      await fs2.writeFile(resolve(path3), data, { encoding: "utf-8" });
-      const savedData = await fs2.readFile(resolve(path3), { encoding: "utf-8" });
-      if (savedData?.toString() !== data?.toString()) {
-        throw new Error(`Sanity check failed for ${path3}
-
-Data[${data.length}]:
-${data}
-
-Saved[${savedData.length}]:
-${savedData}
-`);
-      }
-      return savedData;
-    },
-    bun: async (path3, data) => {
-      try {
-        await saveCreateDirectory(path3);
-        await Bun.write(resolve(path3), data);
-        const file = Bun.file(resolve(path3));
-        const savedData = await file.text();
-        if (savedData?.toString() !== data?.toString()) {
-          throw new Error(`Sanity check failed for ${path3}
+// src/FileManager.ts
+init_esm_shims();
+var import_lodash = __toESM(require_lodash(), 1);
 
-Data[${data.length}]:
-${data}
+// src/BarrelManager.ts
+init_esm_shims();
 
-Saved[${savedData.length}]:
-${savedData}
-`);
-        }
-        return savedData;
-      } catch (e) {
-        console.log(e, resolve(path3));
-      }
-    }
-  },
-  "node"
-);
-async function write(data, path3) {
-  if (data.trim() === "") {
-    return void 0;
-  }
-  return writer(path3, data.trim());
-}
+// src/utils/TreeNode.ts
+init_esm_shims();
 var TreeNode = class _TreeNode {
   constructor(data, parent) {
     this.children = [];
@@ -594,78 +837,67 @@ var TreeNode = class _TreeNode {
 var _options;
 var BarrelManager = class {
   constructor(options = {}) {
-    __privateAdd(this, _options, {});
+    __privateAdd(this, _options, void 0);
     __privateSet(this, _options, options);
     return this;
   }
-  getIndexes(root, extName) {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = __privateGet(this, _options);
-    const extMapper = {
-      ".ts": {
-        extensions: /\.ts/,
-        exclude: [/schemas/, /json/]
-      },
-      ".json": {
-        extensions: /\.json/,
-        exclude: []
-      }
-    };
-    const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
+  getIndexes(pathToBuild) {
+    const { treeNode = {}, isTypeOnly, extName } = __privateGet(this, _options);
+    const tree = TreeNode.build(pathToBuild, treeNode);
     if (!tree) {
       return null;
     }
-    const fileReducer = (files2, currentTree) => {
-      if (!currentTree.children) {
+    const fileReducer = (files, treeNode2) => {
+      if (!treeNode2.children) {
         return [];
       }
-      if (currentTree.children?.length > 1) {
-        const indexPath = path.resolve(currentTree.data.path, "index.ts");
-        const exports = currentTree.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-          if (importPath.includes("index") && indexPath.includes("index")) {
+      if (treeNode2.children.length > 1) {
+        const indexPath = path.resolve(treeNode2.data.path, "index.ts");
+        const exports = treeNode2.children.filter(Boolean).map((file) => {
+          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${trimExtName(file.data.name)}`;
+          if (importPath.endsWith("index") && file.data.type === "file") {
             return void 0;
           }
           return {
-            path: includeExt ? file.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
+            path: extName ? `${importPath}${extName}` : importPath,
             isTypeOnly
           };
         }).filter(Boolean);
-        files2.push({
+        files.push({
           path: indexPath,
           baseName: "index.ts",
           source: "",
-          exports: output ? exports?.filter((item) => {
-            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-          }) : exports
+          exports,
+          meta: {
+            treeNode: treeNode2
+          }
         });
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path.resolve(currentTree.data.path, "index.ts");
-          const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-          const exports = [
-            {
-              path: includeExt ? child.data.type === "directory" ? `${importPath}/index${extName}` : `${importPath}${extName}` : importPath,
-              isTypeOnly
-            }
-          ];
-          files2.push({
-            path: indexPath,
-            baseName: "index.ts",
-            source: "",
-            exports: output ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
-            }) : exports
-          });
+      } else if (treeNode2.children.length === 1) {
+        const [treeNodeChild] = treeNode2.children;
+        const indexPath = path.resolve(treeNode2.data.path, "index.ts");
+        const importPath = treeNodeChild.data.type === "directory" ? `./${treeNodeChild.data.name}/index` : `./${trimExtName(treeNodeChild.data.name)}`;
+        const exports = [
+          {
+            path: extName ? `${importPath}${extName}` : importPath,
+            isTypeOnly
+          }
+        ];
+        files.push({
+          path: indexPath,
+          baseName: "index.ts",
+          source: "",
+          exports,
+          meta: {
+            treeNode: treeNode2
+          }
         });
       }
-      currentTree.children.forEach((childItem) => {
-        fileReducer(files2, childItem);
+      treeNode2.children.forEach((childItem) => {
+        fileReducer(files, childItem);
       });
-      return files2;
+      return files;
     };
-    const files = fileReducer([], tree).reverse();
-    const filteredFiles = filter ? files.filter(filter) : files;
-    return map ? filteredFiles.map(map) : filteredFiles;
+    return fileReducer([], tree).reverse();
   }
 };
 _options = new WeakMap();
@@ -674,25 +906,16 @@ _options = new WeakMap();
 var KubbFile;
 ((KubbFile2) => {
 })(KubbFile || (KubbFile = {}));
-var _cache, _task, _isWriting, _timeout, _queue, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
+var _cache, _task, _queue, _add, add_fn, _addOrAppend, addOrAppend_fn;
 var _FileManager = class _FileManager {
-  constructor(options) {
-    __privateAdd(this, _validate);
+  constructor({ task = async (file) => file, queue = new PQueue() } = {}) {
     __privateAdd(this, _add);
     __privateAdd(this, _addOrAppend);
     __privateAdd(this, _cache, /* @__PURE__ */ new Map());
     __privateAdd(this, _task, void 0);
-    __privateAdd(this, _isWriting, false);
-    /**
-     * Timeout between writes
-     */
-    __privateAdd(this, _timeout, 0);
     __privateAdd(this, _queue, void 0);
-    if (options) {
-      __privateSet(this, _task, options.task);
-      __privateSet(this, _queue, options.queue);
-      __privateSet(this, _timeout, options.timeout || 0);
-    }
+    __privateSet(this, _task, task);
+    __privateSet(this, _queue, queue);
     return this;
   }
   get files() {
@@ -703,11 +926,10 @@ var _FileManager = class _FileManager {
     return files;
   }
   get isExecuting() {
-    return __privateGet(this, _queue)?.hasJobs ?? __privateGet(this, _isWriting) ?? false;
+    return __privateGet(this, _queue).size !== 0 && __privateGet(this, _queue).pending !== 0;
   }
   async add(...files) {
-    const promises = files.map((file) => {
-      __privateMethod(this, _validate, validate_fn).call(this, file);
+    const promises = combineFiles(files).map((file) => {
       if (file.override) {
         return __privateMethod(this, _add, add_fn).call(this, file);
       }
@@ -719,12 +941,47 @@ var _FileManager = class _FileManager {
     }
     return resolvedFiles[0];
   }
-  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
-    const barrelManager = new BarrelManager(options);
-    const files = barrelManager.getIndexes(root, extName);
+  async addIndexes({ root, output, meta, options = {} }) {
+    const { exportType = "barrel" } = output;
+    if (!exportType) {
+      return void 0;
+    }
+    const exportPath = output.path.startsWith("./") ? trimExtName(output.path) : `./${trimExtName(output.path)}`;
+    const mode = _FileManager.getMode(output.path);
+    const barrelManager = new BarrelManager({ extName: output.extName, ...options });
+    const files = barrelManager.getIndexes(resolve(root, output.path));
+    function getPath() {
+      if (output.extName) {
+        if (mode === "directory") {
+          return `${exportPath}/index${output.extName}`;
+        }
+        return `${exportPath}${output.extName}`;
+      }
+      return exportPath;
+    }
     if (!files) {
       return void 0;
     }
+    const rootFile = {
+      path: resolve(root, "index.ts"),
+      baseName: "index.ts",
+      source: "",
+      exports: [
+        output.exportAs ? {
+          name: output.exportAs,
+          asAlias: true,
+          path: getPath(),
+          isTypeOnly: options.isTypeOnly
+        } : {
+          path: getPath(),
+          isTypeOnly: options.isTypeOnly
+        }
+      ]
+    };
+    await __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
+      ...rootFile,
+      meta: meta ? meta : rootFile.meta
+    });
     return await Promise.all(
       files.map((file) => {
         return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
@@ -752,58 +1009,17 @@ var _FileManager = class _FileManager {
     __privateGet(this, _cache).delete(path3);
   }
   async write(...params) {
-    if (!__privateGet(this, _isWriting)) {
-      __privateSet(this, _isWriting, true);
-      const text = await write(...params);
-      __privateSet(this, _isWriting, false);
-      return text;
-    }
-    await timeout(__privateGet(this, _timeout));
-    return this.write(...params);
+    return write(...params);
   }
   async read(...params) {
     return read(...params);
   }
   // statics
   static getSource(file) {
-    if (!_FileManager.isExtensionAllowed(file.baseName)) {
-      return file.source;
-    }
-    const exports = file.exports ? combineExports(file.exports) : [];
-    const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
-    const importNodes = imports.map((item) => factory.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-    const exportNodes = exports.map(
-      (item) => factory.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
-    );
-    return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
+    return getSource(file);
   }
   static combineFiles(files) {
-    return files.filter(Boolean).reduce((acc, file) => {
-      const prevIndex = acc.findIndex((item) => item.path === file.path);
-      if (prevIndex === -1) {
-        return [...acc, file];
-      }
-      const prev = acc[prevIndex];
-      if (prev && file.override) {
-        acc[prevIndex] = {
-          imports: [],
-          exports: [],
-          ...file
-        };
-        return acc;
-      }
-      if (prev) {
-        acc[prevIndex] = {
-          ...file,
-          source: prev.source && file.source ? `${prev.source}
-${file.source}` : "",
-          imports: [...prev.imports || [], ...file.imports || []],
-          exports: [...prev.exports || [], ...file.exports || []],
-          env: { ...prev.env || {}, ...file.env || {} }
-        };
-      }
-      return acc;
-    }, []);
+    return combineFiles(files);
   }
   static getMode(path3) {
     if (!path3) {
@@ -820,33 +1036,19 @@ ${file.source}` : "",
 };
 _cache = new WeakMap();
 _task = new WeakMap();
-_isWriting = new WeakMap();
-_timeout = new WeakMap();
 _queue = new WeakMap();
-_validate = new WeakSet();
-validate_fn = function(file) {
-  if (!file.validate) {
-    return;
-  }
-  if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
-    throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
-  }
-};
 _add = new WeakSet();
 add_fn = async function(file) {
   const controller = new AbortController();
-  const resolvedFile = { id: crypto2.randomUUID(), ...file };
+  const resolvedFile = { id: crypto.randomUUID(), name: trimExtName(file.baseName), ...file };
   __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-  if (__privateGet(this, _queue)) {
-    await __privateGet(this, _queue).run(
-      async () => {
-        var _a;
-        return (_a = __privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
-      },
-      { controller }
-    );
-  }
-  return resolvedFile;
+  return __privateGet(this, _queue).add(
+    async () => {
+      var _a;
+      return (_a = __privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
+    },
+    { signal: controller.signal }
+  );
 };
 _addOrAppend = new WeakSet();
 addOrAppend_fn = async function(file) {
@@ -866,16 +1068,69 @@ ${file.source}` : "",
   return __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;
+  }
+  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 !== trimExtName(file.path);
+  }).map((item) => {
+    return factory.createImportDeclaration({
+      name: item.name,
+      path: item.root ? getRelativePath(item.root, item.path) : item.path,
+      isTypeOnly: item.isTypeOnly
+    });
+  });
+  const exportNodes = exports.map(
+    (item) => factory.createExportDeclaration({
+      name: item.name,
+      path: item.path,
+      isTypeOnly: item.isTypeOnly,
+      asAlias: item.asAlias
+    })
+  );
+  return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
+}
 function combineExports(exports) {
   const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     const name = curr.name;
     const prevByPath = prev.findLast((imp) => imp.path === curr.path);
-    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly);
+    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && (0, import_lodash.default)(imp.name, name) && imp.isTypeOnly);
     if (prevByPathAndIsTypeOnly) {
       return prev;
     }
     const uniquePrev = prev.findLast(
-      (imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
+      (imp) => imp.path === curr.path && (0, import_lodash.default)(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
     );
     if (uniquePrev || Array.isArray(name) && !name.length || prevByPath?.asAlias && !curr.asAlias) {
       return prev;
@@ -908,11 +1163,11 @@ function combineImports(imports, exports, source) {
       return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
     };
     if (Array.isArray(name)) {
-      name = name.filter((item) => hasImportInSource(item));
+      name = name.filter((item) => typeof item === "string" ? hasImportInSource(item) : hasImportInSource(item.propertyName));
     }
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
-    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
-    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly);
+    const uniquePrev = prev.findLast((imp) => imp.path === curr.path && (0, import_lodash.default)(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && (0, import_lodash.default)(imp.name, name) && imp.isTypeOnly);
     if (prevByPathNameAndIsTypeOnly) {
       return prev;
     }
@@ -954,13 +1209,19 @@ function getEnvSource(source, env) {
       throw new TypeError(`Environment should be in upperCase for ${key}`);
     }
     if (typeof replaceBy === "string") {
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = transformers.searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+      prev = searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
+      prev = searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
 `, "ig"), ""), replaceBy, key });
     }
     return prev;
   }, source);
 }
+
+// src/PluginManager.ts
+init_esm_shims();
+
+// src/utils/EventEmitter.ts
+init_esm_shims();
 var _emitter;
 var EventEmitter = class {
   constructor() {
@@ -981,127 +1242,9 @@ var EventEmitter = class {
   }
 };
 _emitter = new WeakMap();
-var _queue2, _workerCount, _maxParallel, _debug, _work, work_fn;
-var Queue = class {
-  constructor(maxParallel, debug = false) {
-    __privateAdd(this, _work);
-    __privateAdd(this, _queue2, []);
-    this.eventEmitter = new EventEmitter();
-    __privateAdd(this, _workerCount, 0);
-    __privateAdd(this, _maxParallel, void 0);
-    __privateAdd(this, _debug, false);
-    __privateSet(this, _maxParallel, maxParallel);
-    __privateSet(this, _debug, debug);
-  }
-  run(job, options = { controller: new AbortController(), name: crypto2.randomUUID(), description: "" }) {
-    return new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
-        reject("Aborted");
-      });
-      __privateGet(this, _queue2).push(item);
-      __privateMethod(this, _work, work_fn).call(this);
-    });
-  }
-  runSync(job, options = { controller: new AbortController(), name: crypto2.randomUUID(), description: "" }) {
-    new Promise((resolve2, reject) => {
-      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
-      });
-      __privateGet(this, _queue2).push(item);
-      __privateMethod(this, _work, work_fn).call(this);
-    });
-  }
-  get hasJobs() {
-    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue2).length > 0;
-  }
-  get count() {
-    return __privateGet(this, _workerCount);
-  }
-};
-_queue2 = new WeakMap();
-_workerCount = new WeakMap();
-_maxParallel = new WeakMap();
-_debug = new WeakMap();
-_work = new WeakSet();
-work_fn = function() {
-  if (__privateGet(this, _workerCount) >= __privateGet(this, _maxParallel)) {
-    return;
-  }
-  __privateWrapper(this, _workerCount)._++;
-  let entry;
-  while (entry = __privateGet(this, _queue2).shift()) {
-    const { reject, resolve: resolve2, job, name, description } = entry;
-    if (__privateGet(this, _debug)) {
-      performance.mark(name + "_start");
-    }
-    job().then((result) => {
-      this.eventEmitter.emit("jobDone", result);
-      resolve2(result);
-      if (__privateGet(this, _debug)) {
-        performance.mark(name + "_stop");
-        performance.measure(description, name + "_start", name + "_stop");
-      }
-    }).catch((err) => {
-      this.eventEmitter.emit("jobFailed", err);
-      reject(err);
-    });
-  }
-  __privateWrapper(this, _workerCount)._--;
-};
-
-// src/utils/uniqueName.ts
-function setUniqueName(originalName, data) {
-  let used = data[originalName] || 0;
-  if (used) {
-    data[originalName] = ++used;
-    return originalName;
-  }
-  data[originalName] = 1;
-  return originalName;
-}
 
 // src/errors.ts
-var PluginError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "PluginError";
-    this.cause = options.cause;
-    this.pluginManager = options.pluginManager;
-  }
-};
-var ParallelPluginError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.errors = [];
-    this.name = "ParallelPluginError";
-    this.errors = options.errors;
-    this.pluginManager = options.pluginManager;
-  }
-  findError(searchError) {
-    if (!searchError) {
-      return void 0;
-    }
-    return this.errors.find((error) => {
-      if (error.cause) {
-        if (error.cause.name == searchError.name) {
-          return true;
-        }
-        return !!this.findError(error.cause);
-      }
-      return error.name === searchError.name;
-    })?.cause;
-  }
-};
-var SummaryError = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "SummaryError";
-    this.summary = options.summary || [];
-  }
-};
+init_esm_shims();
 var Warning = class extends Error {
   constructor(message, options) {
     super(message, { cause: options?.cause });
@@ -1111,7 +1254,11 @@ var Warning = class extends Error {
 var ValidationPluginError = class extends Error {
 };
 
+// src/plugin.ts
+init_esm_shims();
+
 // src/utils/cache.ts
+init_esm_shims();
 function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
   return {
     set(id, value) {
@@ -1151,8 +1298,7 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
-    key: ["controller", "core"],
-    kind: "controller",
+    key: ["core"],
     api() {
       return {
         get config() {
@@ -1189,7 +1335,11 @@ var definePlugin = createPlugin((options) => {
   };
 });
 
+// src/PromiseManager.ts
+init_esm_shims();
+
 // src/utils/executeStrategies.ts
+init_esm_shims();
 function hookSeq(promises) {
   return promises.filter(Boolean).reduce(
     (promise, func) => {
@@ -1219,6 +1369,9 @@ function hookFirst(promises, nullCheck = (state) => state !== null) {
   }
   return promise;
 }
+function hookParallel(promises) {
+  return Promise.allSettled(promises.filter(Boolean).map((promise) => promise()));
+}
 
 // src/PromiseManager.ts
 var _options2;
@@ -1235,6 +1388,9 @@ var PromiseManager = class {
     if (strategy === "first") {
       return hookFirst(promises, __privateGet(this, _options2).nullCheck);
     }
+    if (strategy === "parallel") {
+      return hookParallel(promises);
+    }
     throw new Error(`${strategy} not implemented`);
   }
 };
@@ -1270,7 +1426,7 @@ var PluginManager = class {
     __privateAdd(this, _executeSync);
     __privateAdd(this, _catcher);
     __privateAdd(this, _parse);
-    this.eventEmitter = new EventEmitter();
+    this.events = new EventEmitter();
     this.executed = [];
     __privateAdd(this, _core, void 0);
     __privateAdd(this, _usedPluginNames, {});
@@ -1282,11 +1438,14 @@ var PluginManager = class {
           hookName: "resolvePath",
           parameters: [params.baseName, params.directory, params.options]
         });
-        if (paths && paths?.length > 1) {
-          throw new Error(
+        if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+          this.logger.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)}`
+Paths: ${JSON.stringify(paths, void 0, 2)}
+
+Falling back on the first item.
+`
           );
         }
         return paths?.at(0);
@@ -1303,11 +1462,14 @@ Paths: ${JSON.stringify(paths, void 0, 2)}`
           hookName: "resolveName",
           parameters: [params.name, params.type]
         });
-        if (names && names?.length > 1) {
-          throw new Error(
+        if (names && names?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+          this.logger.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)}`
+Names: ${JSON.stringify(names, void 0, 2)}
+
+Falling back on the first item.
+`
           );
         }
         return transformReservedWord(names?.at(0) || params.name);
@@ -1318,9 +1480,10 @@ Names: ${JSON.stringify(names, void 0, 2)}`
       }).result;
       return transformReservedWord(name);
     };
+    this.config = config;
     this.logger = options.logger;
-    this.queue = new Queue(100, this.logger.logLevel === LogLevel.debug);
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue, timeout: options.writeTimeout });
+    this.queue = new PQueue({ concurrency: 1 });
+    this.fileManager = new FileManager({ task: options.task, queue: this.queue });
     __privateSet(this, _promiseManager, new PromiseManager({ nullCheck: (state) => !!state?.result }));
     const plugins = config.plugins || [];
     const core = definePlugin({
@@ -1338,11 +1501,14 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     });
     return this;
   }
+  /**
+   * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
+   */
   on(eventName, handler) {
-    this.eventEmitter.on(eventName, handler);
+    this.events.on(eventName, handler);
   }
   /**
-   * Run only hook for a specific plugin name
+   * Run a specific hookName for plugin x.
    */
   hookForPlugin({
     pluginKey,
@@ -1360,6 +1526,9 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     }).filter(Boolean);
     return Promise.all(promises);
   }
+  /**
+   * Run a specific hookName for plugin x.
+   */
   hookForPluginSync({
     pluginKey,
     hookName,
@@ -1376,7 +1545,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     }).filter(Boolean);
   }
   /**
-   * Chains, first non-null result stops and returns
+   * First non-null result stops and will return it's value.
    */
   async hookFirst({
     hookName,
@@ -1404,7 +1573,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     return __privateGet(this, _promiseManager).run("first", promises);
   }
   /**
-   * Chains, first non-null result stops and returns
+   * First non-null result stops and will return it's value.
    */
   hookFirstSync({
     hookName,
@@ -1432,33 +1601,26 @@ Names: ${JSON.stringify(names, void 0, 2)}`
     return parseResult;
   }
   /**
-   * Parallel, runs all plugins
+   * Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
    */
   async hookParallel({
     hookName,
     parameters
   }) {
-    const parallelPromises = [];
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
-      const promise = __privateMethod(this, _execute, execute_fn).call(this, { strategy: "hookParallel", hookName, parameters, plugin });
-      if (promise) {
-        parallelPromises.push(promise);
-      }
-    }
-    const results = await Promise.allSettled(parallelPromises);
-    const errors = results.map((result) => {
-      if (isPromiseRejectedResult(result) && result.reason instanceof PluginError) {
-        return result.reason;
+    const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => __privateMethod(this, _execute, execute_fn).call(this, { strategy: "hookParallel", hookName, parameters, plugin });
+    });
+    const results = await __privateGet(this, _promiseManager).run("parallel", promises);
+    results.forEach((result, index) => {
+      if (isPromiseRejectedResult(result)) {
+        const plugin = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)[index];
+        __privateMethod(this, _catcher, catcher_fn).call(this, result.reason, plugin, hookName);
       }
-      return void 0;
-    }).filter(Boolean);
-    if (errors.length) {
-      throw new ParallelPluginError("Error", { errors, pluginManager: this });
-    }
+    });
     return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
   /**
-   * Chains, reduces returned value, handling the reduced value as the first hook argument
+   * Chain all plugins, `reduce` can be passed through to handle every returned value. The return value of the first plugin will be used as the first parameter for the plugin after that.
    */
   hookReduceArg0({
     hookName,
@@ -1496,24 +1658,23 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }
   getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
-    const [searchKind, searchPluginName, searchIdentifier] = pluginKey;
+    const [searchPluginName, searchIdentifier] = pluginKey;
     const pluginByPluginName = plugins.filter((plugin) => plugin[hookName]).filter((item) => {
-      const [kind, name, identifier] = item.key;
+      const [name, identifier] = item.key;
       const identifierCheck = identifier?.toString() === searchIdentifier?.toString();
-      const kindCheck = kind === searchKind;
       const nameCheck = name === searchPluginName;
       if (searchIdentifier) {
-        return identifierCheck && kindCheck && nameCheck;
+        return identifierCheck && nameCheck;
       }
-      return kindCheck && nameCheck;
+      return nameCheck;
     });
     if (!pluginByPluginName?.length) {
       const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
-      if (this.logger.logLevel === "info") {
+      if (this.logger.logLevel === LogLevel.debug) {
         if (corePlugin) {
-          this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`);
+          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] : [];
@@ -1537,7 +1698,7 @@ Names: ${JSON.stringify(names, void 0, 2)}`
   }
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   static get hooks() {
-    return ["validate", "buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
+    return ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
   }
 };
 _core = new WeakMap();
@@ -1547,7 +1708,7 @@ _getSortedPlugins = new WeakSet();
 getSortedPlugins_fn = function(hookName) {
   const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
   if (hookName) {
-    if (this.logger.logLevel === "info") {
+    if (this.logger.logLevel === LogLevel.info) {
       const containsHookName = plugins.some((item) => item[hookName]);
       if (!containsHookName) {
         this.logger.warn(`No hook ${hookName} found`);
@@ -1555,12 +1716,28 @@ getSortedPlugins_fn = function(hookName) {
     }
     return plugins.filter((item) => item[hookName]);
   }
-  return plugins;
+  return plugins.map((plugin) => {
+    if (plugin.pre) {
+      const isValid = plugin.pre.every((pluginName2) => plugins.find((pluginToFind) => pluginToFind.name === pluginName2));
+      if (!isValid) {
+        throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, void 0, 2)})`);
+      }
+    }
+    return plugin;
+  }).sort((a, b) => {
+    if (b.pre?.includes(a.name)) {
+      return 1;
+    }
+    if (b.post?.includes(a.name)) {
+      return -1;
+    }
+    return 0;
+  });
 };
 _addExecutedToCallStack = new WeakSet();
 addExecutedToCallStack_fn = function(executer) {
   if (executer) {
-    this.eventEmitter.emit("executed", executer);
+    this.events.emit("executed", executer);
     this.executed.push(executer);
   }
 };
@@ -1576,7 +1753,7 @@ execute_fn = function({
   if (!hook) {
     return null;
   }
-  this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+  this.events.emit("execute", { strategy, hookName, parameters, plugin });
   const task = Promise.resolve().then(() => {
     if (typeof hook === "function") {
       const possiblePromiseResult = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
@@ -1588,11 +1765,6 @@ execute_fn = function({
     return hook;
   }).then((result) => {
     output = result;
-    return result;
-  }).catch((e) => {
-    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
-    return null;
-  }).finally(() => {
     __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
       parameters,
       output,
@@ -1600,6 +1772,10 @@ execute_fn = function({
       hookName,
       plugin
     });
+    return result;
+  }).catch((e) => {
+    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
   });
   return task;
 };
@@ -1615,7 +1791,7 @@ executeSync_fn = function({
   if (!hook) {
     return null;
   }
-  this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+  this.events.emit("execute", { strategy, hookName, parameters, plugin });
   try {
     if (typeof hook === "function") {
       const fn = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
@@ -1623,11 +1799,6 @@ executeSync_fn = function({
       return fn;
     }
     output = hook;
-    return hook;
-  } catch (e) {
-    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
-    return null;
-  } finally {
     __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
       parameters,
       output,
@@ -1635,24 +1806,24 @@ executeSync_fn = function({
       hookName,
       plugin
     });
+    return hook;
+  } catch (e) {
+    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
   }
 };
 _catcher = new WeakSet();
 catcher_fn = function(e, plugin, hookName) {
-  const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
+  const text = `${e.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})
 `;
-  const pluginError = new PluginError(text, { cause: e, pluginManager: this });
-  this.eventEmitter.emit("error", pluginError);
-  throw pluginError;
+  this.logger.error(text);
+  this.events.emit("error", e);
 };
 _parse = new WeakSet();
 parse_fn = function(plugin, pluginManager, context) {
   const usedPluginNames = __privateGet(pluginManager, _usedPluginNames);
   setUniqueName(plugin.name, usedPluginNames);
-  const key = plugin.key || [plugin.kind, plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
-  if (plugin.name !== "core" && usedPluginNames[plugin.name] >= 2) {
-    pluginManager.logger.warn("Using multiple of the same plugin is an experimental feature");
-  }
+  const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
   if (!plugin.transform) {
     plugin.transform = function transform(code) {
       return code;
@@ -1676,8 +1847,9 @@ parse_fn = function(plugin, pluginManager, context) {
 async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
-async function build(options) {
+async function setup(options) {
   const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
+  let count = 0;
   try {
     if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
       await read(config.input.path);
@@ -1685,7 +1857,7 @@ async function build(options) {
   } catch (e) {
     if (isInputPath(config)) {
       throw new Error(
-        "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3.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 " + p.dim(config.input.path),
         {
           cause: e
         }
@@ -1695,96 +1867,134 @@ async function build(options) {
   if (config.output.clean) {
     await clean(config.output.path);
   }
-  const queueTask = async (file) => {
+  const task = async (file) => {
     const { path: path3 } = file;
-    let code = FileManager.getSource(file);
+    let source = FileManager.getSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
       parameters: [path3]
     });
     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, path3],
+        parameters: [source, path3],
         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, path3]
+            parameters: [source, path3]
           });
         }
-        return pluginManager.hookFirst({
+        await pluginManager.hookFirst({
           hookName: "writeFile",
-          parameters: [transformedCode, path3]
+          parameters: [source, path3]
         });
       }
     }
+    return {
+      ...file,
+      source: source || ""
+    };
   };
-  const pluginManager = new PluginManager(config, { logger, task: queueTask, writeTimeout: 0 });
-  const { plugins, fileManager } = pluginManager;
+  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 === LogLevel.info) {
-        logger.spinner.start(`\u{1F4BE} Writing`);
-      }
-      if (logger.logLevel === "debug") {
-        logger.info(`PluginKey ${pc3.dim(JSON.stringify(plugin.key))} 
+      if (logger.logLevel === LogLevel.debug) {
+        logger.debug(`PluginKey ${p.dim(JSON.stringify(plugin.key))} 
 with source
 
 ${code}`);
       }
     }
   });
+  pluginManager.queue.on("add", () => {
+    if (logger.logLevel !== LogLevel.info) {
+      return;
+    }
+    if (logger.spinner && count === 0) {
+      logger.spinner?.start(`\u{1F4BE} Writing`);
+    }
+  });
+  pluginManager.queue.on("active", () => {
+    if (logger.logLevel !== 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 = p.dim(text);
+    }
+    ++count;
+  });
+  pluginManager.queue.on("completed", () => {
+    if (logger.logLevel !== LogLevel.info) {
+      return;
+    }
+    if (logger.spinner) {
+      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`;
+      logger.spinner.suffixText = p.dim(text);
+    }
+  });
   pluginManager.on("executed", (executer) => {
     const { hookName, plugin, output, parameters } = executer;
-    const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`;
-    if (logger.logLevel === LogLevel.info && logger.spinner) {
-      if (hookName === "writeFile") {
-        const [_code, path3] = parameters;
-        logger.spinner.suffixText = pc3.dim(path3);
-      } else {
-        logger.spinner.suffixText = messsage;
-      }
-    }
     if (logger.logLevel === LogLevel.debug) {
-      logger.info(messsage);
       const logs = [
-        parameters && `${pc3.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        `${randomCliColour(plugin.name)} Executing ${hookName}`,
+        parameters && `${p.bgWhite(`Parameters`)} ${randomCliColour(plugin.name)} ${hookName}`,
         JSON.stringify(parameters, void 0, 2),
-        output && `${pc3.bgWhite("Output")} ${randomPicoColour(plugin.name)} ${hookName}`,
+        output && `${p.bgWhite("Output")} ${randomCliColour(plugin.name)} ${hookName}`,
         output
       ].filter(Boolean);
-      console.log(logs.join("\n"));
+      logger.debug(logs.join("\n"));
     }
   });
-  await pluginManager.hookParallel({
-    hookName: "validate",
-    parameters: [plugins]
-  });
+  return pluginManager;
+}
+async function build(options) {
+  const pluginManager = await setup(options);
+  const { fileManager, logger } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "buildStart",
-    parameters: [config]
+    parameters: [options.config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  if (!fileManager.isExecuting && logger.spinner) {
+  if (logger.logLevel === LogLevel.info && logger.spinner) {
     logger.spinner.suffixText = "";
     logger.spinner.succeed(`\u{1F4BE} Writing completed`);
   }
   return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), 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 === LogLevel.info && logger.spinner) {
+      logger.spinner.suffixText = "";
+      logger.spinner.succeed(`\u{1F4BE} Writing completed`);
+    }
+  } catch (e) {
+    return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager, error: e };
+  }
+  return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager };
+}
 
 // src/Generator.ts
+init_esm_shims();
 var _options3, _context;
 var Generator = class {
   constructor(options, context) {
@@ -1810,9 +2020,13 @@ var Generator = class {
 };
 _options3 = new WeakMap();
 _context = new WeakMap();
-var _cache2, _cwd, _SLASHES;
+
+// src/PackageManager.ts
+init_esm_shims();
+var _cache2, _cwd, _SLASHES, _match, match_fn;
 var _PackageManager = class _PackageManager {
   constructor(workspace) {
+    __privateAdd(this, _match);
     __privateAdd(this, _cwd, void 0);
     __privateAdd(this, _SLASHES, /* @__PURE__ */ new Set(["/", "\\"]));
     if (workspace) {
@@ -1875,30 +2089,33 @@ var _PackageManager = class _PackageManager {
     __privateGet(_PackageManager, _cache2)[dependency] = version;
   }
   async getVersion(dependency) {
-    if (__privateGet(_PackageManager, _cache2)[dependency]) {
+    if (typeof dependency === "string" && __privateGet(_PackageManager, _cache2)[dependency]) {
       return __privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = await this.getPackageJSON();
     if (!packageJSON) {
       return void 0;
     }
-    return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
+    return __privateMethod(this, _match, match_fn).call(this, packageJSON, dependency);
   }
   getVersionSync(dependency) {
-    if (__privateGet(_PackageManager, _cache2)[dependency]) {
+    if (typeof dependency === "string" && __privateGet(_PackageManager, _cache2)[dependency]) {
       return __privateGet(_PackageManager, _cache2)[dependency];
     }
     const packageJSON = this.getPackageJSONSync();
     if (!packageJSON) {
       return void 0;
     }
-    return packageJSON["dependencies"]?.[dependency] || packageJSON["devDependencies"]?.[dependency];
+    return __privateMethod(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 = coerce(packageVersion);
     if (!semVer) {
       throw new Error(`${packageVersion} is not valid`);
@@ -1920,16 +2137,24 @@ var _PackageManager = class _PackageManager {
 _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;
+};
 __privateAdd(_PackageManager, _cache2, {});
 var PackageManager = _PackageManager;
 
-// src/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
-
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, KubbFile, PackageManager, ParallelPluginError, PluginError, PluginManager, PromiseManager, SchemaGenerator, SummaryError, ValidationPluginError, Warning, build, combineExports, combineImports, createPlugin, src_default as default, defineConfig, isInputPath, pluginName as name, pluginName };
+export { FileManager, Generator, KubbFile, PackageManager, PluginManager, PromiseManager, Warning, build, createPlugin, src_default as default, defineConfig, isInputPath, pluginName as name, pluginName, safeBuild };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map