@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

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

@@ -0,0 +1,92 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/legacy-streams.js
+var require_legacy_streams = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var Stream = __require("stream").Stream;
+	module.exports = legacy;
+	function legacy(fs) {
+		return {
+			ReadStream,
+			WriteStream
+		};
+		function ReadStream(path, options) {
+			if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+			Stream.call(this);
+			var self = this;
+			this.path = path;
+			this.fd = null;
+			this.readable = true;
+			this.paused = false;
+			this.flags = "r";
+			this.mode = 438;
+			this.bufferSize = 64 * 1024;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[key];
+			}
+			if (this.encoding) this.setEncoding(this.encoding);
+			if (this.start !== void 0) {
+				if ("number" !== typeof this.start) throw TypeError("start must be a Number");
+				if (this.end === void 0) this.end = Infinity;
+				else if ("number" !== typeof this.end) throw TypeError("end must be a Number");
+				if (this.start > this.end) throw new Error("start must be <= end");
+				this.pos = this.start;
+			}
+			if (this.fd !== null) {
+				process.nextTick(function() {
+					self._read();
+				});
+				return;
+			}
+			fs.open(this.path, this.flags, this.mode, function(err, fd) {
+				if (err) {
+					self.emit("error", err);
+					self.readable = false;
+					return;
+				}
+				self.fd = fd;
+				self.emit("open", fd);
+				self._read();
+			});
+		}
+		function WriteStream(path, options) {
+			if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+			Stream.call(this);
+			this.path = path;
+			this.fd = null;
+			this.writable = true;
+			this.flags = "w";
+			this.encoding = "binary";
+			this.mode = 438;
+			this.bytesWritten = 0;
+			options = options || {};
+			var keys = Object.keys(options);
+			for (var index = 0, length = keys.length; index < length; index++) {
+				var key = keys[index];
+				this[key] = options[key];
+			}
+			if (this.start !== void 0) {
+				if ("number" !== typeof this.start) throw TypeError("start must be a Number");
+				if (this.start < 0) throw new Error("start must be >= zero");
+				this.pos = this.start;
+			}
+			this.busy = false;
+			this._queue = [];
+			if (this.fd === null) {
+				this._open = fs.open;
+				this._queue.push([
+					this._open,
+					this.path,
+					this.flags,
+					this.mode,
+					void 0
+				]);
+				this.flush();
+			}
+		}
+	}
+}));
+//#endregion
+export default require_legacy_streams();
+export { require_legacy_streams };

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

