@ontos-ai/knowhere-claw 0.1.4 → 0.1.5

package/dist/node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/buffer_list.js

@@ -0,0 +1,243 @@
+import { __commonJSMin, __require } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/buffer_list.js
+var require_buffer_list = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function ownKeys(object, enumerableOnly) {
+		var keys = Object.keys(object);
+		if (Object.getOwnPropertySymbols) {
+			var symbols = Object.getOwnPropertySymbols(object);
+			enumerableOnly && (symbols = symbols.filter(function(sym) {
+				return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+			})), keys.push.apply(keys, symbols);
+		}
+		return keys;
+	}
+	function _objectSpread(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = null != arguments[i] ? arguments[i] : {};
+			i % 2 ? ownKeys(Object(source), !0).forEach(function(key) {
+				_defineProperty(target, key, source[key]);
+			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+				Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+			});
+		}
+		return target;
+	}
+	function _defineProperty(obj, key, value) {
+		key = _toPropertyKey(key);
+		if (key in obj) Object.defineProperty(obj, key, {
+			value,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		else obj[key] = value;
+		return obj;
+	}
+	function _classCallCheck(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		Object.defineProperty(Constructor, "prototype", { writable: false });
+		return Constructor;
+	}
+	function _toPropertyKey(arg) {
+		var key = _toPrimitive(arg, "string");
+		return typeof key === "symbol" ? key : String(key);
+	}
+	function _toPrimitive(input, hint) {
+		if (typeof input !== "object" || input === null) return input;
+		var prim = input[Symbol.toPrimitive];
+		if (prim !== void 0) {
+			var res = prim.call(input, hint || "default");
+			if (typeof res !== "object") return res;
+			throw new TypeError("@@toPrimitive must return a primitive value.");
+		}
+		return (hint === "string" ? String : Number)(input);
+	}
+	var Buffer = __require("buffer").Buffer;
+	var inspect = __require("util").inspect;
+	var custom = inspect && inspect.custom || "inspect";
+	function copyBuffer(src, target, offset) {
+		Buffer.prototype.copy.call(src, target, offset);
+	}
+	module.exports = /* @__PURE__ */ function() {
+		function BufferList() {
+			_classCallCheck(this, BufferList);
+			this.head = null;
+			this.tail = null;
+			this.length = 0;
+		}
+		_createClass(BufferList, [
+			{
+				key: "push",
+				value: function push(v) {
+					var entry = {
+						data: v,
+						next: null
+					};
+					if (this.length > 0) this.tail.next = entry;
+					else this.head = entry;
+					this.tail = entry;
+					++this.length;
+				}
+			},
+			{
+				key: "unshift",
+				value: function unshift(v) {
+					var entry = {
+						data: v,
+						next: this.head
+					};
+					if (this.length === 0) this.tail = entry;
+					this.head = entry;
+					++this.length;
+				}
+			},
+			{
+				key: "shift",
+				value: function shift() {
+					if (this.length === 0) return;
+					var ret = this.head.data;
+					if (this.length === 1) this.head = this.tail = null;
+					else this.head = this.head.next;
+					--this.length;
+					return ret;
+				}
+			},
+			{
+				key: "clear",
+				value: function clear() {
+					this.head = this.tail = null;
+					this.length = 0;
+				}
+			},
+			{
+				key: "join",
+				value: function join(s) {
+					if (this.length === 0) return "";
+					var p = this.head;
+					var ret = "" + p.data;
+					while (p = p.next) ret += s + p.data;
+					return ret;
+				}
+			},
+			{
+				key: "concat",
+				value: function concat(n) {
+					if (this.length === 0) return Buffer.alloc(0);
+					var ret = Buffer.allocUnsafe(n >>> 0);
+					var p = this.head;
+					var i = 0;
+					while (p) {
+						copyBuffer(p.data, ret, i);
+						i += p.data.length;
+						p = p.next;
+					}
+					return ret;
+				}
+			},
+			{
+				key: "consume",
+				value: function consume(n, hasStrings) {
+					var ret;
+					if (n < this.head.data.length) {
+						ret = this.head.data.slice(0, n);
+						this.head.data = this.head.data.slice(n);
+					} else if (n === this.head.data.length) ret = this.shift();
+					else ret = hasStrings ? this._getString(n) : this._getBuffer(n);
+					return ret;
+				}
+			},
+			{
+				key: "first",
+				value: function first() {
+					return this.head.data;
+				}
+			},
+			{
+				key: "_getString",
+				value: function _getString(n) {
+					var p = this.head;
+					var c = 1;
+					var ret = p.data;
+					n -= ret.length;
+					while (p = p.next) {
+						var str = p.data;
+						var nb = n > str.length ? str.length : n;
+						if (nb === str.length) ret += str;
+						else ret += str.slice(0, n);
+						n -= nb;
+						if (n === 0) {
+							if (nb === str.length) {
+								++c;
+								if (p.next) this.head = p.next;
+								else this.head = this.tail = null;
+							} else {
+								this.head = p;
+								p.data = str.slice(nb);
+							}
+							break;
+						}
+						++c;
+					}
+					this.length -= c;
+					return ret;
+				}
+			},
+			{
+				key: "_getBuffer",
+				value: function _getBuffer(n) {
+					var ret = Buffer.allocUnsafe(n);
+					var p = this.head;
+					var c = 1;
+					p.data.copy(ret);
+					n -= p.data.length;
+					while (p = p.next) {
+						var buf = p.data;
+						var nb = n > buf.length ? buf.length : n;
+						buf.copy(ret, ret.length - n, 0, nb);
+						n -= nb;
+						if (n === 0) {
+							if (nb === buf.length) {
+								++c;
+								if (p.next) this.head = p.next;
+								else this.head = this.tail = null;
+							} else {
+								this.head = p;
+								p.data = buf.slice(nb);
+							}
+							break;
+						}
+						++c;
+					}
+					this.length -= c;
+					return ret;
+				}
+			},
+			{
+				key: custom,
+				value: function value(_, options) {
+					return inspect(this, _objectSpread(_objectSpread({}, options), {}, {
+						depth: 0,
+						customInspect: false
+					}));
+				}
+			}
+		]);
+		return BufferList;
+	}();
+}));
+//#endregion
+export default require_buffer_list();
+export { require_buffer_list };

