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

package/dist/index.js

@@ -1,18 +1,18 @@
 import mod, { createRequire } from 'module';
 import pc3 from 'picocolors';
-export { default as pc } from 'picocolors';
-import crypto from 'crypto';
 import fs2, { remove } from 'fs-extra';
-import { camelCase, camelCaseTransformMerge } from 'change-case';
-import { orderBy } from 'natural-orderby';
-import { performance } from 'perf_hooks';
 import seedrandom from 'seedrandom';
-import pathParser from 'path';
 import { switcher } from 'js-runtime';
-import dirTree from 'directory-tree';
-import { createImportDeclaration, print, createExportDeclaration } from '@kubb/parser';
+import { camelCase, camelCaseTransformMerge } from 'change-case';
+import crypto2 from 'crypto';
+import path, { resolve, dirname, extname } from 'path';
+import { print } from '@kubb/parser';
+import * as factory from '@kubb/parser/factory';
 import isEqual from 'lodash.isequal';
+import { orderBy } from 'natural-orderby';
+import dirTree from 'directory-tree';
 import { EventEmitter as EventEmitter$1 } from 'events';
+import { performance } from 'perf_hooks';
 import os from 'os';
 import { pathToFileURL } from 'url';
 import { findUp, findUpSync } from 'find-up';
@@ -27,110 +27,45 @@ 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(path) {
-  return remove(path);
-}
-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 = 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 : camelCase(name, { delimiter: "", transform: 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 __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
 };
-
-// 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 __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(path3) {
+  return remove(path3);
 }
-function createLogger(spinner) {
+var LogLevel = {
+  silent: "silent",
+  info: "info",
+  debug: "debug"
+};
+function createLogger({ logLevel, name, spinner }) {
   const logs = [];
   const log = (message) => {
     if (message && spinner) {
@@ -150,12 +85,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,
@@ -165,75 +102,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.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.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) {
-        performance.mark(name + "_start");
-      }
-      job().then((result) => {
-        resolve(result);
-        if (this.#debug) {
-          performance.mark(name + "_stop");
-          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) {
@@ -260,46 +128,22 @@ function randomPicoColour(text, colors = defaultColours) {
   }
   return formatter(text);
 }
-function slash(path, platform = "linux") {
-  const isWindowsPath = /^\\\\\?\\/.test(path);
-  if (["linux", "mac"].includes(platform) && !isWindowsPath) {
-    return path.replaceAll(/\\/g, "/").replace("../", "").trimEnd();
-  }
-  return path.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 = pathParser.relative(rootDir, filePath);
-  const path = slash(relativePath, platform);
-  if (path.startsWith("../")) {
-    return path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)));
-  }
-  return `./${path.replace(pathParser.basename(path), pathParser.basename(path, pathParser.extname(filePath)))}`;
-}
-function getPathMode(path) {
-  if (!path) {
-    return "directory";
-  }
-  return pathParser.extname(path) ? "file" : "directory";
-}
 var reader = switcher(
   {
-    node: async (path) => {
-      return fs2.readFile(path, { encoding: "utf8" });
+    node: async (path3) => {
+      return fs2.readFile(path3, { encoding: "utf8" });
     },
-    bun: async (path) => {
-      const file = Bun.file(path);
+    bun: async (path3) => {
+      const file = Bun.file(path3);
       return file.text();
     }
   },
   "node"
 );
-var syncReader = switcher(
+switcher(
   {
-    node: (path) => {
-      return fs2.readFileSync(path, { encoding: "utf8" });
+    node: (path3) => {
+      return fs2.readFileSync(path3, { encoding: "utf8" });
     },
     bun: () => {
       throw new Error("Bun cannot read sync");
@@ -307,79 +151,118 @@ var syncReader = switcher(
   },
   "node"
 );
-async function read(path) {
-  return reader(path);
+async function read(path3) {
+  return reader(path3);
 }
-function readSync(path) {
-  return syncReader(path);
-}
-
-// 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(path3) {
+    this.path = path3;
+    return this;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  get URL() {
+    return this.toURLPath();
+  }
+  get isURL() {
+    try {
+      const url = new URL(this.path);
+      if (url?.href) {
+        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(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge });
+        const replacement = `\${${pathParam}}`;
+        return prev.replace(curr, replacement);
+      }, this.path);
+    }
+    return `\`${newPath}\``;
+  }
+  getParams(replacer) {
+    const regex = /{(\w|-)*}/g;
+    const found = this.path.match(regex);
+    if (!found) {
+      return void 0;
+    }
+    const params = {};
+    found.forEach((item) => {
+      item = item.replaceAll("{", "").replaceAll("}", "");
+      const pathParam = replacer ? replacer(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: camelCaseTransformMerge });
+      params[pathParam] = pathParam;
+    }, this.path);
+    return params;
+  }
+  /**
+   * Convert Swagger path to URLPath(syntax of Express)
+   * @example /pet/{petId} => /pet/:petId
+   */
+  toURLPath() {
+    return this.path.replaceAll("{", ":").replaceAll("}", "");
+  }
 };
 
+// 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);
   });
 }
@@ -389,6 +272,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("`", "\\`") : "";
@@ -414,24 +313,57 @@ function jsStringEscape(input) {
   });
 }
 
