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

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

@@ -0,0 +1,174 @@
+import utils_default from "../utils.js";
+import buildURL from "../helpers/buildURL.js";
+import InterceptorManager from "./InterceptorManager.js";
+import transitional_default from "../defaults/transitional.js";
+import AxiosHeaders from "./AxiosHeaders.js";
+import buildFullPath from "./buildFullPath.js";
+import mergeConfig from "./mergeConfig.js";
+import dispatchRequest from "./dispatchRequest.js";
+import validator_default from "../helpers/validator.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/core/Axios.js
+const validators = validator_default.validators;
+/**
+* Create a new instance of Axios
+*
+* @param {Object} instanceConfig The default config for the instance
+*
+* @return {Axios} A new instance of Axios
+*/
+var Axios = class {
+	constructor(instanceConfig) {
+		this.defaults = instanceConfig || {};
+		this.interceptors = {
+			request: new InterceptorManager(),
+			response: new InterceptorManager()
+		};
+	}
+	/**
+	* Dispatch a request
+	*
+	* @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
+	* @param {?Object} config
+	*
+	* @returns {Promise} The Promise to be fulfilled
+	*/
+	async request(configOrUrl, config) {
+		try {
+			return await this._request(configOrUrl, config);
+		} catch (err) {
+			if (err instanceof Error) {
+				let dummy = {};
+				Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = /* @__PURE__ */ new Error();
+				const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, "") : "";
+				try {
+					if (!err.stack) err.stack = stack;
+					else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ""))) err.stack += "\n" + stack;
+				} catch (e) {}
+			}
+			throw err;
+		}
+	}
+	_request(configOrUrl, config) {
+		if (typeof configOrUrl === "string") {
+			config = config || {};
+			config.url = configOrUrl;
+		} else config = configOrUrl || {};
+		config = mergeConfig(this.defaults, config);
+		const { transitional, paramsSerializer, headers } = config;
+		if (transitional !== void 0) validator_default.assertOptions(transitional, {
+			silentJSONParsing: validators.transitional(validators.boolean),
+			forcedJSONParsing: validators.transitional(validators.boolean),
+			clarifyTimeoutError: validators.transitional(validators.boolean),
+			legacyInterceptorReqResOrdering: validators.transitional(validators.boolean)
+		}, false);
+		if (paramsSerializer != null) if (utils_default.isFunction(paramsSerializer)) config.paramsSerializer = { serialize: paramsSerializer };
+		else validator_default.assertOptions(paramsSerializer, {
+			encode: validators.function,
+			serialize: validators.function
+		}, true);
+		if (config.allowAbsoluteUrls !== void 0) {} else if (this.defaults.allowAbsoluteUrls !== void 0) config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
+		else config.allowAbsoluteUrls = true;
+		validator_default.assertOptions(config, {
+			baseUrl: validators.spelling("baseURL"),
+			withXsrfToken: validators.spelling("withXSRFToken")
+		}, true);
+		config.method = (config.method || this.defaults.method || "get").toLowerCase();
+		let contextHeaders = headers && utils_default.merge(headers.common, headers[config.method]);
+		headers && utils_default.forEach([
+			"delete",
+			"get",
+			"head",
+			"post",
+			"put",
+			"patch",
+			"common"
+		], (method) => {
+			delete headers[method];
+		});
+		config.headers = AxiosHeaders.concat(contextHeaders, headers);
+		const requestInterceptorChain = [];
+		let synchronousRequestInterceptors = true;
+		this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+			if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) return;
+			synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+			const transitional = config.transitional || transitional_default;
+			if (transitional && transitional.legacyInterceptorReqResOrdering) requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+			else requestInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+		});
+		const responseInterceptorChain = [];
+		this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+			responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+		});
+		let promise;
+		let i = 0;
+		let len;
+		if (!synchronousRequestInterceptors) {
+			const chain = [dispatchRequest.bind(this), void 0];
+			chain.unshift(...requestInterceptorChain);
+			chain.push(...responseInterceptorChain);
+			len = chain.length;
+			promise = Promise.resolve(config);
+			while (i < len) promise = promise.then(chain[i++], chain[i++]);
+			return promise;
+		}
+		len = requestInterceptorChain.length;
+		let newConfig = config;
+		while (i < len) {
+			const onFulfilled = requestInterceptorChain[i++];
+			const onRejected = requestInterceptorChain[i++];
+			try {
+				newConfig = onFulfilled(newConfig);
+			} catch (error) {
+				onRejected.call(this, error);
+				break;
+			}
+		}
+		try {
+			promise = dispatchRequest.call(this, newConfig);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		i = 0;
+		len = responseInterceptorChain.length;
+		while (i < len) promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
+		return promise;
+	}
+	getUri(config) {
+		config = mergeConfig(this.defaults, config);
+		return buildURL(buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls), config.params, config.paramsSerializer);
+	}
+};
+utils_default.forEach([
+	"delete",
+	"get",
+	"head",
+	"options"
+], function forEachMethodNoData(method) {
+	Axios.prototype[method] = function(url, config) {
+		return this.request(mergeConfig(config || {}, {
+			method,
+			url,
+			data: (config || {}).data
+		}));
+	};
+});
+utils_default.forEach([
+	"post",
+	"put",
+	"patch"
+], function forEachMethodWithData(method) {
+	function generateHTTPMethod(isForm) {
+		return function httpMethod(url, data, config) {
+			return this.request(mergeConfig(config || {}, {
+				method,
+				headers: isForm ? { "Content-Type": "multipart/form-data" } : {},
+				url,
+				data
+			}));
+		};
+	}
+	Axios.prototype[method] = generateHTTPMethod();
+	Axios.prototype[method + "Form"] = generateHTTPMethod(true);
+});
+//#endregion
+export { Axios as default };

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

