@proxyrequest/sdk 2.1.0 → 3.0.1

package/dist/index.js

@@ -1,5 +1,883 @@
-import createClient from "openapi-fetch";
+//#region node_modules/openapi-fetch/dist/index.mjs
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+const supportsRequestInitExt = () => {
+	return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+	return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+	let { baseUrl = "", Request: CustomRequest = globalThis.Request, fetch: baseFetch = globalThis.fetch, querySerializer: globalQuerySerializer, bodySerializer: globalBodySerializer, pathSerializer: globalPathSerializer, headers: baseHeaders, requestInitExt = void 0, ...baseOptions } = { ...clientOptions };
+	requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+	baseUrl = removeTrailingSlash(baseUrl);
+	const globalMiddlewares = [];
+	async function coreFetch(schemaPath, fetchOptions) {
+		const { baseUrl: localBaseUrl, fetch = baseFetch, Request = CustomRequest, headers, params = {}, parseAs = "json", querySerializer: requestQuerySerializer, bodySerializer = globalBodySerializer ?? defaultBodySerializer, pathSerializer: requestPathSerializer, body, middleware: requestMiddlewares = [], ...init } = fetchOptions || {};
+		let finalBaseUrl = baseUrl;
+		if (localBaseUrl) finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+		let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+		if (requestQuerySerializer) querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+			...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+			...requestQuerySerializer
+		});
+		const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+		const serializedBody = body === void 0 ? void 0 : bodySerializer(body, mergeHeaders(baseHeaders, headers, params.header));
+		const finalHeaders = mergeHeaders(serializedBody === void 0 || serializedBody instanceof FormData ? {} : { "Content-Type": "application/json" }, baseHeaders, headers, params.header);
+		const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+		const requestInit = {
+			redirect: "follow",
+			...baseOptions,
+			...init,
+			body: serializedBody,
+			headers: finalHeaders
+		};
+		let id;
+		let options;
+		let request = new Request(createFinalURL(schemaPath, {
+			baseUrl: finalBaseUrl,
+			params,
+			querySerializer,
+			pathSerializer
+		}), requestInit);
+		let response;
+		for (const key in init) if (!(key in request)) request[key] = init[key];
+		if (finalMiddlewares.length) {
+			id = randomID();
+			options = Object.freeze({
+				baseUrl: finalBaseUrl,
+				fetch,
+				parseAs,
+				querySerializer,
+				bodySerializer,
+				pathSerializer
+			});
+			for (const m of finalMiddlewares) if (m && typeof m === "object" && typeof m.onRequest === "function") {
+				const result = await m.onRequest({
+					request,
+					schemaPath,
+					params,
+					options,
+					id
+				});
+				if (result) {
+					if (result instanceof Request) request = result;
+					else if (result instanceof Response) {
+						response = result;
+						break;
+					} else throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+				}
+			}
+		}
+		if (!response) {
+			try {
+				response = await fetch(request, requestInitExt);
+			} catch (error2) {
+				let errorAfterMiddleware = error2;
+				if (finalMiddlewares.length) for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+					const m = finalMiddlewares[i];
+					if (m && typeof m === "object" && typeof m.onError === "function") {
+						const result = await m.onError({
+							request,
+							error: errorAfterMiddleware,
+							schemaPath,
+							params,
+							options,
+							id
+						});
+						if (result) {
+							if (result instanceof Response) {
+								errorAfterMiddleware = void 0;
+								response = result;
+								break;
+							}
+							if (result instanceof Error) {
+								errorAfterMiddleware = result;
+								continue;
+							}
+							throw new Error("onError: must return new Response() or instance of Error");
+						}
+					}
+				}
+				if (errorAfterMiddleware) throw errorAfterMiddleware;
+			}
+			if (finalMiddlewares.length) for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+				const m = finalMiddlewares[i];
+				if (m && typeof m === "object" && typeof m.onResponse === "function") {
+					const result = await m.onResponse({
+						request,
+						response,
+						schemaPath,
+						params,
+						options,
+						id
+					});
+					if (result) {
+						if (!(result instanceof Response)) throw new Error("onResponse: must return new Response() when modifying the response");
+						response = result;
+					}
+				}
+			}
+		}
+		const contentLength = response.headers.get("Content-Length");
+		if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) return response.ok ? {
+			data: void 0,
+			response
+		} : {
+			error: void 0,
+			response
+		};
+		if (response.ok) {
+			const getResponseData = async () => {
+				if (parseAs === "stream") return response.body;
+				if (parseAs === "json" && !contentLength) {
+					const raw = await response.text();
+					return raw ? JSON.parse(raw) : void 0;
+				}
+				return await response[parseAs]();
+			};
+			return {
+				data: await getResponseData(),
+				response
+			};
+		}
+		let error = await response.text();
+		try {
+			error = JSON.parse(error);
+		} catch {}
+		return {
+			error,
+			response
+		};
+	}
+	return {
+		request(method, url, init) {
+			return coreFetch(url, {
+				...init,
+				method: method.toUpperCase()
+			});
+		},
+		/** Call a GET endpoint */
+		GET(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "GET"
+			});
+		},
+		/** Call a PUT endpoint */
+		PUT(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "PUT"
+			});
+		},
+		/** Call a POST endpoint */
+		POST(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "POST"
+			});
+		},
+		/** Call a DELETE endpoint */
+		DELETE(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "DELETE"
+			});
+		},
+		/** Call a OPTIONS endpoint */
+		OPTIONS(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "OPTIONS"
+			});
+		},
+		/** Call a HEAD endpoint */
+		HEAD(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "HEAD"
+			});
+		},
+		/** Call a PATCH endpoint */
+		PATCH(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "PATCH"
+			});
+		},
+		/** Call a TRACE endpoint */
+		TRACE(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "TRACE"
+			});
+		},
+		/** Register middleware */
+		use(...middleware) {
+			for (const m of middleware) {
+				if (!m) continue;
+				if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+				globalMiddlewares.push(m);
+			}
+		},
+		/** Unregister middleware */
+		eject(...middleware) {
+			for (const m of middleware) {
+				const i = globalMiddlewares.indexOf(m);
+				if (i !== -1) globalMiddlewares.splice(i, 1);
+			}
+		}
+	};
+}
+function serializePrimitiveParam(name, value, options) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+	if (!value || typeof value !== "object") return "";
+	const values = [];
+	const joiner = {
+		simple: ",",
+		label: ".",
+		matrix: ";"
+	}[options.style] || "&";
+	if (options.style !== "deepObject" && options.explode === false) {
+		for (const k in value) values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+		const final2 = values.join(",");
+		switch (options.style) {
+			case "form": return `${name}=${final2}`;
+			case "label": return `.${final2}`;
+			case "matrix": return `;${name}=${final2}`;
+			default: return final2;
+		}
+	}
+	for (const k in value) {
+		const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+		values.push(serializePrimitiveParam(finalName, value[k], options));
+	}
+	const final = values.join(joiner);
+	return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+	if (!Array.isArray(value)) return "";
+	if (options.explode === false) {
+		const joiner2 = {
+			form: ",",
+			spaceDelimited: "%20",
+			pipeDelimited: "|"
+		}[options.style] || ",";
+		const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(v))).join(joiner2);
+		switch (options.style) {
+			case "simple": return final;
+			case "label": return `.${final}`;
+			case "matrix": return `;${name}=${final}`;
+			default: return `${name}=${final}`;
+		}
+	}
+	const joiner = {
+		simple: ",",
+		label: ".",
+		matrix: ";"
+	}[options.style] || "&";
+	const values = [];
+	for (const v of value) if (options.style === "simple" || options.style === "label") values.push(options.allowReserved === true ? v : encodeURIComponent(v));
+	else values.push(serializePrimitiveParam(name, v, options));
+	return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+	return function querySerializer(queryParams) {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			if (Array.isArray(value)) {
+				if (value.length === 0) continue;
+				search.push(serializeArrayParam(name, value, {
+					style: "form",
+					explode: true,
+					...options?.array,
+					allowReserved: options?.allowReserved || false
+				}));
+				continue;
+			}
+			if (typeof value === "object") {
+				search.push(serializeObjectParam(name, value, {
+					style: "deepObject",
+					explode: true,
+					...options?.object,
+					allowReserved: options?.allowReserved || false
+				}));
+				continue;
+			}
+			search.push(serializePrimitiveParam(name, value, options));
+		}
+		return search.join("&");
+	};
+}
+function defaultPathSerializer(pathname, pathParams) {
+	let nextURL = pathname;
+	for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+		let name = match.substring(1, match.length - 1);
+		let explode = false;
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			style = "label";
+			name = name.substring(1);
+		} else if (name.startsWith(";")) {
+			style = "matrix";
+			name = name.substring(1);
+		}
+		if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) continue;
+		const value = pathParams[name];
+		if (Array.isArray(value)) {
+			nextURL = nextURL.replace(match, serializeArrayParam(name, value, {
+				style,
+				explode
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			nextURL = nextURL.replace(match, serializeObjectParam(name, value, {
+				style,
+				explode
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+			continue;
+		}
+		nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+	}
+	return nextURL;
+}
+function defaultBodySerializer(body, headers) {
+	if (body instanceof FormData) return body;
+	if (headers) {
+		if ((headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"]) === "application/x-www-form-urlencoded") return new URLSearchParams(body).toString();
+	}
+	return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+	let finalURL = `${options.baseUrl}${pathname}`;
+	if (options.params?.path) finalURL = options.pathSerializer(finalURL, options.params.path);
+	let search = options.querySerializer(options.params.query ?? {});
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) finalURL += `?${search}`;
+	return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+	const finalHeaders = new Headers();
+	for (const h of allHeaders) {
+		if (!h || typeof h !== "object") continue;
+		const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+		for (const [k, v] of iterator) if (v === null) finalHeaders.delete(k);
+		else if (Array.isArray(v)) for (const v2 of v) finalHeaders.append(k, v2);
+		else if (v !== void 0) finalHeaders.set(k, v);
+	}
+	return finalHeaders;
+}
+function removeTrailingSlash(url) {
+	if (url.endsWith("/")) return url.substring(0, url.length - 1);
+	return url;
+}
+
+//#endregion
+//#region node_modules/lossless-json/lib/esm/utils.js
+/**
+* Test whether a string contains an integer number
+*/
+function isInteger(value) {
+	return INTEGER_REGEX.test(value);
+}
+const INTEGER_REGEX = /^-?[0-9]+$/;
+/**
+* Test whether a string contains a number
+* http://stackoverflow.com/questions/13340717/json-numbers-regular-expression
+*/
+function isNumber(value) {
+	return NUMBER_REGEX.test(value);
+}
+const NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+/**
+* Test whether a string can be safely represented with a number
+* without information loss.
+*
+* When approx is true, floating point numbers that lose a few digits but
+* are still approximately equal in value are considered safe too.
+* Integer numbers must still be exactly equal.
+*/
+function isSafeNumber(value, config) {
+	if (isInteger(value)) return Number.isSafeInteger(Number.parseInt(value, 10));
+	const parsed = String(Number.parseFloat(value));
+	if (value === parsed) return true;
+	const valueDigits = extractSignificantDigits(value);
+	const parsedDigits = extractSignificantDigits(parsed);
+	if (valueDigits === parsedDigits) return true;
+	if (config?.approx === true) {
+		const requiredDigits = 14;
+		if (!isInteger(value) && parsedDigits.length >= requiredDigits && valueDigits.startsWith(parsedDigits.substring(0, requiredDigits))) return true;
+	}
+	return false;
+}
+let UnsafeNumberReason = /*#__PURE__*/ function(UnsafeNumberReason) {
+	UnsafeNumberReason["underflow"] = "underflow";
+	UnsafeNumberReason["overflow"] = "overflow";
+	UnsafeNumberReason["truncate_integer"] = "truncate_integer";
+	UnsafeNumberReason["truncate_float"] = "truncate_float";
+	return UnsafeNumberReason;
+}({});
+/**
+* When the provided value is an unsafe number, describe what the reason is:
+* overflow, underflow, truncate_integer, or truncate_float.
+* Returns undefined when the value is safe.
+*/
+function getUnsafeNumberReason(value) {
+	if (isSafeNumber(value, { approx: false })) return;
+	if (isInteger(value)) return UnsafeNumberReason.truncate_integer;
+	const num = Number.parseFloat(value);
+	if (!Number.isFinite(num)) return UnsafeNumberReason.overflow;
+	if (num === 0) return UnsafeNumberReason.underflow;
+	return UnsafeNumberReason.truncate_float;
+}
+/**
+* Get the significant digits of a number.
+*
+* For example:
+*   '2.34' returns '234'
+*   '-77' returns '77'
+*   '0.003400' returns '34'
+*   '120.5e+30' returns '1205'
+**/
+function extractSignificantDigits(value) {
+	const { start, end } = getSignificantDigitRange(value);
+	const digits = value.substring(start, end);
+	const dot = digits.indexOf(".");
+	if (dot === -1) return digits;
+	return digits.substring(0, dot) + digits.substring(dot + 1);
+}
+/**
+* Returns the range (start to end) of the significant digits of a value.
+* Note that this range _may_ contain the decimal dot.
+*
+* For example:
+*
+*     getSignificantDigitRange('0.0325900') // { start: 3, end: 7 }
+*     getSignificantDigitRange('2.0300')    // { start: 0, end: 3 }
+*     getSignificantDigitRange('0.0')       // { start: 3, end: 3 }
+*
+*/
+function getSignificantDigitRange(value) {
+	let start = 0;
+	if (value[0] === "-") start++;
+	while (value[start] === "0" || value[start] === ".") start++;
+	let end = value.lastIndexOf("e");
+	if (end === -1) end = value.lastIndexOf("E");
+	if (end === -1) end = value.length;
+	while ((value[end - 1] === "0" || value[end - 1] === ".") && end > start) end--;
+	return {
+		start,
+		end
+	};
+}
 
+//#endregion
+//#region node_modules/lossless-json/lib/esm/LosslessNumber.js
+/**
+* A lossless number. Stores its numeric value as string
+*/
+var LosslessNumber = class {
+	isLosslessNumber = true;
+	constructor(value) {
+		if (!isNumber(value)) throw new Error(`Invalid number (value: "${value}")`);
+		this.value = value;
+	}
+	/**
+	* Get the value of the LosslessNumber as number or bigint.
+	*
+	* - a number is returned for safe numbers and decimal values that only lose some insignificant digits
+	* - a bigint is returned for big integer numbers
+	* - an Error is thrown for values that will overflow or underflow
+	*
+	* Note that you can implement your own strategy for conversion by just getting the value as string
+	* via .toString(), and using util functions like isInteger, isSafeNumber, getUnsafeNumberReason,
+	* and toSafeNumberOrThrow to convert it to a numeric value.
+	*/
+	valueOf() {
+		const unsafeReason = getUnsafeNumberReason(this.value);
+		if (unsafeReason === void 0 || unsafeReason === UnsafeNumberReason.truncate_float) return Number.parseFloat(this.value);
+		if (isInteger(this.value)) return BigInt(this.value);
+		throw new Error(`Cannot safely convert to number: the value '${this.value}' would ${unsafeReason} and become ${Number.parseFloat(this.value)}`);
+	}
+	/**
+	* Get the value of the LosslessNumber as string.
+	*/
+	toString() {
+		return this.value;
+	}
+};
+/**
+* Test whether a value is a LosslessNumber
+*/
+function isLosslessNumber(value) {
+	return value && typeof value === "object" && value.isLosslessNumber || false;
+}
+
+//#endregion
+//#region node_modules/lossless-json/lib/esm/numberParsers.js
+function parseLosslessNumber(value) {
+	return new LosslessNumber(value);
+}
+
+//#endregion
+//#region node_modules/lossless-json/lib/esm/revive.js
+/**
+* Revive a json object.
+* Applies the reviver function recursively on all values in the JSON object.
+* @param json   A JSON Object, Array, or value
+* @param reviver
+*              A reviver function invoked with arguments `key` and `value`,
+*              which must return a replacement value. The function context
+*              (`this`) is the Object or Array that contains the currently
+*              handled value.
+*/
+function revive(json, reviver) {
+	return reviveValue({ "": json }, "", json, reviver);
+}
+/**
+* Revive a value
+*/
+function reviveValue(context, key, value, reviver) {
+	if (Array.isArray(value)) return reviver.call(context, key, reviveArray(value, reviver));
+	if (value && typeof value === "object" && !isLosslessNumber(value)) return reviver.call(context, key, reviveObject(value, reviver));
+	return reviver.call(context, key, value);
+}
+/**
+* Revive the properties of an object
+*/
+function reviveObject(object, reviver) {
+	for (const key of Object.keys(object)) {
+		const value = reviveValue(object, key, object[key], reviver);
+		if (value !== void 0) object[key] = value;
+		else delete object[key];
+	}
+	return object;
+}
+/**
+* Revive the properties of an Array
+*/
+function reviveArray(array, reviver) {
+	for (let i = 0; i < array.length; i++) array[i] = reviveValue(array, String(i), array[i], reviver);
+	return array;
+}
+
+//#endregion
+//#region node_modules/lossless-json/lib/esm/parse.js
+/**
+* The LosslessJSON.parse() method parses a string as JSON, optionally transforming
+* the value produced by parsing.
+*
+* The parser is based on the parser of Tan Li Hou shared in
+* https://lihautan.com/json-parser-with-javascript/
+*
+* @param text
+* The string to parse as JSON. See the JSON object for a description of JSON syntax.
+*
+* @param [reviver]
+* If a function, prescribes how the value originally produced by parsing is
+* transformed, before being returned.
+*
+* @param [options=ParseOptions | NumberParserArgument]
+* Pass a custom number parser. Input is a string, and the output can be unknown
+* numeric value: number, bigint, LosslessNumber, or a custom BigNumber library.
+*
+* @returns Returns the Object corresponding to the given JSON text.
+*
+* @throws Throws a SyntaxError exception if the string to parse is not valid JSON.
+*/
+function parse(text, reviver, options) {
+	const optionsObj = typeof options === "function" ? { parseNumber: options } : options;
+	const parseNumber = optionsObj?.parseNumber ?? parseLosslessNumber;
+	const onDuplicateKey = optionsObj?.onDuplicateKey ?? throwDuplicateKey;
+	let i = 0;
+	const value = parseValue();
+	expectValue(value);
+	expectEndOfInput();
+	return reviver ? revive(value, reviver) : value;
+	function parseObject() {
+		if (text.charCodeAt(i) === codeOpeningBrace) {
+			i++;
+			skipWhitespace();
+			const object = {};
+			let initial = true;
+			while (i < text.length && text.charCodeAt(i) !== codeClosingBrace) {
+				if (!initial) {
+					eatComma();
+					skipWhitespace();
+				} else initial = false;
+				const start = i;
+				const key = parseString();
+				if (key === void 0) {
+					throwObjectKeyExpected();
+					return;
+				}
+				skipWhitespace();
+				eatColon();
+				const value = parseValue();
+				if (value === void 0) {
+					throwObjectValueExpected();
+					return;
+				}
+				if (Object.prototype.hasOwnProperty.call(object, key) && !isDeepEqual(value, object[key])) {
+					const returnedValue = onDuplicateKey({
+						key,
+						position: start + 1,
+						oldValue: object[key],
+						newValue: value
+					});
+					if (returnedValue !== void 0) object[key] = returnedValue;
+				} else object[key] = value;
+			}
+			if (text.charCodeAt(i) !== codeClosingBrace) throwObjectKeyOrEndExpected();
+			i++;
+			return object;
+		}
+	}
+	function parseArray() {
+		if (text.charCodeAt(i) === codeOpeningBracket) {
+			i++;
+			skipWhitespace();
+			const array = [];
+			let initial = true;
+			while (i < text.length && text.charCodeAt(i) !== codeClosingBracket) {
+				if (!initial) eatComma();
+				else initial = false;
+				const value = parseValue();
+				expectArrayItem(value);
+				array.push(value);
+			}
+			if (text.charCodeAt(i) !== codeClosingBracket) throwArrayItemOrEndExpected();
+			i++;
+			return array;
+		}
+	}
+	function parseValue() {
+		skipWhitespace();
+		const value = parseString() ?? parseNumeric() ?? parseObject() ?? parseArray() ?? parseKeyword("true", true) ?? parseKeyword("false", false) ?? parseKeyword("null", null);
+		skipWhitespace();
+		return value;
+	}
+	function parseKeyword(name, value) {
+		if (text.slice(i, i + name.length) === name) {
+			i += name.length;
+			return value;
+		}
+	}
+	function skipWhitespace() {
+		while (isWhitespace(text.charCodeAt(i))) i++;
+	}
+	function parseString() {
+		if (text.charCodeAt(i) === codeDoubleQuote) {
+			i++;
+			let result = "";
+			while (i < text.length && text.charCodeAt(i) !== codeDoubleQuote) {
+				if (text.charCodeAt(i) === codeBackslash) {
+					const char = text[i + 1];
+					const escapeChar = escapeCharacters[char];
+					if (escapeChar !== void 0) {
+						result += escapeChar;
+						i++;
+					} else if (char === "u") {
+						if (isHex(text.charCodeAt(i + 2)) && isHex(text.charCodeAt(i + 3)) && isHex(text.charCodeAt(i + 4)) && isHex(text.charCodeAt(i + 5))) {
+							result += String.fromCharCode(Number.parseInt(text.slice(i + 2, i + 6), 16));
+							i += 5;
+						} else throwInvalidUnicodeCharacter(i);
+					} else throwInvalidEscapeCharacter(i);
+				} else if (isValidStringCharacter(text.charCodeAt(i))) result += text[i];
+				else throwInvalidCharacter(text[i]);
+				i++;
+			}
+			expectEndOfString();
+			i++;
+			return result;
+		}
+	}
+	function parseNumeric() {
+		const start = i;
+		if (text.charCodeAt(i) === codeMinus) {
+			i++;
+			expectDigit(start);
+		}
+		if (text.charCodeAt(i) === codeZero) i++;
+		else if (isNonZeroDigit(text.charCodeAt(i))) {
+			i++;
+			while (isDigit(text.charCodeAt(i))) i++;
+		}
+		if (text.charCodeAt(i) === codeDot) {
+			i++;
+			expectDigit(start);
+			while (isDigit(text.charCodeAt(i))) i++;
+		}
+		if (text.charCodeAt(i) === 101 || text.charCodeAt(i) === 69) {
+			i++;
+			if (text.charCodeAt(i) === codeMinus || text.charCodeAt(i) === codePlus) i++;
+			expectDigit(start);
+			while (isDigit(text.charCodeAt(i))) i++;
+		}
+		if (i > start) return parseNumber(text.slice(start, i));
+	}
+	function eatComma() {
+		if (text.charCodeAt(i) !== codeComma) throw new SyntaxError(`Comma ',' expected after value ${gotAt()}`);
+		i++;
+	}
+	function eatColon() {
+		if (text.charCodeAt(i) !== codeColon) throw new SyntaxError(`Colon ':' expected after property name ${gotAt()}`);
+		i++;
+	}
+	function expectValue(value) {
+		if (value === void 0) throw new SyntaxError(`JSON value expected ${gotAt()}`);
+	}
+	function expectArrayItem(value) {
+		if (value === void 0) throw new SyntaxError(`Array item expected ${gotAt()}`);
+	}
+	function expectEndOfInput() {
+		if (i < text.length) throw new SyntaxError(`Expected end of input ${gotAt()}`);
+	}
+	function expectDigit(start) {
+		if (!isDigit(text.charCodeAt(i))) {
+			const numSoFar = text.slice(start, i);
+			throw new SyntaxError(`Invalid number '${numSoFar}', expecting a digit ${gotAt()}`);
+		}
+	}
+	function expectEndOfString() {
+		if (text.charCodeAt(i) !== codeDoubleQuote) throw new SyntaxError(`End of string '"' expected ${gotAt()}`);
+	}
+	function throwObjectKeyExpected() {
+		throw new SyntaxError(`Quoted object key expected ${gotAt()}`);
+	}
+	function throwDuplicateKey(_ref) {
+		let { key, position } = _ref;
+		throw new SyntaxError(`Duplicate key '${key}' encountered at position ${position}`);
+	}
+	function throwObjectKeyOrEndExpected() {
+		throw new SyntaxError(`Quoted object key or end of object '}' expected ${gotAt()}`);
+	}
+	function throwArrayItemOrEndExpected() {
+		throw new SyntaxError(`Array item or end of array ']' expected ${gotAt()}`);
+	}
+	function throwInvalidCharacter(char) {
+		throw new SyntaxError(`Invalid character '${char}' ${pos()}`);
+	}
+	function throwInvalidEscapeCharacter(start) {
+		const chars = text.slice(start, start + 2);
+		throw new SyntaxError(`Invalid escape character '${chars}' ${pos()}`);
+	}
+	function throwObjectValueExpected() {
+		throw new SyntaxError(`Object value expected after ':' ${pos()}`);
+	}
+	function throwInvalidUnicodeCharacter(start) {
+		const chars = text.slice(start, start + 6);
+		throw new SyntaxError(`Invalid unicode character '${chars}' ${pos()}`);
+	}
+	function pos() {
+		return `at position ${i}`;
+	}
+	function got() {
+		return i < text.length ? `but got '${text[i]}'` : "but reached end of input";
+	}
+	function gotAt() {
+		return `${got()} ${pos()}`;
+	}
+}
+function isWhitespace(code) {
+	return code === codeSpace || code === codeNewline || code === codeTab || code === codeReturn;
+}
+function isHex(code) {
+	return code >= codeZero && code <= codeNine || code >= 65 && code <= 70 || code >= 97 && code <= 102;
+}
+function isDigit(code) {
+	return code >= codeZero && code <= codeNine;
+}
+function isNonZeroDigit(code) {
+	return code >= codeOne && code <= codeNine;
+}
+function isValidStringCharacter(code) {
+	return code >= 32 && code <= 1114111;
+}
+function isDeepEqual(a, b) {
+	if (a === b) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((item, index) => isDeepEqual(item, b[index]));
+	if (isObject$1(a) && isObject$1(b)) return [.../* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)])].every((key) => isDeepEqual(a[key], b[key]));
+	return false;
+}
+function isObject$1(value) {
+	return typeof value === "object" && value !== null;
+}
+const escapeCharacters = {
+	"\"": "\"",
+	"\\": "\\",
+	"/": "/",
+	b: "\b",
+	f: "\f",
+	n: "\n",
+	r: "\r",
+	t: "	"
+};
+const codeBackslash = 92;
+const codeOpeningBrace = 123;
+const codeClosingBrace = 125;
+const codeOpeningBracket = 91;
+const codeClosingBracket = 93;
+const codeSpace = 32;
+const codeNewline = 10;
+const codeTab = 9;
+const codeReturn = 13;
+const codeDoubleQuote = 34;
+const codePlus = 43;
+const codeMinus = 45;
+const codeZero = 48;
+const codeOne = 49;
+const codeNine = 57;
+const codeComma = 44;
+const codeDot = 46;
+const codeColon = 58;
+const codeUppercaseA = 65;
+const codeLowercaseA = 97;
+const codeUppercaseE = 69;
+const codeLowercaseE = 101;
+const codeUppercaseF = 70;
+const codeLowercaseF = 102;
+
+//#endregion
+//#region src/analytics.ts
+/** Decode feed IDs before a native JSON parser can round their UInt64 values. */
+function parseFeedResponse(raw) {
+	const page = parse(raw, void 0, { onDuplicateKey: ({ newValue }) => newValue });
+	if (!isObject(page) || !Array.isArray(page.results)) throw new TypeError("Expected a feed response with a results array.");
+	for (const record of page.results) {
+		if (!isObject(record)) throw new TypeError("Expected a feed record.");
+		const id = isLosslessNumber(record.id) ? record.id.value : record.id;
+		if (typeof id !== "string" || !/^(0|[1-9]\d*)$/u.test(id) || id.length > 20 || id.length === 20 && id > "18446744073709551615") throw new TypeError("Expected a decimal UInt64 feed ID.");
+		record.id = id;
+	}
+	return nativeValues(page);
+}
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function nativeValues(value) {
+	if (isLosslessNumber(value)) return Number(value.value);
+	if (Array.isArray(value)) return value.map(nativeValues);
+	if (isObject(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, nativeValues(item)]));
+	return value;
+}
+
+//#endregion
 //#region src/errors.ts
 const encoder$1 = new TextEncoder();
 var ProxyRequestError = class extends Error {
@@ -1944,7 +2822,7 @@ function offsetFromUrl(url) {
 //#endregion
 //#region src/client.ts
 const DEFAULT_BASE_URL = "https://api.proxyrequest.com/api/v1";
-const SDK_VERSION = "2.1.0";
+const SDK_VERSION = "3.0.1";
 var ProxyRequestClient = class ProxyRequestClient {
 	apiKeys;
 	affiliates;
@@ -2056,10 +2934,10 @@ var ProxyRequestClient = class ProxyRequestClient {
 					...data.body === void 0 ? {} : { body: data.body },
 					...[...controlHeaders].length === 0 ? {} : { headers: controlHeaders },
 					signal: timeout.signal,
-					...spec.binary ? { parseAs: "arrayBuffer" } : {}
+					...spec.binary ? { parseAs: "arrayBuffer" } : spec.operationId === "analytics_feed_retrieve" ? { parseAs: "text" } : {}
 				});
 				if (result.error !== void 0) throw ApiError.unexpected(`ProxyRequest returned an undocumented error for ${spec.operationId}.`, result.error);
-				const dataValue = spec.binary ? binaryResult(spec, result.data, result.response.headers) : result.data;
+				const dataValue = spec.binary ? binaryResult(spec, result.data, result.response.headers) : spec.operationId === "analytics_feed_retrieve" ? parseFeedResponse(result.data) : result.data;
 				const headers = headersToRecord(result.response.headers);
 				const etag = headers.etag;
 				return {