-// src/utils/transformers/transformReservedWord.ts
-var reservedWords = [
-  "abstract",
-  "arguments",
-  "boolean",
-  "break",
-  "byte",
-  "case",
-  "catch",
-  "char",
-  "class",
-  "const",
-  "continue",
-  "debugger",
-  "default",
-  "delete",
-  "do",
-  "double",
+// src/utils/transformers/indent.ts
+function createIndent(size) {
+  return Array.from({ length: size + 1 }).join(" ");
+}
+
+// src/utils/transformers/nameSorter.ts
+function nameSorter(a, b) {
+  if (a.name < b.name) {
+    return -1;
+  }
+  if (a.name > b.name) {
+    return 1;
+  }
+  return 0;
+}
+
+// src/utils/transformers/searchAndReplace.ts
+function searchAndReplace(options) {
+  const { text, replaceBy, prefix = "", key } = options;
+  const searchValues = options.searchValues?.(prefix, key) || [
+    `${prefix}["${key}"]`,
+    `${prefix}['${key}']`,
+    `${prefix}[\`${key}\`]`,
+    `${prefix}"${key}"`,
+    `${prefix}'${key}'`,
+    `${prefix}\`${key}\``,
+    new RegExp(`${prefix}${key}`, "g")
+  ];
+  return searchValues.reduce((prev, searchValue) => {
+    return prev.toString().replaceAll(searchValue, replaceBy);
+  }, text);
+}
+
+// src/utils/transformers/transformReservedWord.ts
+var reservedWords = [
+  "abstract",
+  "arguments",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
   "else",
   "enum",
   "eval",
@@ -506,11 +438,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(path3) {
+  const passedPath = dirname(resolve(path3));
+  await fs2.mkdir(passedPath, { recursive: true });
+}
+var writer = switcher(
+  {
+    node: async (path3, data) => {
+      try {
+        await fs2.stat(resolve(path3));
+        const oldContent = await fs2.readFile(resolve(path3), { encoding: "utf-8" });
+        if (oldContent?.toString() === data?.toString()) {
+          return;
+        }
+      } catch (_err) {
+      }
+      await saveCreateDirectory(path3);
+      await fs2.writeFile(resolve(path3), data, { encoding: "utf-8" });
+      const savedData = await fs2.readFile(resolve(path3), { encoding: "utf-8" });
+      if (savedData?.toString() !== data?.toString()) {
+        throw new Error(`Sanity check failed for ${path3}
+
+Data[${data.length}]:
+${data}
+
+Saved[${savedData.length}]:
+${savedData}
+`);
+      }
+      return savedData;
+    },
+    bun: async (path3, data) => {
+      try {
+        await saveCreateDirectory(path3);
+        await Bun.write(resolve(path3), data);
+        const file = Bun.file(resolve(path3));
+        const savedData = await file.text();
+        if (savedData?.toString() !== data?.toString()) {
+          throw new Error(`Sanity check failed for ${path3}
+
+Data[${data.length}]:
+${data}
+
+Saved[${savedData.length}]:
+${savedData}
+`);
+        }
+        return savedData;
+      } catch (e) {
+        console.log(e, resolve(path3));
+      }
+    }
+  },
+  "node"
+);
+async function write(data, path3) {
+  if (data.trim() === "") {
+    return void 0;
+  }
+  return writer(path3, data.trim());
+}
 var TreeNode = class _TreeNode {
-  data;
-  parent;
-  children = [];
   constructor(data, parent) {
+    this.children = [];
     this.data = data;
     this.parent = parent;
     return this;
@@ -570,16 +580,16 @@ var TreeNode = class _TreeNode {
     }
     return this;
   }
-  static build(path, options = {}) {
+  static build(path3, options = {}) {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] });
+      const filteredTree = dirTree(path3, { 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);
@@ -594,227 +604,290 @@ var TreeNode = class _TreeNode {
   }
 };
 
-// src/utils/uniqueIdFactory.ts
-var uniqueIdFactory = (counter) => (str = "") => `${str}${++counter}`;
-var URLPath = class {
-  path;
-  constructor(path) {
-    this.path = path;
+// 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 = path.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 = path.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
+var KubbFile;
+((KubbFile2) => {
+})(KubbFile || (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(camelCase(curr, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(curr, { delimiter: "", transform: 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(camelCase(item, { delimiter: "", transform: camelCaseTransformMerge })) : camelCase(item, { delimiter: "", transform: 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(path3) {
+    return __privateGet(this, _cache).get(path3);
   }
-};
-async function saveCreateDirectory(path) {
-  const passedPath = pathParser.dirname(pathParser.resolve(path));
-  await fs2.mkdir(passedPath, { recursive: true });
-}
-var writer = switcher(
-  {
-    node: async (path, data) => {
-      try {
-        await fs2.stat(path);
-        const oldContent = await fs2.readFile(path, { encoding: "utf-8" });
-        if (oldContent?.toString() === data) {
-          return;
-        }
-      } catch (_err) {
-      }
-      await saveCreateDirectory(path);
-      return fs2.writeFile(pathParser.resolve(path), data, { encoding: "utf-8" });
-    },
-    bun: async (path, data) => {
-      try {
-        await saveCreateDirectory(path);
-        await Bun.write(pathParser.resolve(path), data);
-      } catch (e) {
-        console.log(e, pathParser.resolve(path));
-      }
-    }
-  },
-  "node"
-);
-async function write(data, path) {
-  return writer(path, data);
-}
-function getIndexes(root, extName, options = {}) {
-  const extMapper = {
-    ".ts": {
-      extensions: /\.ts/,
-      exclude: [/schemas/, /json/]
-    },
-    ".json": {
-      extensions: /\.json/,
-      exclude: []
+  remove(path3) {
+    const cacheItem = this.get(path3);
+    if (!cacheItem) {
+      return;
     }
-  };
-  const tree = TreeNode.build(root, { ...extMapper[extName] || {}, ...options });
-  if (!tree) {
-    return null;
+    __privateGet(this, _cache).delete(path3);
   }
-  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 path = pathParser.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") && path.includes("index")) {
-          return void 0;
-        }
-        return { path: importPath };
-      }).filter(Boolean);
-      files2.push({
-        path,
-        baseName: "index.ts",
-        source: "",
-        exports
-      });
-    } else {
-      currentTree.children?.forEach((child) => {
-        const path = pathParser.resolve(currentTree.data.path, "index.ts");
-        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-        files2.push({
-          path,
-          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.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
+    const exportNodes = exports.map(
+      (item) => factory.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
+    );
+    return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
+  }
+  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(path3) {
+    if (!path3) {
+      return "directory";
     }
-    return acc;
-  }, []);
-}
-var extensions = [".js", ".ts", ".tsx"];
-function isExtensionAllowed(baseName) {
-  return extensions.some((extension) => baseName.endsWith(extension));
-}
+    return extname(path3) ? "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.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 = orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     const name = curr.name;
     const prevByPath = prev.findLast((imp) => imp.path === curr.path);
+    const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly);
+    if (prevByPathAndIsTypeOnly) {
+      return prev;
+    }
     const uniquePrev = prev.findLast(
       (imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
     );
@@ -836,12 +909,16 @@ function combineExports(exports) {
     }
     return [...prev, curr];
   }, []);
+  return orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
 }
 function combineImports(imports, exports, source) {
-  return imports.reduce((prev, curr) => {
+  const combinedImports = 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)) {
@@ -849,6 +926,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(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+    const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isEqual(imp.name, name) && imp.isTypeOnly);
+    if (prevByPathNameAndIsTypeOnly) {
+      return prev;
+    }
     if (uniquePrev || Array.isArray(name) && !name.length) {
       return prev;
     }
@@ -870,43 +951,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) => createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }));
-  const importSource = print(importNodes);
-  const exportNodes = exports.map((item) => createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias }));
-  const exportSource = 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 orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
 }
 function getEnvSource(source, env) {
   if (!env) {
@@ -923,175 +968,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 EventEmitter$1());
+    __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.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.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(path, file) {
-    const previousFiles = this.#cache.get(path) || [];
-    this.#cache.set(path, [...previousFiles, file]);
-  }
-  getCacheByUUID(UUID) {
-    let cache;
-    this.#cache.forEach((files) => {
-      cache = files.find((item) => item.id === UUID);
+      __privateGet(this, _queue2).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
     });
-    return cache;
   }
-  get(path) {
-    return this.#cache.get(path);
+  runSync(job, options = { controller: new AbortController(), name: crypto2.randomUUID(), description: "" }) {
+    new Promise((resolve2, reject) => {
+      const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
+      options.controller?.signal.addEventListener("abort", () => {
+        __privateSet(this, _queue2, __privateGet(this, _queue2).filter((queueItem) => queueItem.name === item.name));
+      });
+      __privateGet(this, _queue2).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
+    });
   }
-  remove(path) {
-    const cacheItem = this.get(path);
-    if (!cacheItem) {
-      return;
-    }
-    this.#cache.delete(path);
+  get hasJobs() {
+    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue2).length > 0;
   }
-  async write(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return write(...params);
-      });
-    }
-    return write(...params);
+  get count() {
+    return __privateGet(this, _workerCount);
   }
-  async read(...params) {
-    if (this.#queue) {
-      return this.#queue.run(async () => {
-        return read(...params);
-      });
-    }
-    return read(...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;
+  }
+  __privateWrapper(this, _workerCount)._++;
+  let entry;
+  while (entry = __privateGet(this, _queue2).shift()) {
+    const { reject, resolve: resolve2, job, name, description } = entry;
+    if (__privateGet(this, _debug)) {
+      performance.mark(name + "_start");
+    }
+    job().then((result) => {
+      this.eventEmitter.emit("jobDone", result);
+      resolve2(result);
+      if (__privateGet(this, _debug)) {
+        performance.mark(name + "_stop");
+        performance.measure(description, name + "_start", name + "_stop");
+      }
+    }).catch((err) => {
+      this.eventEmitter.emit("jobFailed", err);
+      reject(err);
+    });
   }
+  __privateWrapper(this, _workerCount)._--;
 };
 