@@ -0,0 +1,70 @@
+import utils_default from "../utils.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/core/AxiosError.js
+var AxiosError = class AxiosError extends Error {
+	static from(error, code, config, request, response, customProps) {
+		const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
+		axiosError.cause = error;
+		axiosError.name = error.name;
+		if (error.status != null && axiosError.status == null) axiosError.status = error.status;
+		customProps && Object.assign(axiosError, customProps);
+		return axiosError;
+	}
+	/**
+	* Create an Error with the specified message, config, error code, request and response.
+	*
+	* @param {string} message The error message.
+	* @param {string} [code] The error code (for example, 'ECONNABORTED').
+	* @param {Object} [config] The config.
+	* @param {Object} [request] The request.
+	* @param {Object} [response] The response.
+	*
+	* @returns {Error} The created error.
+	*/
+	constructor(message, code, config, request, response) {
+		super(message);
+		Object.defineProperty(this, "message", {
+			value: message,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		this.name = "AxiosError";
+		this.isAxiosError = true;
+		code && (this.code = code);
+		config && (this.config = config);
+		request && (this.request = request);
+		if (response) {
+			this.response = response;
+			this.status = response.status;
+		}
+	}
+	toJSON() {
+		return {
+			message: this.message,
+			name: this.name,
+			description: this.description,
+			number: this.number,
+			fileName: this.fileName,
+			lineNumber: this.lineNumber,
+			columnNumber: this.columnNumber,
+			stack: this.stack,
+			config: utils_default.toJSONObject(this.config),
+			code: this.code,
+			status: this.status
+		};
+	}
+};
+AxiosError.ERR_BAD_OPTION_VALUE = "ERR_BAD_OPTION_VALUE";
+AxiosError.ERR_BAD_OPTION = "ERR_BAD_OPTION";
+AxiosError.ECONNABORTED = "ECONNABORTED";
+AxiosError.ETIMEDOUT = "ETIMEDOUT";
+AxiosError.ERR_NETWORK = "ERR_NETWORK";
+AxiosError.ERR_FR_TOO_MANY_REDIRECTS = "ERR_FR_TOO_MANY_REDIRECTS";
+AxiosError.ERR_DEPRECATED = "ERR_DEPRECATED";
+AxiosError.ERR_BAD_RESPONSE = "ERR_BAD_RESPONSE";
+AxiosError.ERR_BAD_REQUEST = "ERR_BAD_REQUEST";
+AxiosError.ERR_CANCELED = "ERR_CANCELED";
+AxiosError.ERR_NOT_SUPPORT = "ERR_NOT_SUPPORT";
+AxiosError.ERR_INVALID_URL = "ERR_INVALID_URL";
+//#endregion
+export { AxiosError as default };

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

@@ -0,0 +1,204 @@
+import utils_default from "../utils.js";
+import parseHeaders_default from "../helpers/parseHeaders.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/core/AxiosHeaders.js
+const $internals = Symbol("internals");
+function normalizeHeader(header) {
+	return header && String(header).trim().toLowerCase();
+}
+function normalizeValue(value) {
+	if (value === false || value == null) return value;
+	return utils_default.isArray(value) ? value.map(normalizeValue) : String(value);
+}
+function parseTokens(str) {
+	const tokens = Object.create(null);
+	const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+	let match;
+	while (match = tokensRE.exec(str)) tokens[match[1]] = match[2];
+	return tokens;
+}
+const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
+function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
+	if (utils_default.isFunction(filter)) return filter.call(this, value, header);
+	if (isHeaderNameFilter) value = header;
+	if (!utils_default.isString(value)) return;
+	if (utils_default.isString(filter)) return value.indexOf(filter) !== -1;
+	if (utils_default.isRegExp(filter)) return filter.test(value);
+}
+function formatHeader(header) {
+	return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
+		return char.toUpperCase() + str;
+	});
+}
+function buildAccessors(obj, header) {
+	const accessorName = utils_default.toCamelCase(" " + header);
+	[
+		"get",
+		"set",
+		"has"
+	].forEach((methodName) => {
+		Object.defineProperty(obj, methodName + accessorName, {
+			value: function(arg1, arg2, arg3) {
+				return this[methodName].call(this, header, arg1, arg2, arg3);
+			},
+			configurable: true
+		});
+	});
+}
+var AxiosHeaders = class {
+	constructor(headers) {
+		headers && this.set(headers);
+	}
+	set(header, valueOrRewrite, rewrite) {
+		const self = this;
+		function setHeader(_value, _header, _rewrite) {
+			const lHeader = normalizeHeader(_header);
+			if (!lHeader) throw new Error("header name must be a non-empty string");
+			const key = utils_default.findKey(self, lHeader);
+			if (!key || self[key] === void 0 || _rewrite === true || _rewrite === void 0 && self[key] !== false) self[key || _header] = normalizeValue(_value);
+		}
+		const setHeaders = (headers, _rewrite) => utils_default.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
+		if (utils_default.isPlainObject(header) || header instanceof this.constructor) setHeaders(header, valueOrRewrite);
+		else if (utils_default.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) setHeaders(parseHeaders_default(header), valueOrRewrite);
+		else if (utils_default.isObject(header) && utils_default.isIterable(header)) {
+			let obj = {}, dest, key;
+			for (const entry of header) {
+				if (!utils_default.isArray(entry)) throw TypeError("Object iterator must return a key-value pair");
+				obj[key = entry[0]] = (dest = obj[key]) ? utils_default.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
+			}
+			setHeaders(obj, valueOrRewrite);
+		} else header != null && setHeader(valueOrRewrite, header, rewrite);
+		return this;
+	}
+	get(header, parser) {
+		header = normalizeHeader(header);
+		if (header) {
+			const key = utils_default.findKey(this, header);
+			if (key) {
+				const value = this[key];
+				if (!parser) return value;
+				if (parser === true) return parseTokens(value);
+				if (utils_default.isFunction(parser)) return parser.call(this, value, key);
+				if (utils_default.isRegExp(parser)) return parser.exec(value);
+				throw new TypeError("parser must be boolean|regexp|function");
+			}
+		}
+	}
+	has(header, matcher) {
+		header = normalizeHeader(header);
+		if (header) {
+			const key = utils_default.findKey(this, header);
+			return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+		}
+		return false;
+	}
+	delete(header, matcher) {
+		const self = this;
+		let deleted = false;
+		function deleteHeader(_header) {
+			_header = normalizeHeader(_header);
+			if (_header) {
+				const key = utils_default.findKey(self, _header);
+				if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
+					delete self[key];
+					deleted = true;
+				}
+			}
+		}
+		if (utils_default.isArray(header)) header.forEach(deleteHeader);
+		else deleteHeader(header);
+		return deleted;
+	}
+	clear(matcher) {
+		const keys = Object.keys(this);
+		let i = keys.length;
+		let deleted = false;
+		while (i--) {
+			const key = keys[i];
+			if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
+				delete this[key];
+				deleted = true;
+			}
+		}
+		return deleted;
+	}
+	normalize(format) {
+		const self = this;
+		const headers = {};
+		utils_default.forEach(this, (value, header) => {
+			const key = utils_default.findKey(headers, header);
+			if (key) {
+				self[key] = normalizeValue(value);
+				delete self[header];
+				return;
+			}
+			const normalized = format ? formatHeader(header) : String(header).trim();
+			if (normalized !== header) delete self[header];
+			self[normalized] = normalizeValue(value);
+			headers[normalized] = true;
+		});
+		return this;
+	}
+	concat(...targets) {
+		return this.constructor.concat(this, ...targets);
+	}
+	toJSON(asStrings) {
+		const obj = Object.create(null);
+		utils_default.forEach(this, (value, header) => {
+			value != null && value !== false && (obj[header] = asStrings && utils_default.isArray(value) ? value.join(", ") : value);
+		});
+		return obj;
+	}
+	[Symbol.iterator]() {
+		return Object.entries(this.toJSON())[Symbol.iterator]();
+	}
+	toString() {
+		return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
+	}
+	getSetCookie() {
+		return this.get("set-cookie") || [];
+	}
+	get [Symbol.toStringTag]() {
+		return "AxiosHeaders";
+	}
+	static from(thing) {
+		return thing instanceof this ? thing : new this(thing);
+	}
+	static concat(first, ...targets) {
+		const computed = new this(first);
+		targets.forEach((target) => computed.set(target));
+		return computed;
+	}
+	static accessor(header) {
+		const accessors = (this[$internals] = this[$internals] = { accessors: {} }).accessors;
+		const prototype = this.prototype;
+		function defineAccessor(_header) {
+			const lHeader = normalizeHeader(_header);
+			if (!accessors[lHeader]) {
+				buildAccessors(prototype, _header);
+				accessors[lHeader] = true;
+			}
+		}
+		utils_default.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
+		return this;
+	}
+};
+AxiosHeaders.accessor([
+	"Content-Type",
+	"Content-Length",
+	"Accept",
+	"Accept-Encoding",
+	"User-Agent",
+	"Authorization"
+]);
+utils_default.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
+	let mapped = key[0].toUpperCase() + key.slice(1);
+	return {
+		get: () => value,
+		set(headerValue) {
+			this[mapped] = headerValue;
+		}
+	};
+});
+utils_default.freezeMethods(AxiosHeaders);
+//#endregion
+export { AxiosHeaders as default };

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

