@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/theme-set.js

@@ -0,0 +1,99 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_object_assign } from "../../../object-assign@4.1.1/node_modules/object-assign/index.js";
+import { require_base_theme } from "./base-theme.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/theme-set.js
+var require_theme_set = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var objectAssign = require_object_assign();
+	module.exports = function() {
+		return ThemeSetProto.newThemeSet();
+	};
+	var ThemeSetProto = {};
+	ThemeSetProto.baseTheme = require_base_theme();
+	ThemeSetProto.newTheme = function(parent, theme) {
+		if (!theme) {
+			theme = parent;
+			parent = this.baseTheme;
+		}
+		return objectAssign({}, parent, theme);
+	};
+	ThemeSetProto.getThemeNames = function() {
+		return Object.keys(this.themes);
+	};
+	ThemeSetProto.addTheme = function(name, parent, theme) {
+		this.themes[name] = this.newTheme(parent, theme);
+	};
+	ThemeSetProto.addToAllThemes = function(theme) {
+		var themes = this.themes;
+		Object.keys(themes).forEach(function(name) {
+			objectAssign(themes[name], theme);
+		});
+		objectAssign(this.baseTheme, theme);
+	};
+	ThemeSetProto.getTheme = function(name) {
+		if (!this.themes[name]) throw this.newMissingThemeError(name);
+		return this.themes[name];
+	};
+	ThemeSetProto.setDefault = function(opts, name) {
+		if (name == null) {
+			name = opts;
+			opts = {};
+		}
+		var platform = opts.platform == null ? "fallback" : opts.platform;
+		var hasUnicode = !!opts.hasUnicode;
+		var hasColor = !!opts.hasColor;
+		if (!this.defaults[platform]) this.defaults[platform] = {
+			true: {},
+			false: {}
+		};
+		this.defaults[platform][hasUnicode][hasColor] = name;
+	};
+	ThemeSetProto.getDefault = function(opts) {
+		if (!opts) opts = {};
+		var platformName = opts.platform || process.platform;
+		var platform = this.defaults[platformName] || this.defaults.fallback;
+		var hasUnicode = !!opts.hasUnicode;
+		var hasColor = !!opts.hasColor;
+		if (!platform) throw this.newMissingDefaultThemeError(platformName, hasUnicode, hasColor);
+		if (!platform[hasUnicode][hasColor]) {
+			if (hasUnicode && hasColor && platform[!hasUnicode][hasColor]) hasUnicode = false;
+			else if (hasUnicode && hasColor && platform[hasUnicode][!hasColor]) hasColor = false;
+			else if (hasUnicode && hasColor && platform[!hasUnicode][!hasColor]) {
+				hasUnicode = false;
+				hasColor = false;
+			} else if (hasUnicode && !hasColor && platform[!hasUnicode][hasColor]) hasUnicode = false;
+			else if (!hasUnicode && hasColor && platform[hasUnicode][!hasColor]) hasColor = false;
+			else if (platform === this.defaults.fallback) throw this.newMissingDefaultThemeError(platformName, hasUnicode, hasColor);
+		}
+		if (platform[hasUnicode][hasColor]) return this.getTheme(platform[hasUnicode][hasColor]);
+		else return this.getDefault(objectAssign({}, opts, { platform: "fallback" }));
+	};
+	ThemeSetProto.newMissingThemeError = function newMissingThemeError(name) {
+		var err = /* @__PURE__ */ new Error("Could not find a gauge theme named \"" + name + "\"");
+		Error.captureStackTrace.call(err, newMissingThemeError);
+		err.theme = name;
+		err.code = "EMISSINGTHEME";
+		return err;
+	};
+	ThemeSetProto.newMissingDefaultThemeError = function newMissingDefaultThemeError(platformName, hasUnicode, hasColor) {
+		var err = /* @__PURE__ */ new Error("Could not find a gauge theme for your platform/unicode/color use combo:\n    platform = " + platformName + "\n    hasUnicode = " + hasUnicode + "\n    hasColor = " + hasColor);
+		Error.captureStackTrace.call(err, newMissingDefaultThemeError);
+		err.platform = platformName;
+		err.hasUnicode = hasUnicode;
+		err.hasColor = hasColor;
+		err.code = "EMISSINGTHEME";
+		return err;
+	};
+	ThemeSetProto.newThemeSet = function() {
+		var themeset = function(opts) {
+			return themeset.getDefault(opts);
+		};
+		return objectAssign(themeset, ThemeSetProto, {
+			themes: objectAssign({}, this.themes),
+			baseTheme: objectAssign({}, this.baseTheme),
+			defaults: JSON.parse(JSON.stringify(this.defaults || {}))
+		});
+	};
+}));
+//#endregion
+export default require_theme_set();
+export { require_theme_set };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/themes.js