package/dist/node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/destroy.js

@@ -0,0 +1,77 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/destroy.js
+var require_destroy = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function destroy(err, cb) {
+		var _this = this;
+		var readableDestroyed = this._readableState && this._readableState.destroyed;
+		var writableDestroyed = this._writableState && this._writableState.destroyed;
+		if (readableDestroyed || writableDestroyed) {
+			if (cb) cb(err);
+			else if (err) {
+				if (!this._writableState) process.nextTick(emitErrorNT, this, err);
+				else if (!this._writableState.errorEmitted) {
+					this._writableState.errorEmitted = true;
+					process.nextTick(emitErrorNT, this, err);
+				}
+			}
+			return this;
+		}
+		if (this._readableState) this._readableState.destroyed = true;
+		if (this._writableState) this._writableState.destroyed = true;
+		this._destroy(err || null, function(err) {
+			if (!cb && err) if (!_this._writableState) process.nextTick(emitErrorAndCloseNT, _this, err);
+			else if (!_this._writableState.errorEmitted) {
+				_this._writableState.errorEmitted = true;
+				process.nextTick(emitErrorAndCloseNT, _this, err);
+			} else process.nextTick(emitCloseNT, _this);
+			else if (cb) {
+				process.nextTick(emitCloseNT, _this);
+				cb(err);
+			} else process.nextTick(emitCloseNT, _this);
+		});
+		return this;
+	}
+	function emitErrorAndCloseNT(self, err) {
+		emitErrorNT(self, err);
+		emitCloseNT(self);
+	}
+	function emitCloseNT(self) {
+		if (self._writableState && !self._writableState.emitClose) return;
+		if (self._readableState && !self._readableState.emitClose) return;
+		self.emit("close");
+	}
+	function undestroy() {
+		if (this._readableState) {
+			this._readableState.destroyed = false;
+			this._readableState.reading = false;
+			this._readableState.ended = false;
+			this._readableState.endEmitted = false;
+		}
+		if (this._writableState) {
+			this._writableState.destroyed = false;
+			this._writableState.ended = false;
+			this._writableState.ending = false;
+			this._writableState.finalCalled = false;
+			this._writableState.prefinished = false;
+			this._writableState.finished = false;
+			this._writableState.errorEmitted = false;
+		}
+	}
+	function emitErrorNT(self, err) {
+		self.emit("error", err);
+	}
+	function errorOrDestroy(stream, err) {
+		var rState = stream._readableState;
+		var wState = stream._writableState;
+		if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);
+		else stream.emit("error", err);
+	}
+	module.exports = {
+		destroy,
+		undestroy,
+		errorOrDestroy
+	};
+}));
+//#endregion
+export default require_destroy();
+export { require_destroy };

