@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/nopt@5.0.0/node_modules/nopt/lib/nopt.js

@@ -0,0 +1,330 @@
+import { __commonJSMin, __require } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_abbrev } from "../../../../abbrev@1.1.1/node_modules/abbrev/abbrev.js";
+//#region node_modules/.pnpm/nopt@5.0.0/node_modules/nopt/lib/nopt.js
+var require_nopt = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var debug = process.env.DEBUG_NOPT || process.env.NOPT_DEBUG ? function() {
+		console.error.apply(console, arguments);
+	} : function() {};
+	var url = __require("url"), path = __require("path"), Stream = __require("stream").Stream, abbrev = require_abbrev(), os = __require("os");
+	module.exports = exports = nopt;
+	exports.clean = clean;
+	exports.typeDefs = {
+		String: {
+			type: String,
+			validate: validateString
+		},
+		Boolean: {
+			type: Boolean,
+			validate: validateBoolean
+		},
+		url: {
+			type: url,
+			validate: validateUrl
+		},
+		Number: {
+			type: Number,
+			validate: validateNumber
+		},
+		path: {
+			type: path,
+			validate: validatePath
+		},
+		Stream: {
+			type: Stream,
+			validate: validateStream
+		},
+		Date: {
+			type: Date,
+			validate: validateDate
+		}
+	};
+	function nopt(types, shorthands, args, slice) {
+		args = args || process.argv;
+		types = types || {};
+		shorthands = shorthands || {};
+		if (typeof slice !== "number") slice = 2;
+		debug(types, shorthands, args, slice);
+		args = args.slice(slice);
+		var data = {}, argv = {
+			remain: [],
+			cooked: args,
+			original: args.slice(0)
+		};
+		parse(args, data, argv.remain, types, shorthands);
+		clean(data, types, exports.typeDefs);
+		data.argv = argv;
+		Object.defineProperty(data.argv, "toString", {
+			value: function() {
+				return this.original.map(JSON.stringify).join(" ");
+			},
+			enumerable: false
+		});
+		return data;
+	}
+	function clean(data, types, typeDefs) {
+		typeDefs = typeDefs || exports.typeDefs;
+		var remove = {}, typeDefault = [
+			false,
+			true,
+			null,
+			String,
+			Array
+		];
+		Object.keys(data).forEach(function(k) {
+			if (k === "argv") return;
+			var val = data[k], isArray = Array.isArray(val), type = types[k];
+			if (!isArray) val = [val];
+			if (!type) type = typeDefault;
+			if (type === Array) type = typeDefault.concat(Array);
+			if (!Array.isArray(type)) type = [type];
+			debug("val=%j", val);
+			debug("types=", type);
+			val = val.map(function(val) {
+				if (typeof val === "string") {
+					debug("string %j", val);
+					val = val.trim();
+					if (val === "null" && ~type.indexOf(null) || val === "true" && (~type.indexOf(true) || ~type.indexOf(Boolean)) || val === "false" && (~type.indexOf(false) || ~type.indexOf(Boolean))) {
+						val = JSON.parse(val);
+						debug("jsonable %j", val);
+					} else if (~type.indexOf(Number) && !isNaN(val)) {
+						debug("convert to number", val);
+						val = +val;
+					} else if (~type.indexOf(Date) && !isNaN(Date.parse(val))) {
+						debug("convert to date", val);
+						val = new Date(val);
+					}
+				}
+				if (!types.hasOwnProperty(k)) return val;
+				if (val === false && ~type.indexOf(null) && !(~type.indexOf(false) || ~type.indexOf(Boolean))) val = null;
+				var d = {};
+				d[k] = val;
+				debug("prevalidated val", d, val, types[k]);
+				if (!validate(d, k, val, types[k], typeDefs)) {
+					if (exports.invalidHandler) exports.invalidHandler(k, val, types[k], data);
+					else if (exports.invalidHandler !== false) debug("invalid: " + k + "=" + val, types[k]);
+					return remove;
+				}
+				debug("validated val", d, val, types[k]);
+				return d[k];
+			}).filter(function(val) {
+				return val !== remove;
+			});
+			if (!val.length && type.indexOf(Array) === -1) {
+				debug("VAL HAS NO LENGTH, DELETE IT", val, k, type.indexOf(Array));
+				delete data[k];
+			} else if (isArray) {
+				debug(isArray, data[k], val);
+				data[k] = val;
+			} else data[k] = val[0];
+			debug("k=%s val=%j", k, val, data[k]);
+		});
+	}
+	function validateString(data, k, val) {
+		data[k] = String(val);
+	}
+	function validatePath(data, k, val) {
+		if (val === true) return false;
+		if (val === null) return true;
+		val = String(val);
+		var homePattern = process.platform === "win32" ? /^~(\/|\\)/ : /^~\//, home = os.homedir();
+		if (home && val.match(homePattern)) data[k] = path.resolve(home, val.substr(2));
+		else data[k] = path.resolve(val);
+		return true;
+	}
+	function validateNumber(data, k, val) {
+		debug("validate Number %j %j %j", k, val, isNaN(val));
+		if (isNaN(val)) return false;
+		data[k] = +val;
+	}
+	function validateDate(data, k, val) {
+		var s = Date.parse(val);
+		debug("validate Date %j %j %j", k, val, s);
+		if (isNaN(s)) return false;
+		data[k] = new Date(val);
+	}
+	function validateBoolean(data, k, val) {
+		if (val instanceof Boolean) val = val.valueOf();
+		else if (typeof val === "string") if (!isNaN(val)) val = !!+val;
+		else if (val === "null" || val === "false") val = false;
+		else val = true;
+		else val = !!val;
+		data[k] = val;
+	}
+	function validateUrl(data, k, val) {
+		val = url.parse(String(val));
+		if (!val.host) return false;
+		data[k] = val.href;
+	}
+	function validateStream(data, k, val) {
+		if (!(val instanceof Stream)) return false;
+		data[k] = val;
+	}
+	function validate(data, k, val, type, typeDefs) {
+		if (Array.isArray(type)) {
+			for (var i = 0, l = type.length; i < l; i++) {
+				if (type[i] === Array) continue;
+				if (validate(data, k, val, type[i], typeDefs)) return true;
+			}
+			delete data[k];
+			return false;
+		}
+		if (type === Array) return true;
+		if (type !== type) {
+			debug("Poison NaN", k, val, type);
+			delete data[k];
+			return false;
+		}
+		if (val === type) {
+			debug("Explicitly allowed %j", val);
+			data[k] = val;
+			return true;
+		}
+		var ok = false, types = Object.keys(typeDefs);
+		for (var i = 0, l = types.length; i < l; i++) {
+			debug("test type %j %j %j", k, val, types[i]);
+			var t = typeDefs[types[i]];
+			if (t && (type && type.name && t.type && t.type.name ? type.name === t.type.name : type === t.type)) {
+				var d = {};
+				ok = false !== t.validate(d, k, val);
+				val = d[k];
+				if (ok) {
+					data[k] = val;
+					break;
+				}
+			}
+		}
+		debug("OK? %j (%j %j %j)", ok, k, val, types[i]);
+		if (!ok) delete data[k];
+		return ok;
+	}
+	function parse(args, data, remain, types, shorthands) {
+		debug("parse", args, data, remain);
+		var abbrevs = abbrev(Object.keys(types)), shortAbbr = abbrev(Object.keys(shorthands));
+		for (var i = 0; i < args.length; i++) {
+			var arg = args[i];
+			debug("arg", arg);
+			if (arg.match(/^-{2,}$/)) {
+				remain.push.apply(remain, args.slice(i + 1));
+				args[i] = "--";
+				break;
+			}
+			var hadEq = false;
+			if (arg.charAt(0) === "-" && arg.length > 1) {
+				var at = arg.indexOf("=");
+				if (at > -1) {
+					hadEq = true;
+					var v = arg.substr(at + 1);
+					arg = arg.substr(0, at);
+					args.splice(i, 1, arg, v);
+				}
+				var shRes = resolveShort(arg, shorthands, shortAbbr, abbrevs);
+				debug("arg=%j shRes=%j", arg, shRes);
+				if (shRes) {
+					debug(arg, shRes);
+					args.splice.apply(args, [i, 1].concat(shRes));
+					if (arg !== shRes[0]) {
+						i--;
+						continue;
+					}
+				}
+				arg = arg.replace(/^-+/, "");
+				var no = null;
+				while (arg.toLowerCase().indexOf("no-") === 0) {
+					no = !no;
+					arg = arg.substr(3);
+				}
+				if (abbrevs[arg]) arg = abbrevs[arg];
+				var argType = types[arg];
+				var isTypeArray = Array.isArray(argType);
+				if (isTypeArray && argType.length === 1) {
+					isTypeArray = false;
+					argType = argType[0];
+				}
+				var isArray = argType === Array || isTypeArray && argType.indexOf(Array) !== -1;
+				if (!types.hasOwnProperty(arg) && data.hasOwnProperty(arg)) {
+					if (!Array.isArray(data[arg])) data[arg] = [data[arg]];
+					isArray = true;
+				}
+				var val, la = args[i + 1];
+				if (typeof no === "boolean" || argType === Boolean || isTypeArray && argType.indexOf(Boolean) !== -1 || typeof argType === "undefined" && !hadEq || la === "false" && (argType === null || isTypeArray && ~argType.indexOf(null))) {
+					val = !no;
+					if (la === "true" || la === "false") {
+						val = JSON.parse(la);
+						la = null;
+						if (no) val = !val;
+						i++;
+					}
+					if (isTypeArray && la) {
+						if (~argType.indexOf(la)) {
+							val = la;
+							i++;
+						} else if (la === "null" && ~argType.indexOf(null)) {
+							val = null;
+							i++;
+						} else if (!la.match(/^-{2,}[^-]/) && !isNaN(la) && ~argType.indexOf(Number)) {
+							val = +la;
+							i++;
+						} else if (!la.match(/^-[^-]/) && ~argType.indexOf(String)) {
+							val = la;
+							i++;
+						}
+					}
+					if (isArray) (data[arg] = data[arg] || []).push(val);
+					else data[arg] = val;
+					continue;
+				}
+				if (argType === String) {
+					if (la === void 0) la = "";
+					else if (la.match(/^-{1,2}[^-]+/)) {
+						la = "";
+						i--;
+					}
+				}
+				if (la && la.match(/^-{2,}$/)) {
+					la = void 0;
+					i--;
+				}
+				val = la === void 0 ? true : la;
+				if (isArray) (data[arg] = data[arg] || []).push(val);
+				else data[arg] = val;
+				i++;
+				continue;
+			}
+			remain.push(arg);
+		}
+	}
+	function resolveShort(arg, shorthands, shortAbbr, abbrevs) {
+		arg = arg.replace(/^-+/, "");
+		if (abbrevs[arg] === arg) return null;
+		if (shorthands[arg]) {
+			if (shorthands[arg] && !Array.isArray(shorthands[arg])) shorthands[arg] = shorthands[arg].split(/\s+/);
+			return shorthands[arg];
+		}
+		var singles = shorthands.___singles;
+		if (!singles) {
+			singles = Object.keys(shorthands).filter(function(s) {
+				return s.length === 1;
+			}).reduce(function(l, r) {
+				l[r] = true;
+				return l;
+			}, {});
+			shorthands.___singles = singles;
+			debug("shorthand singles", singles);
+		}
+		var chrs = arg.split("").filter(function(c) {
+			return singles[c];
+		});
+		if (chrs.join("") === arg) return chrs.map(function(c) {
+			return shorthands[c];
+		}).reduce(function(l, r) {
+			return l.concat(r);
+		}, []);
+		if (abbrevs[arg] && !shorthands[arg]) return null;
+		if (shortAbbr[arg]) arg = shortAbbr[arg];
+		if (shorthands[arg] && !Array.isArray(shorthands[arg])) shorthands[arg] = shorthands[arg].split(/\s+/);
+		return shorthands[arg];
+	}
+}));
+//#endregion
+export default require_nopt();
+export { require_nopt };

