@ontos-ai/knowhere-claw 0.1.0-beta.0

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/speedometer.js

@@ -0,0 +1,36 @@
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/speedometer.js
+/**
+* Calculate data maxRate
+* @param {Number} [samplesCount= 10]
+* @param {Number} [min= 1000]
+* @returns {Function}
+*/
+function speedometer(samplesCount, min) {
+	samplesCount = samplesCount || 10;
+	const bytes = new Array(samplesCount);
+	const timestamps = new Array(samplesCount);
+	let head = 0;
+	let tail = 0;
+	let firstSampleTS;
+	min = min !== void 0 ? min : 1e3;
+	return function push(chunkLength) {
+		const now = Date.now();
+		const startedAt = timestamps[tail];
+		if (!firstSampleTS) firstSampleTS = now;
+		bytes[head] = chunkLength;
+		timestamps[head] = now;
+		let i = tail;
+		let bytesCount = 0;
+		while (i !== head) {
+			bytesCount += bytes[i++];
+			i = i % samplesCount;
+		}
+		head = (head + 1) % samplesCount;
+		if (head === tail) tail = (tail + 1) % samplesCount;
+		if (now - firstSampleTS < min) return;
+		const passed = startedAt && now - startedAt;
+		return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
+	};
+}
+//#endregion
+export { speedometer as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/spread.js

@@ -0,0 +1,29 @@
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/spread.js
+/**
+* Syntactic sugar for invoking a function and expanding an array for arguments.
+*
+* Common use case would be to use `Function.prototype.apply`.
+*
+*  ```js
+*  function f(x, y, z) {}
+*  const args = [1, 2, 3];
+*  f.apply(null, args);
+*  ```
+*
+* With `spread` this example can be re-written.
+*
+*  ```js
+*  spread(function(x, y, z) {})([1, 2, 3]);
+*  ```
+*
+* @param {Function} callback
+*
+* @returns {Function}
+*/
+function spread(callback) {
+	return function wrap(arr) {
+		return callback.apply(null, arr);
+	};
+}
+//#endregion
+export { spread as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/throttle.js

@@ -0,0 +1,38 @@
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/throttle.js
+/**
+* Throttle decorator
+* @param {Function} fn
+* @param {Number} freq
+* @return {Function}
+*/
+function throttle(fn, freq) {
+	let timestamp = 0;
+	let threshold = 1e3 / freq;
+	let lastArgs;
+	let timer;
+	const invoke = (args, now = Date.now()) => {
+		timestamp = now;
+		lastArgs = null;
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		fn(...args);
+	};
+	const throttled = (...args) => {
+		const now = Date.now();
+		const passed = now - timestamp;
+		if (passed >= threshold) invoke(args, now);
+		else {
+			lastArgs = args;
+			if (!timer) timer = setTimeout(() => {
+				timer = null;
+				invoke(lastArgs);
+			}, threshold - passed);
+		}
+	};
+	const flush = () => lastArgs && invoke(lastArgs);
+	return [throttled, flush];
+}
+//#endregion
+export { throttle as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/toFormData.js

@@ -0,0 +1,151 @@
+import utils_default from "../utils.js";
+import AxiosError from "../core/AxiosError.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/toFormData.js
+/**
+* Determines if the given thing is a array or js object.
+*
+* @param {string} thing - The object or array to be visited.
+*
+* @returns {boolean}
+*/
+function isVisitable(thing) {
+	return utils_default.isPlainObject(thing) || utils_default.isArray(thing);
+}
+/**
+* It removes the brackets from the end of a string
+*
+* @param {string} key - The key of the parameter.
+*
+* @returns {string} the key without the brackets.
+*/
+function removeBrackets(key) {
+	return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
+}
+/**
+* It takes a path, a key, and a boolean, and returns a string
+*
+* @param {string} path - The path to the current key.
+* @param {string} key - The key of the current object being iterated over.
+* @param {string} dots - If true, the key will be rendered with dots instead of brackets.
+*
+* @returns {string} The path to the current key.
+*/
+function renderKey(path, key, dots) {
+	if (!path) return key;
+	return path.concat(key).map(function each(token, i) {
+		token = removeBrackets(token);
+		return !dots && i ? "[" + token + "]" : token;
+	}).join(dots ? "." : "");
+}
+/**
+* If the array is an array and none of its elements are visitable, then it's a flat array.
+*
+* @param {Array<any>} arr - The array to check
+*
+* @returns {boolean}
+*/
+function isFlatArray(arr) {
+	return utils_default.isArray(arr) && !arr.some(isVisitable);
+}
+const predicates = utils_default.toFlatObject(utils_default, {}, null, function filter(prop) {
+	return /^is[A-Z]/.test(prop);
+});
+/**
+* Convert a data object to FormData
+*
+* @param {Object} obj
+* @param {?Object} [formData]
+* @param {?Object} [options]
+* @param {Function} [options.visitor]
+* @param {Boolean} [options.metaTokens = true]
+* @param {Boolean} [options.dots = false]
+* @param {?Boolean} [options.indexes = false]
+*
+* @returns {Object}
+**/
+/**
+* It converts an object into a FormData object
+*
+* @param {Object<any, any>} obj - The object to convert to form data.
+* @param {string} formData - The FormData object to append to.
+* @param {Object<string, any>} options
+*
+* @returns
+*/
+function toFormData(obj, formData, options) {
+	if (!utils_default.isObject(obj)) throw new TypeError("target must be an object");
+	formData = formData || new FormData();
+	options = utils_default.toFlatObject(options, {
+		metaTokens: true,
+		dots: false,
+		indexes: false
+	}, false, function defined(option, source) {
+		return !utils_default.isUndefined(source[option]);
+	});
+	const metaTokens = options.metaTokens;
+	const visitor = options.visitor || defaultVisitor;
+	const dots = options.dots;
+	const indexes = options.indexes;
+	const useBlob = (options.Blob || typeof Blob !== "undefined" && Blob) && utils_default.isSpecCompliantForm(formData);
+	if (!utils_default.isFunction(visitor)) throw new TypeError("visitor must be a function");
+	function convertValue(value) {
+		if (value === null) return "";
+		if (utils_default.isDate(value)) return value.toISOString();
+		if (utils_default.isBoolean(value)) return value.toString();
+		if (!useBlob && utils_default.isBlob(value)) throw new AxiosError("Blob is not supported. Use a Buffer instead.");
+		if (utils_default.isArrayBuffer(value) || utils_default.isTypedArray(value)) return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
+		return value;
+	}
+	/**
+	* Default visitor.
+	*
+	* @param {*} value
+	* @param {String|Number} key
+	* @param {Array<String|Number>} path
+	* @this {FormData}
+	*
+	* @returns {boolean} return true to visit the each prop of the value recursively
+	*/
+	function defaultVisitor(value, key, path) {
+		let arr = value;
+		if (utils_default.isReactNative(formData) && utils_default.isReactNativeBlob(value)) {
+			formData.append(renderKey(path, key, dots), convertValue(value));
+			return false;
+		}
+		if (value && !path && typeof value === "object") {
+			if (utils_default.endsWith(key, "{}")) {
+				key = metaTokens ? key : key.slice(0, -2);
+				value = JSON.stringify(value);
+			} else if (utils_default.isArray(value) && isFlatArray(value) || (utils_default.isFileList(value) || utils_default.endsWith(key, "[]")) && (arr = utils_default.toArray(value))) {
+				key = removeBrackets(key);
+				arr.forEach(function each(el, index) {
+					!(utils_default.isUndefined(el) || el === null) && formData.append(indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + "[]", convertValue(el));
+				});
+				return false;
+			}
+		}
+		if (isVisitable(value)) return true;
+		formData.append(renderKey(path, key, dots), convertValue(value));
+		return false;
+	}
+	const stack = [];
+	const exposedHelpers = Object.assign(predicates, {
+		defaultVisitor,
+		convertValue,
+		isVisitable
+	});
+	function build(value, path) {
+		if (utils_default.isUndefined(value)) return;
+		if (stack.indexOf(value) !== -1) throw Error("Circular reference detected in " + path.join("."));
+		stack.push(value);
+		utils_default.forEach(value, function each(el, key) {
+			if ((!(utils_default.isUndefined(el) || el === null) && visitor.call(formData, el, utils_default.isString(key) ? key.trim() : key, path, exposedHelpers)) === true) build(el, path ? path.concat(key) : [key]);
+		});
+		stack.pop();
+	}
+	if (!utils_default.isObject(obj)) throw new TypeError("data must be an object");
+	build(obj);
+	return formData;
+}
+//#endregion
+export { toFormData as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/toURLEncodedForm.js

@@ -0,0 +1,18 @@
+import utils_default from "../utils.js";
+import toFormData from "./toFormData.js";
+import platform_default from "../platform/index.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/toURLEncodedForm.js
+function toURLEncodedForm(data, options) {
+	return toFormData(data, new platform_default.classes.URLSearchParams(), {
+		visitor: function(value, key, path, helpers) {
+			if (platform_default.isNode && utils_default.isBuffer(value)) {
+				this.append(key, value.toString("base64"));
+				return false;
+			}
+			return helpers.defaultVisitor.apply(this, arguments);
+		},
+		...options
+	});
+}
+//#endregion
+export { toURLEncodedForm as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/trackStream.js

@@ -0,0 +1,69 @@
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/trackStream.js
+const streamChunk = function* (chunk, chunkSize) {
+	let len = chunk.byteLength;
+	if (!chunkSize || len < chunkSize) {
+		yield chunk;
+		return;
+	}
+	let pos = 0;
+	let end;
+	while (pos < len) {
+		end = pos + chunkSize;
+		yield chunk.slice(pos, end);
+		pos = end;
+	}
+};
+const readBytes = async function* (iterable, chunkSize) {
+	for await (const chunk of readStream(iterable)) yield* streamChunk(chunk, chunkSize);
+};
+const readStream = async function* (stream) {
+	if (stream[Symbol.asyncIterator]) {
+		yield* stream;
+		return;
+	}
+	const reader = stream.getReader();
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		await reader.cancel();
+	}
+};
+const trackStream = (stream, chunkSize, onProgress, onFinish) => {
+	const iterator = readBytes(stream, chunkSize);
+	let bytes = 0;
+	let done;
+	let _onFinish = (e) => {
+		if (!done) {
+			done = true;
+			onFinish && onFinish(e);
+		}
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await iterator.next();
+				if (done) {
+					_onFinish();
+					controller.close();
+					return;
+				}
+				let len = value.byteLength;
+				if (onProgress) onProgress(bytes += len);
+				controller.enqueue(new Uint8Array(value));
+			} catch (err) {
+				_onFinish(err);
+				throw err;
+			}
+		},
+		cancel(reason) {
+			_onFinish(reason);
+			return iterator.return();
+		}
+	}, { highWaterMark: 2 });
+};
+//#endregion
+export { trackStream };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/validator.js

@@ -0,0 +1,76 @@
+import AxiosError from "../core/AxiosError.js";
+import { VERSION } from "../env/data.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/helpers/validator.js
+const validators = {};
+[
+	"object",
+	"boolean",
+	"number",
+	"function",
+	"string",
+	"symbol"
+].forEach((type, i) => {
+	validators[type] = function validator(thing) {
+		return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+	};
+});
+const deprecatedWarnings = {};
+/**
+* Transitional option validator
+*
+* @param {function|boolean?} validator - set to false if the transitional option has been removed
+* @param {string?} version - deprecated version / removed since version
+* @param {string?} message - some message with additional info
+*
+* @returns {function}
+*/
+validators.transitional = function transitional(validator, version, message) {
+	function formatMessage(opt, desc) {
+		return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+	}
+	return (value, opt, opts) => {
+		if (validator === false) throw new AxiosError(formatMessage(opt, " has been removed" + (version ? " in " + version : "")), AxiosError.ERR_DEPRECATED);
+		if (version && !deprecatedWarnings[opt]) {
+			deprecatedWarnings[opt] = true;
+			console.warn(formatMessage(opt, " has been deprecated since v" + version + " and will be removed in the near future"));
+		}
+		return validator ? validator(value, opt, opts) : true;
+	};
+};
+validators.spelling = function spelling(correctSpelling) {
+	return (value, opt) => {
+		console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
+		return true;
+	};
+};
+/**
+* Assert object's properties type
+*
+* @param {object} options
+* @param {object} schema
+* @param {boolean?} allowUnknown
+*
+* @returns {object}
+*/
+function assertOptions(options, schema, allowUnknown) {
+	if (typeof options !== "object") throw new AxiosError("options must be an object", AxiosError.ERR_BAD_OPTION_VALUE);
+	const keys = Object.keys(options);
+	let i = keys.length;
+	while (i-- > 0) {
+		const opt = keys[i];
+		const validator = schema[opt];
+		if (validator) {
+			const value = options[opt];
+			const result = value === void 0 || validator(value, opt, options);
+			if (result !== true) throw new AxiosError("option " + opt + " must be " + result, AxiosError.ERR_BAD_OPTION_VALUE);
+			continue;
+		}
+		if (allowUnknown !== true) throw new AxiosError("Unknown option " + opt, AxiosError.ERR_BAD_OPTION);
+	}
+}
+var validator_default = {
+	assertOptions,
+	validators
+};
+//#endregion
+export { validator_default as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/browser/classes/Blob.js

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/browser/classes/Blob.js
+var Blob_default = typeof Blob !== "undefined" ? Blob : null;
+//#endregion
+export { Blob_default as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/browser/classes/FormData.js

@@ -0,0 +1,4 @@
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/browser/classes/FormData.js
+var FormData_default = typeof FormData !== "undefined" ? FormData : null;
+//#endregion
+export { FormData_default as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js

@@ -0,0 +1,5 @@
+import AxiosURLSearchParams from "../../../helpers/AxiosURLSearchParams.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/browser/classes/URLSearchParams.js
+var URLSearchParams_default = typeof URLSearchParams !== "undefined" ? URLSearchParams : AxiosURLSearchParams;
+//#endregion
+export { URLSearchParams_default as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/browser/index.js

@@ -0,0 +1,22 @@
+import URLSearchParams_default from "./classes/URLSearchParams.js";
+import FormData_default from "./classes/FormData.js";
+import Blob_default from "./classes/Blob.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/browser/index.js
+var browser_default = {
+	isBrowser: true,
+	classes: {
+		URLSearchParams: URLSearchParams_default,
+		FormData: FormData_default,
+		Blob: Blob_default
+	},
+	protocols: [
+		"http",
+		"https",
+		"file",
+		"blob",
+		"url",
+		"data"
+	]
+};
+//#endregion
+export { browser_default as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/common/utils.js

@@ -0,0 +1,46 @@
+import { __exportAll } from "../../../../../../../../_virtual/_rolldown/runtime.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/common/utils.js
+var utils_exports = /* @__PURE__ */ __exportAll({
+	hasBrowserEnv: () => hasBrowserEnv,
+	hasStandardBrowserEnv: () => hasStandardBrowserEnv,
+	hasStandardBrowserWebWorkerEnv: () => hasStandardBrowserWebWorkerEnv,
+	navigator: () => _navigator,
+	origin: () => origin
+});
+const hasBrowserEnv = typeof window !== "undefined" && typeof document !== "undefined";
+const _navigator = typeof navigator === "object" && navigator || void 0;
+/**
+* Determine if we're running in a standard browser environment
+*
+* This allows axios to run in a web worker, and react-native.
+* Both environments support XMLHttpRequest, but not fully standard globals.
+*
+* web workers:
+*  typeof window -> undefined
+*  typeof document -> undefined
+*
+* react-native:
+*  navigator.product -> 'ReactNative'
+* nativescript
+*  navigator.product -> 'NativeScript' or 'NS'
+*
+* @returns {boolean}
+*/
+const hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || [
+	"ReactNative",
+	"NativeScript",
+	"NS"
+].indexOf(_navigator.product) < 0);
+/**
+* Determine if we're running in a standard browser webWorker environment
+*
+* Although the `isStandardBrowserEnv` method indicates that
+* `allows axios to run in a web worker`, the WebWorker will still be
+* filtered out due to its judgment standard
+* `typeof window !== 'undefined' && typeof document !== 'undefined'`.
+* This leads to a problem when axios post `FormData` in webWorker
+*/
+const hasStandardBrowserWebWorkerEnv = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope && typeof self.importScripts === "function";
+const origin = hasBrowserEnv && window.location.href || "http://localhost";
+//#endregion
+export { utils_exports };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/index.js

@@ -0,0 +1,9 @@
+import browser_default from "./browser/index.js";
+import { utils_exports } from "./common/utils.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/platform/index.js
+var platform_default = {
+	...utils_exports,
+	...browser_default
+};
+//#endregion
+export { platform_default as default };