package/dist/node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/end-of-stream.js

@@ -0,0 +1,87 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_errors_browser } from "../../../errors-browser.js";
+//#region node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/end-of-stream.js
+var require_end_of_stream = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ERR_STREAM_PREMATURE_CLOSE = require_errors_browser().codes.ERR_STREAM_PREMATURE_CLOSE;
+	function once(callback) {
+		var called = false;
+		return function() {
+			if (called) return;
+			called = true;
+			for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+			callback.apply(this, args);
+		};
+	}
+	function noop() {}
+	function isRequest(stream) {
+		return stream.setHeader && typeof stream.abort === "function";
+	}
+	function eos(stream, opts, callback) {
+		if (typeof opts === "function") return eos(stream, null, opts);
+		if (!opts) opts = {};
+		callback = once(callback || noop);
+		var readable = opts.readable || opts.readable !== false && stream.readable;
+		var writable = opts.writable || opts.writable !== false && stream.writable;
+		var onlegacyfinish = function onlegacyfinish() {
+			if (!stream.writable) onfinish();
+		};
+		var writableEnded = stream._writableState && stream._writableState.finished;
+		var onfinish = function onfinish() {
+			writable = false;
+			writableEnded = true;
+			if (!readable) callback.call(stream);
+		};
+		var readableEnded = stream._readableState && stream._readableState.endEmitted;
+		var onend = function onend() {
+			readable = false;
+			readableEnded = true;
+			if (!writable) callback.call(stream);
+		};
+		var onerror = function onerror(err) {
+			callback.call(stream, err);
+		};
+		var onclose = function onclose() {
+			var err;
+			if (readable && !readableEnded) {
+				if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+				return callback.call(stream, err);
+			}
+			if (writable && !writableEnded) {
+				if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
+				return callback.call(stream, err);
+			}
+		};
+		var onrequest = function onrequest() {
+			stream.req.on("finish", onfinish);
+		};
+		if (isRequest(stream)) {
+			stream.on("complete", onfinish);
+			stream.on("abort", onclose);
+			if (stream.req) onrequest();
+			else stream.on("request", onrequest);
+		} else if (writable && !stream._writableState) {
+			stream.on("end", onlegacyfinish);
+			stream.on("close", onlegacyfinish);
+		}
+		stream.on("end", onend);
+		stream.on("finish", onfinish);
+		if (opts.error !== false) stream.on("error", onerror);
+		stream.on("close", onclose);
+		return function() {
+			stream.removeListener("complete", onfinish);
+			stream.removeListener("abort", onclose);
+			stream.removeListener("request", onrequest);
+			if (stream.req) stream.req.removeListener("finish", onfinish);
+			stream.removeListener("end", onlegacyfinish);
+			stream.removeListener("close", onlegacyfinish);
+			stream.removeListener("finish", onfinish);
+			stream.removeListener("end", onend);
+			stream.removeListener("error", onerror);
+			stream.removeListener("close", onclose);
+		};
+	}
+	module.exports = eos;
+}));
+//#endregion
+export default require_end_of_stream();
+export { require_end_of_stream };

package/dist/node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/from-browser.js

@@ -0,0 +1,10 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/from-browser.js
+var require_from_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function() {
+		throw new Error("Readable.from is not available in the browser");
+	};
+}));
+//#endregion
+export default require_from_browser();
+export { require_from_browser };

package/dist/node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/pipeline.js