@@ -0,0 +1,60 @@
+import utils_default from "../utils.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/core/InterceptorManager.js
+var InterceptorManager = class {
+	constructor() {
+		this.handlers = [];
+	}
+	/**
+	* Add a new interceptor to the stack
+	*
+	* @param {Function} fulfilled The function to handle `then` for a `Promise`
+	* @param {Function} rejected The function to handle `reject` for a `Promise`
+	* @param {Object} options The options for the interceptor, synchronous and runWhen
+	*
+	* @return {Number} An ID used to remove interceptor later
+	*/
+	use(fulfilled, rejected, options) {
+		this.handlers.push({
+			fulfilled,
+			rejected,
+			synchronous: options ? options.synchronous : false,
+			runWhen: options ? options.runWhen : null
+		});
+		return this.handlers.length - 1;
+	}
+	/**
+	* Remove an interceptor from the stack
+	*
+	* @param {Number} id The ID that was returned by `use`
+	*
+	* @returns {void}
+	*/
+	eject(id) {
+		if (this.handlers[id]) this.handlers[id] = null;
+	}
+	/**
+	* Clear all interceptors from the stack
+	*
+	* @returns {void}
+	*/
+	clear() {
+		if (this.handlers) this.handlers = [];
+	}
+	/**
+	* Iterate over all the registered interceptors
+	*
+	* This method is particularly useful for skipping over any
+	* interceptors that may have become `null` calling `eject`.
+	*
+	* @param {Function} fn The function to call for each interceptor
+	*
+	* @returns {void}
+	*/
+	forEach(fn) {
+		utils_default.forEach(this.handlers, function forEachHandler(h) {
+			if (h !== null) fn(h);
+		});
+	}
+};
+//#endregion
+export { InterceptorManager as default };

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

