@kubb/core 1.15.0-canary.20231112T135011 → 2.0.0-alpha.10

package/dist/index.cjs

@@ -3,18 +3,19 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var pc3 = require('picocolors');
-var crypto = require('crypto');
 var fs2 = require('fs-extra');
-var changeCase = require('change-case');
-var naturalOrderby = require('natural-orderby');
-var perf_hooks = require('perf_hooks');
 var seedrandom = require('seedrandom');
-var path2 = require('path');
+var path4 = require('path');
 var jsRuntime = require('js-runtime');
-var dirTree = require('directory-tree');
+var changeCase = require('change-case');
+var crypto2 = require('crypto');
 var parser = require('@kubb/parser');
+var factory = require('@kubb/parser/factory');
 var isEqual = require('lodash.isequal');
+var naturalOrderby = require('natural-orderby');
+var dirTree = require('directory-tree');
 var events = require('events');
+var perf_hooks = require('perf_hooks');
 var mod = require('module');
 var os = require('os');
 var url = require('url');
@@ -24,18 +25,39 @@ var semver = require('semver');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
 var pc3__default = /*#__PURE__*/_interopDefault(pc3);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var fs2__default = /*#__PURE__*/_interopDefault(fs2);
 var seedrandom__default = /*#__PURE__*/_interopDefault(seedrandom);
-var path2__default = /*#__PURE__*/_interopDefault(path2);
-var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
+var path4__default = /*#__PURE__*/_interopDefault(path4);
+var crypto2__default = /*#__PURE__*/_interopDefault(crypto2);
+var factory__namespace = /*#__PURE__*/_interopNamespace(factory);
 var isEqual__default = /*#__PURE__*/_interopDefault(isEqual);
+var dirTree__default = /*#__PURE__*/_interopDefault(dirTree);
 var mod__default = /*#__PURE__*/_interopDefault(mod);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var process__default = /*#__PURE__*/_interopDefault(process);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -43,110 +65,49 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-
