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

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/adapters/adapters.js

@@ -0,0 +1,83 @@
+import utils_default from "../utils.js";
+import AxiosError from "../core/AxiosError.js";
+import xhr_default from "./xhr.js";
+import { getFetch } from "./fetch.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/adapters/adapters.js
+/**
+* Known adapters mapping.
+* Provides environment-specific adapters for Axios:
+* - `http` for Node.js
+* - `xhr` for browsers
+* - `fetch` for fetch API-based requests
+*
+* @type {Object<string, Function|Object>}
+*/
+const knownAdapters = {
+	http: null,
+	xhr: xhr_default,
+	fetch: { get: getFetch }
+};
+utils_default.forEach(knownAdapters, (fn, value) => {
+	if (fn) {
+		try {
+			Object.defineProperty(fn, "name", { value });
+		} catch (e) {}
+		Object.defineProperty(fn, "adapterName", { value });
+	}
+});
+/**
+* Render a rejection reason string for unknown or unsupported adapters
+*
+* @param {string} reason
+* @returns {string}
+*/
+const renderReason = (reason) => `- ${reason}`;
+/**
+* Check if the adapter is resolved (function, null, or false)
+*
+* @param {Function|null|false} adapter
+* @returns {boolean}
+*/
+const isResolvedHandle = (adapter) => utils_default.isFunction(adapter) || adapter === null || adapter === false;
+/**
+* Get the first suitable adapter from the provided list.
+* Tries each adapter in order until a supported one is found.
+* Throws an AxiosError if no adapter is suitable.
+*
+* @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.
+* @param {Object} config - Axios request configuration
+* @throws {AxiosError} If no suitable adapter is available
+* @returns {Function} The resolved adapter function
+*/
+function getAdapter(adapters, config) {
+	adapters = utils_default.isArray(adapters) ? adapters : [adapters];
+	const { length } = adapters;
+	let nameOrAdapter;
+	let adapter;
+	const rejectedReasons = {};
+	for (let i = 0; i < length; i++) {
+		nameOrAdapter = adapters[i];
+		let id;
+		adapter = nameOrAdapter;
+		if (!isResolvedHandle(nameOrAdapter)) {
+			adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+			if (adapter === void 0) throw new AxiosError(`Unknown adapter '${id}'`);
+		}
+		if (adapter && (utils_default.isFunction(adapter) || (adapter = adapter.get(config)))) break;
+		rejectedReasons[id || "#" + i] = adapter;
+	}
+	if (!adapter) {
+		const reasons = Object.entries(rejectedReasons).map(([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build"));
+		throw new AxiosError(`There is no suitable adapter to dispatch the request ` + (length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified"), "ERR_NOT_SUPPORT");
+	}
+	return adapter;
+}
+/**
+* Exports Axios adapters and utility to resolve an adapter
+*/
+var adapters_default = {
+	getAdapter,
+	adapters: knownAdapters
+};
+//#endregion
+export { adapters_default as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/adapters/fetch.js

@@ -0,0 +1,170 @@
+import utils_default from "../utils.js";
+import AxiosError from "../core/AxiosError.js";
+import platform_default from "../platform/index.js";
+import AxiosHeaders from "../core/AxiosHeaders.js";
+import settle from "../core/settle.js";
+import { asyncDecorator, progressEventDecorator, progressEventReducer } from "../helpers/progressEventReducer.js";
+import resolveConfig_default from "../helpers/resolveConfig.js";
+import composeSignals from "../helpers/composeSignals.js";
+import { trackStream } from "../helpers/trackStream.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/adapters/fetch.js
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
+const { isFunction } = utils_default;
+const globalFetchAPI = (({ Request, Response }) => ({
+	Request,
+	Response
+}))(utils_default.global);
+const { ReadableStream, TextEncoder } = utils_default.global;
+const test = (fn, ...args) => {
+	try {
+		return !!fn(...args);
+	} catch (e) {
+		return false;
+	}
+};
+const factory = (env) => {
+	env = utils_default.merge.call({ skipUndefined: true }, globalFetchAPI, env);
+	const { fetch: envFetch, Request, Response } = env;
+	const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === "function";
+	const isRequestSupported = isFunction(Request);
+	const isResponseSupported = isFunction(Response);
+	if (!isFetchSupported) return false;
+	const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream);
+	const encodeText = isFetchSupported && (typeof TextEncoder === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
+	const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
+		let duplexAccessed = false;
+		const hasContentType = new Request(platform_default.origin, {
+			body: new ReadableStream(),
+			method: "POST",
+			get duplex() {
+				duplexAccessed = true;
+				return "half";
+			}
+		}).headers.has("Content-Type");
+		return duplexAccessed && !hasContentType;
+	});
+	const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response("").body));
+	const resolvers = { stream: supportsResponseStream && ((res) => res.body) };
+	isFetchSupported && [
+		"text",
+		"arrayBuffer",
+		"blob",
+		"formData",
+		"stream"
+	].forEach((type) => {
+		!resolvers[type] && (resolvers[type] = (res, config) => {
+			let method = res && res[type];
+			if (method) return method.call(res);
+			throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
+		});
+	});
+	const getBodyLength = async (body) => {
+		if (body == null) return 0;
+		if (utils_default.isBlob(body)) return body.size;
+		if (utils_default.isSpecCompliantForm(body)) return (await new Request(platform_default.origin, {
+			method: "POST",
+			body
+		}).arrayBuffer()).byteLength;
+		if (utils_default.isArrayBufferView(body) || utils_default.isArrayBuffer(body)) return body.byteLength;
+		if (utils_default.isURLSearchParams(body)) body = body + "";
+		if (utils_default.isString(body)) return (await encodeText(body)).byteLength;
+	};
+	const resolveBodyLength = async (headers, body) => {
+		const length = utils_default.toFiniteNumber(headers.getContentLength());
+		return length == null ? getBodyLength(body) : length;
+	};
+	return async (config) => {
+		let { url, method, data, signal, cancelToken, timeout, onDownloadProgress, onUploadProgress, responseType, headers, withCredentials = "same-origin", fetchOptions } = resolveConfig_default(config);
+		let _fetch = envFetch || fetch;
+		responseType = responseType ? (responseType + "").toLowerCase() : "text";
+		let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
+		let request = null;
+		const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+			composedSignal.unsubscribe();
+		});
+		let requestContentLength;
+		try {
+			if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
+				let _request = new Request(url, {
+					method: "POST",
+					body: data,
+					duplex: "half"
+				});
+				let contentTypeHeader;
+				if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) headers.setContentType(contentTypeHeader);
+				if (_request.body) {
+					const [onProgress, flush] = progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress)));
+					data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+				}
+			}
+			if (!utils_default.isString(withCredentials)) withCredentials = withCredentials ? "include" : "omit";
+			const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
+			const resolvedOptions = {
+				...fetchOptions,
+				signal: composedSignal,
+				method: method.toUpperCase(),
+				headers: headers.normalize().toJSON(),
+				body: data,
+				duplex: "half",
+				credentials: isCredentialsSupported ? withCredentials : void 0
+			};
+			request = isRequestSupported && new Request(url, resolvedOptions);
+			let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
+			const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
+			if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
+				const options = {};
+				[
+					"status",
+					"statusText",
+					"headers"
+				].forEach((prop) => {
+					options[prop] = response[prop];
+				});
+				const responseContentLength = utils_default.toFiniteNumber(response.headers.get("content-length"));
+				const [onProgress, flush] = onDownloadProgress && progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true)) || [];
+				response = new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+					flush && flush();
+					unsubscribe && unsubscribe();
+				}), options);
+			}
+			responseType = responseType || "text";
+			let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config);
+			!isStreamResponse && unsubscribe && unsubscribe();
+			return await new Promise((resolve, reject) => {
+				settle(resolve, reject, {
+					data: responseData,
+					headers: AxiosHeaders.from(response.headers),
+					status: response.status,
+					statusText: response.statusText,
+					config,
+					request
+				});
+			});
+		} catch (err) {
+			unsubscribe && unsubscribe();
+			if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) throw Object.assign(new AxiosError("Network Error", AxiosError.ERR_NETWORK, config, request, err && err.response), { cause: err.cause || err });
+			throw AxiosError.from(err, err && err.code, config, request, err && err.response);
+		}
+	};
+};
+const seedCache = /* @__PURE__ */ new Map();
+const getFetch = (config) => {
+	let env = config && config.env || {};
+	const { fetch, Request, Response } = env;
+	const seeds = [
+		Request,
+		Response,
+		fetch
+	];
+	let i = seeds.length, seed, target, map = seedCache;
+	while (i--) {
+		seed = seeds[i];
+		target = map.get(seed);
+		target === void 0 && map.set(seed, target = i ? /* @__PURE__ */ new Map() : factory(env));
+		map = target;
+	}
+	return target;
+};
+getFetch();
+//#endregion
+export { getFetch };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/adapters/xhr.js

