@selvajs/selva 4.8.0-beta.4 → 4.8.0-beta.7

package/build/server/chunks/chunks/chunk-AYH5O3VG.js-YiX3ZqeT.js

@@ -0,0 +1,729 @@
+//#region ../compute/dist/chunk-AYH5O3VG.js
+var oe = Object.defineProperty;
+var se = (e, r, t) => r in e ? oe(e, r, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: t
+}) : e[r] = t;
+var b = (e, r, t) => se(e, typeof r != "symbol" ? r + "" : r, t);
+var u = {
+	NETWORK_ERROR: "NETWORK_ERROR",
+	AUTH_ERROR: "AUTH_ERROR",
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	COMPUTATION_ERROR: "COMPUTATION_ERROR",
+	TIMEOUT_ERROR: "TIMEOUT_ERROR",
+	CORS_ERROR: "CORS_ERROR",
+	NOT_FOUND: "NOT_FOUND",
+	RATE_LIMIT: "RATE_LIMIT",
+	INVALID_RESPONSE: "INVALID_RESPONSE",
+	UNKNOWN_ERROR: "UNKNOWN_ERROR",
+	INVALID_STATE: "INVALID_STATE",
+	INVALID_INPUT: "INVALID_INPUT",
+	INVALID_CONFIG: "INVALID_CONFIG",
+	BROWSER_ONLY: "BROWSER_ONLY",
+	ENVIRONMENT_ERROR: "ENVIRONMENT_ERROR",
+	ENCODING_ERROR: "ENCODING_ERROR",
+	MALFORMED_DEFAULT: "MALFORMED_DEFAULT",
+	SUPERSEDED: "SUPERSEDED",
+	ABORTED: "ABORTED",
+	QUEUE_FULL: "QUEUE_FULL",
+	QUEUE_TIMEOUT: "QUEUE_TIMEOUT",
+	DEFINITION_NOT_CACHED: "DEFINITION_NOT_CACHED"
+};
+var f = class e extends Error {
+	constructor(t, n = u.UNKNOWN_ERROR, o) {
+		super(t);
+		b(this, "code");
+		b(this, "statusCode");
+		b(this, "context");
+		b(this, "originalError");
+		this.name = "ComputeError", this.code = n, this.statusCode = o?.statusCode, this.context = o?.context, this.originalError = o?.originalError, o?.originalError && (this.cause = o.originalError);
+	}
+	static missingValues(t, n, o) {
+		return new e(`Input "${t}" has no values defined${n ? ` (expected ${n})` : ""}`, u.INVALID_INPUT, { context: {
+			inputName: t,
+			expectedType: n,
+			...o
+		} });
+	}
+	static unknownParamType(t, n, o) {
+		return new e(`Unknown paramType: ${t}`, u.VALIDATION_ERROR, { context: {
+			receivedParamType: t,
+			paramName: n,
+			...o
+		} });
+	}
+};
+function S() {
+	let e = globalThis.Buffer;
+	return typeof e == "function" ? e : void 0;
+}
+function Le(e) {
+	let r = S();
+	return r ? r.from(e, "utf-8").toString("base64") : ue(new TextEncoder().encode(e));
+}
+var ie = 64;
+var ae = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function De(e) {
+	if (!e) return null;
+	let r = e.replace(/[\t\n\f\r ]/g, "");
+	r.length % 4 === 0 && (r = r.replace(/={1,2}$/, ""));
+	let t = r.length % 4;
+	if (t === 1 || r.length < ie || !/^[A-Za-z0-9+/]*$/.test(r)) return null;
+	let n = ae.indexOf(r.charAt(r.length - 1));
+	return t === 2 && (n & 15) !== 0 || t === 3 && (n & 3) !== 0 ? null : t === 0 ? r : r + "==".slice(0, 4 - t);
+}
+function $(e) {
+	let r = e.replace(/[\t\n\f\r ]/g, "");
+	if (r.length % 4 === 0 && (r = r.replace(/={1,2}$/, "")), r.length % 4 === 1 || !/^[A-Za-z0-9+/]*$/.test(r)) throw new f("Invalid base64 input.", u.ENCODING_ERROR, { context: { inputLength: e.length } });
+	let t = S();
+	if (t) return new Uint8Array(t.from(r, "base64"));
+	if (typeof globalThis.atob == "function") {
+		let n = globalThis.atob(r), o = new Uint8Array(n.length);
+		for (let i = 0; i < n.length; i++) o[i] = n.charCodeAt(i) & 255;
+		return o;
+	}
+	throw new f("Base64 decoding not supported in this environment.", u.INVALID_STATE, { context: { environmentInfo: "atob or Buffer not available" } });
+}
+function k(e) {
+	let r = S();
+	if (r) return r.byteLength(e, "utf-8");
+	let t = 0;
+	for (let n = 0; n < e.length; n++) {
+		let o = e.charCodeAt(n);
+		o < 128 ? t += 1 : o < 2048 ? t += 2 : o >= 55296 && o <= 56319 && n + 1 < e.length && (e.charCodeAt(n + 1) & 64512) === 56320 ? (t += 4, n++) : t += 3;
+	}
+	return t;
+}
+function ue(e) {
+	let r = S();
+	if (r) return r.from(e).toString("base64");
+	if (typeof globalThis.btoa == "function") {
+		let n = [];
+		for (let o = 0; o < e.length; o += 32766) n.push(globalThis.btoa(String.fromCharCode.apply(null, e.subarray(o, o + 32766))));
+		return n.join("");
+	}
+	throw new f("Base64 encoding not supported in this environment.", u.INVALID_STATE, { context: { environmentInfo: "btoa or Buffer not available" } });
+}
+var I = class {
+	debug() {}
+	info() {}
+	warn() {}
+	error() {}
+};
+var U = class {
+	debug(r, ...t) {
+		console.debug(r, ...t);
+	}
+	info(r, ...t) {
+		console.info(r, ...t);
+	}
+	warn(r, ...t) {
+		console.warn(r, ...t);
+	}
+	error(r, ...t) {
+		console.error(r, ...t);
+	}
+};
+var _ = new I();
+function y() {
+	return _;
+}
+function M(e) {
+	if (e === null) {
+		_ = new I();
+		return;
+	}
+	let r = [
+		"debug",
+		"info",
+		"warn",
+		"error"
+	].filter((t) => typeof e[t] != "function");
+	if (r.length > 0) throw new f(`Logger is missing required method(s): ${r.join(", ")}. A logger must implement debug, info, warn and error.`, u.INVALID_CONFIG, { context: { missingMethods: r } });
+	_ = e;
+}
+function le() {
+	M(new U());
+}
+function R(e, r) {
+	r && y().debug(e);
+}
+function P(e, r) {
+	return `${r.replace(/\/+$/, "")}/${e.replace(/^\/+/, "")}`;
+}
+function ce(e) {
+	try {
+		let r = new URL(e).hostname.toLowerCase();
+		return r === "localhost" || r === "127.0.0.1" || r === "[::1]";
+	} catch {
+		return /(localhost|127\.0\.0\.1|\[::1\])/i.test(e);
+	}
+}
+var B = /* @__PURE__ */ new Set();
+var fe = "RhinoComputeKey";
+function q(e, r) {
+	let t = {
+		...r.headers,
+		"X-Request-ID": e,
+		"Content-Type": "application/json",
+		...r.authToken && { Authorization: r.authToken },
+		...r.apiKey && { [r.apiKeyHeader ?? fe]: r.apiKey }
+	};
+	return !r.apiKey && !r.authToken && !B.has(r.serverUrl) && !ce(r.serverUrl) && (B.add(r.serverUrl), y().warn(`\u26A0\uFE0F [Compute] Request [${e}] targets remote server (${r.serverUrl}) but no API key or auth token is configured. Requests may fail or be rate-limited. (warned once per server)`)), t;
+}
+function H() {
+	return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function de(e) {
+	if (!e) return null;
+	let r = { raw: e }, t = false;
+	for (let n of e.split(",")) {
+		let [o, ...i] = n.trim().split(";"), c = i.find((d) => d.trim().toLowerCase().startsWith("dur"));
+		if (!c) continue;
+		let s = Number(c.split("=")[1]);
+		if (!Number.isFinite(s)) continue;
+		let l = o.trim().toLowerCase();
+		(l === "decode" || l === "solve" || l === "encode") && (r[l] = s, t = true);
+	}
+	return t ? r : null;
+}
+function x(e, r, t, n) {
+	if (!t) return;
+	let o = de(e.headers.get("Server-Timing"));
+	if (o) try {
+		t(o, r);
+	} catch (i) {
+		n && R(`   onServerTiming callback threw: ${i}`, true);
+	}
+}
+var K = /* @__PURE__ */ new WeakMap();
+function N(e, r) {
+	typeof e != "object" || e === null || K.set(e, r);
+}
+function pe(e) {
+	if (!(typeof e != "object" || e === null)) return K.get(e);
+}
+var L = 4096;
+function ge(e) {
+	return e.length <= L ? e : `${e.slice(0, L)}\u2026 [truncated ${e.length - L} chars]`;
+}
+function me(e, r, t, n, o, i, c, s, l) {
+	let { status: d, statusText: a } = e, g = {};
+	e.headers.forEach((te, ne) => {
+		g[ne] = te;
+	});
+	let m = i.trim(), p = m ? ` \u2014 ${m.slice(0, 200)}${m.length > 200 ? "…" : ""}` : "", h = s ?? i, A = {
+		url: r,
+		requestId: t,
+		method: "POST",
+		requestSize: n,
+		serverUrl: o,
+		responseBody: h ? ge(h) : void 0,
+		responseHeaders: g
+	}, w = {
+		401: {
+			message: `HTTP ${d}: ${a}${p}`,
+			code: u.AUTH_ERROR
+		},
+		403: {
+			message: `HTTP ${d}: ${a}${p}`,
+			code: u.AUTH_ERROR
+		},
+		404: {
+			message: `Endpoint not found: ${r}`,
+			code: u.NOT_FOUND
+		},
+		413: {
+			message: `Request too large: ${(n / 1024).toFixed(2)}KB`,
+			code: u.VALIDATION_ERROR
+		},
+		429: {
+			message: `Rate limit exceeded${p}`,
+			code: u.RATE_LIMIT
+		},
+		500: {
+			message: `Server error: ${a}${p}`,
+			code: u.COMPUTATION_ERROR
+		},
+		502: {
+			message: `Service unavailable: ${a}${p}`,
+			code: u.NETWORK_ERROR
+		},
+		503: {
+			message: `Service unavailable: ${a}${p}`,
+			code: u.NETWORK_ERROR
+		},
+		504: {
+			message: `Service unavailable: ${a}${p}`,
+			code: u.NETWORK_ERROR
+		}
+	}[d] || {
+		message: `HTTP ${d}: ${a}${p}`,
+		code: u.UNKNOWN_ERROR
+	}, F = Re(c, l) ?? w.code;
+	throw new f(w.message, F, {
+		statusCode: d,
+		context: A
+	});
+}
+function Re(e, r) {
+	if (!(!e || !r)) return r[e];
+}
+async function z(e, r, t, n, o, i, c, s, l) {
+	let d = Math.round(performance.now() - i);
+	if (!e.ok) {
+		let a = await e.text(), g = a;
+		c && (R(`\u274C Request [${t}] failed with HTTP ${e.status} in ${d}ms`, true), R(`   URL: ${r}`, true), R(`   Status: ${e.status} ${e.statusText}`, true), g && R(`   Response body: ${g.substring(0, 500)}${g.length > 500 ? "..." : ""}`, true));
+		let m;
+		try {
+			let p = JSON.parse(g);
+			typeof p?.code == "string" && (m = p.code);
+		} catch {}
+		if (e.status === 500) try {
+			let p = JSON.parse(g);
+			if (p?.values && (p.errors || p.warnings)) return N(p, g.length), c && (R(`\u26A0\uFE0F Request [${t}] completed with solver errors in ${d}ms`, !0), p.errors?.length > 0 && R(`   Errors: ${JSON.stringify(p.errors, null, 2)}`, !0), p.warnings?.length > 0 && R(`   Warnings: ${JSON.stringify(p.warnings, null, 2)}`, !0)), x(e, t, s, c), p;
+			let h = typeof p?.message == "string" && p.message || typeof p?.Message == "string" && p.Message || "", A = typeof p?.ExceptionType == "string" && p.ExceptionType || "", v = p?.stackTrace ?? p?.StackTrace, w = Array.isArray(v) ? v.join(`
+`) : v || "";
+			h ? g = `${A ? `${A}: ` : ""}${h}${w ? `
+${w}` : ""}` : p?.error && (g = typeof p.error == "string" ? p.error : JSON.stringify(p.error, null, 2));
+		} catch (p) {
+			c && R(`   Failed to parse error body as JSON: ${p}`, true);
+		}
+		me(e, r, t, n, o, g, m, a, l);
+	}
+	R(`\u2705 Request [${t}] completed in ${d}ms`, c), x(e, t, s, c);
+	try {
+		let a = await e.text(), g = JSON.parse(a);
+		return N(g, a.length), g;
+	} catch (a) {
+		let g = (e.headers.get("Content-Type") ?? "").toLowerCase();
+		throw g !== "" && !g.includes("json") ? new f(`Server returned a non-JSON response (Content-Type: ${g}) \u2014 check the server URL / proxy configuration`, u.INVALID_RESPONSE, {
+			statusCode: e.status,
+			context: {
+				url: r,
+				requestId: t,
+				contentType: g
+			},
+			originalError: a instanceof Error ? a : new Error(String(a))
+		}) : new f("Failed to parse JSON response", u.NETWORK_ERROR, {
+			statusCode: e.status,
+			context: {
+				url: r,
+				requestId: t
+			},
+			originalError: a instanceof Error ? a : new Error(String(a))
+		});
+	}
+}
+var T = {
+	attempts: 0,
+	baseDelayMs: 500,
+	maxDelayMs: 3e4,
+	retryOn429: true
+};
+var D = /* @__PURE__ */ new Set([
+	502,
+	503,
+	504
+]);
+var V = 6e4;
+function W(e) {
+	return e ? {
+		attempts: e.attempts ?? T.attempts,
+		baseDelayMs: e.baseDelayMs ?? T.baseDelayMs,
+		maxDelayMs: e.maxDelayMs ?? T.maxDelayMs,
+		retryOn429: e.retryOn429 ?? T.retryOn429
+	} : T;
+}
+function j(e) {
+	if (!e) return null;
+	let r = Number(e);
+	if (Number.isFinite(r) && r >= 0) return r * 1e3;
+	let t = Date.parse(e);
+	if (Number.isFinite(t)) {
+		let n = t - Date.now();
+		return n > 0 ? n : 0;
+	}
+	return null;
+}
+function O(e, r) {
+	let t = r.baseDelayMs * Math.pow(2, e), n = Math.random() * r.baseDelayMs;
+	return Math.min(t + n, r.maxDelayMs);
+}
+function G(e, r) {
+	return new Promise((t, n) => {
+		if (r?.aborted) {
+			n(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		let o = setTimeout(() => {
+			r?.removeEventListener("abort", i), t();
+		}, e), i = () => {
+			clearTimeout(o), n(new DOMException("Aborted", "AbortError"));
+		};
+		r?.addEventListener("abort", i, { once: true });
+	});
+}
+function J(e, r) {
+	let t = () => {}, n = typeof r == "number" && r > 0;
+	if (!e && !n) return {
+		signal: void 0,
+		cleanup: t
+	};
+	if (e && !n) return {
+		signal: e,
+		cleanup: t
+	};
+	let o = typeof AbortSignal < "u" && typeof AbortSignal.timeout == "function";
+	if (!e) {
+		if (o) return {
+			signal: AbortSignal.timeout(r),
+			cleanup: t
+		};
+		let a = new AbortController(), g = setTimeout(() => a.abort(), r);
+		return {
+			signal: a.signal,
+			cleanup: () => clearTimeout(g)
+		};
+	}
+	let i = new AbortController(), c, s;
+	if (o) c = AbortSignal.timeout(r);
+	else {
+		let a = new AbortController();
+		s = setTimeout(() => a.abort(), r), c = a.signal;
+	}
+	let l = [e, c], d = function() {
+		i.abort(this.reason);
+	};
+	for (let a of l) {
+		if (a.aborted) {
+			i.abort(a.reason);
+			break;
+		}
+		a.addEventListener("abort", d, { once: true });
+	}
+	return {
+		signal: i.signal,
+		cleanup: () => {
+			s !== void 0 && clearTimeout(s);
+			for (let a of l) a.removeEventListener("abort", d);
+		}
+	};
+}
+async function ye(e, r, t, n) {
+	let { signal: o, cleanup: i } = J(e.config.signal, e.config.timeoutMs), c = performance.now();
+	try {
+		let s = await fetch(e.fullUrl, {
+			method: "POST",
+			body: e.body,
+			headers: e.headers,
+			signal: o
+		});
+		if ((D.has(s.status) || r.retryOn429 && s.status === 429) && t < n - 1) {
+			let a = j(s.headers.get("Retry-After")), g = a !== null ? Math.min(a, Math.max(r.maxDelayMs, V)) : O(t, r);
+			return await s.text().catch(() => {}), {
+				ok: !1,
+				retry: !0,
+				delayMs: g,
+				cause: new f(`HTTP ${s.status} ${s.statusText} (will retry)`, s.status === 429 ? u.RATE_LIMIT : u.NETWORK_ERROR, {
+					statusCode: s.status,
+					context: { requestId: e.requestId }
+				})
+			};
+		}
+		return {
+			ok: !0,
+			value: await z(s, e.fullUrl, e.requestId, e.requestSize, e.config.serverUrl, c, e.config.debug, e.config.onServerTiming, e.config.serverErrorCodes)
+		};
+	} catch (s) {
+		if (s instanceof Error && (s.name === "AbortError" || s.name === "TimeoutError")) {
+			if (e.config.signal?.aborted === true) return {
+				ok: false,
+				retry: false,
+				cause: new f("Request aborted by caller", u.ABORTED, {
+					context: {
+						endpoint: e.endpoint,
+						requestId: e.requestId,
+						requestSize: e.requestSize
+					},
+					originalError: s
+				})
+			};
+			let a = typeof e.config.timeoutMs == "number" && e.config.timeoutMs > 0 ? new f(`Request timed out after ${e.config.timeoutMs}ms`, u.TIMEOUT_ERROR, {
+				context: {
+					serverUrl: e.config.serverUrl,
+					timeoutMs: e.config.timeoutMs,
+					url: e.fullUrl,
+					requestId: e.requestId,
+					endpoint: e.endpoint,
+					requestSize: e.requestSize
+				},
+				originalError: s
+			}) : new f(`Request aborted by the runtime (${s.name}): ${s.message}`, u.NETWORK_ERROR, {
+				context: {
+					serverUrl: e.config.serverUrl,
+					url: e.fullUrl,
+					requestId: e.requestId,
+					endpoint: e.endpoint,
+					requestSize: e.requestSize
+				},
+				originalError: s
+			});
+			return t < n - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: O(t, r),
+				cause: a
+			} : {
+				ok: false,
+				retry: false,
+				cause: a
+			};
+		}
+		if (s instanceof TypeError) {
+			let l = typeof window < "u" && typeof window.document < "u", d = {
+				serverUrl: e.config.serverUrl,
+				url: e.fullUrl,
+				requestId: e.requestId,
+				endpoint: e.endpoint,
+				requestSize: e.requestSize
+			}, a = l ? new f(`Request failed: ${s.message} \u2014 in a browser this usually means a CORS misconfiguration on the server (or a network failure; the browser does not distinguish them)`, u.CORS_ERROR, {
+				context: d,
+				originalError: s
+			}) : new f(`Network error: ${s.message}`, u.NETWORK_ERROR, {
+				context: d,
+				originalError: s
+			});
+			return t < n - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: O(t, r),
+				cause: a
+			} : {
+				ok: false,
+				retry: false,
+				cause: a
+			};
+		}
+		if (s instanceof f) {
+			let l = s.statusCode;
+			return (s.code === u.NETWORK_ERROR && l !== void 0 && l >= 200 && l < 300 || l !== void 0 && (D.has(l) || r.retryOn429 && l === 429)) && t < n - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: O(t, r),
+				cause: s
+			} : {
+				ok: false,
+				retry: false,
+				cause: s
+			};
+		}
+		return {
+			ok: false,
+			retry: false,
+			cause: new f(s instanceof Error ? s.message : String(s), u.UNKNOWN_ERROR, {
+				context: {
+					endpoint: e.endpoint,
+					requestId: e.requestId
+				},
+				originalError: s instanceof Error ? s : new Error(String(s))
+			})
+		};
+	} finally {
+		i();
+	}
+}
+async function Ee(e, r, t) {
+	let n = H(), o = JSON.stringify(r), i = k(o), c = P(e, t.serverUrl), s = q(n, t), l = W(t.retry), d = l.attempts + 1;
+	if (t.debug) {
+		let g = (i / 1024).toFixed(2);
+		R(`${i > 1e5 ? "⚠️" : "🚀"} Starting compute request [${n}]: ${e} (${g}KB)`, true);
+	}
+	let a = {
+		endpoint: e,
+		body: o,
+		requestSize: i,
+		fullUrl: c,
+		requestId: n,
+		headers: s,
+		config: t
+	};
+	for (let g = 0;; g++) {
+		let m = await ye(a, l, g, d);
+		if (m.ok) return m.value;
+		if (!m.retry) throw m.cause;
+		t.debug && R(`\u{1F501} Request [${n}] retrying after ${m.delayMs}ms (attempt ${g + 2}/${d}): ${m.cause.message}`, true);
+		try {
+			await G(m.delayMs, t.signal);
+		} catch {
+			throw new f("Request aborted by caller", u.ABORTED, {
+				context: {
+					endpoint: e,
+					requestId: n,
+					requestSize: i
+				},
+				originalError: m.cause
+			});
+		}
+	}
+}
+function E(e, r) {
+	if (!e || typeof e != "object") return;
+	let t = e;
+	if (Z(t, r)) return t[r];
+	let n = Q(t).get(r.toLowerCase());
+	return n === void 0 ? void 0 : t[n];
+}
+var Z = (e, r) => Object.prototype.hasOwnProperty.call(e, r);
+function he(e, r) {
+	if (!e || typeof e != "object") return false;
+	let t = e;
+	return Z(t, r) ? true : Q(t).has(r.toLowerCase());
+}
+var Y = /* @__PURE__ */ new WeakMap();
+function Q(e) {
+	let r = Object.keys(e), t = Y.get(e);
+	if (t && t.keyCount === r.length) return t.map;
+	let n = /* @__PURE__ */ new Map();
+	for (let o of r) {
+		let i = o.toLowerCase();
+		n.has(i) || n.set(i, o);
+	}
+	return Y.set(e, {
+		keyCount: r.length,
+		map: n
+	}), n;
+}
+function we(e) {
+	return typeof e == "object" && !(e instanceof Uint8Array) && typeof e.key == "string" && typeof e.load == "function";
+}
+function be(e, r) {
+	let t = e?.trim() ?? "";
+	if (!t) throw new f("serverUrl is required", u.INVALID_CONFIG, { context: { receivedServerUrl: e } });
+	if (!/^https?:\/\//i.test(t)) throw new f(`Invalid serverUrl: "${t}". Must start with "http://" or "https://". For example: "http://localhost:5000" or "https://example.com"`, u.INVALID_CONFIG, { context: { receivedServerUrl: e } });
+	let n;
+	try {
+		n = new URL(t);
+	} catch (c) {
+		throw new f(`Invalid serverUrl: "${t}". Must be a valid URL. Received error: ${c instanceof Error ? c.message : String(c)}`, u.INVALID_CONFIG, {
+			context: { receivedServerUrl: e },
+			originalError: c instanceof Error ? c : void 0
+		});
+	}
+	if (n.username !== "" || n.password !== "") throw new f(`Invalid serverUrl: "${t}". Must not embed credentials (user:pass@host) \u2014 fetch rejects credentialed URLs at request time. Pass the API key separately.`, u.INVALID_CONFIG, { context: { receivedServerUrl: e } });
+	if (t.includes("?") || t.includes("#")) throw new f(`Invalid serverUrl: "${t}". Must not contain a query string or fragment \u2014 endpoint paths are appended to this URL (e.g. "\${serverUrl}/version"), and a "?" or "#" suffix would corrupt every request path.`, u.INVALID_CONFIG, { context: { receivedServerUrl: e } });
+	let o = n.hostname.toLowerCase().replace(/\.+$/, "");
+	if ((["compute.rhino3d.com"]).map((c) => c.toLowerCase().replace(/\.+$/, "")).includes(o)) throw new f("serverUrl must be set to your Compute server URL. The shared public endpoint is not allowed.", u.INVALID_CONFIG, { context: { receivedServerUrl: e } });
+	return t.replace(/\/+$/, "");
+}
+var Oe = async (e, r, t = null) => {
+	if (typeof document > "u" || typeof Blob > "u") throw new f("File download functionality is only available in browser environments. This function requires the DOM API (document, Blob).", u.BROWSER_ONLY, { context: {
+		environment: typeof window < "u" ? "browser (SSR)" : "Node.js",
+		documentAvailable: typeof document < "u",
+		blobAvailable: typeof Blob < "u"
+	} });
+	try {
+		await Ne(await ee(e, t), r);
+	} catch (n) {
+		throw n instanceof f ? n : new f("Failed to download files from compute response", u.INVALID_STATE, {
+			context: { originalError: n instanceof Error ? n.message : String(n) },
+			originalError: n instanceof Error ? n : void 0
+		});
+	}
+};
+var C = (e) => e.replace(/\\/g, "/").split("/").map((r) => r.trim()).filter((r) => r !== "" && r !== "." && r !== ".." && !/^[a-zA-Z]:$/.test(r)).join("/");
+var Ae = (e) => e === true || typeof e == "string" && e.trim().toLowerCase() === "true";
+var ve = (e) => {
+	let r = [];
+	return e.forEach((t) => {
+		let n = E(t, "fileName") ?? "", o = E(t, "fileType") ?? "", i = C(`${n}${o}`);
+		if (i === "") {
+			y().warn(`Skipping file with unusable name "${n}${o}": no safe archive path remains after sanitization.`);
+			return;
+		}
+		let c = E(t, "subFolder"), s = c ? C(c) : "", l = s !== "" ? `${s}/${i}` : i, d = E(t, "data");
+		if (typeof d != "string" || d === "") {
+			y().warn(`Skipping file "${l}": item carries no usable data.`);
+			return;
+		}
+		if (Ae(E(t, "isBase64Encoded"))) try {
+			r.push({
+				fileName: i,
+				content: $(d),
+				path: l
+			});
+		} catch (a) {
+			y().warn(`Skipping file "${l}": base64 decode failed.`, a);
+		}
+		else r.push({
+			fileName: i,
+			content: d,
+			path: l
+		});
+	}), r;
+};
+var Se = 3e4;
+var Ie = async (e) => (await Promise.all(e.map(async (t) => {
+	try {
+		let n = typeof AbortSignal < "u" && typeof AbortSignal.timeout == "function" ? AbortSignal.timeout(Se) : void 0, o = await fetch(t.filePath, { signal: n });
+		if (!o.ok) return y().warn(`Failed to fetch additional file from URL: ${t.filePath}`), null;
+		let i = await o.arrayBuffer(), c = C(t.fileName);
+		if (c === "") return y().warn(`Skipping fetched file with unusable name: ${t.fileName}`), null;
+		let s = t.subFolder ? C(t.subFolder) : "";
+		return {
+			fileName: c,
+			content: new Uint8Array(i),
+			path: s !== "" ? `${s}/${c}` : c
+		};
+	} catch (n) {
+		return y().error(`Error fetching additional file from URL: ${t.filePath}`, n), null;
+	}
+}))).filter((t) => t !== null);
+var ee = async (e, r) => {
+	let t = ve(e);
+	if (r) {
+		let o = Array.isArray(r) ? r : [r];
+		t.push(...await Ie(o));
+	}
+	let n = /* @__PURE__ */ new Set();
+	return t.map((o) => {
+		let i = re(o.path, n);
+		return n.add(i), i === o.path ? o : (y().warn(`Duplicate archive path "${o.path}" \u2014 storing as "${i}".`), {
+			...o,
+			path: i,
+			fileName: i.slice(i.lastIndexOf("/") + 1)
+		});
+	});
+};
+async function Ne(e, r) {
+	let { zip: t, strToU8: n } = await import('./esm.js-5PXzLulY.js'), o = {}, i = /* @__PURE__ */ new Set();
+	e.forEach((l) => {
+		let d = re(l.path, i);
+		i.add(d), d !== l.path && y().warn(`Duplicate archive path "${l.path}" \u2014 storing as "${d}".`), o[d] = typeof l.content == "string" ? n(l.content) : l.content;
+	});
+	let c = await new Promise((l, d) => {
+		t(o, { level: 6 }, (a, g) => a ? d(a) : l(g));
+	});
+	Ce(new Blob([c], { type: "application/zip" }), `${r}.zip`);
+}
+function re(e, r) {
+	if (!r.has(e)) return e;
+	let t = e.lastIndexOf("/"), n = e.lastIndexOf("."), o = n > t ? n : e.length, i = e.slice(0, o), c = e.slice(o);
+	for (let s = 2;; s++) {
+		let l = `${i}-${s}${c}`;
+		if (!r.has(l)) return l;
+	}
+}
+function Ce(e, r) {
+	if (typeof document > "u") throw new f("saveFile requires a browser environment with DOM API access.", u.BROWSER_ONLY, { context: {
+		function: "saveFile",
+		requiredAPI: "document"
+	} });
+	let t = URL.createObjectURL(e), n = document.createElement("a");
+	n.href = t, n.download = r, document.body.appendChild(n), n.click(), n.remove(), setTimeout(() => URL.revokeObjectURL(t), 1e4);
+}
+
+export { De as D, E, Le as L, N, Oe as O, be as a, b, Ee as c, ue as d, f, he as h, le as l, pe as p, u, we as w, y };
+//# sourceMappingURL=chunk-AYH5O3VG.js-YiX3ZqeT.js.map