-// src/utils/cache.ts
-function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
-  return {
-    set(id, value) {
-      Store[id] = [0, value];
-    },
-    get(id) {
-      const item = Store[id];
-      if (!item) {
-        return null;
-      }
-      item[0] = 0;
-      return item[1];
-    },
-    has(id) {
-      const item = Store[id];
-      if (!item) {
-        return false;
-      }
-      item[0] = 0;
-      return true;
-    },
-    delete(id) {
-      return delete Store[id];
-    }
-  };
-}
-async function clean(path3) {
-  return fs2.remove(path3);
-}
-var FunctionParams = class {
-  type;
-  items = [];
-  constructor(type) {
-    this.type = type;
-    return this;
-  }
-  add(item) {
-    if (!item) {
-      return this;
-    }
-    if (Array.isArray(item)) {
-      item.filter(Boolean).forEach((it) => this.items.push(it));
-      return this;
-    }
-    this.items.push(item);
-    return this;
-  }
-  toString() {
-    const sortedData = naturalOrderby.orderBy(this.items.filter(Boolean), [(v) => !v.default, (v) => v.required ?? true], ["desc", "desc"]);
-    return sortedData.filter(({ enabled = true }) => enabled).reduce((acc, { name, type, required = true, ...rest }) => {
-      if (!name) {
-        acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
-        return acc;
-      }
-      const parameterName = name.startsWith("{") ? name : changeCase.camelCase(name, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-      if (type) {
-        if (required) {
-          acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
-        } else {
-          acc.push(`${parameterName}?: ${type}`);
-        }
-      } else {
-        acc.push(`${parameterName}`);
-      }
-      return acc;
-    }, []).join(", ");
-  }
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
 };
-
-// src/utils/getUniqueName.ts
-function getUniqueName(originalName, data) {
-  let used = data[originalName] || 0;
-  if (used) {
-    data[originalName] = ++used;
-    originalName += used;
-  }
-  data[originalName] = 1;
-  return originalName;
-}
-
-// src/utils/isPromise.ts
-function isPromise(result) {
-  return typeof result?.then === "function";
-}
-function isPromiseFulfilledResult(result) {
-  return result.status === "fulfilled";
-}
-function isPromiseRejectedResult(result) {
-  return result.status === "rejected";
-}
-
-// src/utils/jsdoc.ts
-function createJSDocBlockText({ comments }) {
-  const filteredComments = comments.filter(Boolean);
-  if (!filteredComments.length) {
-    return "";
+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);
   }
-  return `/**
- * ${filteredComments.join("\n * ")}
- */`;
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+async function clean(path5) {
+  return fs2.remove(path5);
 }
-function createLogger(spinner) {
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
+};
+function createLogger({ logLevel, name, spinner }) {
   const logs = [];
   const log = (message) => {
     if (message && spinner) {
@@ -166,12 +127,14 @@ function createLogger(spinner) {
     }
   };
   const info = (message) => {
-    if (message && spinner) {
+    if (message && spinner && logLevel !== LogLevel.silent) {
       spinner.info(message);
       logs.push(message);
     }
   };
   const logger = {
+    name,
+    logLevel,
     log,
     error,
     warn,
@@ -181,75 +144,6 @@ function createLogger(spinner) {
   };
   return logger;
 }
-
-// src/utils/nameSorter.ts
-function nameSorter(a, b) {
-  if (a.name < b.name) {
-    return -1;
-  }
-  if (a.name > b.name) {
-    return 1;
-  }
-  return 0;
-}
-var Queue = class {
-  #queue = [];
-  #workerCount = 0;
-  #maxParallel;
-  #debug = false;
-  constructor(maxParallel, debug = false) {
-    this.#maxParallel = maxParallel;
-    this.#debug = debug;
-  }
-  run(job, options = { controller: new AbortController(), name: crypto__default.default.randomUUID(), description: "" }) {
-    return new Promise((resolve, reject) => {
-      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
-        reject("Aborted");
-      });
-      this.#queue.push(item);
-      this.#work();
-    });
-  }
-  runSync(job, options = { controller: new AbortController(), name: crypto__default.default.randomUUID(), description: "" }) {
-    new Promise((resolve, reject) => {
-      const item = { reject, resolve, job, name: options.name, description: options.description || options.name };
-      options.controller?.signal.addEventListener("abort", () => {
-        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
-      });
-      this.#queue.push(item);
-      this.#work();
-    });
-  }
-  get hasJobs() {
-    return this.#workerCount > 0 || this.#queue.length > 0;
-  }
-  get count() {
-    return this.#workerCount;
-  }
-  #work() {
-    if (this.#workerCount >= this.#maxParallel) {
-      return;
-    }
-    this.#workerCount++;
-    let entry;
-    while (entry = this.#queue.shift()) {
-      const { reject, resolve, job, name, description } = entry;
-      if (this.#debug) {
-        perf_hooks.performance.mark(name + "_start");
-      }
-      job().then((result) => {
-        resolve(result);
-        if (this.#debug) {
-          perf_hooks.performance.mark(name + "_stop");
-          perf_hooks.performance.measure(description, name + "_start", name + "_stop");
-        }
-      }).catch((err) => reject(err));
-    }
-    this.#workerCount--;
-  }
-};
 var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
 function randomColour(text, colours = defaultColours) {
   if (!text) {
@@ -276,46 +170,22 @@ function randomPicoColour(text, colors = defaultColours) {
   }
   return formatter(text);
 }
-function slash(path3, platform = "linux") {
-  const isWindowsPath = /^\\\\\?\\/.test(path3);
-  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
-    return path3.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
-  }
-  return path3.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
-}
-function getRelativePath(rootDir, filePath, platform = "linux") {
-  if (!rootDir || !filePath) {
-    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
-  }
-  const relativePath = path2__default.default.relative(rootDir, filePath);
-  const path3 = slash(relativePath, platform);
-  if (path3.startsWith("../")) {
-    return path3.replace(path2__default.default.basename(path3), path2__default.default.basename(path3, path2__default.default.extname(filePath)));
-  }
-  return `./${path3.replace(path2__default.default.basename(path3), path2__default.default.basename(path3, path2__default.default.extname(filePath)))}`;
-}
-function getPathMode(path3) {
-  if (!path3) {
-    return "directory";
-  }
-  return path2__default.default.extname(path3) ? "file" : "directory";
-}
 var reader = jsRuntime.switcher(
   {
-    node: async (path3) => {
-      return fs2__default.default.readFile(path3, { encoding: "utf8" });
+    node: async (path5) => {
+      return fs2__default.default.readFile(path5, { encoding: "utf8" });
     },
-    bun: async (path3) => {
-      const file = Bun.file(path3);
+    bun: async (path5) => {
+      const file = Bun.file(path5);
       return file.text();
     }
   },
   "node"
 );
-var syncReader = jsRuntime.switcher(
+jsRuntime.switcher(
   {
-    node: (path3) => {
-      return fs2__default.default.readFileSync(path3, { encoding: "utf8" });
+    node: (path5) => {
+      return fs2__default.default.readFileSync(path5, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -323,79 +193,118 @@ var syncReader = jsRuntime.switcher(
   },
   "node"
 );
-async function read(path3) {
-  return reader(path3);
-}
-function readSync(path3) {
-  return syncReader(path3);
+async function read(path5) {
+  return reader(path5);
 }
-
-// src/utils/renderTemplate.ts
-function renderTemplate(template, data = void 0) {
-  if (!data || !Object.keys(data).length) {
-    return template.replace(/{{(.*?)}}/g, "");
-  }
-  const matches = template.match(/{{(.*?)}}/g);
-  return matches?.reduce((prev, curr) => {
-    const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim();
-    if (index === void 0) {
-      return prev;
-    }
-    const value = data[index];
-    if (value === void 0) {
-      return prev;
-    }
-    return prev.replace(curr, () => {
-      if (typeof value === "boolean") {
-        return `${value.toString()}` || "false";
+var URLPath = class {
+  constructor(path5) {
+    this.path = path5;
+    return this;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  get URL() {
+    return this.toURLPath();
+  }
+  get isURL() {
+    try {
+      const url = new URL(this.path);
+      if (url?.href) {
+        return true;
       }
-      return value || "";
-    }).trim();
-  }, template) || "";
-}
-
-// src/utils/SummaryError.ts
-var SummaryError = class extends Error {
-  summary;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "SummaryError";
-    this.summary = options.summary || [];
+    } catch (error) {
+      return false;
+    }
+    return false;
   }
-};
-
-// src/utils/throttle.ts
-var throttle = (fn, delay) => {
-  let wait = false;
-  let timeout2;
-  let cancelled = false;
-  return [
-    (...args) => {
-      if (cancelled) {
-        return void 0;
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  get template() {
+    return this.toTemplateString();
+  }
+  get object() {
+    return this.toObject();
+  }
+  get params() {
+    return this.getParams();
+  }
+  toObject({ type = "path", replacer, stringify } = {}) {
+    const object = {
+      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams()
+    };
+    if (stringify) {
+      if (type === "template") {
+        return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
       }
-      if (wait) {
-        return void 0;
+      if (object.params) {
+        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
       }
-      const val = fn(...args);
-      wait = true;
-      timeout2 = setTimeout(() => {
-        wait = false;
-      }, delay);
-      return val;
-    },
-    () => {
-      cancelled = true;
-      clearTimeout(timeout2);
+      return `{ url: '${object.url}' }`;
     }
-  ];
+    return object;
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  toTemplateString(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    let newPath = this.path.replaceAll("{", "${");
+    if (found) {
+      newPath = found.reduce((prev, curr) => {
+        const pathParam = replacer ? replacer(changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
+        const replacement = `\${${pathParam}}`;
+        return prev.replace(curr, replacement);
+      }, this.path);
+    }
+    return `\`${newPath}\``;
+  }
+  getParams(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    if (!found) {
+      return void 0;
+    }
+    const params = {};
+    found.forEach((item) => {
+      item = item.replaceAll("{", "").replaceAll("}", "");
+      const pathParam = replacer ? replacer(changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(item, { delimiter: "", transform: changeCase.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("}", "");
+  }
 };
 
+// src/config.ts
+function defineConfig(options) {
+  return options;
+}
+function isInputPath(result) {
+  return !!result && "path" in result;
+}
+
 // src/utils/timeout.ts
 async function timeout(ms) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     setTimeout(() => {
-      resolve(true);
+      resolve2(true);
     }, ms);
   });
 }
@@ -405,6 +314,22 @@ function combineCodes(codes) {
   return codes.join("\n");
 }
 
+// src/utils/transformers/createJSDocBlockText.ts
+function createJSDocBlockText({ comments, newLine }) {
+  const filteredComments = comments.filter(Boolean);
+  if (!filteredComments.length) {
+    return "";
+  }
+  const source = `/**
+ * ${filteredComments.join("\n * ")}
+ */`;
+  if (newLine) {
+    return `${source}
+`;
+  }
+  return source;
+}
+
 // src/utils/transformers/escape.ts
 function escape(text) {
   return text ? text.replaceAll("`", "\\`") : "";
@@ -430,15 +355,48 @@ function jsStringEscape(input) {
   });
 }
 
-// src/utils/transformers/transformReservedWord.ts
-var reservedWords = [
-  "abstract",
-  "arguments",
-  "boolean",
-  "break",
-  "byte",
-  "case",
-  "catch",
+// 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",
@@ -522,11 +480,89 @@ function transformReservedWord(word) {
   }
   return word;
 }
+
+// src/utils/transformers/trim.ts
+function trim(text) {
+  return text.replaceAll(/\n/g, "").trim();
+}
+
+// src/utils/transformers/index.ts
+var transformers = {
+  combineCodes,
+  escape,
+  jsStringEscape,
+  createIndent,
+  transformReservedWord,
+  nameSorter,
+  searchAndReplace,
+  trim,
+  JSDoc: {
+    createJSDocBlockText
+  }
+};
+async function saveCreateDirectory(path5) {
+  const passedPath = path4.dirname(path4.resolve(path5));
+  await fs2__default.default.mkdir(passedPath, { recursive: true });
+}
+var writer = jsRuntime.switcher(
+  {
+    node: async (path5, data) => {
+      try {
+        await fs2__default.default.stat(path4.resolve(path5));
+        const oldContent = await fs2__default.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
+        if (oldContent?.toString() === data?.toString()) {
+          return;
+        }
+      } catch (_err) {
+      }
+      await saveCreateDirectory(path5);
+      await fs2__default.default.writeFile(path4.resolve(path5), data, { encoding: "utf-8" });
+      const savedData = await fs2__default.default.readFile(path4.resolve(path5), { encoding: "utf-8" });
+      if (savedData?.toString() !== data?.toString()) {
+        throw new Error(`Sanity check failed for ${path5}
+
+Data[${data.length}]:
+${data}
+
+Saved[${savedData.length}]:
+${savedData}
+`);
+      }
+      return savedData;
+    },
+    bun: async (path5, data) => {
+      try {
+        await saveCreateDirectory(path5);
+        await Bun.write(path4.resolve(path5), data);
+        const file = Bun.file(path4.resolve(path5));
+        const savedData = await file.text();
+        if (savedData?.toString() !== data?.toString()) {
+          throw new Error(`Sanity check failed for ${path5}
+
+Data[${data.length}]:
+${data}
+
+Saved[${savedData.length}]:
+${savedData}
+`);
+        }
+        return savedData;
+      } catch (e) {
+        console.log(e, path4.resolve(path5));
+      }
+    }
+  },
+  "node"
+);
+async function write(data, path5) {
+  if (data.trim() === "") {
+    return void 0;
+  }
+  return writer(path5, data.trim());
+}
 var TreeNode = class _TreeNode {
-  data;
-  parent;
-  children = [];
   constructor(data, parent) {
+    this.children = [];
     this.data = data;
     this.parent = parent;
     return this;
@@ -586,16 +622,16 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  static build(path3, options = {}) {
+  static build(path5, options = {}) {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree__default.default(path3, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      const filteredTree = dirTree__default.default(path5, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
       if (!filteredTree) {
         return null;
       }
-      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || getPathMode(filteredTree.path) });
+      const treeNode = new _TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type || FileManager.getMode(filteredTree.path) });
       const recurse = (node, item) => {
-        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || getPathMode(item.path) });
+        const subNode = node.addChild({ name: item.name, path: item.path, type: item.type || FileManager.getMode(item.path) });
         if (item.children?.length) {
           item.children?.forEach((child) => {
             recurse(subNode, child);
@@ -610,227 +646,290 @@ var TreeNode = class _TreeNode {
   }
 };
 
-// src/utils/uniqueIdFactory.ts
-var uniqueIdFactory = (counter) => (str = "") => `${str}${++counter}`;
-var URLPath = class {
-  path;
-  constructor(path3) {
-    this.path = path3;
+// src/BarrelManager.ts
+var _options;
+var BarrelManager = class {
+  constructor(options = {}) {
+    __privateAdd(this, _options, {});
+    __privateSet(this, _options, options);
     return this;
   }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  get URL() {
-    return this.toURLPath();
-  }
-  get isURL() {
-    try {
-      const url = new URL(this.path);
-      if (url?.href) {
-        return true;
+  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: []
       }
-    } catch (error) {
-      return false;
+    };
+    const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...treeNode });
+    if (!tree) {
+      return null;
     }
-    return false;
+    const fileReducer = (files2, currentTree) => {
+      if (!currentTree.children) {
+        return [];
+      }
+      if (currentTree.children?.length > 1) {
+        const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
+        const exports = currentTree.children.filter(Boolean).map((file) => {
+          const importPath = file.data.type === "directory" ? `./${file.data.name}/index` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+          if (importPath.includes("index") && file.data.type === "file") {
+            return void 0;
+          }
+          return {
+            path: includeExt ? `${importPath}${extName}` : importPath,
+            isTypeOnly
+          };
+        }).filter(Boolean);
+        files2.push({
+          path: indexPath,
+          baseName: "index.ts",
+          source: "",
+          exports: output ? exports?.filter((item) => {
+            return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
+          }) : exports
+        });
+      } else {
+        currentTree.children?.forEach((child) => {
+          const indexPath = path4__default.default.resolve(currentTree.data.path, "index.ts");
+          const importPath = child.data.type === "directory" ? `./${child.data.name}/index` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+          const exports = [
+            {
+              path: includeExt ? `${importPath}${extName}` : importPath,
+              isTypeOnly
+            }
+          ];
+          files2.push({
+            path: indexPath,
+            baseName: "index.ts",
+            source: "",
+            exports: output ? exports?.filter((item) => {
+              return item.path.endsWith(output.replace(/\.[^.]*$/, ""));
+            }) : exports
+          });
+        });
+      }
+      currentTree.children.forEach((childItem) => {
+        fileReducer(files2, childItem);
+      });
+      return files2;
+    };
+    const files = fileReducer([], tree).reverse();
+    const filteredFiles = filter ? files.filter(filter) : files;
+    return map ? filteredFiles.map(map) : filteredFiles;
   }
-  /**
-   * 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();
+};
+_options = new WeakMap();
+
+// src/FileManager.ts
+exports.KubbFile = void 0;
+((KubbFile2) => {
+})(exports.KubbFile || (exports.KubbFile = {}));
+var _cache, _task, _isWriting, _timeout, _queue, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
+var _FileManager = class _FileManager {
+  constructor(options) {
+    __privateAdd(this, _validate);
+    __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);
+    }
+    return this;
   }
-  get object() {
-    return this.toObject();
+  get files() {
+    const files = [];
+    __privateGet(this, _cache).forEach((item) => {
+      files.push(...item.flat(1));
+    });
+    return files;
   }
-  get params() {
-    return this.getParams();
+  get isExecuting() {
+    return __privateGet(this, _queue)?.hasJobs ?? __privateGet(this, _isWriting) ?? false;
   }
-  toObject({ type = "path", replacer, stringify } = {}) {
-    const object = {
-      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
-      params: this.getParams()
-    };
-    if (stringify) {
-      if (type !== "template") {
-        throw new Error("Type should be `template` when using stringiyf");
+  async add(...files) {
+    const promises = files.map((file) => {
+      __privateMethod(this, _validate, validate_fn).call(this, file);
+      if (file.override) {
+        return __privateMethod(this, _add, add_fn).call(this, file);
       }
-      return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-    }
-    return object;
-  }
-  /**
-   * Convert Swagger path to template literals/ template strings(camelcase)
-   * @example /pet/{petId} => `/pet/${petId}`
-   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-   * @example /account/userID => `/account/${userId}`
-   */
-  toTemplateString(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    let newPath = this.path.replaceAll("{", "${");
-    if (found) {
-      newPath = found.reduce((prev, curr) => {
-        const pathParam = replacer ? replacer(changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(curr, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-        const replacement = `\${${pathParam}}`;
-        return prev.replace(curr, replacement);
-      }, this.path);
+      return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
+    });
+    const resolvedFiles = await Promise.all(promises);
+    if (files.length > 1) {
+      return resolvedFiles;
     }
-    return `\`${newPath}\``;
+    return resolvedFiles[0];
   }
-  getParams(replacer) {
-    const regex = /{(\w|-)*}/g;
-    const found = this.path.match(regex);
-    if (!found) {
+  async addIndexes({ root, extName = ".ts", meta, options = {} }) {
+    const barrelManager = new BarrelManager(options);
+    const files = barrelManager.getIndexes(root, extName);
+    if (!files) {
       return void 0;
     }
-    const params = {};
-    found.forEach((item) => {
-      item = item.replaceAll("{", "").replaceAll("}", "");
-      const pathParam = replacer ? replacer(changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge })) : changeCase.camelCase(item, { delimiter: "", transform: changeCase.camelCaseTransformMerge });
-      params[pathParam] = pathParam;
-    }, this.path);
-    return params;
+    return await Promise.all(
+      files.map((file) => {
+        return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
+          ...file,
+          meta: meta ? meta : file.meta
+        });
+      })
+    );
   }
-  /**
-   * Convert Swagger path to URLPath(syntax of Express)
-   * @example /pet/{petId} => /pet/:petId
-   */
-  toURLPath() {
-    return this.path.replaceAll("{", ":").replaceAll("}", "");
+  getCacheByUUID(UUID) {
+    let cache;
+    __privateGet(this, _cache).forEach((files) => {
+      cache = files.find((item) => item.id === UUID);
+    });
+    return cache;
   }
-};
-
-// src/utils/Warning.ts
-var Warning = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options?.cause });
-    this.name = "Warning";
+  get(path5) {
+    return __privateGet(this, _cache).get(path5);
   }
-};
-async function saveCreateDirectory(path3) {
-  const passedPath = path2__default.default.dirname(path2__default.default.resolve(path3));
-  await fs2__default.default.mkdir(passedPath, { recursive: true });
-}
-var writer = jsRuntime.switcher(
-  {
-    node: async (path3, data) => {
-      try {
-        await fs2__default.default.stat(path3);
-        const oldContent = await fs2__default.default.readFile(path3, { encoding: "utf-8" });
-        if (oldContent?.toString() === data) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path3);
-      return fs2__default.default.writeFile(path2__default.default.resolve(path3), data, { encoding: "utf-8" });
-    },
-    bun: async (path3, data) => {
-      try {
-        await saveCreateDirectory(path3);
-        await Bun.write(path2__default.default.resolve(path3), data);
-      } catch (e) {
-        console.log(e, path2__default.default.resolve(path3));
-      }
-    }
-  },
-  "node"
-);
-async function write(data, path3) {
-  return writer(path3, data);
-}
-function getIndexes(root, extName, options = {}) {
-  const extMapper = {
-    ".ts": {
-      extensions: /\.ts/,
-      exclude: [/schemas/, /json/]
-    },
-    ".json": {
-      extensions: /\.json/,
-      exclude: []
+  remove(path5) {
+    const cacheItem = this.get(path5);
+    if (!cacheItem) {
+      return;
     }
-  };
-  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...options });
-  if (!tree) {
-    return null;
+    __privateGet(this, _cache).delete(path5);
   }
-  const fileReducer = (files2, currentTree) => {
-    if (!currentTree.children) {
-      return [];
+  async write(...params) {
+    if (!__privateGet(this, _isWriting)) {
+      __privateSet(this, _isWriting, true);
+      const text = await write(...params);
+      __privateSet(this, _isWriting, false);
+      return text;
     }
-    if (currentTree.children?.length > 1) {
-      const path3 = path2__default.default.resolve(currentTree.data.path, "index.ts");
-      const exports = currentTree.children.map((file) => {
-        if (!file) {
-          return void 0;
-        }
-        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-        if (importPath.includes("index") && path3.includes("index")) {
-          return void 0;
-        }
-        return { path: importPath };
-      }).filter(Boolean);
-      files2.push({
-        path: path3,
-        baseName: "index.ts",
-        source: "",
-        exports
-      });
-    } else {
-      currentTree.children?.forEach((child) => {
-        const path3 = path2__default.default.resolve(currentTree.data.path, "index.ts");
-        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-        files2.push({
-          path: path3,
-          baseName: "index.ts",
-          source: "",
-          exports: [{ path: importPath }]
-        });
-      });
+    await timeout(__privateGet(this, _timeout));
+    return this.write(...params);
+  }
+  async read(...params) {
+    return read(...params);
+  }
+  // statics
+  static getSource(file) {
+    if (!_FileManager.isExtensionAllowed(file.baseName)) {
+      return file.source;
     }
-    currentTree.children.forEach((childItem) => {
-      fileReducer(files2, childItem);
-    });
-    return files2;
-  };
-  const files = fileReducer([], tree);
-  return files;
-}
-function combineFiles(files) {
-  return files.filter(Boolean).reduce((acc, curr) => {
-    const prevIndex = acc.findIndex((item) => item.path === curr.path);
-    if (prevIndex !== -1) {
+    const exports = file.exports ? combineExports(file.exports) : [];
+    const imports = file.imports ? combineImports(file.imports, exports, file.source) : [];
+    const importNodes = imports.map((item) => factory__namespace.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
+    const exportNodes = exports.map(
+      (item) => factory__namespace.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
+    );
+    return [parser.print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
+  }
+  static combineFiles(files) {
+    return files.filter(Boolean).reduce((acc, file) => {
+      const prevIndex = acc.findIndex((item) => item.path === file.path);
+      if (prevIndex === -1) {
+        return [...acc, file];
+      }
       const prev = acc[prevIndex];
+      if (prev && file.override) {
+        acc[prevIndex] = {
+          imports: [],
+          exports: [],
+          ...file
+        };
+        return acc;
+      }
       if (prev) {
         acc[prevIndex] = {
-          ...curr,
-          source: prev.source && curr.source ? `${prev.source}
-${curr.source}` : "",
-          imports: [...prev.imports || [], ...curr.imports || []],
-          exports: [...prev.exports || [], ...curr.exports || []],
-          env: { ...prev.env || {}, ...curr.env || {} }
+          ...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 || {} }
         };
       }
-    } else {
-      acc.push(curr);
+      return acc;
+    }, []);
+  }
+  static getMode(path5) {
+    if (!path5) {
+      return "directory";
     }
-    return acc;
-  }, []);
-}
-var extensions = [".js", ".ts", ".tsx"];
-function isExtensionAllowed(baseName) {
-  return extensions.some((extension) => baseName.endsWith(extension));
-}
+    return path4.extname(path5) ? "file" : "directory";
+  }
+  static get extensions() {
+    return [".js", ".ts", ".tsx"];
+  }
+  static isExtensionAllowed(baseName) {
+    return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
+  }
+};
+_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__default.default.randomUUID(), ...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;
+};
+_addOrAppend = new WeakSet();
+addOrAppend_fn = async function(file) {
+  const previousCaches = __privateGet(this, _cache).get(file.path);
+  const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
+  if (previousCache) {
+    __privateGet(this, _cache).delete(previousCache.path);
+    return __privateMethod(this, _add, add_fn).call(this, {
+      ...file,
+      source: previousCache.source && file.source ? `${previousCache.source}
+${file.source}` : "",
+      imports: [...previousCache.imports || [], ...file.imports || []],
+      exports: [...previousCache.exports || [], ...file.exports || []],
+      env: { ...previousCache.env || {}, ...file.env || {} }
+    });
+  }
+  return __privateMethod(this, _add, add_fn).call(this, file);
+};
+var FileManager = _FileManager;
 function combineExports(exports) {
-  return exports.reduce((prev, curr) => {
+  const combinedExports = naturalOrderby.orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     const name = curr.name;
     const prevByPath = prev.findLast((imp) => imp.path === curr.path);
+    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
+    if (prevByPathAndIsTypeOnly) {
+      return prev;
+    }
     const uniquePrev = prev.findLast(
       (imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
     );
@@ -852,12 +951,16 @@ function combineExports(exports) {
     }
     return [...prev, curr];
   }, []);
+  return naturalOrderby.orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
 }
 function combineImports(imports, exports, source) {
-  return imports.reduce((prev, curr) => {
+  const combinedImports = naturalOrderby.orderBy(imports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
     const hasImportInSource = (importName) => {
-      const checker = (name2) => name2 && !!source.includes(`${name2}`);
+      if (!source) {
+        return true;
+      }
+      const checker = (name2) => name2 && !!source.includes(name2);
       return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
     };
     if (Array.isArray(name)) {
@@ -865,6 +968,10 @@ function combineImports(imports, exports, source) {
     }
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
     const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual__default.default(imp.name, name) && imp.isTypeOnly);
+    if (prevByPathNameAndIsTypeOnly) {
+      return prev;
+    }
     if (uniquePrev || Array.isArray(name) && !name.length) {
       return prev;
     }
@@ -886,43 +993,7 @@ function combineImports(imports, exports, source) {
     }
     return [...prev, curr];
   }, []);
-}
-function createFileSource(file) {
-  let { source } = file;
-  if (!isExtensionAllowed(file.baseName)) {
-    return file.source;
-  }
-  const exports = file.exports ? combineExports(file.exports) : [];
-  const imports = file.imports ? combineImports(file.imports, exports, source) : [];
-  const importNodes = imports.map((item) => parser.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-  const importSource = parser.print(importNodes);
-  const exportNodes = exports.map((item) => parser.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias }));
-  const exportSource = parser.print(exportNodes);
-  source = getEnvSource(file.source, file.env);
-  if (importSource) {
-    source = `${importSource}
-${source}`;
-  }
-  if (exportSource) {
-    source = `${exportSource}
-${source}`;
-  }
-  return source;
-}
-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);
+  return naturalOrderby.orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
 }
 function getEnvSource(source, env) {
   if (!env) {
@@ -939,175 +1010,157 @@ function getEnvSource(source, env) {
       throw new TypeError(`Environment should be in upperCase for ${key}`);
     }
     if (typeof replaceBy === "string") {
-      prev = searchAndReplace({ text: prev.replaceAll(`process.env.${key}`, replaceBy), replaceBy, prefix: "process.env", key });
-      prev = searchAndReplace({ text: prev.replaceAll(new RegExp(`(declare const).*
+      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).*
 `, "ig"), ""), replaceBy, key });
     }
     return prev;
   }, source);
 }
-
-// src/managers/fileManager/FileManager.ts
-var FileManager = class {
-  #cache = /* @__PURE__ */ new Map();
-  #task;
-  #queue;
-  constructor(options) {
-    if (options) {
-      this.#task = options.task;
-      this.#queue = options.queue;
-    }
-    return this;
+var _emitter;
+var EventEmitter = class {
+  constructor() {
+    __privateAdd(this, _emitter, new events.EventEmitter());
+    __privateGet(this, _emitter).setMaxListeners(100);
   }
-  get extensions() {
-    return extensions;
+  emit(eventName, ...eventArg) {
+    __privateGet(this, _emitter).emit(eventName, ...eventArg);
   }
-  get files() {
-    const files = [];
-    this.#cache.forEach((item) => {
-      files.push(...item.flat(1));
-    });
-    return files;
+  on(eventName, handler) {
+    __privateGet(this, _emitter).on(eventName, handler);
   }
-  get isExecuting() {
-    return this.#queue?.hasJobs ?? false;
+  off(eventName, handler) {
+    __privateGet(this, _emitter).off(eventName, handler);
   }
-  async add(file) {
-    const controller = new AbortController();
-    const resolvedFile = { id: crypto__default.default.randomUUID(), ...file };
-    this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-    if (this.#queue) {
-      try {
-        await this.#queue.run(
-          async () => {
-            return this.#task?.(resolvedFile);
-          },
-          { controller }
-        );
-      } catch {
-        return resolvedFile;
-      }
-    }
-    return resolvedFile;
+  removeAll() {
+    __privateGet(this, _emitter).removeAllListeners();
   }
-  async addOrAppend(file) {
-    const previousCaches = this.#cache.get(file.path);
-    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
-    if (previousCache) {
-      this.#cache.delete(previousCache.path);
-      return this.add({
-        ...file,
-        source: previousCache.source && file.source ? `${previousCache.source}
-${file.source}` : "",
-        imports: [...previousCache.imports || [], ...file.imports || []],
-        exports: [...previousCache.exports || [], ...file.exports || []],
-        env: { ...previousCache.env || {}, ...file.env || {} }
+};
+_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__default.default.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");
       });
-    }
-    return this.add(file);
-  }
-  async addIndexes(root, extName = ".ts", options = {}) {
-    const files = await getIndexes(root, extName, options);
-    if (!files) {
-      return void 0;
-    }
-    return Promise.all(
-      files.map((file) => {
-        if (file.override) {
-          return this.add(file);
-        }
-        return this.addOrAppend(file);
-      })
-    );
-  }
-  #append(path3, file) {
-    const previousFiles = this.#cache.get(path3) || [];
-    this.#cache.set(path3, [...previousFiles, file]);
+      __privateGet(this, _queue2).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
+    });
   }
-  getCacheByUUID(UUID) {
-    let cache;
-    this.#cache.forEach((files) => {
-      cache = files.find((item) => item.id === UUID);
+  runSync(job, options = { controller: new AbortController(), name: crypto2__default.default.randomUUID(), description: "" }) {
+    new Promise((resolve2, reject) => {
+      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
+      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);
     });
-    return cache;
   }
-  get(path3) {
-    return this.#cache.get(path3);
+  get hasJobs() {
+    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue2).length > 0;
   }
-  remove(path3) {
-    const cacheItem = this.get(path3);
-    if (!cacheItem) {
-      return;
-    }
-    this.#cache.delete(path3);
+  get count() {
+    return __privateGet(this, _workerCount);
   }
-  async write(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return write(...params);
-      });
-    }
-    return write(...params);
+};
+_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;
   }
-  async read(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return read(...params);
-      });
-    }
-    return read(...params);
+  __privateWrapper(this, _workerCount)._++;
+  let entry;
+  while (entry = __privateGet(this, _queue2).shift()) {
+    const { reject, resolve: resolve2, job, name, description } = entry;
+    if (__privateGet(this, _debug)) {
+      perf_hooks.performance.mark(name + "_start");
+    }
+    job().then((result) => {
+      this.eventEmitter.emit("jobDone", result);
+      resolve2(result);
+      if (__privateGet(this, _debug)) {
+        perf_hooks.performance.mark(name + "_stop");
+        perf_hooks.performance.measure(description, name + "_start", name + "_stop");
+      }
+    }).catch((err) => {
+      this.eventEmitter.emit("jobFailed", err);
+      reject(err);
+    });
   }
+  __privateWrapper(this, _workerCount)._--;
 };
 
-// src/managers/pluginManager/ParallelPluginError.ts
-var ParallelPluginError = class extends Error {
-  errors = [];
-  pluginManager;
+// 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 Warning = class extends Error {
   constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "ParallelPluginError";
-    this.errors = options.errors;
-    this.pluginManager = options.pluginManager;
+    super(message, { cause: options?.cause });
+    this.name = "Warning";
   }
-  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);
+};
+var ValidationPluginError = class extends Error {
+};
+
+// src/utils/cache.ts
+function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
+  return {
+    set(id, value) {
+      Store[id] = [0, value];
+    },
+    get(id) {
+      const item = Store[id];
+      if (!item) {
+        return null;
+      }
+      item[0] = 0;
+      return item[1];
+    },
+    has(id) {
+      const item = Store[id];
+      if (!item) {
+        return false;
       }
-      return error.name === searchError.name;
-    })?.cause;
-  }
-};
+      item[0] = 0;
+      return true;
+    },
+    delete(id) {
+      return delete Store[id];
+    }
+  };
+}
 
-// src/managers/pluginManager/PluginError.ts
-var PluginError = class extends Error {
-  pluginManager;
-  cause;
-  constructor(message, options) {
-    super(message, { cause: options.cause });
-    this.name = "PluginError";
-    this.cause = options.cause;
-    this.pluginManager = options.pluginManager;
-  }
-};
-function createPlugin(factory) {
+// src/plugin.ts
+function createPlugin(factory2) {
   return (options) => {
-    const plugin = factory(options);
-    if (Array.isArray(plugin)) {
-      throw new Error("Not implemented");
-    }
-    if (!plugin.transform) {
-      plugin.transform = function transform(code) {
-        return code;
-      };
-    }
-    return plugin;
+    return factory2(options);
   };
 }
 var pluginName = "core";
@@ -1116,6 +1169,8 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
+    key: ["controller", "core"],
+    kind: "controller",
     api() {
       return {
         get config() {
@@ -1124,18 +1179,18 @@ var definePlugin = createPlugin((options) => {
         get plugins() {
           return options.getPlugins();
         },
+        get plugin() {
+          return options.plugin;
+        },
         logger,
         fileManager,
         pluginManager,
         async addFile(...files) {
-          return Promise.all(
-            files.map((file) => {
-              if (file.override) {
-                return fileManager.add(file);
-              }
-              return fileManager.addOrAppend(file);
-            })
-          );
+          const resolvedFiles = await fileManager.add(...files);
+          if (!Array.isArray(resolvedFiles)) {
+            return [resolvedFiles];
+          }
+          return resolvedFiles;
         },
         resolvePath,
         resolveName,
@@ -1143,75 +1198,156 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = path2__default.default.resolve(this.config.root, this.config.output.path);
-      return path2__default.default.resolve(root, baseName);
+      const root = path4__default.default.resolve(this.config.root, this.config.output.path);
+      return path4__default.default.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
     }
   };
 });
-var EventEmitter = class {
-  constructor() {
-    this.#emitter.setMaxListeners(100);
-  }
-  #emitter = new events.EventEmitter();
-  emit(eventName, ...eventArg) {
-    this.#emitter.emit(eventName, ...eventArg);
-  }
-  on(eventName, handler) {
-    this.#emitter.on(eventName, handler);
+
+// src/utils/executeStrategies.ts
+function hookSeq(promises) {
+  return promises.filter(Boolean).reduce(
+    (promise, func) => {
+      if (typeof func !== "function") {
+        throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
+      }
+      return promise.then((state) => {
+        const calledFunc = func(state);
+        if (calledFunc) {
+          return calledFunc.then(Array.prototype.concat.bind(state));
+        }
+      });
+    },
+    Promise.resolve([])
+  );
+}
+function hookFirst(promises, nullCheck = (state) => state !== null) {
+  let promise = Promise.resolve(null);
+  for (const func of promises.filter(Boolean)) {
+    promise = promise.then((state) => {
+      if (nullCheck(state)) {
+        return state;
+      }
+      const calledFunc = func(state);
+      return calledFunc;
+    });
   }
-  off(eventName, handler) {
-    this.#emitter.off(eventName, handler);
+  return promise;
+}
+function hookParallel(promises) {
+  return Promise.allSettled(promises.filter(Boolean).map((promise) => promise()));
+}
+
+// src/PromiseManager.ts
+var _options2;
+var PromiseManager = class {
+  constructor(options = {}) {
+    __privateAdd(this, _options2, {});
+    __privateSet(this, _options2, options);
+    return this;
   }
-  removeAll() {
-    this.#emitter.removeAllListeners();
+  run(strategy, promises) {
+    if (strategy === "seq") {
+      return hookSeq(promises);
+    }
+    if (strategy === "first") {
+      return hookFirst(promises, __privateGet(this, _options2).nullCheck);
+    }
+    if (strategy === "parallel") {
+      return hookParallel(promises);
+    }
+    throw new Error(`${strategy} not implemented`);
   }
 };
-
-// src/managers/pluginManager/pluginParser.ts
-var usedPluginNames = {};
-function pluginParser(plugin, context) {
-  const key = [plugin.kind, plugin.name, getUniqueName(plugin.name, usedPluginNames).split(plugin.name).at(1)];
-  if (plugin.api && typeof plugin.api === "function") {
-    const api = plugin.api.call(context);
-    return {
-      ...plugin,
-      key,
-      api
-    };
-  }
-  return {
-    ...plugin,
-    key
-  };
+_options2 = new WeakMap();
+function isPromise(result) {
+  return !!result && typeof result?.then === "function";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
 }
 
-// src/managers/pluginManager/PluginManager.ts
-var hookNames = {
-  validate: 1,
-  buildStart: 1,
-  resolvePath: 1,
-  resolveName: 1,
-  load: 1,
-  transform: 1,
-  writeFile: 1,
-  buildEnd: 1
-};
-var hooks = Object.keys(hookNames);
+// src/PluginManager.ts
+var _core, _usedPluginNames, _promiseManager, _getSortedPlugins, getSortedPlugins_fn, _addExecutedToCallStack, addExecutedToCallStack_fn, _execute, execute_fn, _executeSync, executeSync_fn, _catcher, catcher_fn, _parse, parse_fn;
 var PluginManager = class {
-  plugins;
-  fileManager;
-  eventEmitter = new EventEmitter();
-  queue;
-  executed = [];
-  logger;
-  #core;
   constructor(config, options) {
+    __privateAdd(this, _getSortedPlugins);
+    __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`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The actual pluginObject to run.
+     */
+    // Implementation signature
+    __privateAdd(this, _execute);
+    /**
+     * Run a sync plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The acutal plugin
+     * @param replaceContext When passed, the plugin context can be overridden.
+     */
+    __privateAdd(this, _executeSync);
+    __privateAdd(this, _catcher);
+    __privateAdd(this, _parse);
+    this.eventEmitter = new EventEmitter();
+    this.executed = [];
+    __privateAdd(this, _core, void 0);
+    __privateAdd(this, _usedPluginNames, {});
+    __privateAdd(this, _promiseManager, void 0);
+    this.resolvePath = (params) => {
+      if (params.pluginKey) {
+        const paths = this.hookForPluginSync({
+          pluginKey: params.pluginKey,
+          hookName: "resolvePath",
+          parameters: [params.baseName, params.directory, params.options]
+        });
+        if (paths && paths?.length > 1) {
+          throw new Error(
+            `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
+
+Paths: ${JSON.stringify(paths, void 0, 2)}`
+          );
+        }
+        return paths?.at(0);
+      }
+      return this.hookFirstSync({
+        hookName: "resolvePath",
+        parameters: [params.baseName, params.directory, params.options]
+      }).result;
+    };
+    this.resolveName = (params) => {
+      if (params.pluginKey) {
+        const names = this.hookForPluginSync({
+          pluginKey: params.pluginKey,
+          hookName: "resolveName",
+          parameters: [params.name, params.type]
+        });
+        if (names && names?.length > 1) {
+          throw new Error(
+            `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
+
+Names: ${JSON.stringify(names, void 0, 2)}`
+          );
+        }
+        return transformReservedWord(names?.at(0) || params.name);
+      }
+      const name = this.hookFirstSync({
+        hookName: "resolveName",
+        parameters: [params.name, params.type]
+      }).result;
+      return transformReservedWord(name);
+    };
+    this.config = config;
     this.logger = options.logger;
-    this.queue = new Queue(100, options.debug);
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue });
+    this.queue = new Queue(100, this.logger.logLevel === LogLevel.debug);
+    this.fileManager = new FileManager({ task: options.task, queue: this.queue, timeout: options.writeTimeout });
+    __privateSet(this, _promiseManager, new PromiseManager({ nullCheck: (state) => !!state?.result }));
+    const plugins = config.plugins || [];
     const core = definePlugin({
       config,
       logger: this.logger,
@@ -1219,44 +1355,14 @@ var PluginManager = class {
       fileManager: this.fileManager,
       resolvePath: this.resolvePath.bind(this),
       resolveName: this.resolveName.bind(this),
-      getPlugins: this.#getSortedPlugins.bind(this),
-      plugin: void 0
+      getPlugins: __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).bind(this)
+    });
+    __privateSet(this, _core, __privateMethod(this, _parse, parse_fn).call(this, core, this, core.api.call(null)));
+    this.plugins = [__privateGet(this, _core), ...plugins].map((plugin) => {
+      return __privateMethod(this, _parse, parse_fn).call(this, plugin, this, __privateGet(this, _core).api);
     });
-    this.#core = pluginParser(core, core.api.call(null));
-    this.plugins = [this.#core, ...config.plugins || []].reduce((prev, plugin) => {
-      const convertedApi = pluginParser(plugin, this.#core?.api);
-      return [...prev, convertedApi];
-    }, []);
     return this;
   }
-  resolvePath = (params) => {
-    if (params.pluginName) {
-      return this.hookForPluginSync({
-        pluginName: params.pluginName,
-        hookName: "resolvePath",
-        parameters: [params.baseName, params.directory, params.options]
-      });
-    }
-    return this.hookFirstSync({
-      hookName: "resolvePath",
-      parameters: [params.baseName, params.directory, params.options]
-    }).result;
-  };
-  resolveName = (params) => {
-    if (params.pluginName) {
-      const name2 = this.hookForPluginSync({
-        pluginName: params.pluginName,
-        hookName: "resolveName",
-        parameters: [params.name, params.type]
-      });
-      return transformReservedWord(name2 || params.name);
-    }
-    const name = this.hookFirstSync({
-      hookName: "resolveName",
-      parameters: [params.name, params.type]
-    }).result;
-    return transformReservedWord(name);
-  };
   on(eventName, handler) {
     this.eventEmitter.on(eventName, handler);
   }
@@ -1264,49 +1370,49 @@ var PluginManager = class {
    * Run only hook for a specific plugin name
    */
   hookForPlugin({
-    pluginName: pluginName2,
+    pluginKey,
     hookName,
     parameters
   }) {
-    const plugin = this.getPlugin(hookName, pluginName2);
-    return this.#execute({
-      strategy: "hookFirst",
-      hookName,
-      parameters,
-      plugin
-    });
+    const plugins = this.getPluginsByKey(hookName, pluginKey);
+    const promises = plugins.map((plugin) => {
+      return __privateMethod(this, _execute, execute_fn).call(this, {
+        strategy: "hookFirst",
+        hookName,
+        parameters,
+        plugin
+      });
+    }).filter(Boolean);
+    return Promise.all(promises);
   }
   hookForPluginSync({
-    pluginName: pluginName2,
+    pluginKey,
     hookName,
     parameters
   }) {
-    const plugin = this.getPlugin(hookName, pluginName2);
-    return this.#executeSync({
-      strategy: "hookFirst",
-      hookName,
-      parameters,
-      plugin
-    });
+    const plugins = this.getPluginsByKey(hookName, pluginKey);
+    return plugins.map((plugin) => {
+      return __privateMethod(this, _executeSync, executeSync_fn).call(this, {
+        strategy: "hookFirst",
+        hookName,
+        parameters,
+        plugin
+      });
+    }).filter(Boolean);
   }
   /**
    * Chains, first non-null result stops and returns
    */
-  hookFirst({
+  async hookFirst({
     hookName,
     parameters,
     skipped
   }) {
-    let promise = Promise.resolve(null);
-    for (const plugin of this.#getSortedPlugins()) {
-      if (skipped && skipped.has(plugin)) {
-        continue;
-      }
-      promise = promise.then(async (parseResult) => {
-        if (parseResult?.result != null) {
-          return parseResult;
-        }
-        const value = await this.#execute({
+    const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).filter((plugin) => {
+      return skipped ? skipped.has(plugin) : true;
+    }).map((plugin) => {
+      return async () => {
+        const value = await __privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1318,9 +1424,9 @@ var PluginManager = class {
             result: value
           }
         );
-      });
-    }
-    return promise;
+      };
+    });
+    return __privateGet(this, _promiseManager).run("first", promises);
   }
   /**
    * Chains, first non-null result stops and returns
@@ -1331,12 +1437,12 @@ var PluginManager = class {
     skipped
   }) {
     let parseResult = null;
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       if (skipped && skipped.has(plugin)) {
         continue;
       }
       parseResult = {
-        result: this.#executeSync({
+        result: __privateMethod(this, _executeSync, executeSync_fn).call(this, {
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -1357,23 +1463,16 @@ var PluginManager = class {
     hookName,
     parameters
   }) {
-    const parallelPromises = [];
-    for (const plugin of this.#getSortedPlugins()) {
-      const promise = this.#execute({ 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);
   }
   /**
@@ -1386,191 +1485,220 @@ var PluginManager = class {
   }) {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
       promise = promise.then((arg0) => {
-        const value = this.#execute({
+        const value = __privateMethod(this, _execute, execute_fn).call(this, {
           strategy: "hookReduceArg0",
           hookName,
           parameters: [arg0, ...rest],
           plugin
         });
         return value;
-      }).then((result) => reduce.call(this.#core.api, argument0, result, plugin));
+      }).then((result) => reduce.call(__privateGet(this, _core).api, argument0, result, plugin));
     }
     return promise;
   }
   /**
    * Chains plugins
    */
-  hookSeq({ hookName, parameters }) {
-    let promise = Promise.resolve();
-    for (const plugin of this.#getSortedPlugins()) {
-      promise = promise.then(() => {
-        this.#execute({
-          strategy: "hookSeq",
-          hookName,
-          parameters,
-          plugin
-        });
+  async hookSeq({ hookName, parameters }) {
+    const promises = __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this).map((plugin) => {
+      return () => __privateMethod(this, _execute, execute_fn).call(this, {
+        strategy: "hookSeq",
+        hookName,
+        parameters,
+        plugin
       });
-    }
-    return promise.then(noReturn);
-  }
-  #getSortedPlugins(hookName) {
-    const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
-    if (hookName) {
-      return plugins.filter((item) => item[hookName]);
-    }
-    return plugins;
+    });
+    return __privateGet(this, _promiseManager).run("seq", promises);
   }
-  getPlugin(hookName, pluginName2) {
+  getPluginsByKey(hookName, pluginKey) {
     const plugins = [...this.plugins];
-    const pluginByPluginName = plugins.find((item) => item.name === pluginName2 && item[hookName]);
-    if (!pluginByPluginName) {
-      return this.#core;
+    const [searchKind, searchPluginName, searchIdentifier] = pluginKey;
+    const pluginByPluginName = plugins.filter((plugin) => plugin[hookName]).filter((item) => {
+      const [kind, 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 kindCheck && nameCheck;
+    });
+    if (!pluginByPluginName?.length) {
+      const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
+      if (this.logger.logLevel === "info") {
+        if (corePlugin) {
+          this.logger.warn(`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`);
+        }
+      }
+      return corePlugin ? [corePlugin] : [];
     }
     return pluginByPluginName;
   }
-  #addExecutedToCallStack(executer) {
-    if (executer) {
-      this.eventEmitter.emit("execute", executer);
-      this.executed.push(executer);
-    }
-  }
-  /**
-   * Run an async plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The actual pluginObject to run.
-   */
-  // Implementation signature
-  #execute({
-    strategy,
-    hookName,
-    parameters,
-    plugin
-  }) {
-    const hook = plugin[hookName];
-    let output;
-    if (!hook) {
-      return null;
+  static getDependedPlugins(plugins, dependedPluginNames) {
+    let pluginNames = [];
+    if (typeof dependedPluginNames === "string") {
+      pluginNames = [dependedPluginNames];
+    } else {
+      pluginNames = dependedPluginNames;
     }
-    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
-    const task = Promise.resolve().then(() => {
-      if (typeof hook === "function") {
-        const possiblePromiseResult = hook.apply({ ...this.#core.api, plugin }, parameters);
-        if (isPromise(possiblePromiseResult)) {
-          return Promise.resolve(possiblePromiseResult);
-        }
-        return possiblePromiseResult;
+    return pluginNames.map((pluginName2) => {
+      const plugin = plugins.find((plugin2) => plugin2.name === pluginName2);
+      if (!plugin) {
+        throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
       }
-      return hook;
-    }).then((result) => {
-      output = result;
-      return result;
-    }).catch((e) => {
-      this.#catcher(e, plugin, hookName);
-      return null;
-    }).finally(() => {
-      this.#addExecutedToCallStack({
-        parameters,
-        output,
-        strategy,
-        hookName,
-        plugin
-      });
+      return plugin;
     });
-    return task;
   }
-  /**
-   * Run a sync plugin hook and return the result.
-   * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-   * @param args Arguments passed to the plugin hook.
-   * @param plugin The acutal plugin
-   * @param replaceContext When passed, the plugin context can be overridden.
-   */
-  #executeSync({
-    strategy,
-    hookName,
-    parameters,
-    plugin
-  }) {
-    const hook = plugin[hookName];
-    let output;
-    if (!hook) {
-      return null;
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  static get hooks() {
+    return ["validate", "buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
+  }
+};
+_core = new WeakMap();
+_usedPluginNames = new WeakMap();
+_promiseManager = new WeakMap();
+_getSortedPlugins = new WeakSet();
+getSortedPlugins_fn = function(hookName) {
+  const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
+  if (hookName) {
+    if (this.logger.logLevel === "info") {
+      const containsHookName = plugins.some((item) => item[hookName]);
+      if (!containsHookName) {
+        this.logger.warn(`No hook ${hookName} found`);
+      }
     }
-    this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
-    try {
-      if (typeof hook === "function") {
-        const fn = hook.apply(this.#core.api, parameters);
-        output = fn;
-        return fn;
+    return plugins.filter((item) => item[hookName]);
+  }
+  return plugins;
+};
+_addExecutedToCallStack = new WeakSet();
+addExecutedToCallStack_fn = function(executer) {
+  if (executer) {
+    this.eventEmitter.emit("executed", executer);
+    this.executed.push(executer);
+  }
+};
+_execute = new WeakSet();
+execute_fn = function({
+  strategy,
+  hookName,
+  parameters,
+  plugin
+}) {
+  const hook = plugin[hookName];
+  let output;
+  if (!hook) {
+    return null;
+  }
+  this.eventEmitter.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);
+      if (isPromise(possiblePromiseResult)) {
+        return Promise.resolve(possiblePromiseResult);
       }
-      output = hook;
-      return hook;
-    } catch (e) {
-      this.#catcher(e, plugin, hookName);
-      return null;
-    } finally {
-      this.#addExecutedToCallStack({
-        parameters,
-        output,
-        strategy,
-        hookName,
-        plugin
-      });
+      return possiblePromiseResult;
     }
+    return hook;
+  }).then((result) => {
+    output = result;
+    __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
+      parameters,
+      output,
+      strategy,
+      hookName,
+      plugin
+    });
+    return result;
+  }).catch((e) => {
+    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
+  });
+  return task;
+};
+_executeSync = new WeakSet();
+executeSync_fn = function({
+  strategy,
+  hookName,
+  parameters,
+  plugin
+}) {
+  const hook = plugin[hookName];
+  let output;
+  if (!hook) {
+    return null;
   }
-  #catcher(e, plugin, hookName) {
-    const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
-`;
-    const pluginError = new PluginError(text, { cause: e, pluginManager: this });
-    this.eventEmitter.emit("error", pluginError);
-    throw pluginError;
+  this.eventEmitter.emit("execute", { strategy, hookName, parameters, plugin });
+  try {
+    if (typeof hook === "function") {
+      const fn = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
+      output = fn;
+      return fn;
+    }
+    output = hook;
+    __privateMethod(this, _addExecutedToCallStack, addExecutedToCallStack_fn).call(this, {
+      parameters,
+      output,
+      strategy,
+      hookName,
+      plugin
+    });
+    return hook;
+  } catch (e) {
+    __privateMethod(this, _catcher, catcher_fn).call(this, e, plugin, hookName);
+    return null;
   }
 };
-function noReturn() {
-}
-
-// src/managers/pluginManager/validate.ts
-var ValidationPluginError = class extends Error {
+_catcher = new WeakSet();
+catcher_fn = function(e, plugin, hookName) {
+  const text = `${e.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})
+`;
+  this.logger.error(text);
+  this.eventEmitter.emit("error", e);
 };
-function getDependedPlugins(plugins, dependedPluginNames) {
-  let pluginNames = [];
-  if (typeof dependedPluginNames === "string") {
-    pluginNames = [dependedPluginNames];
-  } else {
-    pluginNames = dependedPluginNames;
-  }
-  return pluginNames.map((pluginName2) => {
-    const plugin = plugins.find((plugin2) => plugin2.name === pluginName2);
-    if (!plugin) {
-      throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
-    }
-    return plugin;
-  });
-}
-
-// src/types.ts
-var LogLevel = {
-  silent: "silent",
-  info: "info",
-  debug: "debug"
+_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");
+  }
+  if (!plugin.transform) {
+    plugin.transform = function transform(code) {
+      return code;
+    };
+  }
+  if (plugin.api && typeof plugin.api === "function") {
+    const api = plugin.api.call(context);
+    return {
+      ...plugin,
+      key,
+      api
+    };
+  }
+  return {
+    ...plugin,
+    key
+  };
 };
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
   return result;
 }
-async function build(options) {
-  const { config, logLevel, logger = createLogger() } = options;
+async function setup(options) {
+  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
   try {
-    if ("path" in config.input && !new URLPath(config.input.path).isURL) {
+    if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
       await read(config.input.path);
     }
   } catch (e) {
-    if ("path" in config.input) {
+    if (isInputPath(config)) {
       throw new Error(
         "Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config " + pc3__default.default.dim(config.input.path),
         {
@@ -1583,11 +1711,11 @@ async function build(options) {
     await clean(config.output.path);
   }
   const queueTask = async (file) => {
-    const { path: path3 } = file;
-    let code = createFileSource(file);
+    const { path: path5 } = file;
+    let code = FileManager.getSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
-      parameters: [path3]
+      parameters: [path5]
     });
     if (loadedResult && isPromise(loadedResult)) {
       code = await loadedResult;
@@ -1598,28 +1726,52 @@ async function build(options) {
     if (code) {
       const transformedCode = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path3],
+        parameters: [code, path5],
         reduce: transformReducer
       });
       if (config.output.write || config.output.write === void 0) {
-        await pluginManager.hookParallel({
+        if (file.meta?.pluginKey) {
+          return pluginManager.hookForPlugin({
+            pluginKey: file.meta?.pluginKey,
+            hookName: "writeFile",
+            parameters: [transformedCode, path5]
+          });
+        }
+        return pluginManager.hookFirst({
           hookName: "writeFile",
-          parameters: [transformedCode, path3]
+          parameters: [transformedCode, path5]
         });
       }
     }
   };
-  const pluginManager = new PluginManager(config, { debug: logLevel === LogLevel.debug, logger, task: queueTask });
-  const { plugins, fileManager } = pluginManager;
+  const pluginManager = new PluginManager(config, { logger, task: queueTask, writeTimeout: 0 });
   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__default.default.dim(JSON.stringify(plugin.key))} 
+with source
+
+${code}`);
+      }
+    }
+  });
+  pluginManager.on("executed", (executer) => {
     const { hookName, plugin, output, parameters } = executer;
     const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`;
-    if (logLevel === LogLevel.info) {
-      if (logger.spinner) {
+    if (logger.logLevel === LogLevel.info && logger.spinner) {
+      if (hookName === "writeFile") {
+        const [_code, path5] = parameters;
+        logger.spinner.suffixText = pc3__default.default.dim(path5);
+      } else {
         logger.spinner.suffixText = messsage;
       }
     }
-    if (logLevel === LogLevel.debug) {
+    if (logger.logLevel === LogLevel.debug) {
       logger.info(messsage);
       const logs = [
         parameters && `${pc3__default.default.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
@@ -1630,102 +1782,131 @@ async function build(options) {
       console.log(logs.join("\n"));
     }
   });
+  return pluginManager;
+}
+async function build(options) {
+  const pluginManager = await setup(options);
+  const { fileManager, logger } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
-    parameters: [plugins]
+    parameters: [pluginManager.plugins]
   });
   await pluginManager.hookParallel({
     hookName: "buildStart",
-    parameters: [config]
+    parameters: [options.config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  return { files: fileManager.files.map((file) => ({ ...file, source: createFileSource(file) })), pluginManager };
+  if (!fileManager.isExecuting && logger.spinner) {
+    logger.spinner.suffixText = "";
+    logger.spinner.succeed(`\u{1F4BE} Writing completed`);
+  }
+  return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager };
 }
-
-// src/config.ts
-function defineConfig(options) {
-  return options;
+async function safeBuild(options) {
+  const pluginManager = await setup(options);
+  const { fileManager, logger } = pluginManager;
+  try {
+    await pluginManager.hookParallel({
+      hookName: "validate",
+      parameters: [pluginManager.plugins]
+    });
+    await pluginManager.hookParallel({
+      hookName: "buildStart",
+      parameters: [options.config]
+    });
+    await pluginManager.hookParallel({ hookName: "buildEnd" });
+    if (!fileManager.isExecuting && 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/generators/Generator.ts
+// src/Generator.ts
+var _options3, _context;
 var Generator = class {
-  #options = {};
-  #context = {};
   constructor(options, context) {
+    __privateAdd(this, _options3, {});
+    __privateAdd(this, _context, {});
     if (context) {
-      this.#context = context;
+      __privateSet(this, _context, context);
     }
     if (options) {
-      this.#options = options;
+      __privateSet(this, _options3, options);
     }
     return this;
   }
   get options() {
-    return this.#options;
+    return __privateGet(this, _options3);
   }
   get context() {
-    return this.#context;
+    return __privateGet(this, _context);
   }
   set options(options) {
-    this.#options = { ...this.#options, ...options };
+    __privateSet(this, _options3, { ...__privateGet(this, _options3), ...options });
   }
 };
-
-// src/generators/SchemaGenerator.ts
-var SchemaGenerator = class extends Generator {
-};
+_options3 = new WeakMap();
+_context = new WeakMap();
 
 // ../../node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
 var Node = class {
-  value;
-  next;
   constructor(value) {
+    __publicField(this, "value");
+    __publicField(this, "next");
     this.value = value;
   }
 };
+var _head, _tail, _size;
 var Queue2 = class {
-  #head;
-  #tail;
-  #size;
   constructor() {
+    __privateAdd(this, _head, void 0);
+    __privateAdd(this, _tail, void 0);
+    __privateAdd(this, _size, void 0);
     this.clear();
   }
   enqueue(value) {
     const node = new Node(value);
-    if (this.#head) {
-      this.#tail.next = node;
-      this.#tail = node;
+    if (__privateGet(this, _head)) {
+      __privateGet(this, _tail).next = node;
+      __privateSet(this, _tail, node);
     } else {
-      this.#head = node;
-      this.#tail = node;
+      __privateSet(this, _head, node);
+      __privateSet(this, _tail, node);
     }
-    this.#size++;
+    __privateWrapper(this, _size)._++;
   }
   dequeue() {
-    const current = this.#head;
+    const current = __privateGet(this, _head);
     if (!current) {
       return;
     }
-    this.#head = this.#head.next;
-    this.#size--;
+    __privateSet(this, _head, __privateGet(this, _head).next);
+    __privateWrapper(this, _size)._--;
     return current.value;
   }
   clear() {
-    this.#head = void 0;
-    this.#tail = void 0;
-    this.#size = 0;
+    __privateSet(this, _head, void 0);
+    __privateSet(this, _tail, void 0);
+    __privateSet(this, _size, 0);
   }
   get size() {
-    return this.#size;
+    return __privateGet(this, _size);
   }
   *[Symbol.iterator]() {
-    let current = this.#head;
+    let current = __privateGet(this, _head);
     while (current) {
       yield current.value;
       current = current.next;
     }
   }
 };
+_head = new WeakMap();
+_tail = new WeakMap();
+_size = new WeakMap();
 
 // ../../node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
 function pLimit(concurrency) {
@@ -1740,18 +1921,18 @@ function pLimit(concurrency) {
       queue.dequeue()();
     }
   };
-  const run = async (fn, resolve, args) => {
+  const run = async (fn, resolve2, args) => {
     activeCount++;
     const result = (async () => fn(...args))();
-    resolve(result);
+    resolve2(result);
     try {
       await result;
     } catch {
     }
     next();
   };
-  const enqueue = (fn, resolve, args) => {
-    queue.enqueue(run.bind(void 0, fn, resolve, args));
+  const enqueue = (fn, resolve2, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve2, args));
     (async () => {
       await Promise.resolve();
       if (activeCount < concurrency && queue.size > 0) {
@@ -1759,8 +1940,8 @@ function pLimit(concurrency) {
       }
     })();
   };
-  const generator = (fn, ...args) => new Promise((resolve) => {
-    enqueue(fn, resolve, args);
+  const generator = (fn, ...args) => new Promise((resolve2) => {
+    enqueue(fn, resolve2, args);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -1835,7 +2016,7 @@ async function locatePath(paths, {
   const statFunction = allowSymlinks ? fs3.promises.stat : fs3.promises.lstat;
   return pLocate(paths, async (path_) => {
     try {
-      const stat = await statFunction(path2__default.default.resolve(cwd, path_));
+      const stat = await statFunction(path4__default.default.resolve(cwd, path_));
       return matchType(type, stat);
     } catch {
       return false;
@@ -1852,7 +2033,7 @@ function locatePathSync(paths, {
   const statFunction = allowSymlinks ? fs3__default.default.statSync : fs3__default.default.lstatSync;
   for (const path_ of paths) {
     try {
-      const stat = statFunction(path2__default.default.resolve(cwd, path_), {
+      const stat = statFunction(path4__default.default.resolve(cwd, path_), {
         throwIfNoEntry: false
       });
       if (!stat) {
@@ -1870,9 +2051,9 @@ function locatePathSync(paths, {
 var toPath2 = (urlOrPath) => urlOrPath instanceof URL ? url.fileURLToPath(urlOrPath) : urlOrPath;
 var findUpStop = Symbol("findUpStop");
 async function findUpMultiple(name, options = {}) {
-  let directory = path2__default.default.resolve(toPath2(options.cwd) || "");
-  const { root } = path2__default.default.parse(directory);
-  const stopAt = path2__default.default.resolve(directory, options.stopAt || root);
+  let directory = path4__default.default.resolve(toPath2(options.cwd) || "");
+  const { root } = path4__default.default.parse(directory);
+  const stopAt = path4__default.default.resolve(directory, options.stopAt || root);
   const limit = options.limit || Number.POSITIVE_INFINITY;
   const paths = [name].flat();
   const runMatcher = async (locateOptions) => {
@@ -1892,18 +2073,18 @@ async function findUpMultiple(name, options = {}) {
       break;
     }
     if (foundPath) {
-      matches.push(path2__default.default.resolve(directory, foundPath));
+      matches.push(path4__default.default.resolve(directory, foundPath));
     }
     if (directory === stopAt || matches.length >= limit) {
       break;
     }
-    directory = path2__default.default.dirname(directory);
+    directory = path4__default.default.dirname(directory);
   }
   return matches;
 }
 function findUpMultipleSync(name, options = {}) {
-  let directory = path2__default.default.resolve(toPath2(options.cwd) || "");
-  const { root } = path2__default.default.parse(directory);
+  let directory = path4__default.default.resolve(toPath2(options.cwd) || "");
+  const { root } = path4__default.default.parse(directory);
   const stopAt = options.stopAt || root;
   const limit = options.limit || Number.POSITIVE_INFINITY;
   const paths = [name].flat();
@@ -1924,12 +2105,12 @@ function findUpMultipleSync(name, options = {}) {
       break;
     }
     if (foundPath) {
-      matches.push(path2__default.default.resolve(directory, foundPath));
+      matches.push(path4__default.default.resolve(directory, foundPath));
     }
     if (directory === stopAt || matches.length >= limit) {
       break;
     }
-    directory = path2__default.default.dirname(directory);
+    directory = path4__default.default.dirname(directory);
   }
   return matches;
 }
@@ -1941,39 +2122,40 @@ function findUpSync(name, options = {}) {
   const matches = findUpMultipleSync(name, { ...options, limit: 1 });
   return matches[0];
 }
-var PackageManager = class _PackageManager {
-  static #cache = {};
-  #cwd;
-  #SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
+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) {
-      this.#cwd = workspace;
+      __privateSet(this, _cwd, workspace);
     }
     return this;
   }
   set workspace(workspace) {
-    this.#cwd = workspace;
+    __privateSet(this, _cwd, workspace);
   }
   get workspace() {
-    return this.#cwd;
+    return __privateGet(this, _cwd);
   }
   normalizeDirectory(directory) {
-    if (!this.#SLASHES.has(directory[directory.length - 1])) {
+    if (!__privateGet(this, _SLASHES).has(directory[directory.length - 1])) {
       return `${directory}/`;
     }
     return directory;
   }
-  getLocation(path3) {
-    let location = path3;
-    if (this.#cwd) {
-      const require2 = mod__default.default.createRequire(this.normalizeDirectory(this.#cwd));
-      location = require2.resolve(path3);
+  getLocation(path5) {
+    let location = path5;
+    if (__privateGet(this, _cwd)) {
+      const require2 = mod__default.default.createRequire(this.normalizeDirectory(__privateGet(this, _cwd)));
+      location = require2.resolve(path5);
     }
     return location;
   }
-  async import(path3) {
+  async import(path5) {
     try {
-      let location = this.getLocation(path3);
+      let location = this.getLocation(path5);
       if (os__default.default.platform() == "win32") {
         location = url.pathToFileURL(location).href;
       }
@@ -1986,7 +2168,7 @@ var PackageManager = class _PackageManager {
   }
   async getPackageJSON() {
     const pkgPath = await findUp(["package.json"], {
-      cwd: this.#cwd
+      cwd: __privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
@@ -1995,7 +2177,7 @@ var PackageManager = class _PackageManager {
   }
   getPackageJSONSync() {
     const pkgPath = findUpSync(["package.json"], {
-      cwd: this.#cwd
+      cwd: __privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
@@ -2003,33 +2185,36 @@ var PackageManager = class _PackageManager {
     return __require(pkgPath);
   }
   static setVersion(dependency, version) {
-    _PackageManager.#cache[dependency] = version;
+    __privateGet(_PackageManager, _cache2)[dependency] = version;
   }
   async getVersion(dependency) {
-    if (_PackageManager.#cache[dependency]) {
-      return _PackageManager.#cache[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 (_PackageManager.#cache[dependency]) {
-      return _PackageManager.#cache[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 = semver.coerce(packageVersion);
     if (!semVer) {
       throw new Error(`${packageVersion} is not valid`);
@@ -2048,68 +2233,48 @@ var PackageManager = class _PackageManager {
     return semver.satisfies(semVer, version);
   }
 };
+_cache2 = new WeakMap();
+_cwd = new WeakMap();
+_SLASHES = new WeakMap();
+_match = new WeakSet();
+match_fn = function(packageJSON, dependency) {
+  const dependencies = {
+    ...packageJSON["dependencies"] || {},
+    ...packageJSON["devDependencies"] || {}
+  };
+  if (typeof dependency === "string" && dependencies[dependency]) {
+    return dependencies[dependency];
+  }
+  const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
+  return matchedDependency ? dependencies[matchedDependency] : void 0;
+};
+__privateAdd(_PackageManager, _cache2, {});
+var PackageManager = _PackageManager;
+
+// src/SchemaGenerator.ts
+var SchemaGenerator = class extends Generator {
+};
 
 // src/index.ts
 var src_default = build;
 
-Object.defineProperty(exports, 'pc', {
-  enumerable: true,
-  get: function () { return pc3__default.default; }
-});
 exports.FileManager = FileManager;
-exports.FunctionParams = FunctionParams;
 exports.Generator = Generator;
-exports.LogLevel = LogLevel;
 exports.PackageManager = PackageManager;
-exports.ParallelPluginError = ParallelPluginError;
-exports.PluginError = PluginError;
 exports.PluginManager = PluginManager;
-exports.Queue = Queue;
+exports.PromiseManager = PromiseManager;
 exports.SchemaGenerator = SchemaGenerator;
-exports.SummaryError = SummaryError;
-exports.TreeNode = TreeNode;
-exports.URLPath = URLPath;
 exports.ValidationPluginError = ValidationPluginError;
 exports.Warning = Warning;
 exports.build = build;
-exports.clean = clean;
-exports.combineCodes = combineCodes;
 exports.combineExports = combineExports;
-exports.combineFiles = combineFiles;
 exports.combineImports = combineImports;
-exports.createFileSource = createFileSource;
-exports.createJSDocBlockText = createJSDocBlockText;
-exports.createLogger = createLogger;
 exports.createPlugin = createPlugin;
-exports.createPluginCache = createPluginCache;
 exports.default = src_default;
-exports.defaultColours = defaultColours;
 exports.defineConfig = defineConfig;
-exports.escape = escape;
-exports.extensions = extensions;
-exports.getDependedPlugins = getDependedPlugins;
-exports.getIndexes = getIndexes;
-exports.getPathMode = getPathMode;
-exports.getRelativePath = getRelativePath;
-exports.getUniqueName = getUniqueName;
-exports.hooks = hooks;
-exports.isExtensionAllowed = isExtensionAllowed;
-exports.isPromise = isPromise;
-exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
-exports.isPromiseRejectedResult = isPromiseRejectedResult;
-exports.jsStringEscape = jsStringEscape;
+exports.isInputPath = isInputPath;
 exports.name = pluginName;
-exports.nameSorter = nameSorter;
 exports.pluginName = pluginName;
-exports.randomColour = randomColour;
-exports.randomPicoColour = randomPicoColour;
-exports.read = read;
-exports.readSync = readSync;
-exports.renderTemplate = renderTemplate;
-exports.throttle = throttle;
-exports.timeout = timeout;
-exports.transformReservedWord = transformReservedWord;
-exports.uniqueIdFactory = uniqueIdFactory;
-exports.write = write;
+exports.safeBuild = safeBuild;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map