@@ -0,0 +1,20 @@
+import isAbsoluteURL from "../helpers/isAbsoluteURL.js";
+import combineURLs from "../helpers/combineURLs.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/core/buildFullPath.js
+/**
+* Creates a new URL by combining the baseURL with the requestedURL,
+* only when the requestedURL is not already an absolute URL.
+* If the requestURL is absolute, this function returns the requestedURL untouched.
+*
+* @param {string} baseURL The base URL
+* @param {string} requestedURL Absolute or relative URL to combine
+*
+* @returns {string} The combined full path
+*/
+function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+	let isRelativeUrl = !isAbsoluteURL(requestedURL);
+	if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) return combineURLs(baseURL, requestedURL);
+	return requestedURL;
+}
+//#endregion
+export { buildFullPath as default };

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

@@ -0,0 +1,52 @@
+import defaults from "../defaults/index.js";
+import AxiosHeaders from "./AxiosHeaders.js";
+import transformData from "./transformData.js";
+import isCancel from "../cancel/isCancel.js";
+import CanceledError from "../cancel/CanceledError.js";
+import adapters_default from "../adapters/adapters.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/core/dispatchRequest.js
+/**
+* Throws a `CanceledError` if cancellation has been requested.
+*
+* @param {Object} config The config that is to be used for the request
+*
+* @returns {void}
+*/
+function throwIfCancellationRequested(config) {
+	if (config.cancelToken) config.cancelToken.throwIfRequested();
+	if (config.signal && config.signal.aborted) throw new CanceledError(null, config);
+}
+/**
+* Dispatch a request to the server using the configured adapter.
+*
+* @param {object} config The config that is to be used for the request
+*
+* @returns {Promise} The Promise to be fulfilled
+*/
+function dispatchRequest(config) {
+	throwIfCancellationRequested(config);
+	config.headers = AxiosHeaders.from(config.headers);
+	config.data = transformData.call(config, config.transformRequest);
+	if ([
+		"post",
+		"put",
+		"patch"
+	].indexOf(config.method) !== -1) config.headers.setContentType("application/x-www-form-urlencoded", false);
+	return adapters_default.getAdapter(config.adapter || defaults.adapter, config)(config).then(function onAdapterResolution(response) {
+		throwIfCancellationRequested(config);
+		response.data = transformData.call(config, config.transformResponse, response);
+		response.headers = AxiosHeaders.from(response.headers);
+		return response;
+	}, function onAdapterRejection(reason) {
+		if (!isCancel(reason)) {
+			throwIfCancellationRequested(config);
+			if (reason && reason.response) {
+				reason.response.data = transformData.call(config, config.transformResponse, reason.response);
+				reason.response.headers = AxiosHeaders.from(reason.response.headers);
+			}
+		}
+		return Promise.reject(reason);
+	});
+}
+//#endregion
+export { dispatchRequest as default };

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