@@ -0,0 +1,255 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
+var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var constants = __require("constants");
+	var origCwd = process.cwd;
+	var cwd = null;
+	var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+	process.cwd = function() {
+		if (!cwd) cwd = origCwd.call(process);
+		return cwd;
+	};
+	try {
+		process.cwd();
+	} catch (er) {}
+	if (typeof process.chdir === "function") {
+		var chdir = process.chdir;
+		process.chdir = function(d) {
+			cwd = null;
+			chdir.call(process, d);
+		};
+		if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+	}
+	module.exports = patch;
+	function patch(fs) {
+		if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) patchLchmod(fs);
+		if (!fs.lutimes) patchLutimes(fs);
+		fs.chown = chownFix(fs.chown);
+		fs.fchown = chownFix(fs.fchown);
+		fs.lchown = chownFix(fs.lchown);
+		fs.chmod = chmodFix(fs.chmod);
+		fs.fchmod = chmodFix(fs.fchmod);
+		fs.lchmod = chmodFix(fs.lchmod);
+		fs.chownSync = chownFixSync(fs.chownSync);
+		fs.fchownSync = chownFixSync(fs.fchownSync);
+		fs.lchownSync = chownFixSync(fs.lchownSync);
+		fs.chmodSync = chmodFixSync(fs.chmodSync);
+		fs.fchmodSync = chmodFixSync(fs.fchmodSync);
+		fs.lchmodSync = chmodFixSync(fs.lchmodSync);
+		fs.stat = statFix(fs.stat);
+		fs.fstat = statFix(fs.fstat);
+		fs.lstat = statFix(fs.lstat);
+		fs.statSync = statFixSync(fs.statSync);
+		fs.fstatSync = statFixSync(fs.fstatSync);
+		fs.lstatSync = statFixSync(fs.lstatSync);
+		if (fs.chmod && !fs.lchmod) {
+			fs.lchmod = function(path, mode, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs.lchmodSync = function() {};
+		}
+		if (fs.chown && !fs.lchown) {
+			fs.lchown = function(path, uid, gid, cb) {
+				if (cb) process.nextTick(cb);
+			};
+			fs.lchownSync = function() {};
+		}
+		if (platform === "win32") fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
+			function rename(from, to, cb) {
+				var start = Date.now();
+				var backoff = 0;
+				fs$rename(from, to, function CB(er) {
+					if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+						setTimeout(function() {
+							fs.stat(to, function(stater, st) {
+								if (stater && stater.code === "ENOENT") fs$rename(from, to, CB);
+								else cb(er);
+							});
+						}, backoff);
+						if (backoff < 100) backoff += 10;
+						return;
+					}
+					if (cb) cb(er);
+				});
+			}
+			if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+			return rename;
+		})(fs.rename);
+		fs.read = typeof fs.read !== "function" ? fs.read : (function(fs$read) {
+			function read(fd, buffer, offset, length, position, callback_) {
+				var callback;
+				if (callback_ && typeof callback_ === "function") {
+					var eagCounter = 0;
+					callback = function(er, _, __) {
+						if (er && er.code === "EAGAIN" && eagCounter < 10) {
+							eagCounter++;
+							return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+						}
+						callback_.apply(this, arguments);
+					};
+				}
+				return fs$read.call(fs, fd, buffer, offset, length, position, callback);
+			}
+			if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+			return read;
+		})(fs.read);
+		fs.readSync = typeof fs.readSync !== "function" ? fs.readSync : (function(fs$readSync) {
+			return function(fd, buffer, offset, length, position) {
+				var eagCounter = 0;
+				while (true) try {
+					return fs$readSync.call(fs, fd, buffer, offset, length, position);
+				} catch (er) {
+					if (er.code === "EAGAIN" && eagCounter < 10) {
+						eagCounter++;
+						continue;
+					}
+					throw er;
+				}
+			};
+		})(fs.readSync);
+		function patchLchmod(fs) {
+			fs.lchmod = function(path, mode, callback) {
+				fs.open(path, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+					if (err) {
+						if (callback) callback(err);
+						return;
+					}
+					fs.fchmod(fd, mode, function(err) {
+						fs.close(fd, function(err2) {
+							if (callback) callback(err || err2);
+						});
+					});
+				});
+			};
+			fs.lchmodSync = function(path, mode) {
+				var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode);
+				var threw = true;
+				var ret;
+				try {
+					ret = fs.fchmodSync(fd, mode);
+					threw = false;
+				} finally {
+					if (threw) try {
+						fs.closeSync(fd);
+					} catch (er) {}
+					else fs.closeSync(fd);
+				}
+				return ret;
+			};
+		}
+		function patchLutimes(fs) {
+			if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+				fs.lutimes = function(path, at, mt, cb) {
+					fs.open(path, constants.O_SYMLINK, function(er, fd) {
+						if (er) {
+							if (cb) cb(er);
+							return;
+						}
+						fs.futimes(fd, at, mt, function(er) {
+							fs.close(fd, function(er2) {
+								if (cb) cb(er || er2);
+							});
+						});
+					});
+				};
+				fs.lutimesSync = function(path, at, mt) {
+					var fd = fs.openSync(path, constants.O_SYMLINK);
+					var ret;
+					var threw = true;
+					try {
+						ret = fs.futimesSync(fd, at, mt);
+						threw = false;
+					} finally {
+						if (threw) try {
+							fs.closeSync(fd);
+						} catch (er) {}
+						else fs.closeSync(fd);
+					}
+					return ret;
+				};
+			} else if (fs.futimes) {
+				fs.lutimes = function(_a, _b, _c, cb) {
+					if (cb) process.nextTick(cb);
+				};
+				fs.lutimesSync = function() {};
+			}
+		}
+		function chmodFix(orig) {
+			if (!orig) return orig;
+			return function(target, mode, cb) {
+				return orig.call(fs, target, mode, function(er) {
+					if (chownErOk(er)) er = null;
+					if (cb) cb.apply(this, arguments);
+				});
+			};
+		}
+		function chmodFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, mode) {
+				try {
+					return orig.call(fs, target, mode);
+				} catch (er) {
+					if (!chownErOk(er)) throw er;
+				}
+			};
+		}
+		function chownFix(orig) {
+			if (!orig) return orig;
+			return function(target, uid, gid, cb) {
+				return orig.call(fs, target, uid, gid, function(er) {
+					if (chownErOk(er)) er = null;
+					if (cb) cb.apply(this, arguments);
+				});
+			};
+		}
+		function chownFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, uid, gid) {
+				try {
+					return orig.call(fs, target, uid, gid);
+				} catch (er) {
+					if (!chownErOk(er)) throw er;
+				}
+			};
+		}
+		function statFix(orig) {
+			if (!orig) return orig;
+			return function(target, options, cb) {
+				if (typeof options === "function") {
+					cb = options;
+					options = null;
+				}
+				function callback(er, stats) {
+					if (stats) {
+						if (stats.uid < 0) stats.uid += 4294967296;
+						if (stats.gid < 0) stats.gid += 4294967296;
+					}
+					if (cb) cb.apply(this, arguments);
+				}
+				return options ? orig.call(fs, target, options, callback) : orig.call(fs, target, callback);
+			};
+		}
+		function statFixSync(orig) {
+			if (!orig) return orig;
+			return function(target, options) {
+				var stats = options ? orig.call(fs, target, options) : orig.call(fs, target);
+				if (stats) {
+					if (stats.uid < 0) stats.uid += 4294967296;
+					if (stats.gid < 0) stats.gid += 4294967296;
+				}
+				return stats;
+			};
+		}
+		function chownErOk(er) {
+			if (!er) return true;
+			if (er.code === "ENOSYS") return true;
+			if (!process.getuid || process.getuid() !== 0) {
+				if (er.code === "EINVAL" || er.code === "EPERM") return true;
+			}
+			return false;
+		}
+	}
+}));
+//#endregion
+export default require_polyfills();
+export { require_polyfills };