@@ -0,0 +1,106 @@
+import utils_default from "../utils.js";
+import AxiosError from "../core/AxiosError.js";
+import transitional_default from "../defaults/transitional.js";
+import platform_default from "../platform/index.js";
+import AxiosHeaders from "../core/AxiosHeaders.js";
+import CanceledError from "../cancel/CanceledError.js";
+import settle from "../core/settle.js";
+import parseProtocol from "../helpers/parseProtocol.js";
+import { progressEventReducer } from "../helpers/progressEventReducer.js";
+import resolveConfig_default from "../helpers/resolveConfig.js";
+var xhr_default = typeof XMLHttpRequest !== "undefined" && function(config) {
+	return new Promise(function dispatchXhrRequest(resolve, reject) {
+		const _config = resolveConfig_default(config);
+		let requestData = _config.data;
+		const requestHeaders = AxiosHeaders.from(_config.headers).normalize();
+		let { responseType, onUploadProgress, onDownloadProgress } = _config;
+		let onCanceled;
+		let uploadThrottled, downloadThrottled;
+		let flushUpload, flushDownload;
+		function done() {
+			flushUpload && flushUpload();
+			flushDownload && flushDownload();
+			_config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
+			_config.signal && _config.signal.removeEventListener("abort", onCanceled);
+		}
+		let request = new XMLHttpRequest();
+		request.open(_config.method.toUpperCase(), _config.url, true);
+		request.timeout = _config.timeout;
+		function onloadend() {
+			if (!request) return;
+			const responseHeaders = AxiosHeaders.from("getAllResponseHeaders" in request && request.getAllResponseHeaders());
+			settle(function _resolve(value) {
+				resolve(value);
+				done();
+			}, function _reject(err) {
+				reject(err);
+				done();
+			}, {
+				data: !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response,
+				status: request.status,
+				statusText: request.statusText,
+				headers: responseHeaders,
+				config,
+				request
+			});
+			request = null;
+		}
+		if ("onloadend" in request) request.onloadend = onloadend;
+		else request.onreadystatechange = function handleLoad() {
+			if (!request || request.readyState !== 4) return;
+			if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) return;
+			setTimeout(onloadend);
+		};
+		request.onabort = function handleAbort() {
+			if (!request) return;
+			reject(new AxiosError("Request aborted", AxiosError.ECONNABORTED, config, request));
+			request = null;
+		};
+		request.onerror = function handleError(event) {
+			const err = new AxiosError(event && event.message ? event.message : "Network Error", AxiosError.ERR_NETWORK, config, request);
+			err.event = event || null;
+			reject(err);
+			request = null;
+		};
+		request.ontimeout = function handleTimeout() {
+			let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
+			const transitional = _config.transitional || transitional_default;
+			if (_config.timeoutErrorMessage) timeoutErrorMessage = _config.timeoutErrorMessage;
+			reject(new AxiosError(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED, config, request));
+			request = null;
+		};
+		requestData === void 0 && requestHeaders.setContentType(null);
+		if ("setRequestHeader" in request) utils_default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+			request.setRequestHeader(key, val);
+		});
+		if (!utils_default.isUndefined(_config.withCredentials)) request.withCredentials = !!_config.withCredentials;
+		if (responseType && responseType !== "json") request.responseType = _config.responseType;
+		if (onDownloadProgress) {
+			[downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
+			request.addEventListener("progress", downloadThrottled);
+		}
+		if (onUploadProgress && request.upload) {
+			[uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
+			request.upload.addEventListener("progress", uploadThrottled);
+			request.upload.addEventListener("loadend", flushUpload);
+		}
+		if (_config.cancelToken || _config.signal) {
+			onCanceled = (cancel) => {
+				if (!request) return;
+				reject(!cancel || cancel.type ? new CanceledError(null, config, request) : cancel);
+				request.abort();
+				request = null;
+			};
+			_config.cancelToken && _config.cancelToken.subscribe(onCanceled);
+			if (_config.signal) _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
+		}
+		const protocol = parseProtocol(_config.url);
+		if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
+			reject(new AxiosError("Unsupported protocol " + protocol + ":", AxiosError.ERR_BAD_REQUEST, config));
+			return;
+		}
+		request.send(requestData || null);
+	});
+};
+//#endregion
+export { xhr_default as default };

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