@@ -0,0 +1,67 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_console_control_strings } from "../../../console-control-strings@1.1.0/node_modules/console-control-strings/index.js";
+import { require_theme_set } from "./theme-set.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/themes.js
+var require_themes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var color = require_console_control_strings().color;
+	var themes = module.exports = new (require_theme_set())();
+	themes.addTheme("ASCII", {
+		preProgressbar: "[",
+		postProgressbar: "]",
+		progressbarTheme: {
+			complete: "#",
+			remaining: "."
+		},
+		activityIndicatorTheme: "-\\|/",
+		preSubsection: ">"
+	});
+	themes.addTheme("colorASCII", themes.getTheme("ASCII"), { progressbarTheme: {
+		preComplete: color("bgBrightWhite", "brightWhite"),
+		complete: "#",
+		postComplete: color("reset"),
+		preRemaining: color("bgBrightBlack", "brightBlack"),
+		remaining: ".",
+		postRemaining: color("reset")
+	} });
+	themes.addTheme("brailleSpinner", {
+		preProgressbar: "⸨",
+		postProgressbar: "⸩",
+		progressbarTheme: {
+			complete: "#",
+			remaining: "⠂"
+		},
+		activityIndicatorTheme: "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏",
+		preSubsection: ">"
+	});
+	themes.addTheme("colorBrailleSpinner", themes.getTheme("brailleSpinner"), { progressbarTheme: {
+		preComplete: color("bgBrightWhite", "brightWhite"),
+		complete: "#",
+		postComplete: color("reset"),
+		preRemaining: color("bgBrightBlack", "brightBlack"),
+		remaining: "⠂",
+		postRemaining: color("reset")
+	} });
+	themes.setDefault({}, "ASCII");
+	themes.setDefault({ hasColor: true }, "colorASCII");
+	themes.setDefault({
+		platform: "darwin",
+		hasUnicode: true
+	}, "brailleSpinner");
+	themes.setDefault({
+		platform: "darwin",
+		hasUnicode: true,
+		hasColor: true
+	}, "colorBrailleSpinner");
+	themes.setDefault({
+		platform: "linux",
+		hasUnicode: true
+	}, "brailleSpinner");
+	themes.setDefault({
+		platform: "linux",
+		hasUnicode: true,
+		hasColor: true
+	}, "colorBrailleSpinner");
+}));
+//#endregion
+export default require_themes();
+export { require_themes };

package/dist/node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/wide-truncate.js

@@ -0,0 +1,22 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_strip_ansi } from "../../../strip-ansi@6.0.1/node_modules/strip-ansi/index.js";
+import { require_string_width } from "../../../string-width@4.2.3/node_modules/string-width/index.js";
+//#region node_modules/.pnpm/gauge@3.0.2/node_modules/gauge/wide-truncate.js
+var require_wide_truncate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var stringWidth = require_string_width();
+	var stripAnsi = require_strip_ansi();
+	module.exports = wideTruncate;
+	function wideTruncate(str, target) {
+		if (stringWidth(str) === 0) return str;
+		if (target <= 0) return "";
+		if (stringWidth(str) <= target) return str;
+		var noAnsi = stripAnsi(str);
+		var ansiSize = str.length + noAnsi.length;
+		var truncated = str.slice(0, target + ansiSize);
+		while (stringWidth(truncated) > target) truncated = truncated.slice(0, -1);
+		return truncated;
+	}
+}));
+//#endregion
+export default require_wide_truncate();
+export { require_wide_truncate };

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