-// src/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";
@@ -1100,6 +1127,8 @@ var definePlugin = createPlugin((options) => {
   return {
     name: pluginName,
     options,
+    key: ["controller", "core"],
+    kind: "controller",
     api() {
       return {
         get config() {
@@ -1108,18 +1137,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,
@@ -1127,75 +1156,156 @@ var definePlugin = createPlugin((options) => {
       };
     },
     resolvePath(baseName) {
-      const root = pathParser.resolve(this.config.root, this.config.output.path);
-      return pathParser.resolve(root, baseName);
+      const root = path.resolve(this.config.root, this.config.output.path);
+      return path.resolve(root, baseName);
     },
     resolveName(name) {
       return name;
     }
   };
 });
-var EventEmitter = class {
-  constructor() {
-    this.#emitter.setMaxListeners(100);
-  }
-  #emitter = new EventEmitter$1();
-  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,
@@ -1203,44 +1313,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);
   }
@@ -1248,49 +1328,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,
@@ -1302,9 +1382,9 @@ var PluginManager = class {
             result: value
           }
         );
-      });
-    }
-    return promise;
+      };
+    });
+    return __privateGet(this, _promiseManager).run("first", promises);
   }
   /**
    * Chains, first non-null result stops and returns
@@ -1315,12 +1395,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,
@@ -1341,23 +1421,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);
   }
   /**
@@ -1370,191 +1443,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.dim(config.input.path),
         {
@@ -1567,11 +1669,11 @@ async function build(options) {
     await clean(config.output.path);
   }
   const queueTask = async (file) => {
-    const { path } = file;
-    let code = createFileSource(file);
+    const { path: path3 } = file;
+    let code = FileManager.getSource(file);
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: "load",
-      parameters: [path]
+      parameters: [path3]
     });
     if (loadedResult && isPromise(loadedResult)) {
       code = await loadedResult;
@@ -1582,28 +1684,52 @@ async function build(options) {
     if (code) {
       const transformedCode = await pluginManager.hookReduceArg0({
         hookName: "transform",
-        parameters: [code, path],
+        parameters: [code, path3],
         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, path3]
+          });
+        }
+        return pluginManager.hookFirst({
           hookName: "writeFile",
-          parameters: [transformedCode, path]
+          parameters: [transformedCode, path3]
         });
       }
     }
   };
-  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.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, path3] = parameters;
+        logger.spinner.suffixText = pc3.dim(path3);
+      } else {
         logger.spinner.suffixText = messsage;
       }
     }
-    if (logLevel === LogLevel.debug) {
+    if (logger.logLevel === LogLevel.debug) {
       logger.info(messsage);
       const logs = [
         parameters && `${pc3.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
@@ -1614,83 +1740,109 @@ 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 {
-};
-var PackageManager = class _PackageManager {
-  static #cache = {};
-  #cwd;
-  #SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
+_options3 = new WeakMap();
+_context = new WeakMap();
+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(path) {
-    let location = path;
-    if (this.#cwd) {
-      const require2 = mod.createRequire(this.normalizeDirectory(this.#cwd));
-      location = require2.resolve(path);
+  getLocation(path3) {
+    let location = path3;
+    if (__privateGet(this, _cwd)) {
+      const require2 = mod.createRequire(this.normalizeDirectory(__privateGet(this, _cwd)));
+      location = require2.resolve(path3);
     }
     return location;
   }
-  async import(path) {
+  async import(path3) {
     try {
-      let location = this.getLocation(path);
+      let location = this.getLocation(path3);
       if (os.platform() == "win32") {
         location = pathToFileURL(location).href;
       }
@@ -1703,7 +1855,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;
@@ -1712,7 +1864,7 @@ var PackageManager = class _PackageManager {
   }
   getPackageJSONSync() {
     const pkgPath = findUpSync(["package.json"], {
-      cwd: this.#cwd
+      cwd: __privateGet(this, _cwd)
     });
     if (!pkgPath) {
       return void 0;
@@ -1720,33 +1872,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 = coerce(packageVersion);
     if (!semVer) {
       throw new Error(`${packageVersion} is not valid`);
@@ -1765,10 +1920,31 @@ var PackageManager = class _PackageManager {
     return 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;
 
-export { FileManager, FunctionParams, Generator, LogLevel, PackageManager, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, SummaryError, TreeNode, URLPath, ValidationPluginError, Warning, build, clean, combineCodes, combineExports, combineFiles, combineImports, createFileSource, createJSDocBlockText, createLogger, createPlugin, createPluginCache, src_default as default, defaultColours, defineConfig, escape, extensions, getDependedPlugins, getIndexes, getPathMode, getRelativePath, getUniqueName, hooks, isExtensionAllowed, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, jsStringEscape, pluginName as name, nameSorter, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, throttle, timeout, transformReservedWord, uniqueIdFactory, write };
+export { FileManager, Generator, KubbFile, PackageManager, PluginManager, PromiseManager, SchemaGenerator, ValidationPluginError, Warning, build, combineExports, combineImports, createPlugin, src_default as default, defineConfig, isInputPath, pluginName as name, pluginName, safeBuild };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map