@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

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

@@ -0,0 +1,451 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_inherits_browser } from "../../../inherits@2.0.4/node_modules/inherits/inherits_browser.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_sync } from "./sync.js";
+import { require_once } from "../../../once@1.4.0/node_modules/once/once.js";
+import { require_inflight } from "../../../inflight@1.0.6/node_modules/inflight/inflight.js";
+//#region node_modules/.pnpm/glob@7.2.3/node_modules/glob/glob.js
+var require_glob = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = glob;
+	var rp = require_fs_realpath();
+	var minimatch = require_minimatch();
+	minimatch.Minimatch;
+	var inherits = require_inherits_browser();
+	var EE = __require("events").EventEmitter;
+	var path = __require("path");
+	var assert = __require("assert");
+	var isAbsolute = require_path_is_absolute();
+	var globSync = require_sync();
+	var common = require_common();
+	var setopts = common.setopts;
+	var ownProp = common.ownProp;
+	var inflight = require_inflight();
+	__require("util");
+	var childrenIgnored = common.childrenIgnored;
+	var isIgnored = common.isIgnored;
+	var once = require_once();
+	function glob(pattern, options, cb) {
+		if (typeof options === "function") cb = options, options = {};
+		if (!options) options = {};
+		if (options.sync) {
+			if (cb) throw new TypeError("callback provided to sync glob");
+			return globSync(pattern, options);
+		}
+		return new Glob(pattern, options, cb);
+	}
+	glob.sync = globSync;
+	var GlobSync = glob.GlobSync = globSync.GlobSync;
+	glob.glob = glob;
+	function extend(origin, add) {
+		if (add === null || typeof add !== "object") return origin;
+		var keys = Object.keys(add);
+		var i = keys.length;
+		while (i--) origin[keys[i]] = add[keys[i]];
+		return origin;
+	}
+	glob.hasMagic = function(pattern, options_) {
+		var options = extend({}, options_);
+		options.noprocess = true;
+		var set = new Glob(pattern, options).minimatch.set;
+		if (!pattern) return false;
+		if (set.length > 1) return true;
+		for (var j = 0; j < set[0].length; j++) if (typeof set[0][j] !== "string") return true;
+		return false;
+	};
+	glob.Glob = Glob;
+	inherits(Glob, EE);
+	function Glob(pattern, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = null;
+		}
+		if (options && options.sync) {
+			if (cb) throw new TypeError("callback provided to sync glob");
+			return new GlobSync(pattern, options);
+		}
+		if (!(this instanceof Glob)) return new Glob(pattern, options, cb);
+		setopts(this, pattern, options);
+		this._didRealPath = false;
+		var n = this.minimatch.set.length;
+		this.matches = new Array(n);
+		if (typeof cb === "function") {
+			cb = once(cb);
+			this.on("error", cb);
+			this.on("end", function(matches) {
+				cb(null, matches);
+			});
+		}
+		var self = this;
+		this._processing = 0;
+		this._emitQueue = [];
+		this._processQueue = [];
+		this.paused = false;
+		if (this.noprocess) return this;
+		if (n === 0) return done();
+		var sync = true;
+		for (var i = 0; i < n; i++) this._process(this.minimatch.set[i], i, false, done);
+		sync = false;
+		function done() {
+			--self._processing;
+			if (self._processing <= 0) if (sync) process.nextTick(function() {
+				self._finish();
+			});
+			else self._finish();
+		}
+	}
+	Glob.prototype._finish = function() {
+		assert(this instanceof Glob);
+		if (this.aborted) return;
+		if (this.realpath && !this._didRealpath) return this._realpath();
+		common.finish(this);
+		this.emit("end", this.found);
+	};
+	Glob.prototype._realpath = function() {
+		if (this._didRealpath) return;
+		this._didRealpath = true;
+		var n = this.matches.length;
+		if (n === 0) return this._finish();
+		var self = this;
+		for (var i = 0; i < this.matches.length; i++) this._realpathSet(i, next);
+		function next() {
+			if (--n === 0) self._finish();
+		}
+	};
+	Glob.prototype._realpathSet = function(index, cb) {
+		var matchset = this.matches[index];
+		if (!matchset) return cb();
+		var found = Object.keys(matchset);
+		var self = this;
+		var n = found.length;
+		if (n === 0) return cb();
+		var set = this.matches[index] = Object.create(null);
+		found.forEach(function(p, i) {
+			p = self._makeAbs(p);
+			rp.realpath(p, self.realpathCache, function(er, real) {
+				if (!er) set[real] = true;
+				else if (er.syscall === "stat") set[p] = true;
+				else self.emit("error", er);
+				if (--n === 0) {
+					self.matches[index] = set;
+					cb();
+				}
+			});
+		});
+	};
+	Glob.prototype._mark = function(p) {
+		return common.mark(this, p);
+	};
+	Glob.prototype._makeAbs = function(f) {
+		return common.makeAbs(this, f);
+	};
+	Glob.prototype.abort = function() {
+		this.aborted = true;
+		this.emit("abort");
+	};
+	Glob.prototype.pause = function() {
+		if (!this.paused) {
+			this.paused = true;
+			this.emit("pause");
+		}
+	};
+	Glob.prototype.resume = function() {
+		if (this.paused) {
+			this.emit("resume");
+			this.paused = false;
+			if (this._emitQueue.length) {
+				var eq = this._emitQueue.slice(0);
+				this._emitQueue.length = 0;
+				for (var i = 0; i < eq.length; i++) {
+					var e = eq[i];
+					this._emitMatch(e[0], e[1]);
+				}
+			}
+			if (this._processQueue.length) {
+				var pq = this._processQueue.slice(0);
+				this._processQueue.length = 0;
+				for (var i = 0; i < pq.length; i++) {
+					var p = pq[i];
+					this._processing--;
+					this._process(p[0], p[1], p[2], p[3]);
+				}
+			}
+		}
+	};
+	Glob.prototype._process = function(pattern, index, inGlobStar, cb) {
+		assert(this instanceof Glob);
+		assert(typeof cb === "function");
+		if (this.aborted) return;
+		this._processing++;
+		if (this.paused) {
+			this._processQueue.push([
+				pattern,
+				index,
+				inGlobStar,
+				cb
+			]);
+			return;
+		}
+		var n = 0;
+		while (typeof pattern[n] === "string") n++;
+		var prefix;
+		switch (n) {
+			case pattern.length:
+				this._processSimple(pattern.join("/"), index, cb);
+				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 cb();
+		if (remain[0] === minimatch.GLOBSTAR) this._processGlobStar(prefix, read, abs, remain, index, inGlobStar, cb);
+		else this._processReaddir(prefix, read, abs, remain, index, inGlobStar, cb);
+	};
+	Glob.prototype._processReaddir = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+		var self = this;
+		this._readdir(abs, inGlobStar, function(er, entries) {
+			return self._processReaddir2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+		});
+	};
+	Glob.prototype._processReaddir2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+		if (!entries) return cb();
+		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 cb();
+		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 !== "/") e = prefix + "/" + e;
+				else e = prefix + e;
+				if (e.charAt(0) === "/" && !this.nomount) e = path.join(this.root, e);
+				this._emitMatch(index, e);
+			}
+			return cb();
+		}
+		remain.shift();
+		for (var i = 0; i < len; i++) {
+			var e = matchedEntries[i];
+			if (prefix) if (prefix !== "/") e = prefix + "/" + e;
+			else e = prefix + e;
+			this._process([e].concat(remain), index, inGlobStar, cb);
+		}
+		cb();
+	};
+	Glob.prototype._emitMatch = function(index, e) {
+		if (this.aborted) return;
+		if (isIgnored(this, e)) return;
+		if (this.paused) {
+			this._emitQueue.push([index, e]);
+			return;
+		}
+		var abs = isAbsolute(e) ? e : 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;
+		var st = this.statCache[abs];
+		if (st) this.emit("stat", e, st);
+		this.emit("match", e);
+	};
+	Glob.prototype._readdirInGlobStar = function(abs, cb) {
+		if (this.aborted) return;
+		if (this.follow) return this._readdir(abs, false, cb);
+		var lstatkey = "lstat\0" + abs;
+		var self = this;
+		var lstatcb = inflight(lstatkey, lstatcb_);
+		if (lstatcb) self.fs.lstat(abs, lstatcb);
+		function lstatcb_(er, lstat) {
+			if (er && er.code === "ENOENT") return cb();
+			var isSym = lstat && lstat.isSymbolicLink();
+			self.symlinks[abs] = isSym;
+			if (!isSym && lstat && !lstat.isDirectory()) {
+				self.cache[abs] = "FILE";
+				cb();
+			} else self._readdir(abs, false, cb);
+		}
+	};
+	Glob.prototype._readdir = function(abs, inGlobStar, cb) {
+		if (this.aborted) return;
+		cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
+		if (!cb) return;
+		if (inGlobStar && !ownProp(this.symlinks, abs)) return this._readdirInGlobStar(abs, cb);
+		if (ownProp(this.cache, abs)) {
+			var c = this.cache[abs];
+			if (!c || c === "FILE") return cb();
+			if (Array.isArray(c)) return cb(null, c);
+		}
+		this.fs.readdir(abs, readdirCb(this, abs, cb));
+	};
+	function readdirCb(self, abs, cb) {
+		return function(er, entries) {
+			if (er) self._readdirError(abs, er, cb);
+			else self._readdirEntries(abs, entries, cb);
+		};
+	}
+	Glob.prototype._readdirEntries = function(abs, entries, cb) {
+		if (this.aborted) return;
+		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 cb(null, entries);
+	};
+	Glob.prototype._readdirError = function(f, er, cb) {
+		if (this.aborted) return;
+		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;
+					this.emit("error", error);
+					this.abort();
+				}
+				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) {
+					this.emit("error", er);
+					this.abort();
+				}
+				if (!this.silent) console.error("glob error", er);
+				break;
+		}
+		return cb();
+	};
+	Glob.prototype._processGlobStar = function(prefix, read, abs, remain, index, inGlobStar, cb) {
+		var self = this;
+		this._readdir(abs, inGlobStar, function(er, entries) {
+			self._processGlobStar2(prefix, read, abs, remain, index, inGlobStar, entries, cb);
+		});
+	};
+	Glob.prototype._processGlobStar2 = function(prefix, read, abs, remain, index, inGlobStar, entries, cb) {
+		if (!entries) return cb();
+		var remainWithoutGlobStar = remain.slice(1);
+		var gspref = prefix ? [prefix] : [];
+		var noGlobStar = gspref.concat(remainWithoutGlobStar);
+		this._process(noGlobStar, index, false, cb);
+		var isSym = this.symlinks[abs];
+		var len = entries.length;
+		if (isSym && inGlobStar) return cb();
+		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, cb);
+			var below = gspref.concat(entries[i], remain);
+			this._process(below, index, true, cb);
+		}
+		cb();
+	};
+	Glob.prototype._processSimple = function(prefix, index, cb) {
+		var self = this;
+		this._stat(prefix, function(er, exists) {
+			self._processSimple2(prefix, index, er, exists, cb);
+		});
+	};
+	Glob.prototype._processSimple2 = function(prefix, index, er, exists, cb) {
+		if (!this.matches[index]) this.matches[index] = Object.create(null);
+		if (!exists) return cb();
+		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);
+		cb();
+	};
+	Glob.prototype._stat = function(f, cb) {
+		var abs = this._makeAbs(f);
+		var needDir = f.slice(-1) === "/";
+		if (f.length > this.maxLength) return cb();
+		if (!this.stat && ownProp(this.cache, abs)) {
+			var c = this.cache[abs];
+			if (Array.isArray(c)) c = "DIR";
+			if (!needDir || c === "DIR") return cb(null, c);
+			if (needDir && c === "FILE") return cb();
+		}
+		var stat = this.statCache[abs];
+		if (stat !== void 0) if (stat === false) return cb(null, stat);
+		else {
+			var type = stat.isDirectory() ? "DIR" : "FILE";
+			if (needDir && type === "FILE") return cb();
+			else return cb(null, type, stat);
+		}
+		var self = this;
+		var statcb = inflight("stat\0" + abs, lstatcb_);
+		if (statcb) self.fs.lstat(abs, statcb);
+		function lstatcb_(er, lstat) {
+			if (lstat && lstat.isSymbolicLink()) return self.fs.stat(abs, function(er, stat) {
+				if (er) self._stat2(f, abs, null, lstat, cb);
+				else self._stat2(f, abs, er, stat, cb);
+			});
+			else self._stat2(f, abs, er, lstat, cb);
+		}
+	};
+	Glob.prototype._stat2 = function(f, abs, er, stat, cb) {
+		if (er && (er.code === "ENOENT" || er.code === "ENOTDIR")) {
+			this.statCache[abs] = false;
+			return cb();
+		}
+		var needDir = f.slice(-1) === "/";
+		this.statCache[abs] = stat;
+		if (abs.slice(-1) === "/" && stat && !stat.isDirectory()) return cb(null, false, stat);
+		var c = true;
+		if (stat) c = stat.isDirectory() ? "DIR" : "FILE";
+		this.cache[abs] = this.cache[abs] || c;
+		if (needDir && c === "FILE") return cb();
+		return cb(null, c, stat);
+	};
+}));
+//#endregion
+export default require_glob();
+export { require_glob };