@@ -0,0 +1,80 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_errors_browser } from "../../../errors-browser.js";
+import { require_end_of_stream } from "./end-of-stream.js";
+//#region node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/pipeline.js
+var require_pipeline = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var eos;
+	function once(callback) {
+		var called = false;
+		return function() {
+			if (called) return;
+			called = true;
+			callback.apply(void 0, arguments);
+		};
+	}
+	var _require$codes = require_errors_browser().codes, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
+	function noop(err) {
+		if (err) throw err;
+	}
+	function isRequest(stream) {
+		return stream.setHeader && typeof stream.abort === "function";
+	}
+	function destroyer(stream, reading, writing, callback) {
+		callback = once(callback);
+		var closed = false;
+		stream.on("close", function() {
+			closed = true;
+		});
+		if (eos === void 0) eos = require_end_of_stream();
+		eos(stream, {
+			readable: reading,
+			writable: writing
+		}, function(err) {
+			if (err) return callback(err);
+			closed = true;
+			callback();
+		});
+		var destroyed = false;
+		return function(err) {
+			if (closed) return;
+			if (destroyed) return;
+			destroyed = true;
+			if (isRequest(stream)) return stream.abort();
+			if (typeof stream.destroy === "function") return stream.destroy();
+			callback(err || new ERR_STREAM_DESTROYED("pipe"));
+		};
+	}
+	function call(fn) {
+		fn();
+	}
+	function pipe(from, to) {
+		return from.pipe(to);
+	}
+	function popCallback(streams) {
+		if (!streams.length) return noop;
+		if (typeof streams[streams.length - 1] !== "function") return noop;
+		return streams.pop();
+	}
+	function pipeline() {
+		for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) streams[_key] = arguments[_key];
+		var callback = popCallback(streams);
+		if (Array.isArray(streams[0])) streams = streams[0];
+		if (streams.length < 2) throw new ERR_MISSING_ARGS("streams");
+		var error;
+		var destroys = streams.map(function(stream, i) {
+			var reading = i < streams.length - 1;
+			return destroyer(stream, reading, i > 0, function(err) {
+				if (!error) error = err;
+				if (err) destroys.forEach(call);
+				if (reading) return;
+				destroys.forEach(call);
+				callback(error);
+			});
+		});
+		return streams.reduce(pipe);
+	}
+	module.exports = pipeline;
+}));
+//#endregion
+export default require_pipeline();
+export { require_pipeline };

package/dist/node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/state.js

@@ -0,0 +1,21 @@
+import { __commonJSMin } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+import { require_errors_browser } from "../../../errors-browser.js";
+//#region node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/state.js
+var require_state = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var ERR_INVALID_OPT_VALUE = require_errors_browser().codes.ERR_INVALID_OPT_VALUE;
+	function highWaterMarkFrom(options, isDuplex, duplexKey) {
+		return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+	}
+	function getHighWaterMark(state, options, duplexKey, isDuplex) {
+		var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+		if (hwm != null) {
+			if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) throw new ERR_INVALID_OPT_VALUE(isDuplex ? duplexKey : "highWaterMark", hwm);
+			return Math.floor(hwm);
+		}
+		return state.objectMode ? 16 : 16 * 1024;
+	}
+	module.exports = { getHighWaterMark };
+}));
+//#endregion
+export default require_state();
+export { require_state };

package/dist/node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/stream-browser.js

@@ -0,0 +1,8 @@
+import { __commonJSMin, __require } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/lib/internal/streams/stream-browser.js
+var require_stream_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = __require("events").EventEmitter;
+}));
+//#endregion
+export default require_stream_browser();
+export { require_stream_browser };

package/dist/node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/readable-browser.js

@@ -0,0 +1,23 @@
+import { __commonJSMin } from "../../../../../_virtual/_rolldown/runtime.js";
+import { require__stream_writable } from "./lib/_stream_writable.js";
+import { require__stream_duplex } from "./lib/_stream_duplex.js";
+import { require_end_of_stream } from "./lib/internal/streams/end-of-stream.js";
+import { require__stream_readable } from "./lib/_stream_readable.js";
+import { require__stream_transform } from "./lib/_stream_transform.js";
+import { require__stream_passthrough } from "./lib/_stream_passthrough.js";
+import { require_pipeline } from "./lib/internal/streams/pipeline.js";
+//#region node_modules/.pnpm/readable-stream@3.6.2/node_modules/readable-stream/readable-browser.js
+var require_readable_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	exports = module.exports = require__stream_readable();
+	exports.Stream = exports;
+	exports.Readable = exports;
+	exports.Writable = require__stream_writable();
+	exports.Duplex = require__stream_duplex();
+	exports.Transform = require__stream_transform();
+	exports.PassThrough = require__stream_passthrough();
+	exports.finished = require_end_of_stream();
+	exports.pipeline = require_pipeline();
+}));
+//#endregion
+export default require_readable_browser();
+export { require_readable_browser };