package/dist/node_modules/.pnpm/npmlog@5.0.1/node_modules/npmlog/log.js

@@ -0,0 +1,305 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_lib } from "../../../are-we-there-yet@2.0.0/node_modules/are-we-there-yet/lib/index.js";
+import { require_console_control_strings } from "../../../console-control-strings@1.1.0/node_modules/console-control-strings/index.js";
+import { require_gauge } from "../../../gauge@3.0.2/node_modules/gauge/index.js";
+import { require_set_blocking } from "../../../set-blocking@2.0.0/node_modules/set-blocking/index.js";
+//#region node_modules/.pnpm/npmlog@5.0.1/node_modules/npmlog/log.js
+var require_log = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Progress = require_lib();
+	var Gauge = require_gauge();
+	var EE = __require("events").EventEmitter;
+	var log = exports = module.exports = new EE();
+	var util = __require("util");
+	var setBlocking = require_set_blocking();
+	var consoleControl = require_console_control_strings();
+	setBlocking(true);
+	var stream = process.stderr;
+	Object.defineProperty(log, "stream", {
+		set: function(newStream) {
+			stream = newStream;
+			if (this.gauge) this.gauge.setWriteTo(stream, stream);
+		},
+		get: function() {
+			return stream;
+		}
+	});
+	var colorEnabled;
+	log.useColor = function() {
+		return colorEnabled != null ? colorEnabled : stream.isTTY;
+	};
+	log.enableColor = function() {
+		colorEnabled = true;
+		this.gauge.setTheme({
+			hasColor: colorEnabled,
+			hasUnicode: unicodeEnabled
+		});
+	};
+	log.disableColor = function() {
+		colorEnabled = false;
+		this.gauge.setTheme({
+			hasColor: colorEnabled,
+			hasUnicode: unicodeEnabled
+		});
+	};
+	log.level = "info";
+	log.gauge = new Gauge(stream, {
+		enabled: false,
+		theme: { hasColor: log.useColor() },
+		template: [
+			{
+				type: "progressbar",
+				length: 20
+			},
+			{
+				type: "activityIndicator",
+				kerning: 1,
+				length: 1
+			},
+			{
+				type: "section",
+				default: ""
+			},
+			":",
+			{
+				type: "logline",
+				kerning: 1,
+				default: ""
+			}
+		]
+	});
+	log.tracker = new Progress.TrackerGroup();
+	log.progressEnabled = log.gauge.isEnabled();
+	var unicodeEnabled;
+	log.enableUnicode = function() {
+		unicodeEnabled = true;
+		this.gauge.setTheme({
+			hasColor: this.useColor(),
+			hasUnicode: unicodeEnabled
+		});
+	};
+	log.disableUnicode = function() {
+		unicodeEnabled = false;
+		this.gauge.setTheme({
+			hasColor: this.useColor(),
+			hasUnicode: unicodeEnabled
+		});
+	};
+	log.setGaugeThemeset = function(themes) {
+		this.gauge.setThemeset(themes);
+	};
+	log.setGaugeTemplate = function(template) {
+		this.gauge.setTemplate(template);
+	};
+	log.enableProgress = function() {
+		if (this.progressEnabled) return;
+		this.progressEnabled = true;
+		this.tracker.on("change", this.showProgress);
+		if (this._paused) return;
+		this.gauge.enable();
+	};
+	log.disableProgress = function() {
+		if (!this.progressEnabled) return;
+		this.progressEnabled = false;
+		this.tracker.removeListener("change", this.showProgress);
+		this.gauge.disable();
+	};
+	var trackerConstructors = [
+		"newGroup",
+		"newItem",
+		"newStream"
+	];
+	var mixinLog = function(tracker) {
+		Object.keys(log).forEach(function(P) {
+			if (P[0] === "_") return;
+			if (trackerConstructors.filter(function(C) {
+				return C === P;
+			}).length) return;
+			if (tracker[P]) return;
+			if (typeof log[P] !== "function") return;
+			var func = log[P];
+			tracker[P] = function() {
+				return func.apply(log, arguments);
+			};
+		});
+		if (tracker instanceof Progress.TrackerGroup) trackerConstructors.forEach(function(C) {
+			var func = tracker[C];
+			tracker[C] = function() {
+				return mixinLog(func.apply(tracker, arguments));
+			};
+		});
+		return tracker;
+	};
+	trackerConstructors.forEach(function(C) {
+		log[C] = function() {
+			return mixinLog(this.tracker[C].apply(this.tracker, arguments));
+		};
+	});
+	log.clearProgress = function(cb) {
+		if (!this.progressEnabled) return cb && process.nextTick(cb);
+		this.gauge.hide(cb);
+	};
+	log.showProgress = function(name, completed) {
+		if (!this.progressEnabled) return;
+		var values = {};
+		if (name) values.section = name;
+		var last = log.record[log.record.length - 1];
+		if (last) {
+			values.subsection = last.prefix;
+			var disp = log.disp[last.level] || last.level;
+			var logline = this._format(disp, log.style[last.level]);
+			if (last.prefix) logline += " " + this._format(last.prefix, this.prefixStyle);
+			logline += " " + last.message.split(/\r?\n/)[0];
+			values.logline = logline;
+		}
+		values.completed = completed || this.tracker.completed();
+		this.gauge.show(values);
+	}.bind(log);
+	log.pause = function() {
+		this._paused = true;
+		if (this.progressEnabled) this.gauge.disable();
+	};
+	log.resume = function() {
+		if (!this._paused) return;
+		this._paused = false;
+		var b = this._buffer;
+		this._buffer = [];
+		b.forEach(function(m) {
+			this.emitLog(m);
+		}, this);
+		if (this.progressEnabled) this.gauge.enable();
+	};
+	log._buffer = [];
+	var id = 0;
+	log.record = [];
+	log.maxRecordSize = 1e4;
+	log.log = function(lvl, prefix, message) {
+		if (this.levels[lvl] === void 0) return this.emit("error", new Error(util.format("Undefined log level: %j", lvl)));
+		var a = new Array(arguments.length - 2);
+		var stack = null;
+		for (var i = 2; i < arguments.length; i++) {
+			var arg = a[i - 2] = arguments[i];
+			if (typeof arg === "object" && arg instanceof Error && arg.stack) Object.defineProperty(arg, "stack", {
+				value: stack = arg.stack + "",
+				enumerable: true,
+				writable: true
+			});
+		}
+		if (stack) a.unshift(stack + "\n");
+		message = util.format.apply(util, a);
+		var m = {
+			id: id++,
+			level: lvl,
+			prefix: String(prefix || ""),
+			message,
+			messageRaw: a
+		};
+		this.emit("log", m);
+		this.emit("log." + lvl, m);
+		if (m.prefix) this.emit(m.prefix, m);
+		this.record.push(m);
+		var mrs = this.maxRecordSize;
+		if (this.record.length - mrs > mrs / 10) {
+			var newSize = Math.floor(mrs * .9);
+			this.record = this.record.slice(-1 * newSize);
+		}
+		this.emitLog(m);
+	}.bind(log);
+	log.emitLog = function(m) {
+		if (this._paused) {
+			this._buffer.push(m);
+			return;
+		}
+		if (this.progressEnabled) this.gauge.pulse(m.prefix);
+		var l = this.levels[m.level];
+		if (l === void 0) return;
+		if (l < this.levels[this.level]) return;
+		if (l > 0 && !isFinite(l)) return;
+		var disp = log.disp[m.level] != null ? log.disp[m.level] : m.level;
+		this.clearProgress();
+		m.message.split(/\r?\n/).forEach(function(line) {
+			if (this.heading) {
+				this.write(this.heading, this.headingStyle);
+				this.write(" ");
+			}
+			this.write(disp, log.style[m.level]);
+			var p = m.prefix || "";
+			if (p) this.write(" ");
+			this.write(p, this.prefixStyle);
+			this.write(" " + line + "\n");
+		}, this);
+		this.showProgress();
+	};
+	log._format = function(msg, style) {
+		if (!stream) return;
+		var output = "";
+		if (this.useColor()) {
+			style = style || {};
+			var settings = [];
+			if (style.fg) settings.push(style.fg);
+			if (style.bg) settings.push("bg" + style.bg[0].toUpperCase() + style.bg.slice(1));
+			if (style.bold) settings.push("bold");
+			if (style.underline) settings.push("underline");
+			if (style.inverse) settings.push("inverse");
+			if (settings.length) output += consoleControl.color(settings);
+			if (style.beep) output += consoleControl.beep();
+		}
+		output += msg;
+		if (this.useColor()) output += consoleControl.color("reset");
+		return output;
+	};
+	log.write = function(msg, style) {
+		if (!stream) return;
+		stream.write(this._format(msg, style));
+	};
+	log.addLevel = function(lvl, n, style, disp) {
+		if (disp == null) disp = lvl;
+		this.levels[lvl] = n;
+		this.style[lvl] = style;
+		if (!this[lvl]) this[lvl] = function() {
+			var a = new Array(arguments.length + 1);
+			a[0] = lvl;
+			for (var i = 0; i < arguments.length; i++) a[i + 1] = arguments[i];
+			return this.log.apply(this, a);
+		}.bind(this);
+		this.disp[lvl] = disp;
+	};
+	log.prefixStyle = { fg: "magenta" };
+	log.headingStyle = {
+		fg: "white",
+		bg: "black"
+	};
+	log.style = {};
+	log.levels = {};
+	log.disp = {};
+	log.addLevel("silly", -Infinity, { inverse: true }, "sill");
+	log.addLevel("verbose", 1e3, {
+		fg: "blue",
+		bg: "black"
+	}, "verb");
+	log.addLevel("info", 2e3, { fg: "green" });
+	log.addLevel("timing", 2500, {
+		fg: "green",
+		bg: "black"
+	});
+	log.addLevel("http", 3e3, {
+		fg: "green",
+		bg: "black"
+	});
+	log.addLevel("notice", 3500, {
+		fg: "blue",
+		bg: "black"
+	});
+	log.addLevel("warn", 4e3, {
+		fg: "black",
+		bg: "yellow"
+	}, "WARN");
+	log.addLevel("error", 5e3, {
+		fg: "red",
+		bg: "black"
+	}, "ERR!");
+	log.addLevel("silent", Infinity);
+	log.on("error", function() {});
+}));
+//#endregion
+export default require_log();
+export { require_log };

