@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/glob@7.2.3/node_modules/glob/sync.js

@@ -0,0 +1,280 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_fs_realpath } from "../../../fs.realpath@1.0.0/node_modules/fs.realpath/index.js";
+import { require_minimatch } from "../../../minimatch@3.1.5/node_modules/minimatch/minimatch.js";
+import { require_path_is_absolute } from "../../../path-is-absolute@1.0.1/node_modules/path-is-absolute/index.js";
+import { require_common } from "./common.js";
+import { require_glob } from "./glob.js";
+//#region node_modules/.pnpm/glob@7.2.3/node_modules/glob/sync.js
+var require_sync = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = globSync;
+	globSync.GlobSync = GlobSync;
+	var rp = require_fs_realpath();
+	var minimatch = require_minimatch();
+	minimatch.Minimatch;
+	require_glob().Glob;
+	__require("util");
+	var path = __require("path");
+	var assert = __require("assert");
+	var isAbsolute = require_path_is_absolute();
+	var common = require_common();
+	var setopts = common.setopts;
+	var ownProp = common.ownProp;
+	var childrenIgnored = common.childrenIgnored;
+	var isIgnored = common.isIgnored;
+	function globSync(pattern, options) {
+		if (typeof options === "function" || arguments.length === 3) throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+		return new GlobSync(pattern, options).found;
+	}
+	function GlobSync(pattern, options) {
+		if (!pattern) throw new Error("must provide pattern");
+		if (typeof options === "function" || arguments.length === 3) throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
+		if (!(this instanceof GlobSync)) return new GlobSync(pattern, options);
+		setopts(this, pattern, options);
+		if (this.noprocess) return this;
+		var n = this.minimatch.set.length;
+		this.matches = new Array(n);
+		for (var i = 0; i < n; i++) this._process(this.minimatch.set[i], i, false);
+		this._finish();
+	}
+	GlobSync.prototype._finish = function() {
+		assert.ok(this instanceof GlobSync);
+		if (this.realpath) {
+			var self = this;
+			this.matches.forEach(function(matchset, index) {
+				var set = self.matches[index] = Object.create(null);
+				for (var p in matchset) try {
+					p = self._makeAbs(p);
+					var real = rp.realpathSync(p, self.realpathCache);
+					set[real] = true;
+				} catch (er) {
+					if (er.syscall === "stat") set[self._makeAbs(p)] = true;
+					else throw er;
+				}
+			});
+		}
+		common.finish(this);
+	};
+	GlobSync.prototype._process = function(pattern, index, inGlobStar) {
+		assert.ok(this instanceof GlobSync);
+		var n = 0;
+		while (typeof pattern[n] === "string") n++;
+		var prefix;
+		switch (n) {
+			case pattern.length:
+				this._processSimple(pattern.join("/"), index);
+				return;
+			case 0:
+				prefix = null;
+				break;
+			default:
+				prefix = pattern.slice(0, n).join("/");
+				break;
+		}
+		var remain = pattern.slice(n);
+		var read;
+		if (prefix === null) read = ".";
+		else if (isAbsolute(prefix) || isAbsolute(pattern.map(function(p) {
+			return typeof p === "string" ? p : "[*]";
+		}).join("/"))) {
+			if (!prefix || !isAbsolute(prefix)) prefix = "/" + prefix;
+			read = prefix;
+		} else read = prefix;
+		var abs = this._makeAbs(read);
+		if (childrenIgnored(this, read)) return;
+		if (remain[0] === minimatch.GLOBSTAR) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar);
+		else this._processReaddir(prefix, read, abs, remain, index, inGlobStar);
+	};
+	GlobSync.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar) {
+		var entries = this._readdir(abs, inGlobStar);
+		if (!entries) return;
+		var pn = remain[0];
+		var negate = !!this.minimatch.negate;
+		var rawGlob = pn._glob;
+		var dotOk = this.dot || rawGlob.charAt(0) === ".";
+		var matchedEntries = [];
+		for (var i = 0; i < entries.length; i++) {
+			var e = entries[i];
+			if (e.charAt(0) !== "." || dotOk) {
+				var m;
+				if (negate && !prefix) m = !e.match(pn);
+				else m = e.match(pn);
+				if (m) matchedEntries.push(e);
+			}
+		}
+		var len = matchedEntries.length;
+		if (len === 0) return;
+		if (remain.length === 1 && !this.mark && !this.stat) {
+			if (!this.matches[index]) this.matches[index] = Object.create(null);
+			for (var i = 0; i < len; i++) {
+				var e = matchedEntries[i];
+				if (prefix) if (prefix.slice(-1) !== "/") e = prefix + "/" + e;
+				else e = prefix + e;
+				if (e.charAt(0) === "/" && !this.nomount) e = path.join(this.root, e);
+				this._emitMatch(index, e);
+			}
+			return;
+		}
+		remain.shift();
+		for (var i = 0; i < len; i++) {
+			var e = matchedEntries[i];
+			var newPattern;
+			if (prefix) newPattern = [prefix, e];
+			else newPattern = [e];
+			this._process(newPattern.concat(remain), index, inGlobStar);
+		}
+	};
+	GlobSync.prototype._emitMatch = function(index, e) {
+		if (isIgnored(this, e)) return;
+		var abs = this._makeAbs(e);
+		if (this.mark) e = this._mark(e);
+		if (this.absolute) e = abs;
+		if (this.matches[index][e]) return;
+		if (this.nodir) {
+			var c = this.cache[abs];
+			if (c === "DIR" || Array.isArray(c)) return;
+		}
+		this.matches[index][e] = true;
+		if (this.stat) this._stat(e);
+	};
+	GlobSync.prototype._readdirInGlobStar = function(abs) {
+		if (this.follow) return this._readdir(abs, false);
+		var entries;
+		var lstat;
+		try {
+			lstat = this.fs.lstatSync(abs);
+		} catch (er) {
+			if (er.code === "ENOENT") return null;
+		}
+		var isSym = lstat && lstat.isSymbolicLink();
+		this.symlinks[abs] = isSym;
+		if (!isSym && lstat && !lstat.isDirectory()) this.cache[abs] = "FILE";
+		else entries = this._readdir(abs, false);
+		return entries;
+	};
+	GlobSync.prototype._readdir = function(abs, inGlobStar) {
+		if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs);
+		if (ownProp(this.cache, abs)) {
+			var c = this.cache[abs];
+			if (!c || c === "FILE") return null;
+			if (Array.isArray(c)) return c;
+		}
+		try {
+			return this._readdirEntries(abs, this.fs.readdirSync(abs));
+		} catch (er) {
+			this._readdirError(abs, er);
+			return null;
+		}
+	};
+	GlobSync.prototype._readdirEntries = function(abs, entries) {
+		if (!this.mark && !this.stat) for (var i = 0; i < entries.length; i++) {
+			var e = entries[i];
+			if (abs === "/") e = abs + e;
+			else e = abs + "/" + e;
+			this.cache[e] = true;
+		}
+		this.cache[abs] = entries;
+		return entries;
+	};
+	GlobSync.prototype._readdirError = function(f, er) {
+		switch (er.code) {
+			case "ENOTSUP":
+			case "ENOTDIR":
+				var abs = this._makeAbs(f);
+				this.cache[abs] = "FILE";
+				if (abs === this.cwdAbs) {
+					var error = /* @__PURE__ */ new Error(er.code + " invalid cwd " + this.cwd);
+					error.path = this.cwd;
+					error.code = er.code;
+					throw error;
+				}
+				break;
+			case "ENOENT":
+			case "ELOOP":
+			case "ENAMETOOLONG":
+			case "UNKNOWN":
+				this.cache[this._makeAbs(f)] = false;
+				break;
+			default:
+				this.cache[this._makeAbs(f)] = false;
+				if (this.strict) throw er;
+				if (!this.silent) console.error("glob error", er);
+				break;
+		}
+	};
+	GlobSync.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar) {
+		var entries = this._readdir(abs, inGlobStar);
+		if (!entries) return;
+		var remainWithoutGlobStar = remain.slice(1);
+		var gspref = prefix ? [prefix] : [];
+		var noGlobStar = gspref.concat(remainWithoutGlobStar);
+		this._process(noGlobStar, index, false);
+		var len = entries.length;
+		if (this.symlinks[abs] && inGlobStar) return;
+		for (var i = 0; i < len; i++) {
+			if (entries[i].charAt(0) === "." && !this.dot) continue;
+			var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+			this._process(instead, index, true);
+			var below = gspref.concat(entries[i], remain);
+			this._process(below, index, true);
+		}
+	};
+	GlobSync.prototype._processSimple = function(prefix, index) {
+		var exists = this._stat(prefix);
+		if (!this.matches[index]) this.matches[index] = Object.create(null);
+		if (!exists) return;
+		if (prefix && isAbsolute(prefix) && !this.nomount) {
+			var trail = /[\/\\]$/.test(prefix);
+			if (prefix.charAt(0) === "/") prefix = path.join(this.root, prefix);
+			else {
+				prefix = path.resolve(this.root, prefix);
+				if (trail) prefix += "/";
+			}
+		}
+		if (process.platform === "win32") prefix = prefix.replace(/\\/g, "/");
+		this._emitMatch(index, prefix);
+	};
+	GlobSync.prototype._stat = function(f) {
+		var abs = this._makeAbs(f);
+		var needDir = f.slice(-1) === "/";
+		if (f.length > this.maxLength) return false;
+		if (!this.stat && ownProp(this.cache, abs)) {
+			var c = this.cache[abs];
+			if (Array.isArray(c)) c = "DIR";
+			if (!needDir || c === "DIR") return c;
+			if (needDir && c === "FILE") return false;
+		}
+		var stat = this.statCache[abs];
+		if (!stat) {
+			var lstat;
+			try {
+				lstat = this.fs.lstatSync(abs);
+			} catch (er) {
+				if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+					this.statCache[abs] = false;
+					return false;
+				}
+			}
+			if (lstat && lstat.isSymbolicLink()) try {
+				stat = this.fs.statSync(abs);
+			} catch (er) {
+				stat = lstat;
+			}
+			else stat = lstat;
+		}
+		this.statCache[abs] = stat;
+		var c = true;
+		if (stat) c = stat.isDirectory() ? "DIR" : "FILE";
+		this.cache[abs] = this.cache[abs] || c;
+		if (needDir && c === "FILE") return false;
+		return c;
+	};
+	GlobSync.prototype._mark = function(p) {
+		return common.mark(this, p);
+	};
+	GlobSync.prototype._makeAbs = function(f) {
+		return common.makeAbs(this, f);
+	};
+}));
+//#endregion
+export default require_sync();
+export { require_sync };

