@kubb/core 3.0.0-alpha.6 → 3.0.0-alpha.8

package/dist/chunk-5IGANEGE.cjs

@@ -0,0 +1,1564 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+var _chunkA6PCLWEYcjs = require('./chunk-A6PCLWEY.cjs');
+
+
+
+
+var _chunkSEH6NUCXcjs = require('./chunk-SEH6NUCX.cjs');
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js
+var require_eventemitter3 = _chunkSEH6NUCXcjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    _chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
+// src/utils/index.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+
+// src/utils/FunctionParams.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+var FunctionParams = class _FunctionParams {
+  #items = [];
+  constructor() {
+    return this;
+  }
+  get items() {
+    return this.#items.flat();
+  }
+  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;
+  }
+  static #orderItems(items) {
+    return _chunkA6PCLWEYcjs.orderBy.call(void 0, 
+      items.filter(Boolean),
+      [
+        (v) => {
+          if (Array.isArray(v)) {
+            return void 0;
+          }
+          return !v.default;
+        },
+        (v) => {
+          if (Array.isArray(v)) {
+            return void 0;
+          }
+          return _nullishCoalesce(v.required, () => ( true));
+        }
+      ],
+      ["desc", "desc"]
+    );
+  }
+  static #addParams(acc, item) {
+    const { enabled = true, name, type, required = true, ...rest } = item;
+    if (!enabled) {
+      return acc;
+    }
+    if (!name) {
+      acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
+      return acc;
+    }
+    const parameterName = name.startsWith("{") ? name : _chunkA6PCLWEYcjs.camelCase.call(void 0, name);
+    if (type) {
+      if (required) {
+        acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
+      } else {
+        acc.push(`${parameterName}?: ${type}`);
+      }
+    } else {
+      acc.push(`${parameterName}`);
+    }
+    return acc;
+  }
+  static toObject(items) {
+    let type = [];
+    let name = [];
+    const enabled = items.every((item) => item.enabled) ? _optionalChain([items, 'access', _ => _.at, 'call', _2 => _2(0), 'optionalAccess', _3 => _3.enabled]) : true;
+    const required = _nullishCoalesce(items.every((item) => item.required), () => ( true));
+    items.forEach((item) => {
+      name = _FunctionParams.#addParams(name, { ...item, type: void 0 });
+      if (items.some((item2) => item2.type)) {
+        type = _FunctionParams.#addParams(type, item);
+      }
+    });
+    return {
+      name: `{ ${name.join(", ")} }`,
+      type: type.length ? `{ ${type.join("; ")} }` : void 0,
+      enabled,
+      required
+    };
+  }
+  static toString(items) {
+    const sortedData = _FunctionParams.#orderItems(items);
+    return sortedData.reduce((acc, item) => {
+      if (Array.isArray(item)) {
+        if (item.length <= 0) {
+          return acc;
+        }
+        const subItems = _FunctionParams.#orderItems(item);
+        const objectItem = _FunctionParams.toObject(subItems);
+        return _FunctionParams.#addParams(acc, objectItem);
+      }
+      return _FunctionParams.#addParams(acc, item);
+    }, []).join(", ");
+  }
+  toObject() {
+    const items = _FunctionParams.#orderItems(this.#items).flat();
+    return _FunctionParams.toObject(items);
+  }
+  toString() {
+    const items = _FunctionParams.#orderItems(this.#items);
+    return _FunctionParams.toString(items);
+  }
+};
+
+// src/utils/promise.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+function isPromise(result) {
+  return !!result && typeof _optionalChain([result, 'optionalAccess', _4 => _4.then]) === "function";
+}
+function isPromiseFulfilledResult(result) {
+  return result.status === "fulfilled";
+}
+function isPromiseRejectedResult(result) {
+  return result.status === "rejected";
+}
+
+// src/utils/renderTemplate.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+function renderTemplate(template, data = void 0) {
+  if (!data || !Object.keys(data).length) {
+    return template.replace(/{{(.*?)}}/g, "");
+  }
+  const matches = template.match(/{{(.*?)}}/g);
+  return _optionalChain([matches, 'optionalAccess', _5 => _5.reduce, 'call', _6 => _6((prev, curr) => {
+    const index = _optionalChain([curr, 'access', _7 => _7.split, 'call', _8 => _8(/{{|}}/), 'access', _9 => _9.filter, 'call', _10 => _10(Boolean), 'access', _11 => _11[0], 'optionalAccess', _12 => _12.trim, 'call', _13 => _13()]);
+    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";
+      }
+      return value || "";
+    }).trim();
+  }, template)]) || "";
+}
+
+// src/utils/timeout.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+async function timeout(ms) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true);
+    }, ms);
+  });
+}
+
+// src/utils/uniqueName.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+function getUniqueName(originalName, data) {
+  let used = data[originalName] || 0;
+  if (used) {
+    data[originalName] = ++used;
+    originalName += used;
+  }
+  data[originalName] = 1;
+  return originalName;
+}
+function setUniqueName(originalName, data) {
+  let used = data[originalName] || 0;
+  if (used) {
+    data[originalName] = ++used;
+    return originalName;
+  }
+  data[originalName] = 1;
+  return originalName;
+}
+
+// src/utils/URLPath.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+var URLPath = class {
+  
+  constructor(path) {
+    this.path = path;
+    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 (_optionalChain([url, 'optionalAccess', _14 => _14.href])) {
+        return true;
+      }
+    } catch (error) {
+      return false;
+    }
+    return false;
+  }
+  /**
+   * Convert Swagger path to template literals/ template strings(camelcase)
+   * @example /pet/{petId} => `/pet/${petId}`
+   * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+   * @example /account/userID => `/account/${userId}`
+   */
+  get template() {
+    return this.toTemplateString();
+  }
+  get object() {
+    return this.toObject();
+  }
+  get params() {
+    return this.getParams();
+  }
+  toObject({ type = "path", replacer, stringify } = {}) {
+    const object = {
+      url: type === "path" ? this.toURLPath() : this.toTemplateString(replacer),
+      params: this.getParams()
+    };
+    if (stringify) {
+      if (type === "template") {
+        return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+      }
+      if (object.params) {
+        return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+      }
+      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(_chunkA6PCLWEYcjs.camelCase.call(void 0, curr)) : _chunkA6PCLWEYcjs.camelCase.call(void 0, curr);
+        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(_chunkA6PCLWEYcjs.camelCase.call(void 0, item)) : _chunkA6PCLWEYcjs.camelCase.call(void 0, item);
+      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/utils/parser.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+var _path = require('path');
+var _fs = require('@kubb/fs');
+var _objecthash = require('object-hash'); var _objecthash2 = _interopRequireDefault(_objecthash);
+
+// src/FileManager.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+
+var _remeda = require('remeda');
+
+
+// src/BarrelManager.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+
+
+// src/utils/TreeNode.ts
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+var TreeNode = (_class = class _TreeNode {
+  
+  
+  __init() {this.children = []}
+  constructor(data, parent) {;_class.prototype.__init.call(this);
+    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 (_optionalChain([this, 'access', _15 => _15.children, 'optionalAccess', _16 => _16.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++) {
+        _optionalChain([this, 'access', _17 => _17.children, 'access', _18 => _18[i], 'optionalAccess', _19 => _19.forEach, 'call', _20 => _20(callback)]);
+      }
+    }
+    return this;
+  }
+  filter(callback) {
+    let data = [];
+    if (typeof callback !== "function") {
+      throw new TypeError("forEach() callback must be a function");
+    }
+    if (callback(this)) {
+      data.push(this);
+    }
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        const childData = _optionalChain([this, 'access', _21 => _21.children, 'access', _22 => _22[i], 'optionalAccess', _23 => _23.filter, 'call', _24 => _24(callback), 'access', _25 => _25.filter, 'call', _26 => _26(Boolean)]) || [];
+        data = [.../* @__PURE__ */ new Set([...data, ...childData])];
+      }
+    }
+    return data;
+  }
+  map(callback) {
+    let data = [];
+    if (typeof callback !== "function") {
+      throw new TypeError("forEach() callback must be a function");
+    }
+    data.push(callback(this));
+    if (this.children) {
+      for (let i = 0, { length } = this.children; i < length; i++) {
+        const childData = _optionalChain([this, 'access', _27 => _27.children, 'access', _28 => _28[i], 'optionalAccess', _29 => _29.map, 'call', _30 => _30(callback), 'access', _31 => _31.filter, 'call', _32 => _32(Boolean)]) || [];
+        data = [.../* @__PURE__ */ new Set([...data, ...childData])];
+      }
+    }
+    return data;
+  }
+  static build(files, root) {
+    try {
+      const filteredTree = buildDirectoryTree(files, root);
+      if (!filteredTree) {
+        return null;
+      }
+      const treeNode = new _TreeNode({
+        name: filteredTree.name,
+        path: filteredTree.path,
+        file: filteredTree.file,
+        type: FileManager.getMode(filteredTree.path)
+      });
+      const recurse = (node, item) => {
+        const subNode = node.addChild({
+          name: item.name,
+          path: item.path,
+          file: item.file,
+          type: FileManager.getMode(item.path)
+        });
+        if (_optionalChain([item, 'access', _33 => _33.children, 'optionalAccess', _34 => _34.length])) {
+          _optionalChain([item, 'access', _35 => _35.children, 'optionalAccess', _36 => _36.forEach, 'call', _37 => _37((child) => {
+            recurse(subNode, child);
+          })]);
+        }
+      };
+      _optionalChain([filteredTree, 'access', _38 => _38.children, 'optionalAccess', _39 => _39.forEach, 'call', _40 => _40((child) => recurse(treeNode, child))]);
+      return treeNode;
+    } catch (e) {
+      throw new Error("Something went wrong with creating barrel files with the TreeNode class", { cause: e });
+    }
+  }
+}, _class);
+function buildDirectoryTree(files, rootFolder = "") {
+  const rootPrefix = rootFolder.endsWith("/") ? rootFolder : `${rootFolder}/`;
+  const filteredFiles = files.filter((file) => rootFolder ? file.path.startsWith(rootPrefix) && !file.path.endsWith(".json") : !file.path.endsWith(".json"));
+  if (filteredFiles.length === 0) {
+    return null;
+  }
+  const root = {
+    name: rootFolder || "",
+    path: rootFolder || "",
+    children: []
+  };
+  filteredFiles.forEach((file) => {
+    const path = file.path.slice(rootFolder.length);
+    const parts = path.split("/");
+    let currentLevel = root.children;
+    let currentPath = rootFolder;
+    parts.forEach((part, index) => {
+      if (index !== 0) {
+        currentPath += `/${part}`;
+      } else {
+        currentPath += `${part}`;
+      }
+      let existingNode = currentLevel.find((node) => node.name === part);
+      if (!existingNode) {
+        if (index === parts.length - 1) {
+          existingNode = {
+            name: part,
+            file,
+            path: currentPath
+          };
+        } else {
+          existingNode = {
+            name: part,
+            path: currentPath,
+            children: []
+          };
+        }
+        currentLevel.push(existingNode);
+      }
+      if (!existingNode.file) {
+        currentLevel = existingNode.children;
+      }
+    });
+  });
+  return root;
+}
+
+// src/BarrelManager.ts
+
+var BarrelManager = class {
+  #options;
+  constructor(options = {}) {
+    this.#options = options;
+    return this;
+  }
+  getFiles(generatedFiles, root) {
+    const { logger } = this.#options;
+    const files = /* @__PURE__ */ new Map();
+    _optionalChain([TreeNode, 'access', _41 => _41.build, 'call', _42 => _42(generatedFiles, root), 'optionalAccess', _43 => _43.forEach, 'call', _44 => _44((treeNode) => {
+      if (!treeNode || !treeNode.children || !_optionalChain([treeNode, 'access', _45 => _45.parent, 'optionalAccess', _46 => _46.data, 'access', _47 => _47.path])) {
+        return void 0;
+      }
+      const barrelPath = _path.join.call(void 0, _optionalChain([treeNode, 'access', _48 => _48.parent, 'optionalAccess', _49 => _49.data, 'access', _50 => _50.path]), "index.ts");
+      const leaves = treeNode.leaves;
+      const exports = leaves.map((item) => {
+        if (!item.data.name) {
+          return void 0;
+        }
+        const sources = _optionalChain([item, 'access', _51 => _51.data, 'access', _52 => _52.file, 'optionalAccess', _53 => _53.sources]) || [];
+        if (!sources.some((source) => source.isIndexable)) {
+          _optionalChain([logger, 'optionalAccess', _54 => _54.emit, 'call', _55 => _55(
+            "warning",
+            `No isIndexable source found(source should have a name and isIndexable):
+File: ${JSON.stringify(item.data.file, void 0, 2)}`
+          )]);
+        }
+        return sources.map((source) => {
+          if (!_optionalChain([item, 'access', _56 => _56.data, 'access', _57 => _57.file, 'optionalAccess', _58 => _58.path]) || !source.isIndexable) {
+            return void 0;
+          }
+          const isSubExport = !!_optionalChain([treeNode, 'access', _59 => _59.parent, 'optionalAccess', _60 => _60.data, 'access', _61 => _61.path, 'optionalAccess', _62 => _62.split, 'optionalCall', _63 => _63("/"), 'optionalAccess', _64 => _64.length]);
+          if (isSubExport) {
+            return {
+              name: [source.name],
+              path: _fs.getRelativePath.call(void 0, _optionalChain([treeNode, 'access', _65 => _65.parent, 'optionalAccess', _66 => _66.data, 'access', _67 => _67.path]), item.data.path),
+              isTypeOnly: source.isTypeOnly
+            };
+          }
+          return {
+            name: [source.name],
+            path: `./${item.data.file.baseName}`,
+            isTypeOnly: source.isTypeOnly
+          };
+        });
+      }).flat().filter(Boolean);
+      const barrelFile = {
+        path: barrelPath,
+        baseName: "index.ts",
+        exports,
+        sources: exports.flatMap((item) => {
+          if (Array.isArray(item.name)) {
+            return item.name.map((name) => {
+              return {
+                name,
+                isTypeOnly: item.isTypeOnly,
+                //TODO use parser to generate import
+                value: "",
+                isExportable: false,
+                isIndexable: false
+              };
+            });
+          }
+          return [
+            {
+              name: item.name,
+              isTypeOnly: item.isTypeOnly,
+              //TODO use parser to generate import
+              value: "",
+              isExportable: false,
+              isIndexable: false
+            }
+          ];
+        })
+      };
+      const previousBarrelFile = files.get(barrelFile.path);
+      if (previousBarrelFile) {
+        files.set(barrelFile.path, {
+          ...previousBarrelFile,
+          ...barrelFile,
+          exports: combineExports([...previousBarrelFile.exports || [], ...barrelFile.exports || []]),
+          sources: combineSources([...previousBarrelFile.sources || [], ...barrelFile.sources || []])
+        });
+      } else {
+        files.set(barrelFile.path, barrelFile);
+      }
+    })]);
+    return [...files.values()];
+  }
+};
+
+// src/FileManager.ts
+
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+
+// ../../node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+var import_index = _chunkSEH6NUCXcjs.__toESM.call(void 0, require_eventemitter3(), 1);
+
+// ../../node_modules/.pnpm/p-timeout@6.1.2/node_modules/p-timeout/index.js
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError(errorMessage) : new DOMException(errorMessage);
+var getAbortedReason = (signal) => {
+  const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
+  return reason instanceof Error ? reason : getDOMException(reason);
+};
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout }
+  } = options;
+  let timer;
+  const wrappedPromise = new Promise((resolve, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (options.signal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        reject(getAbortedReason(signal));
+      }
+      signal.addEventListener("abort", () => {
+        reject(getAbortedReason(signal));
+      });
+    }
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      promise.then(resolve, reject);
+      return;
+    }
+    const timeoutError = new TimeoutError();
+    timer = customTimers.setTimeout.call(void 0, () => {
+      if (fallback) {
+        try {
+          resolve(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = _nullishCoalesce(message, () => ( `Promise timed out after ${milliseconds} milliseconds`));
+        reject(timeoutError);
+      }
+    }, milliseconds);
+    (async () => {
+      try {
+        resolve(await promise);
+      } catch (error) {
+        reject(error);
+      }
+    })();
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(void 0, timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
+}
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/priority-queue.js
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/lower-bound.js
+_chunkSEH6NUCXcjs.init_cjs_shims.call(void 0, );
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/priority-queue.js
+var PriorityQueue = class {
+  #queue = [];
+  enqueue(run, options) {
+    options = {
+      priority: 0,
+      ...options
+    };
+    const element = {
+      priority: options.priority,
+      run
+    };
+    if (this.size && this.#queue[this.size - 1].priority >= options.priority) {
+      this.#queue.push(element);
+      return;
+    }
+    const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+    this.#queue.splice(index, 0, element);
+  }
+  dequeue() {
+    const item = this.#queue.shift();
+    return _optionalChain([item, 'optionalAccess', _68 => _68.run]);
+  }
+  filter(options) {
+    return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return this.#queue.length;
+  }
+};
+
+// ../../node_modules/.pnpm/p-queue@8.0.1/node_modules/p-queue/dist/index.js
+var PQueue = class extends import_index.default {
+  #carryoverConcurrencyCount;
+  #isIntervalIgnored;
+  #intervalCount = 0;
+  #intervalCap;
+  #interval;
+  #intervalEnd = 0;
+  #intervalId;
+  #timeoutId;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+  #concurrency;
+  #isPaused;
+  #throwOnTimeout;
+  /**
+      Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+  
+      Applies to each future operation.
+      */
+  
+  // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
+  constructor(options) {
+    super();
+    options = {
+      carryoverConcurrencyCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${_nullishCoalesce(_optionalChain([options, 'access', _69 => _69.intervalCap, 'optionalAccess', _70 => _70.toString, 'call', _71 => _71()]), () => ( ""))}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${_nullishCoalesce(_optionalChain([options, 'access', _72 => _72.interval, 'optionalAccess', _73 => _73.toString, 'call', _74 => _74()]), () => ( ""))}\` (${typeof options.interval})`);
+    }
+    this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+    this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+    this.#intervalCap = options.intervalCap;
+    this.#interval = options.interval;
+    this.#queue = new options.queueClass();
+    this.#queueClass = options.queueClass;
+    this.concurrency = options.concurrency;
+    this.timeout = options.timeout;
+    this.#throwOnTimeout = options.throwOnTimeout === true;
+    this.#isPaused = options.autoStart === false;
+  }
+  get #doesIntervalAllowAnother() {
+    return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+  }
+  get #doesConcurrentAllowAnother() {
+    return this.#pending < this.#concurrency;
+  }
+  #next() {
+    this.#pending--;
+    this.#tryToStartAnother();
+    this.emit("next");
+  }
+  #onResumeInterval() {
+    this.#onInterval();
+    this.#initializeIntervalIfNeeded();
+    this.#timeoutId = void 0;
+  }
+  get #isIntervalPaused() {
+    const now = Date.now();
+    if (this.#intervalId === void 0) {
+      const delay = this.#intervalEnd - now;
+      if (delay < 0) {
+        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+      } else {
+        if (this.#timeoutId === void 0) {
+          this.#timeoutId = setTimeout(() => {
+            this.#onResumeInterval();
+          }, delay);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      if (this.#intervalId) {
+        clearInterval(this.#intervalId);
+      }
+      this.#intervalId = void 0;
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.emit("idle");
+      }
+      return false;
+    }
+    if (!this.#isPaused) {
+      const canInitializeInterval = !this.#isIntervalPaused;
+      if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+        const job = this.#queue.dequeue();
+        if (!job) {
+          return false;
+        }
+        this.emit("active");
+        job();
+        if (canInitializeInterval) {
+          this.#initializeIntervalIfNeeded();
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #initializeIntervalIfNeeded() {
+    if (this.#isIntervalIgnored || this.#intervalId !== void 0) {
+      return;
+    }
+    this.#intervalId = setInterval(() => {
+      this.#onInterval();
+    }, this.#interval);
+    this.#intervalEnd = Date.now() + this.#interval;
+  }
+  #onInterval() {
+    if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = void 0;
+    }
+    this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+    this.#processQueue();
+  }
+  /**
+  Executes all queued functions until it reaches the limit.
+  */
+  #processQueue() {
+    while (this.#tryToStartAnother()) {
+    }
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  async #throwOnAbort(signal) {
+    return new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+      }, { once: true });
+    });
+  }
+  async add(function_, options = {}) {
+    options = {
+      timeout: this.timeout,
+      throwOnTimeout: this.#throwOnTimeout,
+      ...options
+    };
+    return new Promise((resolve, reject) => {
+      this.#queue.enqueue(async () => {
+        this.#pending++;
+        this.#intervalCount++;
+        try {
+          _optionalChain([options, 'access', _75 => _75.signal, 'optionalAccess', _76 => _76.throwIfAborted, 'call', _77 => _77()]);
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
+          }
+          const result = await operation;
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          if (error instanceof TimeoutError && !options.throwOnTimeout) {
+            resolve();
+            return;
+          }
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          this.#next();
+        }
+      }, options);
+      this.emit("add");
+      this.#tryToStartAnother();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    this.#isPaused = true;
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    this.#queue = new this.#queueClass();
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  /**
+      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+  
+      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+      */
+  async onIdle() {
+    if (this.#pending === 0 && this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  async #onEvent(event, filter) {
+    return new Promise((resolve) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve();
+      };
+      this.on(event, listener);
+    });
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return this.#queue.size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return this.#pending;
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return this.#isPaused;
+  }
+};
+
+// src/FileManager.ts
+var FileManager = class {
+  #filesByPath = /* @__PURE__ */ new Map();
+  #files = /* @__PURE__ */ new Set();
+  constructor() {
+    return this;
+  }
+  get files() {
+    return Array.from(this.#files);
+  }
+  get orderedFiles() {
+    return _chunkA6PCLWEYcjs.orderBy.call(void 0, Array.from(this.#files), [
+      (v) => _optionalChain([v, 'optionalAccess', _78 => _78.meta]) && "pluginKey" in v.meta && !v.meta.pluginKey,
+      (v) => v.path.length,
+      (v) => _fs.trimExtName.call(void 0, v.path).endsWith("index"),
+      (v) => _fs.trimExtName.call(void 0, v.baseName),
+      (v) => v.path.split(".").pop()
+    ]);
+  }
+  get groupedFiles() {
+    return buildDirectoryTree(Array.from(this.#files));
+  }
+  get treeNode() {
+    return TreeNode.build(Array.from(this.#files));
+  }
+  async add(...files) {
+    const promises = files.map((file) => {
+      if (file.override) {
+        return this.#add(file);
+      }
+      return this.#addOrAppend(file);
+    });
+    const resolvedFiles = await Promise.all(promises);
+    if (files.length > 1) {
+      return resolvedFiles;
+    }
+    return resolvedFiles[0];
+  }
+  async #add(file) {
+    const resolvedFile = createFile(file);
+    this.#filesByPath.set(resolvedFile.path, resolvedFile);
+    this.#files.add(resolvedFile);
+    return resolvedFile;
+  }
+  clear() {
+    this.#filesByPath.clear();
+    this.#files.clear();
+  }
+  async #addOrAppend(file) {
+    const previousFile = this.#filesByPath.get(file.path);
+    if (previousFile) {
+      this.#filesByPath.delete(previousFile.path);
+      this.#files.delete(previousFile);
+      return this.#add(mergeFile(previousFile, file));
+    }
+    return this.#add(file);
+  }
+  getCacheById(id) {
+    let cache;
+    this.#files.forEach((file) => {
+      if (file.id === id) {
+        cache = file;
+      }
+    });
+    return cache;
+  }
+  getByPath(path) {
+    return this.#filesByPath.get(path);
+  }
+  deleteByPath(path) {
+    const cacheItem = this.getByPath(path);
+    if (!cacheItem) {
+      return;
+    }
+    this.#filesByPath.delete(path);
+    this.#files.delete(cacheItem);
+  }
+  async getBarrelFiles({ files, meta, root, output, logger }) {
+    const { exportType = "barrelNamed" } = output;
+    const barrelManager = new BarrelManager({ logger });
+    if (exportType === false) {
+      return [];
+    }
+    const pathToBuildFrom = _path.join.call(void 0, root, output.path);
+    if (_fs.trimExtName.call(void 0, pathToBuildFrom).endsWith("index")) {
+      _optionalChain([logger, 'optionalAccess', _79 => _79.emit, 'call', _80 => _80("warning", "Output has the same fileName as the barrelFiles, please disable barrel generation")]);
+      return [];
+    }
+    const barrelFiles = barrelManager.getFiles(files, pathToBuildFrom);
+    if (exportType === "barrel") {
+      return barrelFiles.map((file) => {
+        return {
+          ...file,
+          exports: _optionalChain([file, 'access', _81 => _81.exports, 'optionalAccess', _82 => _82.map, 'call', _83 => _83((exportItem) => {
+            return {
+              ...exportItem,
+              name: void 0
+            };
+          })])
+        };
+      });
+    }
+    return barrelFiles.map((indexFile) => {
+      return {
+        ...indexFile,
+        meta
+      };
+    });
+  }
+  async write(...params) {
+    return _fs.write.call(void 0, ...params);
+  }
+  async read(...params) {
+    return _fs.read.call(void 0, ...params);
+  }
+  // statics
+  static getMode(path) {
+    if (!path) {
+      return "split";
+    }
+    return _path.extname.call(void 0, path) ? "single" : "split";
+  }
+};
+async function getSource(file, { logger } = {}) {
+  const parser = await getFileParser(file.extName);
+  return parser.print(file, { logger });
+}
+function mergeFile(a, b) {
+  return {
+    ...a,
+    sources: [...a.sources || [], ...b.sources || []],
+    imports: [...a.imports || [], ...b.imports || []],
+    exports: [...a.exports || [], ...b.exports || []]
+  };
+}
+function combineSources(sources) {
+  return sources.reduce(
+    (prev, curr) => {
+      const prevByName = prev.findLast((imp) => imp.name === curr.name);
+      const prevByPathAndIsExportable = prev.findLast((imp) => imp.name === curr.name && imp.isExportable);
+      if (prevByPathAndIsExportable) {
+        return [...prev, curr];
+      }
+      if (prevByName) {
+        prevByName.value = curr.value;
+        prevByName.isExportable = curr.isExportable;
+        prevByName.isTypeOnly = curr.isTypeOnly;
+        prevByName.isIndexable = curr.isIndexable;
+        return prev;
+      }
+      return [...prev, curr];
+    },
+    []
+  );
+}
+function combineExports(exports) {
+  const combinedExports = exports.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 && _remeda.isDeepEqual.call(void 0, imp.name, name) && imp.isTypeOnly);
+      if (prevByPathAndIsTypeOnly) {
+        return prev;
+      }
+      const uniquePrev = prev.findLast(
+        (imp) => imp.path === curr.path && _remeda.isDeepEqual.call(void 0, imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
+      );
+      if (uniquePrev || Array.isArray(name) && !name.length || _optionalChain([prevByPath, 'optionalAccess', _84 => _84.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 _chunkA6PCLWEYcjs.orderBy.call(void 0, combinedExports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => Array.isArray(v.name) ? _chunkA6PCLWEYcjs.orderBy.call(void 0, v.name) : v.name
+  ]);
+}
+function combineImports(imports, exports, source) {
+  const combinedImports = imports.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 && _remeda.isDeepEqual.call(void 0, imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
+      const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && _remeda.isDeepEqual.call(void 0, 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 _chunkA6PCLWEYcjs.orderBy.call(void 0, combinedImports, [
+    (v) => !!Array.isArray(v.name),
+    (v) => !v.isTypeOnly,
+    (v) => v.path,
+    (v) => !!v.name,
+    (v) => Array.isArray(v.name) ? _chunkA6PCLWEYcjs.orderBy.call(void 0, v.name) : v.name
+  ]);
+}
+var queue = new PQueue({ concurrency: 100 });
+async function processFiles({ dryRun, config, logger, files }) {
+  const orderedFiles = _chunkA6PCLWEYcjs.orderBy.call(void 0, files, [
+    (v) => _optionalChain([v, 'optionalAccess', _85 => _85.meta]) && "pluginKey" in v.meta && !v.meta.pluginKey,
+    (v) => v.path.length,
+    (v) => _fs.trimExtName.call(void 0, v.path).endsWith("index")
+  ]);
+  logger.emit("debug", {
+    logs: [JSON.stringify({ files: orderedFiles }, null, 2)],
+    fileName: "kubb-files.json",
+    override: true
+  });
+  if (!dryRun) {
+    const size = orderedFiles.length;
+    logger.emit("progress_start", { id: "files", size });
+    const promises = orderedFiles.map(async (file) => {
+      await queue.add(async () => {
+        const source = await getSource(file, { logger });
+        await _fs.write.call(void 0, file.path, source, { sanity: false });
+        logger.emit("progress", { id: "files", data: file ? _path.relative.call(void 0, config.root, file.path) : "" });
+      });
+    });
+    await Promise.all(promises);
+    logger.emit("progress_stop", { id: "files" });
+  }
+  return files;
+}
+
+// src/utils/parser.ts
+function createFile(file) {
+  const extName = _path.extname.call(void 0, file.baseName);
+  if (!extName) {
+    throw new Error(`No extName found for ${file.baseName}`);
+  }
+  const source = file.sources.map((item) => item.value).join("\n\n");
+  const exports = file.exports ? combineExports(file.exports) : [];
+  const imports = file.imports && source ? combineImports(file.imports, exports, source) : [];
+  const sources = file.sources ? combineSources(file.sources) : [];
+  return {
+    ...file,
+    id: _objecthash2.default.call(void 0, { path: file.path }),
+    name: trimExtName2(file.baseName),
+    extName,
+    imports: imports.map((item) => createFileImport(item)),
+    exports: exports.map((item) => createFileExport(item)),
+    sources: sources.map((item) => createFileSource(item))
+  };
+}
+function createFileSource(source) {
+  return source;
+}
+function createFileImport(imp) {
+  const extName = _path.extname.call(void 0, imp.path);
+  return {
+    ...imp,
+    extName: imp.extName ? imp.extName : extName
+  };
+}
+function createFileExport(exp) {
+  const extName = _path.extname.call(void 0, exp.path);
+  return {
+    ...exp,
+    extName: exp.extName ? exp.extName : extName
+  };
+}
+function createFileParser(parser) {
+  return parser;
+}
+var typeScriptParser = createFileParser({
+  render() {
+    return void 0;
+  },
+  async print(file) {
+    const module = await Promise.resolve().then(() => _interopRequireWildcard(require("@kubb/parser-ts")));
+    const importNodes = file.imports.map((item) => {
+      const path = item.root ? _fs.getRelativePath.call(void 0, item.root, item.path) : item.path;
+      return module.factory.createImportDeclaration({
+        name: item.name,
+        path,
+        isTypeOnly: item.isTypeOnly
+      });
+    }).filter(Boolean);
+    const exportNodes = file.exports.map((item) => {
+      return module.factory.createExportDeclaration({
+        name: item.name,
+        path: item.path,
+        isTypeOnly: item.isTypeOnly,
+        asAlias: item.asAlias
+      });
+    }).filter(Boolean);
+    const source = [module.print([...importNodes, ...exportNodes]), file.sources.map((item) => item.value).join("\n\n")].join("\n");
+    return module.print([], { source, noEmitHelpers: false });
+  }
+});
+var defaultParser = createFileParser({
+  render() {
+    return void 0;
+  },
+  async print(file, { logger }) {
+    return file.sources.map((item) => item.value).join("\n\n");
+  }
+});
+var parsers = {
+  ".ts": typeScriptParser,
+  ".js": typeScriptParser,
+  ".jsx": typeScriptParser,
+  ".tsx": typeScriptParser,
+  ".json": defaultParser
+};
+async function getFileParser(extName) {
+  if (!extName) {
+    return defaultParser;
+  }
+  const parser = parsers[extName];
+  if (!parser) {
+    console.warn(`[parser] No parser found for ${extName}, default parser will be used`);
+  }
+  return parser || defaultParser;
+}
+function trimExtName2(text) {
+  const extName = text.split(".").pop();
+  return text.replace(`.${extName}`, "");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FunctionParams = FunctionParams; exports.isPromise = isPromise; exports.isPromiseFulfilledResult = isPromiseFulfilledResult; exports.isPromiseRejectedResult = isPromiseRejectedResult; exports.renderTemplate = renderTemplate; exports.timeout = timeout; exports.getUniqueName = getUniqueName; exports.setUniqueName = setUniqueName; exports.URLPath = URLPath; exports.createFile = createFile; exports.createFileImport = createFileImport; exports.createFileExport = createFileExport; exports.createFileParser = createFileParser; exports.getFileParser = getFileParser; exports.FileManager = FileManager; exports.getSource = getSource; exports.processFiles = processFiles;
+//# sourceMappingURL=chunk-5IGANEGE.cjs.map