@kubb/core 2.17.0 → 2.18.0

package/dist/index.js

@@ -1,1578 +1,26 @@
 import {
-  searchAndReplace,
-  transformReservedWord,
-  transformers_default,
-  trimExtName
-} from "./chunk-YQ5ZU5PV.js";
-import {
-  URLPath,
-  setUniqueName
-} from "./chunk-GBVPADCA.js";
-import {
-  orderBy
-} from "./chunk-PVJACA4A.js";
-import {
-  EventEmitter,
-  LogLevel,
-  createLogger,
-  p,
-  randomCliColour
-} from "./chunk-JLT7YQF5.js";
-import {
-  clean
-} from "./chunk-5PLDNXZK.js";
-import {
-  write
-} from "./chunk-2F7E62RD.js";
-import "./chunk-4ARKZPSY.js";
-import {
-  getRelativePath,
-  read,
-  readSync
-} from "./chunk-NLZ2T737.js";
-import {
-  __privateAdd,
-  __privateGet,
-  __privateMethod,
-  __privateSet
-} from "./chunk-Z4BLTVTB.js";
-
-// src/FileManager.ts
-import crypto from "crypto";
-import { extname, resolve } from "path";
-import { print } from "@kubb/parser";
-import * as factory from "@kubb/parser/factory";
-import PQueue from "p-queue";
-import { isDeepEqual } from "remeda";
-
-// src/BarrelManager.ts
-import { getExports } from "@kubb/parser";
-import path from "path";
-
-// src/utils/TreeNode.ts
-import dirTree from "directory-tree";
-var TreeNode = class _TreeNode {
-  constructor(data, parent) {
-    this.children = [];
-    this.data = data;
-    this.parent = parent;
-    return this;
-  }
-  addChild(data) {
-    const child = new _TreeNode(data, this);
-    if (!this.children) {
-      this.children = [];
-    }
-    this.children.push(child);
-    return child;
-  }
-  find(data) {
-    if (!data) {
-      return null;
-    }
-    if (data === this.data) {
-      return this;
-    }
-    if (this.children?.length) {
-      for (let i = 0, { length } = this.children, target = null; i < length; i++) {
-        target = this.children[i].find(data);
-        if (target) {
-          return target;
-        }
-      }
-    }
-    return null;
-  }
-  get leaves() {
-    if (!this.children || this.children.length === 0) {
-      return [this];
-    }
-    const leaves = [];
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        leaves.push.apply(leaves, this.children[i].leaves);
-      }
-    }
-    return leaves;
-  }
-  get root() {
-    if (!this.parent) {
-      return this;
-    }
-    return this.parent.root;
-  }
-  forEach(callback) {
-    if (typeof callback !== "function") {
-      throw new TypeError("forEach() callback must be a function");
-    }
-    callback(this);
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        this.children[i]?.forEach(callback);
-      }
-    }
-    return this;
-  }
-  static build(path3, options = {}) {
-    try {
-      const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean);
-      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: FileManager.getMode(filteredTree.path)
-      });
-      const recurse = (node, item) => {
-        const subNode = node.addChild({
-          name: item.name,
-          path: item.path,
-          type: FileManager.getMode(item.path)
-        });
-        if (item.children?.length) {
-          item.children?.forEach((child) => {
-            recurse(subNode, child);
-          });
-        }
-      };
-      filteredTree.children?.forEach((child) => recurse(treeNode, child));
-      return treeNode;
-    } catch (e) {
-      throw new Error("Something went wrong with creating index files with the TreehNode class", { cause: e });
-    }
-  }
-};
-
-// src/BarrelManager.ts
-var _options;
-var BarrelManager = class {
-  constructor(options = {}) {
-    __privateAdd(this, _options, void 0);
-    __privateSet(this, _options, options);
-    return this;
-  }
-  getNamedExport(root, item) {
-    const exportedNames = getExports(path.resolve(root, item.path));
-    if (!exportedNames) {
-      return [item];
-    }
-    return exportedNames.reduce(
-      (prev, curr) => {
-        if (!prev[0]?.name || !prev[1]?.name) {
-          return prev;
-        }
-        if (curr.isTypeOnly) {
-          prev[1] = { ...prev[1], name: [...prev[1].name, curr.name] };
-        } else {
-          prev[0] = { ...prev[0], name: [...prev[0].name, curr.name] };
-        }
-        return prev;
-      },
-      [
-        {
-          ...item,
-          name: [],
-          isTypeOnly: false
-        },
-        {
-          ...item,
-          name: [],
-          isTypeOnly: true
-        }
-      ]
-    );
-  }
-  getNamedExports(root, exports) {
-    return exports?.flatMap((item) => {
-      return this.getNamedExport(root, item);
-    });
-  }
-  getIndexes(root) {
-    const { treeNode = {}, isTypeOnly, extName } = __privateGet(this, _options);
-    const tree = TreeNode.build(root, treeNode);
-    if (!tree) {
-      return null;
-    }
-    const fileReducer = (files, treeNode2) => {
-      if (!treeNode2.children) {
-        return [];
-      }
-      if (treeNode2.children.length > 1) {
-        const indexPath = path.resolve(treeNode2.data.path, "index.ts");
-        const exports = treeNode2.children.filter(Boolean).map((file) => {
-          const importPath = file.data.type === "split" ? `./${file.data.name}/index` : `./${trimExtName(file.data.name)}`;
-          if (importPath.endsWith("index") && file.data.type === "single") {
-            return void 0;
-          }
-          return {
-            path: extName ? `${importPath}${extName}` : importPath,
-            isTypeOnly
-          };
-        }).filter(Boolean);
-        files.push({
-          path: indexPath,
-          baseName: "index.ts",
-          source: "",
-          exports,
-          exportable: true
-        });
-      } else if (treeNode2.children.length === 1) {
-        const [treeNodeChild] = treeNode2.children;
-        const indexPath = path.resolve(treeNode2.data.path, "index.ts");
-        const importPath = treeNodeChild.data.type === "split" ? `./${treeNodeChild.data.name}/index` : `./${trimExtName(treeNodeChild.data.name)}`;
-        const exports = [
-          {
-            path: extName ? `${importPath}${extName}` : importPath,
-            isTypeOnly
-          }
-        ];
-        files.push({
-          path: indexPath,
-          baseName: "index.ts",
-          source: "",
-          exports,
-          exportable: true
-        });
-      }
-      treeNode2.children.forEach((childItem) => {
-        fileReducer(files, childItem);
-      });
-      return files;
-    };
-    return fileReducer([], tree).reverse();
-  }
-};
-_options = new WeakMap();
-
-// src/FileManager.ts
-var KubbFile;
-((KubbFile2) => {
-})(KubbFile || (KubbFile = {}));
-var _cache, _task, _queue, _add, add_fn, _addOrAppend, addOrAppend_fn;
-var _FileManager = class _FileManager {
-  constructor({ task = async (file) => file, queue = new PQueue() } = {}) {
-    __privateAdd(this, _add);
-    __privateAdd(this, _addOrAppend);
-    __privateAdd(this, _cache, /* @__PURE__ */ new Map());
-    __privateAdd(this, _task, void 0);
-    __privateAdd(this, _queue, void 0);
-    __privateSet(this, _task, task);
-    __privateSet(this, _queue, queue);
-    return this;
-  }
-  get files() {
-    const files = [];
-    __privateGet(this, _cache).forEach((item) => {
-      files.push(...item.flat(1));
-    });
-    return files;
-  }
-  get isExecuting() {
-    return __privateGet(this, _queue).size !== 0 && __privateGet(this, _queue).pending !== 0;
-  }
-  async add(...files) {
-    const promises = combineFiles(files).map((file) => {
-      if (file.override) {
-        return __privateMethod(this, _add, add_fn).call(this, file);
-      }
-      return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
-    });
-    const resolvedFiles = await Promise.all(promises);
-    if (files.length > 1) {
-      return resolvedFiles;
-    }
-    return resolvedFiles[0];
-  }
-  async addIndexes({ root, output, meta, logger, options = {} }) {
-    const { exportType = "barrel" } = output;
-    if (exportType === false) {
-      return void 0;
-    }
-    const pathToBuildFrom = resolve(root, output.path);
-    if (transformers_default.trimExtName(pathToBuildFrom).endsWith("index")) {
-      logger.emit("warning", "Output has the same fileName as the barrelFiles, please disable barrel generation");
-      return;
-    }
-    const exportPath = output.path.startsWith("./") ? trimExtName(output.path) : `./${trimExtName(output.path)}`;
-    const mode = _FileManager.getMode(output.path);
-    const barrelManager = new BarrelManager({
-      extName: output.extName,
-      ...options
-    });
-    let files = barrelManager.getIndexes(pathToBuildFrom);
-    if (!files) {
-      return void 0;
-    }
-    if (exportType === "barrelNamed") {
-      files = files.map((file) => {
-        if (file.exports) {
-          return {
-            ...file,
-            exports: barrelManager.getNamedExports(pathToBuildFrom, file.exports)
-          };
-        }
-        return file;
-      });
-    }
-    await Promise.all(
-      files.map((file) => {
-        return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
-          ...file,
-          meta: meta ? meta : file.meta
-        });
-      })
-    );
-    const rootPath = mode === "split" ? `${exportPath}/index${output.extName || ""}` : `${exportPath}${output.extName || ""}`;
-    const rootFile = {
-      path: resolve(root, "index.ts"),
-      baseName: "index.ts",
-      source: "",
-      exports: [
-        output.exportAs ? {
-          name: output.exportAs,
-          asAlias: true,
-          path: rootPath,
-          isTypeOnly: options.isTypeOnly
-        } : {
-          path: rootPath,
-          isTypeOnly: options.isTypeOnly
-        }
-      ],
-      exportable: true
-    };
-    if (exportType === "barrelNamed" && !output.exportAs && rootFile.exports?.[0]) {
-      rootFile.exports = barrelManager.getNamedExport(root, rootFile.exports[0]);
-    }
-    await __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
-      ...rootFile,
-      meta: meta ? meta : rootFile.meta
-    });
-  }
-  getCacheByUUID(UUID) {
-    let cache;
-    __privateGet(this, _cache).forEach((files) => {
-      cache = files.find((item) => item.id === UUID);
-    });
-    return cache;
-  }
-  get(path3) {
-    return __privateGet(this, _cache).get(path3);
-  }
-  remove(path3) {
-    const cacheItem = this.get(path3);
-    if (!cacheItem) {
-      return;
-    }
-    __privateGet(this, _cache).delete(path3);
-  }
-  async write(...params) {
-    return write(...params);
-  }
-  async read(...params) {
-    return read(...params);
-  }
-  // statics
-  static getSource(file) {
-    return getSource(file);
-  }
-  static combineFiles(files) {
-    return combineFiles(files);
-  }
-  static getMode(path3) {
-    if (!path3) {
-      return "split";
-    }
-    return extname(path3) ? "single" : "split";
-  }
-  static get extensions() {
-    return [".js", ".ts", ".tsx"];
-  }
-  static isJavascript(baseName) {
-    return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
-  }
-};
-_cache = new WeakMap();
-_task = new WeakMap();
-_queue = new WeakMap();
-_add = new WeakSet();
-add_fn = async function(file) {
-  const controller = new AbortController();
-  const resolvedFile = {
-    id: crypto.randomUUID(),
-    name: trimExtName(file.baseName),
-    ...file
-  };
-  if (resolvedFile.exports?.length) {
-    const folder = resolvedFile.path.replace(resolvedFile.baseName, "");
-    resolvedFile.exports = resolvedFile.exports.filter((exportItem) => {
-      const exportedFile = this.files.find((file2) => file2.path.includes(resolve(folder, exportItem.path)));
-      if (exportedFile) {
-        return exportedFile.exportable;
-      }
-      return true;
-    });
-  }
-  __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-  return __privateGet(this, _queue).add(
-    async () => {
-      var _a;
-      return (_a = __privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
-    },
-    { signal: controller.signal }
-  );
-};
-_addOrAppend = new WeakSet();
-addOrAppend_fn = async function(file) {
-  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 combineFiles(files) {
-  return files.filter(Boolean).reduce(
-    (acc, file) => {
-      const prevIndex = acc.findIndex((item) => item.path === file.path);
-      if (prevIndex === -1) {
-        return [...acc, file];
-      }
-      const prev = acc[prevIndex];
-      if (prev && file.override) {
-        acc[prevIndex] = {
-          imports: [],
-          exports: [],
-          ...file
-        };
-        return acc;
-      }
-      if (prev) {
-        acc[prevIndex] = {
-          ...file,
-          source: prev.source && file.source ? `${prev.source}
-${file.source}` : "",
-          imports: [...prev.imports || [], ...file.imports || []],
-          exports: [...prev.exports || [], ...file.exports || []],
-          env: { ...prev.env || {}, ...file.env || {} }
-        };
-      }
-      return acc;
-    },
-    []
-  );
-}
-function getSource(file) {
-  if (file.language ? !["typescript", "javascript"].includes(file.language) : !FileManager.isJavascript(file.baseName)) {
-    return file.source;
-  }
-  const exports = file.exports ? combineExports(file.exports) : [];
-  const imports = file.imports && file.source ? combineImports(file.imports, exports, file.source) : [];
-  const importNodes = imports.filter((item) => {
-    const path3 = item.root ? getRelativePath(item.root, item.path) : item.path;
-    return path3 !== trimExtName(file.path);
-  }).map((item) => {
-    return factory.createImportDeclaration({
-      name: item.name,
-      path: item.root ? getRelativePath(item.root, item.path) : item.path,
-      isTypeOnly: item.isTypeOnly
-    });
-  });
-  const exportNodes = exports.map(
-    (item) => factory.createExportDeclaration({
-      name: item.name,
-      path: item.path,
-      isTypeOnly: item.isTypeOnly,
-      asAlias: item.asAlias
-    })
-  );
-  const source = [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join("\n");
-  return print([], { source, noEmitHelpers: false });
-}
-function combineExports(exports) {
-  const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce(
-    (prev, curr) => {
-      const name = curr.name;
-      const prevByPath = prev.findLast((imp) => imp.path === curr.path);
-      const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly);
-      if (prevByPathAndIsTypeOnly) {
-        return prev;
-      }
-      const uniquePrev = prev.findLast(
-        (imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
-      );
-      if (uniquePrev || Array.isArray(name) && !name.length || prevByPath?.asAlias && !curr.asAlias) {
-        return prev;
-      }
-      if (!prevByPath) {
-        return [
-          ...prev,
-          {
-            ...curr,
-            name: Array.isArray(name) ? [...new Set(name)] : name
-          }
-        ];
-      }
-      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-        prevByPath.name = [.../* @__PURE__ */ new Set([...prevByPath.name, ...curr.name])];
-        return prev;
-      }
-      return [...prev, curr];
-    },
-    []
-  );
-  return orderBy(combinedExports, [(v) => !v.isTypeOnly, (v) => v.asAlias], ["desc", "desc"]);
-}
-function combineImports(imports, exports, source) {
-  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) => {
-        if (!source) {
-          return true;
-        }
-        const checker = (name2) => name2 && !!source.includes(name2);
-        return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
-      };
-      if (curr.path === curr.root) {
-        return prev;
-      }
-      if (Array.isArray(name)) {
-        name = name.filter((item) => typeof item === "string" ? hasImportInSource(item) : hasImportInSource(item.propertyName));
-      }
-      const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
-      const uniquePrev = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
-      const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && isDeepEqual(imp.name, name) && imp.isTypeOnly);
-      if (prevByPathNameAndIsTypeOnly) {
-        return prev;
-      }
-      if (uniquePrev || Array.isArray(name) && !name.length) {
-        return prev;
-      }
-      if (!prevByPath) {
-        return [
-          ...prev,
-          {
-            ...curr,
-            name
-          }
-        ];
-      }
-      if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
-        prevByPath.name = [.../* @__PURE__ */ new Set([...prevByPath.name, ...name])];
-        return prev;
-      }
-      if (!Array.isArray(name) && name && !hasImportInSource(name)) {
-        return prev;
-      }
-      return [...prev, curr];
-    },
-    []
-  );
-  return orderBy(combinedImports, [(v) => !v.isTypeOnly], ["desc"]);
-}
-function getEnvSource(source, env) {
-  if (!env) {
-    return source;
-  }
-  const keys = Object.keys(env);
-  if (!keys.length) {
-    return source;
-  }
-  return keys.reduce((prev, key) => {
-    const environmentValue = env[key];
-    const replaceBy = environmentValue ? `'${environmentValue.replaceAll('"', "")?.replaceAll("'", "")}'` : "undefined";
-    if (key.toUpperCase() !== key) {
-      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(/(declare const).*\n/gi, ""),
-        replaceBy,
-        key
-      });
-    }
-    return prev;
-  }, source);
-}
-
-// src/PluginManager.ts
-import PQueue2 from "p-queue";
-
-// 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;
-    });
-  }
-  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;
-  }
-  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`);
-  }
-};
-_options2 = new WeakMap();
-function isPromise(result) {
-  return !!result && typeof result?.then === "function";
-}
-function isPromiseRejectedResult(result) {
-  return result.status === "rejected";
-}
-
-// src/errors.ts
-var Warning = class extends Error {
-  constructor(message, options) {
-    super(message, { cause: options?.cause });
-    this.name = "Warning";
-  }
-};
-var ValidationPluginError = class extends Error {
-};
-
-// src/plugin.ts
-import path2 from "path";
-
-// 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];
-    }
-  };
-}
-
-// src/plugin.ts
-function createPlugin(factory2) {
-  return (options) => {
-    return factory2(options);
-  };
-}
-var pluginName = "core";
-var definePlugin = createPlugin((options) => {
-  const { fileManager, pluginManager, resolvePath, resolveName, logger } = options;
-  return {
-    name: pluginName,
-    options,
-    key: ["core"],
-    api() {
-      return {
-        get config() {
-          return options.config;
-        },
-        get plugins() {
-          return options.getPlugins();
-        },
-        get plugin() {
-          return options.plugin;
-        },
-        logger,
-        fileManager,
-        pluginManager,
-        async addFile(...files) {
-          const resolvedFiles = await fileManager.add(...files);
-          if (!Array.isArray(resolvedFiles)) {
-            return [resolvedFiles];
-          }
-          return resolvedFiles;
-        },
-        resolvePath,
-        resolveName,
-        cache: createPluginCache()
-      };
-    },
-    resolvePath(baseName) {
-      const root = path2.resolve(this.config.root, this.config.output.path);
-      return path2.resolve(root, baseName);
-    },
-    resolveName(name) {
-      return name;
-    }
-  };
-});
-
-// src/PluginManager.ts
-var _core, _usedPluginNames, _promiseManager, _getSortedPlugins, getSortedPlugins_fn, _addExecutedToCallStack, addExecutedToCallStack_fn, _execute, execute_fn, _executeSync, executeSync_fn, _catcher, catcher_fn, _parse, parse_fn;
-var PluginManager = class {
-  constructor(config, options) {
-    __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.events = 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.mode, params.options]
-        });
-        if (paths && paths?.length > 1) {
-          this.logger.emit("debug", [
-            `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
-
-Paths: ${JSON.stringify(paths, void 0, 2)}
-
-Falling back on the first item.
-`
-          ]);
-        }
-        return paths?.at(0);
-      }
-      return this.hookFirstSync({
-        hookName: "resolvePath",
-        parameters: [params.baseName, params.mode, params.options]
-      }).result;
-    };
-    this.resolveName = (params) => {
-      if (params.pluginKey) {
-        const names = this.hookForPluginSync({
-          pluginKey: params.pluginKey,
-          hookName: "resolveName",
-          parameters: [params.name, params.type]
-        });
-        if (names && names?.length > 1) {
-          this.logger.emit("debug", [
-            `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough
-
-Names: ${JSON.stringify(names, void 0, 2)}
-
-Falling back on the first item.
-`
-          ]);
-        }
-        return 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 PQueue2({ concurrency: 1 });
-    this.fileManager = new FileManager({
-      task: options.task,
-      queue: this.queue
-    });
-    __privateSet(this, _promiseManager, new PromiseManager({
-      nullCheck: (state) => !!state?.result
-    }));
-    const plugins = config.plugins || [];
-    const core = definePlugin({
-      config,
-      logger: this.logger,
-      pluginManager: this,
-      fileManager: this.fileManager,
-      resolvePath: this.resolvePath.bind(this),
-      resolveName: this.resolveName.bind(this),
-      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);
-    });
-    return this;
-  }
-  getFile({ name, mode, extName, pluginKey, options }) {
-    let source = "";
-    const baseName = `${name}${extName}`;
-    const path3 = this.resolvePath({ baseName, mode, pluginKey, options });
-    if (!path3) {
-      throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`);
-    }
-    try {
-      source = readSync(path3);
-    } catch (_e) {
-    }
-    return {
-      path: path3,
-      baseName,
-      meta: {
-        pluginKey
-      },
-      source
-    };
-  }
-  /**
-   * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
-   */
-  on(eventName, handler) {
-    this.events.on(eventName, handler);
-  }
-  /**
-   * Run a specific hookName for plugin x.
-   */
-  hookForPlugin({
-    pluginKey,
-    hookName,
-    parameters
-  }) {
-    const plugins = this.getPluginsByKey(hookName, pluginKey);
-    const promises = plugins.map((plugin) => {
-      return __privateMethod(this, _execute, execute_fn).call(this, {
-        strategy: "hookFirst",
-        hookName,
-        parameters,
-        plugin
-      });
-    }).filter(Boolean);
-    return Promise.all(promises);
-  }
-  /**
-   * Run a specific hookName for plugin x.
-   */
-  hookForPluginSync({
-    pluginKey,
-    hookName,
-    parameters
-  }) {
-    const plugins = this.getPluginsByKey(hookName, pluginKey);
-    return plugins.map((plugin) => {
-      return __privateMethod(this, _executeSync, executeSync_fn).call(this, {
-        strategy: "hookFirst",
-        hookName,
-        parameters,
-        plugin
-      });
-    }).filter(Boolean);
-  }
-  /**
-   * First non-null result stops and will return it's value.
-   */
-  async hookFirst({
-    hookName,
-    parameters,
-    skipped
-  }) {
-    const promises = __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,
-          plugin
-        });
-        return Promise.resolve({
-          plugin,
-          result: value
-        });
-      };
-    });
-    return __privateGet(this, _promiseManager).run("first", promises);
-  }
-  /**
-   * First non-null result stops and will return it's value.
-   */
-  hookFirstSync({
-    hookName,
-    parameters,
-    skipped
-  }) {
-    let parseResult = null;
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
-      if (skipped?.has(plugin)) {
-        continue;
-      }
-      parseResult = {
-        result: __privateMethod(this, _executeSync, executeSync_fn).call(this, {
-          strategy: "hookFirst",
-          hookName,
-          parameters,
-          plugin
-        }),
-        plugin
-      };
-      if (parseResult?.result != null) {
-        break;
-      }
-    }
-    return parseResult;
-  }
-  /**
-   * Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
-   */
-  async hookParallel({
-    hookName,
-    parameters
-  }) {
-    const promises = __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 results.filter((result) => result.status === "fulfilled").map((result) => result.value);
-  }
-  /**
-   * Chain all plugins, `reduce` can be passed through to handle every returned value. The return value of the first plugin will be used as the first parameter for the plugin after that.
-   */
-  hookReduceArg0({
-    hookName,
-    parameters,
-    reduce
-  }) {
-    const [argument0, ...rest] = parameters;
-    let promise = Promise.resolve(argument0);
-    for (const plugin of __privateMethod(this, _getSortedPlugins, getSortedPlugins_fn).call(this)) {
-      promise = promise.then((arg0) => {
-        const value = __privateMethod(this, _execute, execute_fn).call(this, {
-          strategy: "hookReduceArg0",
-          hookName,
-          parameters: [arg0, ...rest],
-          plugin
-        });
-        return value;
-      }).then((result) => reduce.call(__privateGet(this, _core).api, argument0, result, plugin));
-    }
-    return promise;
-  }
-  /**
-   * Chains plugins
-   */
-  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 __privateGet(this, _promiseManager).run("seq", promises);
-  }
-  getPluginsByKey(hookName, pluginKey) {
-    const plugins = [...this.plugins];
-    const [searchPluginName, searchIdentifier] = pluginKey;
-    const pluginByPluginName = plugins.filter((plugin) => plugin[hookName]).filter((item) => {
-      const [name, identifier] = item.key;
-      const identifierCheck = identifier?.toString() === searchIdentifier?.toString();
-      const nameCheck = name === searchPluginName;
-      if (searchIdentifier) {
-        return identifierCheck && nameCheck;
-      }
-      return nameCheck;
-    });
-    if (!pluginByPluginName?.length) {
-      const corePlugin = plugins.find((plugin) => plugin.name === "core" && plugin[hookName]);
-      if (corePlugin) {
-        this.logger.emit("debug", [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`]);
-      } else {
-        this.logger.emit("debug", [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`]);
-      }
-      return corePlugin ? [corePlugin] : [];
-    }
-    return pluginByPluginName;
-  }
-  static getDependedPlugins(plugins, dependedPluginNames) {
-    let pluginNames = [];
-    if (typeof dependedPluginNames === "string") {
-      pluginNames = [dependedPluginNames];
-    } else {
-      pluginNames = dependedPluginNames;
-    }
-    return pluginNames.map((pluginName2) => {
-      const plugin = plugins.find((plugin2) => plugin2.name === pluginName2);
-      if (!plugin) {
-        throw new ValidationPluginError(`This plugin depends on the ${pluginName2} plugin.`);
-      }
-      return plugin;
-    });
-  }
-  static get hooks() {
-    return ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
-  }
-};
-_core = new WeakMap();
-_usedPluginNames = new WeakMap();
-_promiseManager = new WeakMap();
-_getSortedPlugins = new WeakSet();
-getSortedPlugins_fn = function(hookName) {
-  const plugins = [...this.plugins].filter((plugin) => plugin.name !== "core");
-  if (hookName) {
-    if (this.logger.logLevel === LogLevel.info) {
-      const containsHookName = plugins.some((item) => item[hookName]);
-      if (!containsHookName) {
-        this.logger.emit("warning", `No hook ${hookName} found`);
-      }
-    }
-    return plugins.filter((item) => item[hookName]);
-  }
-  return plugins.map((plugin) => {
-    if (plugin.pre) {
-      const isValid = plugin.pre.every((pluginName2) => plugins.find((pluginToFind) => pluginToFind.name === pluginName2));
-      if (!isValid) {
-        throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, void 0, 2)})`);
-      }
-    }
-    return plugin;
-  }).sort((a, b) => {
-    if (b.pre?.includes(a.name)) {
-      return 1;
-    }
-    if (b.post?.includes(a.name)) {
-      return -1;
-    }
-    return 0;
-  });
-};
-_addExecutedToCallStack = new WeakSet();
-addExecutedToCallStack_fn = function(executer) {
-  if (executer) {
-    this.events.emit("executed", executer);
-    this.executed.push(executer);
-  }
-};
-_execute = new WeakSet();
-execute_fn = function({
-  strategy,
-  hookName,
-  parameters,
-  plugin
-}) {
-  const hook = plugin[hookName];
-  let output;
-  if (!hook) {
-    return null;
-  }
-  this.events.emit("execute", { strategy, hookName, parameters, plugin });
-  const task = Promise.resolve().then(() => {
-    if (typeof hook === "function") {
-      const possiblePromiseResult = hook.apply({ ...__privateGet(this, _core).api, plugin }, parameters);
-      if (isPromise(possiblePromiseResult)) {
-        return Promise.resolve(possiblePromiseResult);
-      }
-      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;
-  }
-  this.events.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;
-  }
-};
-_catcher = new WeakSet();
-catcher_fn = function(cause, plugin, hookName) {
-  const text = `${cause.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})`;
-  this.logger.emit("error", text, cause);
-  this.events.emit("error", cause);
-};
-_parse = new WeakSet();
-parse_fn = function(plugin, pluginManager, context) {
-  const usedPluginNames = __privateGet(pluginManager, _usedPluginNames);
-  setUniqueName(plugin.name, usedPluginNames);
-  const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean);
-  if (!plugin.transform) {
-    plugin.transform = function transform(code) {
-      return code;
-    };
-  }
-  if (plugin.api && typeof plugin.api === "function") {
-    const api = plugin.api.call(context);
-    return {
-      ...plugin,
-      key,
-      api
-    };
-  }
-  return {
-    ...plugin,
-    key
-  };
-};
-
-// src/config.ts
-function defineConfig(options) {
-  return options;
-}
-function isInputPath(result) {
-  return !!result && "path" in result;
-}
-
-// src/build.ts
-async function transformReducer(_previousCode, result, _plugin) {
-  return result;
-}
-async function setup(options) {
-  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options;
-  let count = 0;
-  try {
-    if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
-      await read(config.input.path);
-    }
-  } catch (e) {
-    if (isInputPath(config)) {
-      throw new Error(
-        `Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${p.dim(config.input.path)}`,
-        {
-          cause: e
-        }
-      );
-    }
-  }
-  if (config.output.clean) {
-    await clean(config.output.path);
-  }
-  const task = async (file) => {
-    const { path: path3 } = file;
-    let source = FileManager.getSource(file);
-    const { result: loadedResult } = await pluginManager.hookFirst({
-      hookName: "load",
-      parameters: [path3]
-    });
-    if (loadedResult && isPromise(loadedResult)) {
-      source = await loadedResult;
-    }
-    if (loadedResult && !isPromise(loadedResult)) {
-      source = loadedResult;
-    }
-    if (source) {
-      source = await pluginManager.hookReduceArg0({
-        hookName: "transform",
-        parameters: [source, path3],
-        reduce: transformReducer
-      });
-      if (config.output.write || config.output.write === void 0) {
-        if (file.meta?.pluginKey) {
-          await pluginManager.hookForPlugin({
-            pluginKey: file.meta?.pluginKey,
-            hookName: "writeFile",
-            parameters: [source, path3]
-          });
-        }
-        await pluginManager.hookFirst({
-          hookName: "writeFile",
-          parameters: [source, path3]
-        });
-      }
-    }
-    return {
-      ...file,
-      source: source || ""
-    };
-  };
-  const pluginManager = new PluginManager(config, { logger, task });
-  pluginManager.on("execute", (executer) => {
-    const { hookName, parameters, plugin } = executer;
-    if (hookName === "writeFile") {
-      const [code] = parameters;
-      logger.emit("debug", [`PluginKey ${p.dim(JSON.stringify(plugin.key))} 
-with source
-
-${code}`]);
-    }
-  });
-  pluginManager.queue.on("add", () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return;
-    }
-    if (count === 0) {
-      logger.emit("start", "\u{1F4BE} Writing");
-    }
-  });
-  pluginManager.queue.on("active", () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return;
-    }
-    if (logger.spinner && pluginManager.queue.size > 0) {
-      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`;
-      logger.spinner.suffixText = p.dim(text);
-    }
-    ++count;
-  });
-  pluginManager.queue.on("completed", () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return;
-    }
-    if (logger.spinner) {
-      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`;
-      logger.spinner.suffixText = p.dim(text);
-    }
-  });
-  pluginManager.on("executed", (executer) => {
-    const { hookName, plugin, output, parameters } = executer;
-    const logs = [
-      `${randomCliColour(plugin.name)} Executing ${hookName}`,
-      parameters && `${p.bgWhite("Parameters")} ${randomCliColour(plugin.name)} ${hookName}`,
-      JSON.stringify(parameters, void 0, 2),
-      output && `${p.bgWhite("Output")} ${randomCliColour(plugin.name)} ${hookName}`,
-      output
-    ].filter(Boolean);
-    logger.emit("debug", logs);
-  });
-  return pluginManager;
-}
-async function build(options) {
-  const pluginManager = await setup(options);
-  const { fileManager, logger } = pluginManager;
-  await pluginManager.hookParallel({
-    hookName: "buildStart",
-    parameters: [options.config]
-  });
-  await pluginManager.hookParallel({ hookName: "buildEnd" });
-  if (logger.logLevel === LogLevel.info) {
-    logger.emit("end", "\u{1F4BE} Writing completed");
-  }
-  return {
-    files: fileManager.files.map((file) => ({
-      ...file,
-      source: FileManager.getSource(file)
-    })),
-    pluginManager
-  };
-}
-async function safeBuild(options) {
-  const pluginManager = await setup(options);
-  const { fileManager, logger } = pluginManager;
-  try {
-    await pluginManager.hookParallel({
-      hookName: "buildStart",
-      parameters: [options.config]
-    });
-    await pluginManager.hookParallel({ hookName: "buildEnd" });
-    if (logger.logLevel === LogLevel.info) {
-      logger.emit("end", "\u{1F4BE} Writing completed");
-    }
-  } catch (e) {
-    return {
-      files: fileManager.files.map((file) => ({
-        ...file,
-        source: FileManager.getSource(file)
-      })),
-      pluginManager,
-      error: e
-    };
-  }
-  return {
-    files: fileManager.files.map((file) => ({
-      ...file,
-      source: FileManager.getSource(file)
-    })),
-    pluginManager
-  };
-}
-
-// src/Generator.ts
-var _options3, _context;
-var Generator = class {
-  constructor(options, context) {
-    __privateAdd(this, _options3, {});
-    __privateAdd(this, _context, {});
-    if (context) {
-      __privateSet(this, _context, context);
-    }
-    if (options) {
-      __privateSet(this, _options3, options);
-    }
-    return this;
-  }
-  get options() {
-    return __privateGet(this, _options3);
-  }
-  get context() {
-    return __privateGet(this, _context);
-  }
-  set options(options) {
-    __privateSet(this, _options3, { ...__privateGet(this, _options3), ...options });
-  }
-};
-_options3 = new WeakMap();
-_context = new WeakMap();
-
-// src/PackageManager.ts
-import mod from "module";
-import os from "os";
-import { pathToFileURL } from "url";
-import { findUp, findUpSync } from "find-up";
-import { coerce, satisfies } from "semver";
-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) {
-      __privateSet(this, _cwd, workspace);
-    }
-    return this;
-  }
-  set workspace(workspace) {
-    __privateSet(this, _cwd, workspace);
-  }
-  get workspace() {
-    return __privateGet(this, _cwd);
-  }
-  normalizeDirectory(directory) {
-    if (!__privateGet(this, _SLASHES).has(directory[directory.length - 1])) {
-      return `${directory}/`;
-    }
-    return directory;
-  }
-  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(path3) {
-    try {
-      let location = this.getLocation(path3);
-      if (os.platform() === "win32") {
-        location = pathToFileURL(location).href;
-      }
-      const module = await import(location);
-      return module?.default ?? module;
-    } catch (e) {
-      console.log(e);
-      return void 0;
-    }
-  }
-  async getPackageJSON() {
-    const pkgPath = await findUp(["package.json"], {
-      cwd: __privateGet(this, _cwd)
-    });
-    if (!pkgPath) {
-      return void 0;
-    }
-    const json = await read(pkgPath);
-    return JSON.parse(json);
-  }
-  getPackageJSONSync() {
-    const pkgPath = findUpSync(["package.json"], {
-      cwd: __privateGet(this, _cwd)
-    });
-    if (!pkgPath) {
-      return void 0;
-    }
-    const json = readSync(pkgPath);
-    return JSON.parse(json);
-  }
-  static setVersion(dependency, version) {
-    __privateGet(_PackageManager, _cache2)[dependency] = version;
-  }
-  async getVersion(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 __privateMethod(this, _match, match_fn).call(this, packageJSON, dependency);
-  }
-  getVersionSync(dependency) {
-    if (typeof dependency === "string" && __privateGet(_PackageManager, _cache2)[dependency]) {
-      return __privateGet(_PackageManager, _cache2)[dependency];
-    }
-    const packageJSON = this.getPackageJSONSync();
-    if (!packageJSON) {
-      return void 0;
-    }
-    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`);
-    }
-    return satisfies(semVer, version);
-  }
-  isValidSync(dependency, version) {
-    const packageVersion = this.getVersionSync(dependency);
-    if (!packageVersion) {
-      return false;
-    }
-    const semVer = coerce(packageVersion);
-    if (!semVer) {
-      throw new Error(`${packageVersion} is not valid`);
-    }
-    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/kubb.ts
-var kubb_exports = {};
+  FileManager,
+  Generator,
+  KubbFile,
+  PackageManager,
+  PluginManager,
+  PromiseManager,
+  Warning,
+  build,
+  createPlugin,
+  defineConfig,
+  isInputPath,
+  kubb_exports,
+  pluginName,
+  safeBuild
+} from "./chunk-PXP5K73S.js";
+import "./chunk-UCKFXEKM.js";
+import "./chunk-ECWTIHD5.js";
+import "./chunk-4X5FFJPJ.js";
+import "./chunk-JLT7YQF5.js";
+import "./chunk-MDO6MCFJ.js";
+import "./chunk-2F7E62RD.js";
+import "./chunk-Z4BLTVTB.js";
 export {
   FileManager,
   Generator,