@@ -0,0 +1,57 @@
+import bind from "./helpers/bind.js";
+import utils_default from "./utils.js";
+import AxiosError from "./core/AxiosError.js";
+import toFormData from "./helpers/toFormData.js";
+import formDataToJSON from "./helpers/formDataToJSON.js";
+import defaults from "./defaults/index.js";
+import AxiosHeaders from "./core/AxiosHeaders.js";
+import isCancel from "./cancel/isCancel.js";
+import CanceledError from "./cancel/CanceledError.js";
+import mergeConfig from "./core/mergeConfig.js";
+import adapters_default from "./adapters/adapters.js";
+import { VERSION } from "./env/data.js";
+import Axios from "./core/Axios.js";
+import CancelToken from "./cancel/CancelToken.js";
+import spread from "./helpers/spread.js";
+import isAxiosError from "./helpers/isAxiosError.js";
+import HttpStatusCode from "./helpers/HttpStatusCode.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/axios.js
+/**
+* Create an instance of Axios
+*
+* @param {Object} defaultConfig The default config for the instance
+*
+* @returns {Axios} A new instance of Axios
+*/
+function createInstance(defaultConfig) {
+	const context = new Axios(defaultConfig);
+	const instance = bind(Axios.prototype.request, context);
+	utils_default.extend(instance, Axios.prototype, context, { allOwnKeys: true });
+	utils_default.extend(instance, context, null, { allOwnKeys: true });
+	instance.create = function create(instanceConfig) {
+		return createInstance(mergeConfig(defaultConfig, instanceConfig));
+	};
+	return instance;
+}
+const axios = createInstance(defaults);
+axios.Axios = Axios;
+axios.CanceledError = CanceledError;
+axios.CancelToken = CancelToken;
+axios.isCancel = isCancel;
+axios.VERSION = VERSION;
+axios.toFormData = toFormData;
+axios.AxiosError = AxiosError;
+axios.Cancel = axios.CanceledError;
+axios.all = function all(promises) {
+	return Promise.all(promises);
+};
+axios.spread = spread;
+axios.isAxiosError = isAxiosError;
+axios.mergeConfig = mergeConfig;
+axios.AxiosHeaders = AxiosHeaders;
+axios.formToJSON = (thing) => formDataToJSON(utils_default.isHTMLForm(thing) ? new FormData(thing) : thing);
+axios.getAdapter = adapters_default.getAdapter;
+axios.HttpStatusCode = HttpStatusCode;
+axios.default = axios;
+//#endregion
+export { axios as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/cancel/CancelToken.js

@@ -0,0 +1,90 @@
+import CanceledError from "./CanceledError.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/cancel/CancelToken.js
+/**
+* A `CancelToken` is an object that can be used to request cancellation of an operation.
+*
+* @param {Function} executor The executor function.
+*
+* @returns {CancelToken}
+*/
+var CancelToken = class CancelToken {
+	constructor(executor) {
+		if (typeof executor !== "function") throw new TypeError("executor must be a function.");
+		let resolvePromise;
+		this.promise = new Promise(function promiseExecutor(resolve) {
+			resolvePromise = resolve;
+		});
+		const token = this;
+		this.promise.then((cancel) => {
+			if (!token._listeners) return;
+			let i = token._listeners.length;
+			while (i-- > 0) token._listeners[i](cancel);
+			token._listeners = null;
+		});
+		this.promise.then = (onfulfilled) => {
+			let _resolve;
+			const promise = new Promise((resolve) => {
+				token.subscribe(resolve);
+				_resolve = resolve;
+			}).then(onfulfilled);
+			promise.cancel = function reject() {
+				token.unsubscribe(_resolve);
+			};
+			return promise;
+		};
+		executor(function cancel(message, config, request) {
+			if (token.reason) return;
+			token.reason = new CanceledError(message, config, request);
+			resolvePromise(token.reason);
+		});
+	}
+	/**
+	* Throws a `CanceledError` if cancellation has been requested.
+	*/
+	throwIfRequested() {
+		if (this.reason) throw this.reason;
+	}
+	/**
+	* Subscribe to the cancel signal
+	*/
+	subscribe(listener) {
+		if (this.reason) {
+			listener(this.reason);
+			return;
+		}
+		if (this._listeners) this._listeners.push(listener);
+		else this._listeners = [listener];
+	}
+	/**
+	* Unsubscribe from the cancel signal
+	*/
+	unsubscribe(listener) {
+		if (!this._listeners) return;
+		const index = this._listeners.indexOf(listener);
+		if (index !== -1) this._listeners.splice(index, 1);
+	}
+	toAbortSignal() {
+		const controller = new AbortController();
+		const abort = (err) => {
+			controller.abort(err);
+		};
+		this.subscribe(abort);
+		controller.signal.unsubscribe = () => this.unsubscribe(abort);
+		return controller.signal;
+	}
+	/**
+	* Returns an object that contains a new `CancelToken` and a function that, when called,
+	* cancels the `CancelToken`.
+	*/
+	static source() {
+		let cancel;
+		return {
+			token: new CancelToken(function executor(c) {
+				cancel = c;
+			}),
+			cancel
+		};
+	}
+};
+//#endregion
+export { CancelToken as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/cancel/CanceledError.js

@@ -0,0 +1,20 @@
+import AxiosError from "../core/AxiosError.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/cancel/CanceledError.js
+var CanceledError = class extends AxiosError {
+	/**
+	* A `CanceledError` is an object that is thrown when an operation is canceled.
+	*
+	* @param {string=} message The message.
+	* @param {Object=} config The config.
+	* @param {Object=} request The request.
+	*
+	* @returns {CanceledError} The created error.
+	*/
+	constructor(message, config, request) {
+		super(message == null ? "canceled" : message, AxiosError.ERR_CANCELED, config, request);
+		this.name = "CanceledError";
+		this.__CANCEL__ = true;
+	}
+};
+//#endregion
+export { CanceledError as default };

package/dist/node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/cancel/isCancel.js

@@ -0,0 +1,6 @@
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/cancel/isCancel.js
+function isCancel(value) {
+	return !!(value && value.__CANCEL__);
+}
+//#endregion
+export { isCancel as default };