@@ -0,0 +1,81 @@
+import utils_default from "../utils.js";
+import AxiosHeaders from "./AxiosHeaders.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/core/mergeConfig.js
+const headersToObject = (thing) => thing instanceof AxiosHeaders ? { ...thing } : thing;
+/**
+* Config-specific merge-function which creates a new config-object
+* by merging two configuration objects together.
+*
+* @param {Object} config1
+* @param {Object} config2
+*
+* @returns {Object} New object resulting from merging config2 to config1
+*/
+function mergeConfig(config1, config2) {
+	config2 = config2 || {};
+	const config = {};
+	function getMergedValue(target, source, prop, caseless) {
+		if (utils_default.isPlainObject(target) && utils_default.isPlainObject(source)) return utils_default.merge.call({ caseless }, target, source);
+		else if (utils_default.isPlainObject(source)) return utils_default.merge({}, source);
+		else if (utils_default.isArray(source)) return source.slice();
+		return source;
+	}
+	function mergeDeepProperties(a, b, prop, caseless) {
+		if (!utils_default.isUndefined(b)) return getMergedValue(a, b, prop, caseless);
+		else if (!utils_default.isUndefined(a)) return getMergedValue(void 0, a, prop, caseless);
+	}
+	function valueFromConfig2(a, b) {
+		if (!utils_default.isUndefined(b)) return getMergedValue(void 0, b);
+	}
+	function defaultToConfig2(a, b) {
+		if (!utils_default.isUndefined(b)) return getMergedValue(void 0, b);
+		else if (!utils_default.isUndefined(a)) return getMergedValue(void 0, a);
+	}
+	function mergeDirectKeys(a, b, prop) {
+		if (prop in config2) return getMergedValue(a, b);
+		else if (prop in config1) return getMergedValue(void 0, a);
+	}
+	const mergeMap = {
+		url: valueFromConfig2,
+		method: valueFromConfig2,
+		data: valueFromConfig2,
+		baseURL: defaultToConfig2,
+		transformRequest: defaultToConfig2,
+		transformResponse: defaultToConfig2,
+		paramsSerializer: defaultToConfig2,
+		timeout: defaultToConfig2,
+		timeoutMessage: defaultToConfig2,
+		withCredentials: defaultToConfig2,
+		withXSRFToken: defaultToConfig2,
+		adapter: defaultToConfig2,
+		responseType: defaultToConfig2,
+		xsrfCookieName: defaultToConfig2,
+		xsrfHeaderName: defaultToConfig2,
+		onUploadProgress: defaultToConfig2,
+		onDownloadProgress: defaultToConfig2,
+		decompress: defaultToConfig2,
+		maxContentLength: defaultToConfig2,
+		maxBodyLength: defaultToConfig2,
+		beforeRedirect: defaultToConfig2,
+		transport: defaultToConfig2,
+		httpAgent: defaultToConfig2,
+		httpsAgent: defaultToConfig2,
+		cancelToken: defaultToConfig2,
+		socketPath: defaultToConfig2,
+		responseEncoding: defaultToConfig2,
+		validateStatus: mergeDirectKeys,
+		headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
+	};
+	utils_default.forEach(Object.keys({
+		...config1,
+		...config2
+	}), function computeConfigValue(prop) {
+		if (prop === "__proto__" || prop === "constructor" || prop === "prototype") return;
+		const merge = utils_default.hasOwnProp(mergeMap, prop) ? mergeMap[prop] : mergeDeepProperties;
+		const configValue = merge(config1[prop], config2[prop], prop);
+		utils_default.isUndefined(configValue) && merge !== mergeDirectKeys || (config[prop] = configValue);
+	});
+	return config;
+}
+//#endregion
+export { mergeConfig as default };

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

@@ -0,0 +1,18 @@
+import AxiosError from "./AxiosError.js";
+//#region node_modules/.pnpm/axios@1.13.6/node_modules/axios/lib/core/settle.js
+/**
+* Resolve or reject a Promise based on response status.
+*
+* @param {Function} resolve A function that resolves the promise.
+* @param {Function} reject A function that rejects the promise.
+* @param {object} response The response.
+*
+* @returns {object} The response.
+*/
+function settle(resolve, reject, response) {
+	const validateStatus = response.config.validateStatus;
+	if (!response.status || !validateStatus || validateStatus(response.status)) resolve(response);
+	else reject(new AxiosError("Request failed with status code " + response.status, [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], response.config, response.request, response));
+}
+//#endregion
+export { settle as default };