package/dist/node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js

@@ -0,0 +1,54 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var require_object_assign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+	function toObject(val) {
+		if (val === null || val === void 0) throw new TypeError("Object.assign cannot be called with null or undefined");
+		return Object(val);
+	}
+	function shouldUseNative() {
+		try {
+			if (!Object.assign) return false;
+			var test1 = /* @__PURE__ */ new String("abc");
+			test1[5] = "de";
+			if (Object.getOwnPropertyNames(test1)[0] === "5") return false;
+			var test2 = {};
+			for (var i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i;
+			if (Object.getOwnPropertyNames(test2).map(function(n) {
+				return test2[n];
+			}).join("") !== "0123456789") return false;
+			var test3 = {};
+			"abcdefghijklmnopqrst".split("").forEach(function(letter) {
+				test3[letter] = letter;
+			});
+			if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") return false;
+			return true;
+		} catch (err) {
+			return false;
+		}
+	}
+	module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+		var from;
+		var to = toObject(target);
+		var symbols;
+		for (var s = 1; s < arguments.length; s++) {
+			from = Object(arguments[s]);
+			for (var key in from) if (hasOwnProperty.call(from, key)) to[key] = from[key];
+			if (getOwnPropertySymbols) {
+				symbols = getOwnPropertySymbols(from);
+				for (var i = 0; i < symbols.length; i++) if (propIsEnumerable.call(from, symbols[i])) to[symbols[i]] = from[symbols[i]];
+			}
+		}
+		return to;
+	};
+}));
+//#endregion
+export default require_object_assign();
+export { require_object_assign };