package/dist/node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js

@@ -0,0 +1,20 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/clone.js
+var require_clone = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = clone;
+	var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+		return obj.__proto__;
+	};
+	function clone(obj) {
+		if (obj === null || typeof obj !== "object") return obj;
+		if (obj instanceof Object) var copy = { __proto__: getPrototypeOf(obj) };
+		else var copy = Object.create(null);
+		Object.getOwnPropertyNames(obj).forEach(function(key) {
+			Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+		});
+		return copy;
+	}
+}));
+//#endregion
+export default require_clone();
+export { require_clone };

package/dist/node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js

@@ -0,0 +1,362 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_polyfills } from "./polyfills.js";
+import { require_legacy_streams } from "./legacy-streams.js";
+import { require_clone } from "./clone.js";
+//#region node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js
+var require_graceful_fs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var fs = __require("fs");
+	var polyfills = require_polyfills();
+	var legacy = require_legacy_streams();
+	var clone = require_clone();
+	var util = __require("util");
+	/* istanbul ignore next - node 0.x polyfill */
+	var gracefulQueue;
+	var previousSymbol;
+	/* istanbul ignore else - node 0.x polyfill */
+	if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+		gracefulQueue = Symbol.for("graceful-fs.queue");
+		previousSymbol = Symbol.for("graceful-fs.previous");
+	} else {
+		gracefulQueue = "___graceful-fs.queue";
+		previousSymbol = "___graceful-fs.previous";
+	}
+	function noop() {}
+	function publishQueue(context, queue) {
+		Object.defineProperty(context, gracefulQueue, { get: function() {
+			return queue;
+		} });
+	}
+	var debug = noop;
+	if (util.debuglog) debug = util.debuglog("gfs4");
+	else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) debug = function() {
+		var m = util.format.apply(util, arguments);
+		m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+		console.error(m);
+	};
+	if (!fs[gracefulQueue]) {
+		publishQueue(fs, global[gracefulQueue] || []);
+		fs.close = (function(fs$close) {
+			function close(fd, cb) {
+				return fs$close.call(fs, fd, function(err) {
+					if (!err) resetQueue();
+					if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+			Object.defineProperty(close, previousSymbol, { value: fs$close });
+			return close;
+		})(fs.close);
+		fs.closeSync = (function(fs$closeSync) {
+			function closeSync(fd) {
+				fs$closeSync.apply(fs, arguments);
+				resetQueue();
+			}
+			Object.defineProperty(closeSync, previousSymbol, { value: fs$closeSync });
+			return closeSync;
+		})(fs.closeSync);
+		if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
+			debug(fs[gracefulQueue]);
+			__require("assert").equal(fs[gracefulQueue].length, 0);
+		});
+	}
+	if (!global[gracefulQueue]) publishQueue(global, fs[gracefulQueue]);
+	module.exports = patch(clone(fs));
+	if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+		module.exports = patch(fs);
+		fs.__patched = true;
+	}
+	function patch(fs) {
+		polyfills(fs);
+		fs.gracefulify = patch;
+		fs.createReadStream = createReadStream;
+		fs.createWriteStream = createWriteStream;
+		var fs$readFile = fs.readFile;
+		fs.readFile = readFile;
+		function readFile(path, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$readFile(path, options, cb);
+			function go$readFile(path, options, cb, startTime) {
+				return fs$readFile(path, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readFile,
+						[
+							path,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$writeFile = fs.writeFile;
+		fs.writeFile = writeFile;
+		function writeFile(path, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$writeFile(path, data, options, cb);
+			function go$writeFile(path, data, options, cb, startTime) {
+				return fs$writeFile(path, data, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$writeFile,
+						[
+							path,
+							data,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$appendFile = fs.appendFile;
+		if (fs$appendFile) fs.appendFile = appendFile;
+		function appendFile(path, data, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			return go$appendFile(path, data, options, cb);
+			function go$appendFile(path, data, options, cb, startTime) {
+				return fs$appendFile(path, data, options, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$appendFile,
+						[
+							path,
+							data,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$copyFile = fs.copyFile;
+		if (fs$copyFile) fs.copyFile = copyFile;
+		function copyFile(src, dest, flags, cb) {
+			if (typeof flags === "function") {
+				cb = flags;
+				flags = 0;
+			}
+			return go$copyFile(src, dest, flags, cb);
+			function go$copyFile(src, dest, flags, cb, startTime) {
+				return fs$copyFile(src, dest, flags, function(err) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$copyFile,
+						[
+							src,
+							dest,
+							flags,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		var fs$readdir = fs.readdir;
+		fs.readdir = readdir;
+		var noReaddirOptionVersions = /^v[0-5]\./;
+		function readdir(path, options, cb) {
+			if (typeof options === "function") cb = options, options = null;
+			var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, fs$readdirCallback(path, options, cb, startTime));
+			} : function go$readdir(path, options, cb, startTime) {
+				return fs$readdir(path, options, fs$readdirCallback(path, options, cb, startTime));
+			};
+			return go$readdir(path, options, cb);
+			function fs$readdirCallback(path, options, cb, startTime) {
+				return function(err, files) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$readdir,
+						[
+							path,
+							options,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else {
+						if (files && files.sort) files.sort();
+						if (typeof cb === "function") cb.call(this, err, files);
+					}
+				};
+			}
+		}
+		if (process.version.substr(0, 4) === "v0.8") {
+			var legStreams = legacy(fs);
+			ReadStream = legStreams.ReadStream;
+			WriteStream = legStreams.WriteStream;
+		}
+		var fs$ReadStream = fs.ReadStream;
+		if (fs$ReadStream) {
+			ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+			ReadStream.prototype.open = ReadStream$open;
+		}
+		var fs$WriteStream = fs.WriteStream;
+		if (fs$WriteStream) {
+			WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+			WriteStream.prototype.open = WriteStream$open;
+		}
+		Object.defineProperty(fs, "ReadStream", {
+			get: function() {
+				return ReadStream;
+			},
+			set: function(val) {
+				ReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		Object.defineProperty(fs, "WriteStream", {
+			get: function() {
+				return WriteStream;
+			},
+			set: function(val) {
+				WriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileReadStream = ReadStream;
+		Object.defineProperty(fs, "FileReadStream", {
+			get: function() {
+				return FileReadStream;
+			},
+			set: function(val) {
+				FileReadStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		var FileWriteStream = WriteStream;
+		Object.defineProperty(fs, "FileWriteStream", {
+			get: function() {
+				return FileWriteStream;
+			},
+			set: function(val) {
+				FileWriteStream = val;
+			},
+			enumerable: true,
+			configurable: true
+		});
+		function ReadStream(path, options) {
+			if (this instanceof ReadStream) return fs$ReadStream.apply(this, arguments), this;
+			else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+		}
+		function ReadStream$open() {
+			var that = this;
+			open(that.path, that.flags, that.mode, function(err, fd) {
+				if (err) {
+					if (that.autoClose) that.destroy();
+					that.emit("error", err);
+				} else {
+					that.fd = fd;
+					that.emit("open", fd);
+					that.read();
+				}
+			});
+		}
+		function WriteStream(path, options) {
+			if (this instanceof WriteStream) return fs$WriteStream.apply(this, arguments), this;
+			else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+		}
+		function WriteStream$open() {
+			var that = this;
+			open(that.path, that.flags, that.mode, function(err, fd) {
+				if (err) {
+					that.destroy();
+					that.emit("error", err);
+				} else {
+					that.fd = fd;
+					that.emit("open", fd);
+				}
+			});
+		}
+		function createReadStream(path, options) {
+			return new fs.ReadStream(path, options);
+		}
+		function createWriteStream(path, options) {
+			return new fs.WriteStream(path, options);
+		}
+		var fs$open = fs.open;
+		fs.open = open;
+		function open(path, flags, mode, cb) {
+			if (typeof mode === "function") cb = mode, mode = null;
+			return go$open(path, flags, mode, cb);
+			function go$open(path, flags, mode, cb, startTime) {
+				return fs$open(path, flags, mode, function(err, fd) {
+					if (err && (err.code === "EMFILE" || err.code === "ENFILE")) enqueue([
+						go$open,
+						[
+							path,
+							flags,
+							mode,
+							cb
+						],
+						err,
+						startTime || Date.now(),
+						Date.now()
+					]);
+					else if (typeof cb === "function") cb.apply(this, arguments);
+				});
+			}
+		}
+		return fs;
+	}
+	function enqueue(elem) {
+		debug("ENQUEUE", elem[0].name, elem[1]);
+		fs[gracefulQueue].push(elem);
+		retry();
+	}
+	var retryTimer;
+	function resetQueue() {
+		var now = Date.now();
+		for (var i = 0; i < fs[gracefulQueue].length; ++i) if (fs[gracefulQueue][i].length > 2) {
+			fs[gracefulQueue][i][3] = now;
+			fs[gracefulQueue][i][4] = now;
+		}
+		retry();
+	}
+	function retry() {
+		clearTimeout(retryTimer);
+		retryTimer = void 0;
+		if (fs[gracefulQueue].length === 0) return;
+		var elem = fs[gracefulQueue].shift();
+		var fn = elem[0];
+		var args = elem[1];
+		var err = elem[2];
+		var startTime = elem[3];
+		var lastTime = elem[4];
+		if (startTime === void 0) {
+			debug("RETRY", fn.name, args);
+			fn.apply(null, args);
+		} else if (Date.now() - startTime >= 6e4) {
+			debug("TIMEOUT", fn.name, args);
+			var cb = args.pop();
+			if (typeof cb === "function") cb.call(null, err);
+		} else {
+			var sinceAttempt = Date.now() - lastTime;
+			var sinceStart = Math.max(lastTime - startTime, 1);
+			if (sinceAttempt >= Math.min(sinceStart * 1.2, 100)) {
+				debug("RETRY", fn.name, args);
+				fn.apply(null, args.concat([startTime]));
+			} else fs[gracefulQueue].push(elem);
+		}
+		if (retryTimer === void 0) retryTimer = setTimeout(retry, 0);
+	}
+}));
+//#endregion
+export default require_graceful_fs();
+export { require_graceful_fs };