@kubb/core 0.40.0 → 0.41.1

package/dist/index.global.js

@@ -4289,9 +4289,9 @@ var kubb = (function (exports) {
           if (typeof maybeCb !== "function") {
             throw new TypeError("The last argument must be of type Function");
           }
-          var self = this;
+          var self2 = this;
           var cb = function() {
-            return maybeCb.apply(self, arguments);
+            return maybeCb.apply(self2, arguments);
           };
           original.apply(this, args).then(
             function(ret) {
@@ -4334,17 +4334,17 @@ var kubb = (function (exports) {
           throw new TypeError("Cannot call a class as a function");
         }
       }
-      function _possibleConstructorReturn(self, call) {
+      function _possibleConstructorReturn(self2, call) {
         if (call && (_typeof(call) === "object" || typeof call === "function")) {
           return call;
         }
-        return _assertThisInitialized(self);
+        return _assertThisInitialized(self2);
       }
-      function _assertThisInitialized(self) {
-        if (self === void 0) {
+      function _assertThisInitialized(self2) {
+        if (self2 === void 0) {
           throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
         }
-        return self;
+        return self2;
       }
       function _getPrototypeOf(o) {
         _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
@@ -4550,17 +4550,17 @@ var kubb = (function (exports) {
           _defineProperties(Constructor, staticProps);
         return Constructor;
       }
-      function _possibleConstructorReturn(self, call) {
+      function _possibleConstructorReturn(self2, call) {
         if (call && (_typeof(call) === "object" || typeof call === "function")) {
           return call;
         }
-        return _assertThisInitialized(self);
+        return _assertThisInitialized(self2);
       }
-      function _assertThisInitialized(self) {
-        if (self === void 0) {
+      function _assertThisInitialized(self2) {
+        if (self2 === void 0) {
           throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
         }
-        return self;
+        return self2;
       }
       function _inherits(subClass, superClass) {
         if (typeof superClass !== "function" && superClass !== null) {
@@ -7936,16 +7936,16 @@ var kubb = (function (exports) {
         });
         return this;
       }
-      function emitErrorAndCloseNT(self, err) {
-        emitErrorNT(self, err);
-        emitCloseNT(self);
+      function emitErrorAndCloseNT(self2, err) {
+        emitErrorNT(self2, err);
+        emitCloseNT(self2);
       }
-      function emitCloseNT(self) {
-        if (self._writableState && !self._writableState.emitClose)
+      function emitCloseNT(self2) {
+        if (self2._writableState && !self2._writableState.emitClose)
           return;
-        if (self._readableState && !self._readableState.emitClose)
+        if (self2._readableState && !self2._readableState.emitClose)
           return;
-        self.emit("close");
+        self2.emit("close");
       }
       function undestroy() {
         if (this._readableState) {
@@ -7964,8 +7964,8 @@ var kubb = (function (exports) {
           this._writableState.errorEmitted = false;
         }
       }
-      function emitErrorNT(self, err) {
-        self.emit("error", err);
+      function emitErrorNT(self2, err) {
+        self2.emit("error", err);
       }
       function errorOrDestroy(stream, err) {
         var rState = stream._readableState;
@@ -8732,8 +8732,8 @@ var kubb = (function (exports) {
           return;
         define_process_default.nextTick(onEndNT, this);
       }
-      function onEndNT(self) {
-        self.end();
+      function onEndNT(self2) {
+        self2.end();
       }
       Object.defineProperty(Duplex.prototype, "destroyed", {
         // making it explicit this property is not enumerable
@@ -8942,14 +8942,14 @@ var kubb = (function (exports) {
           return 4;
         return byte >> 6 === 2 ? -1 : -2;
       }
-      function utf8CheckIncomplete(self, buf, i) {
+      function utf8CheckIncomplete(self2, buf, i) {
         var j = buf.length - 1;
         if (j < i)
           return 0;
         var nb = utf8CheckByte(buf[j]);
         if (nb >= 0) {
           if (nb > 0)
-            self.lastNeed = nb - 1;
+            self2.lastNeed = nb - 1;
           return nb;
         }
         if (--j < i || nb === -2)
@@ -8957,7 +8957,7 @@ var kubb = (function (exports) {
         nb = utf8CheckByte(buf[j]);
         if (nb >= 0) {
           if (nb > 0)
-            self.lastNeed = nb - 2;
+            self2.lastNeed = nb - 2;
           return nb;
         }
         if (--j < i || nb === -2)
@@ -8968,25 +8968,25 @@ var kubb = (function (exports) {
             if (nb === 2)
               nb = 0;
             else
-              self.lastNeed = nb - 3;
+              self2.lastNeed = nb - 3;
           }
           return nb;
         }
         return 0;
       }
-      function utf8CheckExtraBytes(self, buf, p) {
+      function utf8CheckExtraBytes(self2, buf, p) {
         if ((buf[0] & 192) !== 128) {
-          self.lastNeed = 0;
+          self2.lastNeed = 0;
           return "\uFFFD";
         }
-        if (self.lastNeed > 1 && buf.length > 1) {
+        if (self2.lastNeed > 1 && buf.length > 1) {
           if ((buf[1] & 192) !== 128) {
-            self.lastNeed = 1;
+            self2.lastNeed = 1;
             return "\uFFFD";
           }
-          if (self.lastNeed > 2 && buf.length > 2) {
+          if (self2.lastNeed > 2 && buf.length > 2) {
             if ((buf[2] & 192) !== 128) {
-              self.lastNeed = 2;
+              self2.lastNeed = 2;
               return "\uFFFD";
             }
           }
@@ -9939,18 +9939,18 @@ var kubb = (function (exports) {
         }
         return res;
       };
-      function updateReadableListening(self) {
-        var state = self._readableState;
-        state.readableListening = self.listenerCount("readable") > 0;
+      function updateReadableListening(self2) {
+        var state = self2._readableState;
+        state.readableListening = self2.listenerCount("readable") > 0;
         if (state.resumeScheduled && !state.paused) {
           state.flowing = true;
-        } else if (self.listenerCount("data") > 0) {
-          self.resume();
+        } else if (self2.listenerCount("data") > 0) {
+          self2.resume();
         }
       }
-      function nReadingNextTick(self) {
+      function nReadingNextTick(self2) {
         debug("readable nexttick read 0");
-        self.read(0);
+        self2.read(0);
       }
       Readable.prototype.resume = function() {
         var state = this._readableState;
@@ -12026,12 +12026,12 @@ var kubb = (function (exports) {
             this.props = Object.assign({ Node: node_1.Node, Link: node_1.Link, File: node_1.File }, props);
             var root = this.createLink();
             root.setNode(this.createNode(true));
-            var self = this;
+            var self2 = this;
             this.StatWatcher = /** @class */
             function(_super) {
               __extends(StatWatcher2, _super);
               function StatWatcher2() {
-                return _super.call(this, self) || this;
+                return _super.call(this, self2) || this;
               }
               return StatWatcher2;
             }(StatWatcher);
@@ -12044,7 +12044,7 @@ var kubb = (function (exports) {
                 for (var _i = 0; _i < arguments.length; _i++) {
                   args[_i] = arguments[_i];
                 }
-                return _super.apply(this, __spreadArray([self], args, false)) || this;
+                return _super.apply(this, __spreadArray([self2], args, false)) || this;
               }
               return class_1;
             }(_ReadStream);
@@ -12057,7 +12057,7 @@ var kubb = (function (exports) {
                 for (var _i = 0; _i < arguments.length; _i++) {
                   args[_i] = arguments[_i];
                 }
-                return _super.apply(this, __spreadArray([self], args, false)) || this;
+                return _super.apply(this, __spreadArray([self2], args, false)) || this;
               }
               return class_2;
             }(_WriteStream);
@@ -12065,7 +12065,7 @@ var kubb = (function (exports) {
             function(_super) {
               __extends(FSWatcher2, _super);
               function FSWatcher2() {
-                return _super.call(this, self) || this;
+                return _super.call(this, self2) || this;
               }
               return FSWatcher2;
             }(FSWatcher);
@@ -13358,8 +13358,8 @@ var kubb = (function (exports) {
         }()
       );
       exports.Volume = Volume;
-      function emitStop(self) {
-        self.emit("stop");
+      function emitStop(self2) {
+        self2.emit("stop");
       }
       var StatWatcher = (
         /** @class */
@@ -13460,19 +13460,19 @@ var kubb = (function (exports) {
         });
       }
       FsReadStream.prototype.open = function() {
-        var self = this;
+        var self2 = this;
         this._vol.open(this.path, this.flags, this.mode, function(er, fd) {
           if (er) {
-            if (self.autoClose) {
-              if (self.destroy)
-                self.destroy();
+            if (self2.autoClose) {
+              if (self2.destroy)
+                self2.destroy();
             }
-            self.emit("error", er);
+            self2.emit("error", er);
             return;
           }
-          self.fd = fd;
-          self.emit("open", fd);
-          self.read();
+          self2.fd = fd;
+          self2.emit("open", fd);
+          self2.read();
         });
       };
       FsReadStream.prototype._read = function(n) {
@@ -13493,24 +13493,24 @@ var kubb = (function (exports) {
           toRead = Math.min(this.end - this.pos + 1, toRead);
         if (toRead <= 0)
           return this.push(null);
-        var self = this;
+        var self2 = this;
         this._vol.read(this.fd, pool, pool.used, toRead, this.pos, onread);
         if (this.pos !== void 0)
           this.pos += toRead;
         pool.used += toRead;
         function onread(er, bytesRead) {
           if (er) {
-            if (self.autoClose && self.destroy) {
-              self.destroy();
+            if (self2.autoClose && self2.destroy) {
+              self2.destroy();
             }
-            self.emit("error", er);
+            self2.emit("error", er);
           } else {
             var b = null;
             if (bytesRead > 0) {
-              self.bytesRead += bytesRead;
+              self2.bytesRead += bytesRead;
               b = thisPool.slice(start, start + bytesRead);
             }
-            self.push(b);
+            self2.push(b);
           }
         }
       };
@@ -13605,15 +13605,15 @@ var kubb = (function (exports) {
             this._write(data, encoding, cb);
           });
         }
-        var self = this;
+        var self2 = this;
         this._vol.write(this.fd, data, 0, data.length, this.pos, function(er, bytes) {
           if (er) {
-            if (self.autoClose && self.destroy) {
-              self.destroy();
+            if (self2.autoClose && self2.destroy) {
+              self2.destroy();
             }
             return cb(er);
           }
-          self.bytesWritten += bytes;
+          self2.bytesWritten += bytes;
           cb();
         });
         if (this.pos !== void 0)
@@ -13625,7 +13625,7 @@ var kubb = (function (exports) {
             this._writev(data, cb);
           });
         }
-        var self = this;
+        var self2 = this;
         var len = data.length;
         var chunks = new Array(len);
         var size = 0;
@@ -13637,11 +13637,11 @@ var kubb = (function (exports) {
         var buf = buffer_1.Buffer.concat(chunks);
         this._vol.write(this.fd, buf, 0, buf.length, this.pos, function(er, bytes) {
           if (er) {
-            if (self.destroy)
-              self.destroy();
+            if (self2.destroy)
+              self2.destroy();
             return cb(er);
           }
-          self.bytesWritten += bytes;
+          self2.bytesWritten += bytes;
           cb();
         });
         if (this.pos !== void 0)
@@ -14550,7 +14550,7 @@ var kubb = (function (exports) {
         var reClassStart = -1;
         var classStart = -1;
         var patternStart = pattern.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
-        var self = this;
+        var self2 = this;
         function clearStateChar() {
           if (stateChar) {
             switch (stateChar) {
@@ -14566,7 +14566,7 @@ var kubb = (function (exports) {
                 re += "\\" + stateChar;
                 break;
             }
-            self.debug("clearStateChar %j %j", stateChar, re);
+            self2.debug("clearStateChar %j %j", stateChar, re);
             stateChar = false;
           }
         }
@@ -14598,7 +14598,7 @@ var kubb = (function (exports) {
                 re += c;
                 continue;
               }
-              self.debug("call clearStateChar %j", stateChar);
+              self2.debug("call clearStateChar %j", stateChar);
               clearStateChar();
               stateChar = c;
               if (options.noext)
@@ -14963,12 +14963,12 @@ var kubb = (function (exports) {
       function alphasort(a, b) {
         return a.localeCompare(b, "en");
       }
-      function setupIgnores(self, options) {
-        self.ignore = options.ignore || [];
-        if (!Array.isArray(self.ignore))
-          self.ignore = [self.ignore];
-        if (self.ignore.length) {
-          self.ignore = self.ignore.map(ignoreMap);
+      function setupIgnores(self2, options) {
+        self2.ignore = options.ignore || [];
+        if (!Array.isArray(self2.ignore))
+          self2.ignore = [self2.ignore];
+        if (self2.ignore.length) {
+          self2.ignore = self2.ignore.map(ignoreMap);
         }
       }
       function ignoreMap(pattern) {
@@ -14982,7 +14982,7 @@ var kubb = (function (exports) {
           gmatcher
         };
       }
-      function setopts(self, pattern, options) {
+      function setopts(self2, pattern, options) {
         if (!options)
           options = {};
         if (options.matchBase && -1 === pattern.indexOf("/")) {
@@ -14991,61 +14991,61 @@ var kubb = (function (exports) {
           }
           pattern = "**/" + pattern;
         }
-        self.silent = !!options.silent;
-        self.pattern = pattern;
-        self.strict = options.strict !== false;
-        self.realpath = !!options.realpath;
-        self.realpathCache = options.realpathCache || /* @__PURE__ */ Object.create(null);
-        self.follow = !!options.follow;
-        self.dot = !!options.dot;
-        self.mark = !!options.mark;
-        self.nodir = !!options.nodir;
-        if (self.nodir)
-          self.mark = true;
-        self.sync = !!options.sync;
-        self.nounique = !!options.nounique;
-        self.nonull = !!options.nonull;
-        self.nosort = !!options.nosort;
-        self.nocase = !!options.nocase;
-        self.stat = !!options.stat;
-        self.noprocess = !!options.noprocess;
-        self.absolute = !!options.absolute;
-        self.fs = options.fs || fs3;
-        self.maxLength = options.maxLength || Infinity;
-        self.cache = options.cache || /* @__PURE__ */ Object.create(null);
-        self.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
-        self.symlinks = options.symlinks || /* @__PURE__ */ Object.create(null);
-        setupIgnores(self, options);
-        self.changedCwd = false;
+        self2.silent = !!options.silent;
+        self2.pattern = pattern;
+        self2.strict = options.strict !== false;
+        self2.realpath = !!options.realpath;
+        self2.realpathCache = options.realpathCache || /* @__PURE__ */ Object.create(null);
+        self2.follow = !!options.follow;
+        self2.dot = !!options.dot;
+        self2.mark = !!options.mark;
+        self2.nodir = !!options.nodir;
+        if (self2.nodir)
+          self2.mark = true;
+        self2.sync = !!options.sync;
+        self2.nounique = !!options.nounique;
+        self2.nonull = !!options.nonull;
+        self2.nosort = !!options.nosort;
+        self2.nocase = !!options.nocase;
+        self2.stat = !!options.stat;
+        self2.noprocess = !!options.noprocess;
+        self2.absolute = !!options.absolute;
+        self2.fs = options.fs || fs3;
+        self2.maxLength = options.maxLength || Infinity;
+        self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
+        self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
+        self2.symlinks = options.symlinks || /* @__PURE__ */ Object.create(null);
+        setupIgnores(self2, options);
+        self2.changedCwd = false;
         var cwd = define_process_default.cwd();
         if (!ownProp(options, "cwd"))
-          self.cwd = cwd;
+          self2.cwd = cwd;
         else {
-          self.cwd = path.resolve(options.cwd);
-          self.changedCwd = self.cwd !== cwd;
+          self2.cwd = path.resolve(options.cwd);
+          self2.changedCwd = self2.cwd !== cwd;
         }
-        self.root = options.root || path.resolve(self.cwd, "/");
-        self.root = path.resolve(self.root);
+        self2.root = options.root || path.resolve(self2.cwd, "/");
+        self2.root = path.resolve(self2.root);
         if (define_process_default.platform === "win32")
-          self.root = self.root.replace(/\\/g, "/");
-        self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+          self2.root = self2.root.replace(/\\/g, "/");
+        self2.cwdAbs = isAbsolute(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
         if (define_process_default.platform === "win32")
-          self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
-        self.nomount = !!options.nomount;
+          self2.cwdAbs = self2.cwdAbs.replace(/\\/g, "/");
+        self2.nomount = !!options.nomount;
         options.nonegate = true;
         options.nocomment = true;
         options.allowWindowsEscape = false;
-        self.minimatch = new Minimatch(pattern, options);
-        self.options = self.minimatch.options;
+        self2.minimatch = new Minimatch(pattern, options);
+        self2.options = self2.minimatch.options;
       }
-      function finish(self) {
-        var nou = self.nounique;
+      function finish(self2) {
+        var nou = self2.nounique;
         var all = nou ? [] : /* @__PURE__ */ Object.create(null);
-        for (var i = 0, l = self.matches.length; i < l; i++) {
-          var matches = self.matches[i];
+        for (var i = 0, l = self2.matches.length; i < l; i++) {
+          var matches = self2.matches[i];
           if (!matches || Object.keys(matches).length === 0) {
-            if (self.nonull) {
-              var literal = self.minimatch.globSet[i];
+            if (self2.nonull) {
+              var literal = self2.minimatch.globSet[i];
               if (nou)
                 all.push(literal);
               else
@@ -15063,31 +15063,31 @@ var kubb = (function (exports) {
         }
         if (!nou)
           all = Object.keys(all);
-        if (!self.nosort)
+        if (!self2.nosort)
           all = all.sort(alphasort);
-        if (self.mark) {
+        if (self2.mark) {
           for (var i = 0; i < all.length; i++) {
-            all[i] = self._mark(all[i]);
+            all[i] = self2._mark(all[i]);
           }
-          if (self.nodir) {
+          if (self2.nodir) {
             all = all.filter(function(e) {
               var notDir = !/\/$/.test(e);
-              var c = self.cache[e] || self.cache[makeAbs(self, e)];
+              var c = self2.cache[e] || self2.cache[makeAbs(self2, e)];
               if (notDir && c)
                 notDir = c !== "DIR" && !Array.isArray(c);
               return notDir;
             });
           }
         }
-        if (self.ignore.length)
+        if (self2.ignore.length)
           all = all.filter(function(m2) {
-            return !isIgnored(self, m2);
+            return !isIgnored(self2, m2);
           });
-        self.found = all;
+        self2.found = all;
       }
-      function mark(self, p) {
-        var abs = makeAbs(self, p);
-        var c = self.cache[abs];
+      function mark(self2, p) {
+        var abs = makeAbs(self2, p);
+        var c = self2.cache[abs];
         var m = p;
         if (c) {
           var isDir = c === "DIR" || Array.isArray(c);
@@ -15097,21 +15097,21 @@ var kubb = (function (exports) {
           else if (!isDir && slash)
             m = m.slice(0, -1);
           if (m !== p) {
-            var mabs = makeAbs(self, m);
-            self.statCache[mabs] = self.statCache[abs];
-            self.cache[mabs] = self.cache[abs];
+            var mabs = makeAbs(self2, m);
+            self2.statCache[mabs] = self2.statCache[abs];
+            self2.cache[mabs] = self2.cache[abs];
           }
         }
         return m;
       }
-      function makeAbs(self, f) {
+      function makeAbs(self2, f) {
         var abs = f;
         if (f.charAt(0) === "/") {
-          abs = path.join(self.root, f);
+          abs = path.join(self2.root, f);
         } else if (isAbsolute(f) || f === "") {
           abs = f;
-        } else if (self.changedCwd) {
-          abs = path.resolve(self.cwd, f);
+        } else if (self2.changedCwd) {
+          abs = path.resolve(self2.cwd, f);
         } else {
           abs = path.resolve(f);
         }
@@ -15119,17 +15119,17 @@ var kubb = (function (exports) {
           abs = abs.replace(/\\/g, "/");
         return abs;
       }
-      function isIgnored(self, path2) {
-        if (!self.ignore.length)
+      function isIgnored(self2, path2) {
+        if (!self2.ignore.length)
           return false;
-        return self.ignore.some(function(item) {
+        return self2.ignore.some(function(item) {
           return item.matcher.match(path2) || !!(item.gmatcher && item.gmatcher.match(path2));
         });
       }
-      function childrenIgnored(self, path2) {
-        if (!self.ignore.length)
+      function childrenIgnored(self2, path2) {
+        if (!self2.ignore.length)
           return false;
-        return self.ignore.some(function(item) {
+        return self2.ignore.some(function(item) {
           return !!(item.gmatcher && item.gmatcher.match(path2));
         });
       }
@@ -15180,17 +15180,17 @@ var kubb = (function (exports) {
       GlobSync.prototype._finish = function() {
         assert.ok(this instanceof GlobSync);
         if (this.realpath) {
-          var self = this;
+          var self2 = this;
           this.matches.forEach(function(matchset, index) {
-            var set = self.matches[index] = /* @__PURE__ */ Object.create(null);
+            var set = self2.matches[index] = /* @__PURE__ */ Object.create(null);
             for (var p in matchset) {
               try {
-                p = self._makeAbs(p);
-                var real = rp.realpathSync(p, self.realpathCache);
+                p = self2._makeAbs(p);
+                var real = rp.realpathSync(p, self2.realpathCache);
                 set[real] = true;
               } catch (er) {
                 if (er.syscall === "stat")
-                  set[self._makeAbs(p)] = true;
+                  set[self2._makeAbs(p)] = true;
                 else
                   throw er;
               }
@@ -15700,7 +15700,7 @@ var kubb = (function (exports) {
             cb(null, matches);
           });
         }
-        var self = this;
+        var self2 = this;
         this._processing = 0;
         this._emitQueue = [];
         this._processQueue = [];
@@ -15715,14 +15715,14 @@ var kubb = (function (exports) {
         }
         sync = false;
         function done() {
-          --self._processing;
-          if (self._processing <= 0) {
+          --self2._processing;
+          if (self2._processing <= 0) {
             if (sync) {
               define_process_default.nextTick(function() {
-                self._finish();
+                self2._finish();
               });
             } else {
-              self._finish();
+              self2._finish();
             }
           }
         }
@@ -15743,12 +15743,12 @@ var kubb = (function (exports) {
         var n = this.matches.length;
         if (n === 0)
           return this._finish();
-        var self = this;
+        var self2 = this;
         for (var i = 0; i < this.matches.length; i++)
           this._realpathSet(i, next);
         function next() {
           if (--n === 0)
-            self._finish();
+            self2._finish();
         }
       };
       Glob.prototype._realpathSet = function(index, cb) {
@@ -15756,22 +15756,22 @@ var kubb = (function (exports) {
         if (!matchset)
           return cb();
         var found = Object.keys(matchset);
-        var self = this;
+        var self2 = this;
         var n = found.length;
         if (n === 0)
           return cb();
         var set = this.matches[index] = /* @__PURE__ */ Object.create(null);
         found.forEach(function(p, i) {
-          p = self._makeAbs(p);
-          rp.realpath(p, self.realpathCache, function(er, real) {
+          p = self2._makeAbs(p);
+          rp.realpath(p, self2.realpathCache, function(er, real) {
             if (!er)
               set[real] = true;
             else if (er.syscall === "stat")
               set[p] = true;
             else
-              self.emit("error", er);
+              self2.emit("error", er);
             if (--n === 0) {
-              self.matches[index] = set;
+              self2.matches[index] = set;
               cb();
             }
           });
@@ -15864,9 +15864,9 @@ var kubb = (function (exports) {
           this._processReaddir(prefix, read2, abs, remain, index, inGlobStar, cb);
       };
       Glob.prototype._processReaddir = function(prefix, read2, abs, remain, index, inGlobStar, cb) {
-        var self = this;
+        var self2 = this;
         this._readdir(abs, inGlobStar, function(er, entries) {
-          return self._processReaddir2(prefix, read2, abs, remain, index, inGlobStar, entries, cb);
+          return self2._processReaddir2(prefix, read2, abs, remain, index, inGlobStar, entries, cb);
         });
       };
       Glob.prototype._processReaddir2 = function(prefix, read2, abs, remain, index, inGlobStar, entries, cb) {
@@ -15957,20 +15957,20 @@ var kubb = (function (exports) {
         if (this.follow)
           return this._readdir(abs, false, cb);
         var lstatkey = "lstat\0" + abs;
-        var self = this;
+        var self2 = this;
         var lstatcb = inflight(lstatkey, lstatcb_);
         if (lstatcb)
-          self.fs.lstat(abs, lstatcb);
+          self2.fs.lstat(abs, lstatcb);
         function lstatcb_(er, lstat) {
           if (er && er.code === "ENOENT")
             return cb();
           var isSym = lstat && lstat.isSymbolicLink();
-          self.symlinks[abs] = isSym;
+          self2.symlinks[abs] = isSym;
           if (!isSym && lstat && !lstat.isDirectory()) {
-            self.cache[abs] = "FILE";
+            self2.cache[abs] = "FILE";
             cb();
           } else
-            self._readdir(abs, false, cb);
+            self2._readdir(abs, false, cb);
         }
       };
       Glob.prototype._readdir = function(abs, inGlobStar, cb) {
@@ -15988,15 +15988,15 @@ var kubb = (function (exports) {
           if (Array.isArray(c))
             return cb(null, c);
         }
-        var self = this;
-        self.fs.readdir(abs, readdirCb(this, abs, cb));
+        var self2 = this;
+        self2.fs.readdir(abs, readdirCb(this, abs, cb));
       };
-      function readdirCb(self, abs, cb) {
+      function readdirCb(self2, abs, cb) {
         return function(er, entries) {
           if (er)
-            self._readdirError(abs, er, cb);
+            self2._readdirError(abs, er, cb);
           else
-            self._readdirEntries(abs, entries, cb);
+            self2._readdirEntries(abs, entries, cb);
         };
       }
       Glob.prototype._readdirEntries = function(abs, entries, cb) {
@@ -16050,9 +16050,9 @@ var kubb = (function (exports) {
         return cb();
       };
       Glob.prototype._processGlobStar = function(prefix, read2, abs, remain, index, inGlobStar, cb) {
-        var self = this;
+        var self2 = this;
         this._readdir(abs, inGlobStar, function(er, entries) {
-          self._processGlobStar2(prefix, read2, abs, remain, index, inGlobStar, entries, cb);
+          self2._processGlobStar2(prefix, read2, abs, remain, index, inGlobStar, entries, cb);
         });
       };
       Glob.prototype._processGlobStar2 = function(prefix, read2, abs, remain, index, inGlobStar, entries, cb) {
@@ -16078,9 +16078,9 @@ var kubb = (function (exports) {
         cb();
       };
       Glob.prototype._processSimple = function(prefix, index, cb) {
-        var self = this;
+        var self2 = this;
         this._stat(prefix, function(er, exists) {
-          self._processSimple2(prefix, index, er, exists, cb);
+          self2._processSimple2(prefix, index, er, exists, cb);
         });
       };
       Glob.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
@@ -16129,20 +16129,20 @@ var kubb = (function (exports) {
               return cb(null, type, stat);
           }
         }
-        var self = this;
+        var self2 = this;
         var statcb = inflight("stat\0" + abs, lstatcb_);
         if (statcb)
-          self.fs.lstat(abs, statcb);
+          self2.fs.lstat(abs, statcb);
         function lstatcb_(er, lstat) {
           if (lstat && lstat.isSymbolicLink()) {
-            return self.fs.stat(abs, function(er2, stat2) {
+            return self2.fs.stat(abs, function(er2, stat2) {
               if (er2)
-                self._stat2(f, abs, null, lstat, cb);
+                self2._stat2(f, abs, null, lstat, cb);
               else
-                self._stat2(f, abs, er2, stat2, cb);
+                self2._stat2(f, abs, er2, stat2, cb);
             });
           } else {
-            self._stat2(f, abs, er, lstat, cb);
+            self2._stat2(f, abs, er, lstat, cb);
           }
         }
       };
@@ -16448,6 +16448,335 @@ var kubb = (function (exports) {
     }
   });
 
+  // ../../node_modules/.pnpm/lodash.uniq@4.5.0/node_modules/lodash.uniq/index.js
+  var require_lodash = __commonJS({
+    "../../node_modules/.pnpm/lodash.uniq@4.5.0/node_modules/lodash.uniq/index.js"(exports, module) {
+      init_define_process();
+      var LARGE_ARRAY_SIZE = 200;
+      var HASH_UNDEFINED = "__lodash_hash_undefined__";
+      var INFINITY = 1 / 0;
+      var funcTag = "[object Function]";
+      var genTag = "[object GeneratorFunction]";
+      var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+      var reIsHostCtor = /^\[object .+?Constructor\]$/;
+      var freeGlobal = typeof globalThis == "object" && globalThis && globalThis.Object === Object && globalThis;
+      var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+      var root = freeGlobal || freeSelf || Function("return this")();
+      function arrayIncludes(array, value) {
+        var length = array ? array.length : 0;
+        return !!length && baseIndexOf(array, value, 0) > -1;
+      }
+      function arrayIncludesWith(array, value, comparator) {
+        var index = -1, length = array ? array.length : 0;
+        while (++index < length) {
+          if (comparator(value, array[index])) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function baseFindIndex(array, predicate, fromIndex, fromRight) {
+        var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+        while (fromRight ? index-- : ++index < length) {
+          if (predicate(array[index], index, array)) {
+            return index;
+          }
+        }
+        return -1;
+      }
+      function baseIndexOf(array, value, fromIndex) {
+        if (value !== value) {
+          return baseFindIndex(array, baseIsNaN, fromIndex);
+        }
+        var index = fromIndex - 1, length = array.length;
+        while (++index < length) {
+          if (array[index] === value) {
+            return index;
+          }
+        }
+        return -1;
+      }
+      function baseIsNaN(value) {
+        return value !== value;
+      }
+      function cacheHas(cache, key) {
+        return cache.has(key);
+      }
+      function getValue(object, key) {
+        return object == null ? void 0 : object[key];
+      }
+      function isHostObject(value) {
+        var result = false;
+        if (value != null && typeof value.toString != "function") {
+          try {
+            result = !!(value + "");
+          } catch (e) {
+          }
+        }
+        return result;
+      }
+      function setToArray(set) {
+        var index = -1, result = Array(set.size);
+        set.forEach(function(value) {
+          result[++index] = value;
+        });
+        return result;
+      }
+      var arrayProto = Array.prototype;
+      var funcProto = Function.prototype;
+      var objectProto = Object.prototype;
+      var coreJsData = root["__core-js_shared__"];
+      var maskSrcKey = function() {
+        var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+        return uid ? "Symbol(src)_1." + uid : "";
+      }();
+      var funcToString = funcProto.toString;
+      var hasOwnProperty = objectProto.hasOwnProperty;
+      var objectToString = objectProto.toString;
+      var reIsNative = RegExp(
+        "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+      );
+      var splice = arrayProto.splice;
+      var Map2 = getNative(root, "Map");
+      var Set2 = getNative(root, "Set");
+      var nativeCreate = getNative(Object, "create");
+      function Hash(entries) {
+        var index = -1, length = entries ? entries.length : 0;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      function hashClear() {
+        this.__data__ = nativeCreate ? nativeCreate(null) : {};
+      }
+      function hashDelete(key) {
+        return this.has(key) && delete this.__data__[key];
+      }
+      function hashGet(key) {
+        var data = this.__data__;
+        if (nativeCreate) {
+          var result = data[key];
+          return result === HASH_UNDEFINED ? void 0 : result;
+        }
+        return hasOwnProperty.call(data, key) ? data[key] : void 0;
+      }
+      function hashHas(key) {
+        var data = this.__data__;
+        return nativeCreate ? data[key] !== void 0 : hasOwnProperty.call(data, key);
+      }
+      function hashSet(key, value) {
+        var data = this.__data__;
+        data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+        return this;
+      }
+      Hash.prototype.clear = hashClear;
+      Hash.prototype["delete"] = hashDelete;
+      Hash.prototype.get = hashGet;
+      Hash.prototype.has = hashHas;
+      Hash.prototype.set = hashSet;
+      function ListCache(entries) {
+        var index = -1, length = entries ? entries.length : 0;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      function listCacheClear() {
+        this.__data__ = [];
+      }
+      function listCacheDelete(key) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        if (index < 0) {
+          return false;
+        }
+        var lastIndex = data.length - 1;
+        if (index == lastIndex) {
+          data.pop();
+        } else {
+          splice.call(data, index, 1);
+        }
+        return true;
+      }
+      function listCacheGet(key) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        return index < 0 ? void 0 : data[index][1];
+      }
+      function listCacheHas(key) {
+        return assocIndexOf(this.__data__, key) > -1;
+      }
+      function listCacheSet(key, value) {
+        var data = this.__data__, index = assocIndexOf(data, key);
+        if (index < 0) {
+          data.push([key, value]);
+        } else {
+          data[index][1] = value;
+        }
+        return this;
+      }
+      ListCache.prototype.clear = listCacheClear;
+      ListCache.prototype["delete"] = listCacheDelete;
+      ListCache.prototype.get = listCacheGet;
+      ListCache.prototype.has = listCacheHas;
+      ListCache.prototype.set = listCacheSet;
+      function MapCache(entries) {
+        var index = -1, length = entries ? entries.length : 0;
+        this.clear();
+        while (++index < length) {
+          var entry = entries[index];
+          this.set(entry[0], entry[1]);
+        }
+      }
+      function mapCacheClear() {
+        this.__data__ = {
+          "hash": new Hash(),
+          "map": new (Map2 || ListCache)(),
+          "string": new Hash()
+        };
+      }
+      function mapCacheDelete(key) {
+        return getMapData(this, key)["delete"](key);
+      }
+      function mapCacheGet(key) {
+        return getMapData(this, key).get(key);
+      }
+      function mapCacheHas(key) {
+        return getMapData(this, key).has(key);
+      }
+      function mapCacheSet(key, value) {
+        getMapData(this, key).set(key, value);
+        return this;
+      }
+      MapCache.prototype.clear = mapCacheClear;
+      MapCache.prototype["delete"] = mapCacheDelete;
+      MapCache.prototype.get = mapCacheGet;
+      MapCache.prototype.has = mapCacheHas;
+      MapCache.prototype.set = mapCacheSet;
+      function SetCache(values) {
+        var index = -1, length = values ? values.length : 0;
+        this.__data__ = new MapCache();
+        while (++index < length) {
+          this.add(values[index]);
+        }
+      }
+      function setCacheAdd(value) {
+        this.__data__.set(value, HASH_UNDEFINED);
+        return this;
+      }
+      function setCacheHas(value) {
+        return this.__data__.has(value);
+      }
+      SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+      SetCache.prototype.has = setCacheHas;
+      function assocIndexOf(array, key) {
+        var length = array.length;
+        while (length--) {
+          if (eq(array[length][0], key)) {
+            return length;
+          }
+        }
+        return -1;
+      }
+      function baseIsNative(value) {
+        if (!isObject(value) || isMasked(value)) {
+          return false;
+        }
+        var pattern = isFunction(value) || isHostObject(value) ? reIsNative : reIsHostCtor;
+        return pattern.test(toSource(value));
+      }
+      function baseUniq(array, iteratee, comparator) {
+        var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
+        if (comparator) {
+          isCommon = false;
+          includes = arrayIncludesWith;
+        } else if (length >= LARGE_ARRAY_SIZE) {
+          var set = iteratee ? null : createSet(array);
+          if (set) {
+            return setToArray(set);
+          }
+          isCommon = false;
+          includes = cacheHas;
+          seen = new SetCache();
+        } else {
+          seen = iteratee ? [] : result;
+        }
+        outer:
+          while (++index < length) {
+            var value = array[index], computed = iteratee ? iteratee(value) : value;
+            value = comparator || value !== 0 ? value : 0;
+            if (isCommon && computed === computed) {
+              var seenIndex = seen.length;
+              while (seenIndex--) {
+                if (seen[seenIndex] === computed) {
+                  continue outer;
+                }
+              }
+              if (iteratee) {
+                seen.push(computed);
+              }
+              result.push(value);
+            } else if (!includes(seen, computed, comparator)) {
+              if (seen !== result) {
+                seen.push(computed);
+              }
+              result.push(value);
+            }
+          }
+        return result;
+      }
+      var createSet = !(Set2 && 1 / setToArray(new Set2([, -0]))[1] == INFINITY) ? noop : function(values) {
+        return new Set2(values);
+      };
+      function getMapData(map, key) {
+        var data = map.__data__;
+        return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+      }
+      function getNative(object, key) {
+        var value = getValue(object, key);
+        return baseIsNative(value) ? value : void 0;
+      }
+      function isKeyable(value) {
+        var type = typeof value;
+        return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+      }
+      function isMasked(func) {
+        return !!maskSrcKey && maskSrcKey in func;
+      }
+      function toSource(func) {
+        if (func != null) {
+          try {
+            return funcToString.call(func);
+          } catch (e) {
+          }
+          try {
+            return func + "";
+          } catch (e) {
+          }
+        }
+        return "";
+      }
+      function uniq2(array) {
+        return array && array.length ? baseUniq(array) : [];
+      }
+      function eq(value, other) {
+        return value === other || value !== value && other !== other;
+      }
+      function isFunction(value) {
+        var tag = isObject(value) ? objectToString.call(value) : "";
+        return tag == funcTag || tag == genTag;
+      }
+      function isObject(value) {
+        var type = typeof value;
+        return !!value && (type == "object" || type == "function");
+      }
+      function noop() {
+      }
+      module.exports = uniq2;
+    }
+  });
+
   // ../../node_modules/.pnpm/directory-tree@3.5.1/node_modules/directory-tree/lib/directory-tree.js
   var require_directory_tree = __commonJS({
     "../../node_modules/.pnpm/directory-tree@3.5.1/node_modules/directory-tree/lib/directory-tree.js"(exports, module) {
@@ -16691,9 +17020,6 @@ var kubb = (function (exports) {
     };
   }
   var name = "core";
-  var isEmittedFile = (result) => {
-    return !!result.id;
-  };
   var definePlugin = createPlugin((options) => {
     const { fileManager, resolveId, load } = options;
     const api = {
@@ -16701,17 +17027,7 @@ var kubb = (function (exports) {
         return options.config;
       },
       fileManager,
-      async addFile(file, options2) {
-        if (isEmittedFile(file)) {
-          const resolvedId = await resolveId({ fileName: file.id, directory: file.importer, options: file.options });
-          const path = resolvedId || file.importer || file.id;
-          return fileManager.add({
-            path,
-            fileName: file.name || file.id,
-            source: file.source || ""
-          });
-        }
-        if (options2?.root) ;
+      async addFile(file) {
         return fileManager.addOrAppend(file);
       },
       resolveId,
@@ -16720,6 +17036,7 @@ var kubb = (function (exports) {
     };
     return {
       name,
+      options,
       api,
       resolveId(fileName, directory) {
         if (!directory) {
@@ -16738,6 +17055,9 @@ var kubb = (function (exports) {
   var import_index = __toESM(require_eventemitter3(), 1);
   var eventemitter3_default = import_index.default;
 
+  // src/managers/fileManager/FileManager.ts
+  var import_lodash = __toESM(require_lodash());
+
   // ../../node_modules/.pnpm/uuid@9.0.0/node_modules/uuid/dist/esm-browser/index.js
   init_define_process();
 
@@ -16883,32 +17203,16 @@ var kubb = (function (exports) {
       });
       return count;
     }
-    get files() {
-      const files = [];
-      this.cache.forEach((item) => {
-        files.push(item.file);
-      });
-      return files;
-    }
-    add(file) {
-      const cacheItem = { id: v4_default(), file, status: "new" };
-      this.cache.set(cacheItem.id, cacheItem);
-      this.events.emitFile(cacheItem.id, file);
-      return new Promise((resolve) => {
-        const unsubscribe = this.events.onRemove(cacheItem.id, (file2) => {
-          resolve(file2);
-          unsubscribe();
-        });
-      });
-    }
-    build(file) {
+    getSource(file) {
       const imports = [];
       file.imports?.forEach((curr) => {
         const exists = imports.find((imp) => imp.path === curr.path);
-        if (exists) {
-          exists.name = [...exists.name, ...curr.name];
-        } else {
+        if (!exists) {
           imports.push(curr);
+          return;
+        }
+        if (exists && Array.isArray(curr.name)) {
+          exists.name = (0, import_lodash.default)([...exists.name, ...curr.name]);
         }
       });
       const importSource = imports.reduce((prev, curr) => {
@@ -16925,6 +17229,30 @@ ${file.source}`;
       }
       return file.source;
     }
+    get files() {
+      const files = [];
+      this.cache.forEach((item) => {
+        files.push(item.file);
+      });
+      return files;
+    }
+    add(file) {
+      const cacheItem = { id: v4_default(), file, status: "new" };
+      this.cache.set(cacheItem.id, cacheItem);
+      this.events.emitFile(cacheItem.id, file);
+      return new Promise((resolve) => {
+        const unsubscribe = this.events.onRemove(cacheItem.id, (file2) => {
+          resolve(file2);
+          unsubscribe();
+        });
+      });
+    }
+    build(file) {
+      return {
+        ...file,
+        source: this.getSource(file)
+      };
+    }
     addOrAppend(file) {
       const previousCache = this.getCacheByPath(file.path);
       if (previousCache) {
@@ -17264,12 +17592,12 @@ ${file.source}`,
     fileManager.events.onSuccess(async () => {
       await pluginManager.hookParallel("buildEnd");
       setTimeout(() => {
-        done({ files: fileManager.files });
+        done({ files: fileManager.files.map((file) => fileManager.build(file)) });
       }, 1e3);
     });
     fileManager.events.onAdd(async (id, file) => {
       const { path } = file;
-      let code = fileManager.build(file);
+      let { source: code } = fileManager.build(file);
       const loadedResult = await pluginManager.hookFirst("load", [path]);
       if (loadedResult) {
         code = loadedResult;