@@ -0,0 +1,162 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.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";
+//#region node_modules/.pnpm/glob@7.2.3/node_modules/glob/common.js
+var require_common = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.setopts = setopts;
+	exports.ownProp = ownProp;
+	exports.makeAbs = makeAbs;
+	exports.finish = finish;
+	exports.mark = mark;
+	exports.isIgnored = isIgnored;
+	exports.childrenIgnored = childrenIgnored;
+	function ownProp(obj, field) {
+		return Object.prototype.hasOwnProperty.call(obj, field);
+	}
+	var fs = __require("fs");
+	var path = __require("path");
+	var minimatch = require_minimatch();
+	var isAbsolute = require_path_is_absolute();
+	var Minimatch = minimatch.Minimatch;
+	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 ignoreMap(pattern) {
+		var gmatcher = null;
+		if (pattern.slice(-3) === "/**") gmatcher = new Minimatch(pattern.replace(/(\/\*\*)+$/, ""), { dot: true });
+		return {
+			matcher: new Minimatch(pattern, { dot: true }),
+			gmatcher
+		};
+	}
+	function setopts(self, pattern, options) {
+		if (!options) options = {};
+		if (options.matchBase && -1 === pattern.indexOf("/")) {
+			if (options.noglobstar) throw new Error("base matching requires globstar");
+			pattern = "**/" + pattern;
+		}
+		self.silent = !!options.silent;
+		self.pattern = pattern;
+		self.strict = options.strict !== false;
+		self.realpath = !!options.realpath;
+		self.realpathCache = options.realpathCache || 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 || fs;
+		self.maxLength = options.maxLength || Infinity;
+		self.cache = options.cache || Object.create(null);
+		self.statCache = options.statCache || Object.create(null);
+		self.symlinks = options.symlinks || Object.create(null);
+		setupIgnores(self, options);
+		self.changedCwd = false;
+		var cwd = process.cwd();
+		if (!ownProp(options, "cwd")) self.cwd = cwd;
+		else {
+			self.cwd = path.resolve(options.cwd);
+			self.changedCwd = self.cwd !== cwd;
+		}
+		self.root = options.root || path.resolve(self.cwd, "/");
+		self.root = path.resolve(self.root);
+		if (process.platform === "win32") self.root = self.root.replace(/\\/g, "/");
+		self.cwdAbs = isAbsolute(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+		if (process.platform === "win32") self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
+		self.nomount = !!options.nomount;
+		options.nonegate = true;
+		options.nocomment = true;
+		options.allowWindowsEscape = false;
+		self.minimatch = new Minimatch(pattern, options);
+		self.options = self.minimatch.options;
+	}
+	function finish(self) {
+		var nou = self.nounique;
+		var all = nou ? [] : Object.create(null);
+		for (var i = 0, l = self.matches.length; i < l; i++) {
+			var matches = self.matches[i];
+			if (!matches || Object.keys(matches).length === 0) {
+				if (self.nonull) {
+					var literal = self.minimatch.globSet[i];
+					if (nou) all.push(literal);
+					else all[literal] = true;
+				}
+			} else {
+				var m = Object.keys(matches);
+				if (nou) all.push.apply(all, m);
+				else m.forEach(function(m) {
+					all[m] = true;
+				});
+			}
+		}
+		if (!nou) all = Object.keys(all);
+		if (!self.nosort) all = all.sort(alphasort);
+		if (self.mark) {
+			for (var i = 0; i < all.length; i++) all[i] = self._mark(all[i]);
+			if (self.nodir) all = all.filter(function(e) {
+				var notDir = !/\/$/.test(e);
+				var c = self.cache[e] || self.cache[makeAbs(self, e)];
+				if (notDir && c) notDir = c !== "DIR" && !Array.isArray(c);
+				return notDir;
+			});
+		}
+		if (self.ignore.length) all = all.filter(function(m) {
+			return !isIgnored(self, m);
+		});
+		self.found = all;
+	}
+	function mark(self, p) {
+		var abs = makeAbs(self, p);
+		var c = self.cache[abs];
+		var m = p;
+		if (c) {
+			var isDir = c === "DIR" || Array.isArray(c);
+			var slash = p.slice(-1) === "/";
+			if (isDir && !slash) m += "/";
+			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];
+			}
+		}
+		return m;
+	}
+	function makeAbs(self, f) {
+		var abs = f;
+		if (f.charAt(0) === "/") abs = path.join(self.root, f);
+		else if (isAbsolute(f) || f === "") abs = f;
+		else if (self.changedCwd) abs = path.resolve(self.cwd, f);
+		else abs = path.resolve(f);
+		if (process.platform === "win32") abs = abs.replace(/\\/g, "/");
+		return abs;
+	}
+	function isIgnored(self, path) {
+		if (!self.ignore.length) return false;
+		return self.ignore.some(function(item) {
+			return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path));
+		});
+	}
+	function childrenIgnored(self, path) {
+		if (!self.ignore.length) return false;
+		return self.ignore.some(function(item) {
+			return !!(item.gmatcher && item.gmatcher.match(path));
+		});
+	}
+}));
+//#endregion
+export default require_common();
+export { require_common };