package/dist/node_modules/.pnpm/has-unicode@2.0.1/node_modules/has-unicode/index.js

@@ -0,0 +1,14 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/has-unicode@2.0.1/node_modules/has-unicode/index.js
+var require_has_unicode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var os = __require("os");
+	module.exports = function() {
+		if (os.type() == "Windows_NT") return false;
+		var isUTF8 = /UTF-?8$/i;
+		var ctype = process.env.LC_ALL || process.env.LC_CTYPE || process.env.LANG;
+		return isUTF8.test(ctype);
+	};
+}));
+//#endregion
+export default require_has_unicode();
+export { require_has_unicode };

package/dist/node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js

@@ -0,0 +1,45 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_wrappy } from "../../../wrappy@1.0.2/node_modules/wrappy/wrappy.js";
+import { require_once } from "../../../once@1.4.0/node_modules/once/once.js";
+//#region node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js
+var require_inflight = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var wrappy = require_wrappy();
+	var reqs = Object.create(null);
+	var once = require_once();
+	module.exports = wrappy(inflight);
+	function inflight(key, cb) {
+		if (reqs[key]) {
+			reqs[key].push(cb);
+			return null;
+		} else {
+			reqs[key] = [cb];
+			return makeres(key);
+		}
+	}
+	function makeres(key) {
+		return once(function RES() {
+			var cbs = reqs[key];
+			var len = cbs.length;
+			var args = slice(arguments);
+			try {
+				for (var i = 0; i < len; i++) cbs[i].apply(null, args);
+			} finally {
+				if (cbs.length > len) {
+					cbs.splice(0, len);
+					process.nextTick(function() {
+						RES.apply(null, args);
+					});
+				} else delete reqs[key];
+			}
+		});
+	}
+	function slice(args) {
+		var length = args.length;
+		var array = [];
+		for (var i = 0; i < length; i++) array[i] = args[i];
+		return array;
+	}
+}));
+//#endregion
+export default require_inflight();
+export { require_inflight };

package/dist/node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
+var require_inherits_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (typeof Object.create === "function") module.exports = function inherits(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			ctor.prototype = Object.create(superCtor.prototype, { constructor: {
+				value: ctor,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			} });
+		}
+	};
+	else module.exports = function inherits(ctor, superCtor) {
+		if (superCtor) {
+			ctor.super_ = superCtor;
+			var TempCtor = function() {};
+			TempCtor.prototype = superCtor.prototype;
+			ctor.prototype = new TempCtor();
+			ctor.prototype.constructor = ctor;
+		}
+	};
+}));
+//#endregion
+export default require_inherits_browser();
+export { require_inherits_browser };

package/dist/node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js

@@ -0,0 +1,14 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/is-fullwidth-code-point@3.0.0/node_modules/is-fullwidth-code-point/index.js
+var require_is_fullwidth_code_point = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isFullwidthCodePoint = (codePoint) => {
+		if (Number.isNaN(codePoint)) return false;
+		if (codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || 11904 <= codePoint && codePoint <= 12871 && codePoint !== 12351 || 12880 <= codePoint && codePoint <= 19903 || 19968 <= codePoint && codePoint <= 42182 || 43360 <= codePoint && codePoint <= 43388 || 44032 <= codePoint && codePoint <= 55203 || 63744 <= codePoint && codePoint <= 64255 || 65040 <= codePoint && codePoint <= 65049 || 65072 <= codePoint && codePoint <= 65131 || 65281 <= codePoint && codePoint <= 65376 || 65504 <= codePoint && codePoint <= 65510 || 110592 <= codePoint && codePoint <= 110593 || 127488 <= codePoint && codePoint <= 127569 || 131072 <= codePoint && codePoint <= 262141)) return true;
+		return false;
+	};
+	module.exports = isFullwidthCodePoint;
+	module.exports.default = isFullwidthCodePoint;
+}));
+//#endregion
+export default require_is_fullwidth_code_point();
+export { require_is_fullwidth_code_point };

package/dist/node_modules/.pnpm/jsonfile@6.2.0/node_modules/jsonfile/index.js

@@ -0,0 +1,68 @@
+import { __commonJSMin, __require } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require_universalify } from "../../../universalify@2.0.1/node_modules/universalify/index.js";
+import { require_graceful_fs } from "../../../graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js";
+import { require_utils } from "./utils.js";
+//#region node_modules/.pnpm/jsonfile@6.2.0/node_modules/jsonfile/index.js
+var require_jsonfile = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let _fs;
+	try {
+		_fs = require_graceful_fs();
+	} catch (_) {
+		_fs = __require("fs");
+	}
+	const universalify = require_universalify();
+	const { stringify, stripBom } = require_utils();
+	async function _readFile(file, options = {}) {
+		if (typeof options === "string") options = { encoding: options };
+		const fs = options.fs || _fs;
+		const shouldThrow = "throws" in options ? options.throws : true;
+		let data = await universalify.fromCallback(fs.readFile)(file, options);
+		data = stripBom(data);
+		let obj;
+		try {
+			obj = JSON.parse(data, options ? options.reviver : null);
+		} catch (err) {
+			if (shouldThrow) {
+				err.message = `${file}: ${err.message}`;
+				throw err;
+			} else return null;
+		}
+		return obj;
+	}
+	const readFile = universalify.fromPromise(_readFile);
+	function readFileSync(file, options = {}) {
+		if (typeof options === "string") options = { encoding: options };
+		const fs = options.fs || _fs;
+		const shouldThrow = "throws" in options ? options.throws : true;
+		try {
+			let content = fs.readFileSync(file, options);
+			content = stripBom(content);
+			return JSON.parse(content, options.reviver);
+		} catch (err) {
+			if (shouldThrow) {
+				err.message = `${file}: ${err.message}`;
+				throw err;
+			} else return null;
+		}
+	}
+	async function _writeFile(file, obj, options = {}) {
+		const fs = options.fs || _fs;
+		const str = stringify(obj, options);
+		await universalify.fromCallback(fs.writeFile)(file, str, options);
+	}
+	const writeFile = universalify.fromPromise(_writeFile);
+	function writeFileSync(file, obj, options = {}) {
+		const fs = options.fs || _fs;
+		const str = stringify(obj, options);
+		return fs.writeFileSync(file, str, options);
+	}
+	module.exports = {
+		readFile,
+		readFileSync,
+		writeFile,
+		writeFileSync
+	};
+}));
+//#endregion
+export default require_jsonfile();
+export { require_jsonfile };

package/dist/node_modules/.pnpm/jsonfile@6.2.0/node_modules/jsonfile/utils.js

@@ -0,0 +1,19 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/jsonfile@6.2.0/node_modules/jsonfile/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function stringify(obj, { EOL = "\n", finalEOL = true, replacer = null, spaces } = {}) {
+		const EOF = finalEOL ? EOL : "";
+		return JSON.stringify(obj, replacer, spaces).replace(/\n/g, EOL) + EOF;
+	}
+	function stripBom(content) {
+		if (Buffer.isBuffer(content)) content = content.toString("utf8");
+		return content.replace(/^\uFEFF/, "");
+	}
+	module.exports = {
+		stringify,
+		stripBom
+	};
+}));
+//#endregion
+export default require_utils();
+export { require_utils };