chore: include build artifacts for HF

dist/index.mjs

@@ -0,0 +1,1909 @@
+import { Elysia } from "elysia";
+import { logger } from "@chneau/elysia-logger";
+import { cors } from "@elysiajs/cors";
+import { css } from "@emotion/css";
+import util from "node:util";
+import * as txtgen from "txtgen";
+import * as randomwordslugs from "random-word-slugs";
+import axios, { AxiosError } from "axios";
+import createError from "http-errors";
+import { Hono } from "hono";
+import { cors as cors$1 } from "hono/cors";
+import { logger as logger$1 } from "hono/logger";
+import { trimTrailingSlash } from "hono/trailing-slash";
+import { proxy } from "hono/proxy";
+import ky from "ky";
+import { stream } from "hono/streaming";
+import { alphabet, generateRandomString } from "oslo/crypto";
+import random from "random-string-generator";
+import * as fflate from "fflate";
+import * as devalue from "devalue";
+import { sValidator } from "@hono/standard-validator";
+import * as v from "valibot";
+import prettify from "html-prettify";
+
+//#region ../../../packages/lib/env.runtime.ts
+let ENV_VAR_DB = {};
+/**
+* Detects the current JavaScript runtime environment.
+* Works for Bun, Node.js, Deno, or Browser contexts.
+*/
+function detectRuntime() {
+	if (typeof Bun !== "undefined" && typeof Bun.version === "string") return "bun";
+	if (typeof Deno !== "undefined" && typeof Deno.version === "object") return "deno";
+	if (typeof process !== "undefined" && typeof process.versions === "object" && !!process.versions.node) return "node";
+	if (typeof window !== "undefined" || typeof self !== "undefined") return "browser";
+	return "unknown";
+}
+/**
+* Convenience boolean flags
+*/
+const IS_BUN = detectRuntime() === "bun";
+const IS_NODE = detectRuntime() === "node";
+const IS_DENO = detectRuntime() === "deno";
+const IS_BROWSER = detectRuntime() === "browser";
+const APP_ENV$1 = (IS_DENO || IS_BUN || IS_NODE ? process?.env?.APP_ENV : void 0) || ENV_VAR_DB?.APP_ENV;
+const NODE_ENV = (IS_DENO || IS_BUN || IS_NODE ? process?.env?.NODE_ENV : void 0) || ENV_VAR_DB?.NODE_ENV;
+async function set_env_var_db() {
+	try {
+		const ENV_VAR_JSON_DB = IS_DENO || IS_BUN || IS_NODE ? process?.env?.ENV_VAR_JSON_DB : import.meta.env.ENV_VAR_JSON_DB;
+		const ID = IS_DENO || IS_BUN || IS_NODE ? process?.env?.ID : import.meta.env.ID;
+		if (NODE_ENV === "production") {
+			if (!ENV_VAR_JSON_DB) {
+				console.log(`❌ ENV_VAR_JSON_DB:`, ENV_VAR_JSON_DB);
+				return;
+			}
+			if (ENV_VAR_JSON_DB) console.log(`✅ ENV_VAR_JSON_DB:`, ENV_VAR_JSON_DB);
+		}
+		if (!ENV_VAR_JSON_DB) return;
+		let R_ = await (await fetch(ENV_VAR_JSON_DB)).json();
+		if (!R_ || typeof R_ !== "object") return;
+		(() => {
+			if (!Array.isArray(R_) || !ID) return;
+			const _data = R_.find((xx) => xx?._ID === ID);
+			if (!_data) return;
+			const _new = { ..._data };
+			const _R_ = R_;
+			R_ = _new;
+			const app_env = _new.APP_ENV;
+			if (!app_env) return;
+			const __data = _R_.find((xx) => xx[`${app_env}`])?.[`${app_env}`];
+			if (typeof __data !== "object" || Array.isArray(__data)) return;
+			R_ = {
+				...R_,
+				...__data
+			};
+		})();
+		(() => {
+			if (typeof R_ !== "object" || Array.isArray(R_)) {
+				R_ = {};
+				return;
+			}
+			ENV_VAR_DB = R_;
+			set({ kv: R_ });
+		})();
+		function set(arg0) {
+			const { kv } = arg0;
+			const remoteEnvKV = kv;
+			for (const [key, value] of Object.entries(remoteEnvKV)) if (process && !process.env[key] && typeof value === "string" && !key.startsWith("_")) process.env[key] = value;
+		}
+		return R_;
+	} catch (error) {
+		console.error("❌ Failed to load remote env vars:", error);
+	}
+}
+const IS_CLOUDFLARE_WORKER = `${IS_BUN || IS_NODE ? process?.env?.IS_CLOUDFLARE_WORKER : void 0}` === "1";
+const IS_VERCEL_WORKER = `${IS_BUN || IS_NODE ? process?.env?.IS_VERCEL_WORKER || process?.env?.VERCEL : void 0}` === "1";
+const IS_SERVERLESS_ENV = `${IS_BUN || IS_NODE ? process?.env?.IS_SERVERLESS_ENV || process?.env?.VERCEL : void 0}` === "1";
+const NITRO_PRESET = IS_DENO || IS_BUN || IS_NODE ? process?.env?.NITRO_PRESET : void 0;
+const IS_RENDER_COM = (IS_DENO || IS_BUN || IS_NODE ? process?.env?.IS_RENDER_COM : void 0) === "1" || NITRO_PRESET === "render_com";
+const IS_PROD = NODE_ENV === "production" || APP_ENV$1 && [
+	"prod",
+	"pre_prod",
+	"pprod"
+].includes(APP_ENV$1);
+async function browser_check_book() {
+	if (!IS_BROWSER) return;
+	const prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
+	const isChromium = !!window.chrome;
+	const isFirefox = typeof window.InstallTrigger !== "undefined" || CSS.supports("-moz-appearance", "none");
+	const lowMemory = (navigator.deviceMemory ?? 8) <= 4;
+	const lowCPU = navigator.hardwareConcurrency <= 4;
+	/Android|iPhone|iPad|iPod|webOS|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) || "ontouchstart" in window && navigator.maxTouchPoints > 1 && /Windows/i.test(navigator.userAgent);
+	const mobileUA = /Android|iPhone|iPad|iPod|webOS|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+	const isMobilePlatform = /Android|iPhone|iPad|iPod/i.test(navigator.platform ?? "");
+	return {
+		isChromium,
+		isFirefox,
+		lowCPU,
+		lowMemory,
+		prefersReducedMotion,
+		isMobile: mobileUA || isMobilePlatform,
+		animation_performance: checkAnimationPerformance
+	};
+	function checkAnimationPerformance() {
+		return new Promise((resolve) => {
+			if (document.hidden) document.addEventListener("visibilitychange", run, { once: true });
+			else run();
+			function run() {
+				let frameCount = 0;
+				let lastTime = performance.now();
+				const drops = [];
+				function measure(now) {
+					const delta = now - lastTime;
+					drops.push(delta);
+					lastTime = now;
+					frameCount++;
+					if (frameCount < 30) requestAnimationFrame(measure);
+					else resolve({ avg: drops.slice(5).reduce((a, b) => a + b, 0) / (drops.length - 5) });
+				}
+				requestAnimationFrame(measure);
+			}
+		});
+	}
+}
+const NS_runtime = {
+	detectRuntime,
+	IS_BUN,
+	IS_BROWSER,
+	IS_DENO,
+	IS_NODE,
+	IS_CLOUDFLARE_WORKER,
+	IS_VERCEL_WORKER,
+	IS_SERVERLESS_ENV,
+	IS_PROD,
+	IS_RENDER_COM,
+	browser_check_book,
+	set_env_var_db,
+	ENV_VAR_DB
+};
+
+//#endregion
+//#region ../../../packages/lib/astro-environment.ts
+const APP_ENV = () => {
+	if (IS_BUN || IS_NODE) return NS_runtime.ENV_VAR_DB?.APP_ENV || process?.env?.APP_ENV;
+	if (IS_BROWSER) return import.meta.env?.PUBLIC_APP_ENV;
+};
+const dev = APP_ENV() === "dev" || import.meta?.env?.DEV;
+const browser = NS_runtime.IS_BROWSER || import.meta?.env?.SSR;
+const version = "1";
+
+//#endregion
+//#region ../../../packages/lib/helpers/client/misc.ts
+function isUrlEncoded(str) {
+	try {
+		return decodeURIComponent(str) !== str;
+	} catch (e) {
+		return false;
+	}
+}
+function F_is_within_range(arg0) {
+	const { value, min, max } = arg0;
+	const numValue = typeof value === "string" ? parseFloat(value) : value;
+	if (typeof numValue === "number" && !isNaN(numValue)) return numValue >= min && numValue <= max;
+	return false;
+}
+function F_scroll_to_top() {
+	window.scrollTo({
+		top: 0,
+		behavior: "smooth"
+	});
+}
+async function F_copy_to_clipboard(arg0) {
+	const { text } = arg0;
+	try {
+		await navigator.clipboard.writeText(text);
+		F_console_log({
+			ENV: "dev",
+			_browser: true,
+			_log: ["Text copied to clipboard:", text]
+		});
+		return true;
+	} catch (err) {
+		F_console_error({
+			ENV: "dev",
+			_browser: true,
+			_log: ["Failed to copy text:", err]
+		});
+		return false;
+	}
+}
+function F_console_log(arg0) {
+	const { ENV, _browser, _log, _off } = arg0;
+	if (_off) return;
+	switch (ENV) {
+		case "all":
+			if (_browser && browser) console.log(..._log);
+			else if (!_browser && !browser) console.log(..._log);
+			break;
+		case "dev":
+			if (dev) {
+				if (_browser && browser) console.log(..._log);
+				else if (!_browser && !browser) console.log(..._log);
+			}
+			break;
+		case "prod":
+			if (!dev) {
+				if (_browser && browser) console.log(..._log);
+				else if (!_browser && !browser) console.log(..._log);
+			}
+			break;
+	}
+}
+function F_console_warn(arg0) {
+	const { ENV, _browser, _log, _off } = arg0;
+	if (_off) return;
+	switch (ENV) {
+		case "all":
+			if (_browser && browser) console.warn(..._log);
+			else if (!browser && !_browser) console.warn(..._log);
+			break;
+		case "dev":
+			if (dev) {
+				if (_browser && browser) console.warn(..._log);
+				else if (!_browser && !browser) console.warn(..._log);
+			}
+			break;
+		case "prod":
+			if (!dev) {
+				if (_browser && browser) console.warn(..._log);
+				else if (!_browser && !browser) console.warn(..._log);
+			}
+			break;
+	}
+}
+function F_console_error(arg0) {
+	const { ENV, _browser, _log, _off } = arg0;
+	if (_off) return;
+	switch (ENV) {
+		case "all":
+			if (_browser && browser) console.error(..._log);
+			else if (!_browser && !browser) console.error(..._log);
+			break;
+		case "dev":
+			if (dev) {
+				if (_browser && browser) console.error(..._log);
+				else if (!_browser && !browser) console.error(..._log);
+			}
+			break;
+		case "prod":
+			if (version) {
+				if (_browser && browser) console.error(..._log);
+				else if (!_browser && !browser) console.error(..._log);
+			}
+			break;
+	}
+}
+function F_handle_dynamic_link_nav(arg0) {
+	const { href, _target, download } = arg0;
+	const a = document.createElement("a");
+	if (href) a.setAttribute("href", href);
+	if (_target) a.setAttribute("_target", _target);
+	a.click();
+}
+function F_handle_dynamic_form(arg0) {
+	const { form_action } = arg0;
+	const styles = css`
+    display: none;
+  `;
+	const form = document.createElement("form");
+	if (form_action) {
+		form.method = "post";
+		form.action = form_action;
+	}
+	form.classList.add(styles);
+	const body = document.querySelector("body");
+	if (body) {
+		body.append(form);
+		form.submit();
+	}
+}
+const F_is_even = (num) => num % 2 === 0;
+const F_is_odd = (num) => num % 2 === 1;
+function F_is_record(obj) {
+	return typeof obj === "object" && obj !== null && !Array.isArray(obj) && !!obj && obj.constructor === Object;
+}
+function F_create_dynamic_btn(arg0) {
+	const { attrs } = arg0;
+	const btn = document.createElement("button");
+	attrs.forEach((XX) => {
+		btn.setAttribute(XX.attr_name, XX.attr_value);
+	});
+	return btn;
+}
+function F_check_unique_obj_entry(arg0) {
+	const { _array, new_entry } = arg0;
+	if (!Array.isArray(_array) || !NS_Misc.F_is_record(new_entry)) throw new Error("Invalid input: expected an array and a non-null object.");
+	return {
+		is_duplicate: _array.some((existingEntry) => JSON.stringify(existingEntry) === JSON.stringify(new_entry)),
+		entry: new_entry
+	};
+}
+function F_convert_circular_structure_to_twin_string(arg0) {
+	const { circular_structure } = arg0;
+	return util.inspect(circular_structure, {
+		showHidden: false,
+		depth: 2,
+		colors: false,
+		compact: false,
+		breakLength: void 0
+	});
+}
+function add_zero_if_less_than_ten(number) {
+	if (number < 10) return "0" + number;
+	else return number.toString();
+}
+function F_extract_numbers_from_string_pattern(arg0) {
+	const { str } = arg0;
+	const matches = str.match(/\d+/g);
+	if (matches) return matches.map(Number);
+	return [];
+}
+function F_extract_number_from_end_string(arg0) {
+	const { str } = arg0;
+	if (!str) return null;
+	const match = str.match(/(\d+)$/);
+	if (match && match[1]) return parseInt(match[1], 10);
+	else return null;
+}
+function F_lock_scroll() {
+	window.scrollY;
+	document.body.style.overflow = "hidden";
+}
+function F_unlock_scroll() {
+	document.body.style.overflow = "";
+	delete document.body.dataset.scrollY;
+}
+function F_create_delay(arg0) {
+	const { ms } = arg0;
+	if (typeof ms !== "number") return;
+	return new Promise((r) => setTimeout(r, ms));
+}
+function F_shuffle_array(arg0) {
+	const { arr } = arg0;
+	for (let i = arr.length - 1; i > 0; i--) {
+		const j = Math.floor(Math.random() * (i + 1));
+		[arr[i], arr[j]] = [arr[j], arr[i]];
+	}
+	return arr;
+}
+function F_gen_placeholder_text(arg0) {
+	const { text } = arg0;
+	switch (text) {
+		case "word": return randomwordslugs.generateSlug(arg0.word_count, arg0.options);
+		case "sentence": return txtgen.sentence();
+		case "paragraph": return txtgen.paragraph();
+		case "article": return txtgen.article();
+		case "lorem": return txtgen.lorem(arg0.word_min, arg0.word_max);
+	}
+}
+function equals_ignore_str_case(a, b) {
+	return typeof a === "string" && typeof b === "string" && a.toLowerCase() === b.toLowerCase();
+}
+function flatten_object(obj, prefix = "") {
+	const result = {};
+	for (const key in obj) {
+		const fullKey = prefix ? `${prefix}.${key}` : key;
+		if (typeof obj[key] === "object" && obj[key] !== null && !Array.isArray(obj[key])) Object.assign(result, flatten_object(obj[key], fullKey));
+		else result[fullKey] = obj[key];
+	}
+	return result;
+}
+function F_remove_last_array_element(arg0) {
+	const { arr } = arg0;
+	if (arr.length > 0) arr.pop();
+	return arr;
+}
+function F_merge_arrays_by_keys(arg0) {
+	const { arrays, keys, deep_merge } = arg0;
+	const map = /* @__PURE__ */ new Map();
+	const make_key = (item) => keys.map((k) => String(item[k])).join("_");
+	for (const arr of arrays) for (const item of arr) {
+		const key = make_key(item);
+		if (map.has(key)) if (deep_merge) map.set(key, F_deep_merge({
+			target: map.get(key),
+			source: item,
+			array_strategy: deep_merge.array_strategy
+		}));
+		else map.set(key, {
+			...map.get(key),
+			...item
+		});
+		else map.set(key, { ...item });
+	}
+	return Array.from(map.values());
+}
+function F_deep_merge(arg0) {
+	const { target, source, array_strategy } = arg0;
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const src_val = source[key];
+		const tgt_val = result[key];
+		if (Array.isArray(src_val)) if (array_strategy === "concat") result[key] = Array.isArray(tgt_val) ? [...tgt_val, ...src_val] : [...src_val];
+		else result[key] = src_val;
+		else if (src_val && typeof src_val === "object" && !Array.isArray(src_val)) result[key] = F_deep_merge({
+			target: tgt_val ?? {},
+			source: src_val,
+			array_strategy
+		});
+		else result[key] = src_val;
+	}
+	return result;
+}
+/**
+* Extracts the code inside a function as a string.
+* Works for:
+*  - Regular functions
+*  - Arrow functions (block or expression body)
+*/
+function F_extract_function_body(arg0) {
+	const { fn } = arg0;
+	const fnString = fn.toString().trim();
+	if (fnString.includes("{")) return fnString.substring(fnString.indexOf("{") + 1, fnString.lastIndexOf("}")).trim();
+	const arrowIndex = fnString.indexOf("=>");
+	if (arrowIndex !== -1) return fnString.substring(arrowIndex + 2).trim().replace(/^(\(|\s)*return\s+/, "").trim();
+	return fnString;
+}
+/**
+* Sets a cookie in the browser with a specified TTL (time-to-live)
+*/
+function set_dom_cookie(arg0) {
+	const { name, value, ttl, sameSite = "Lax", secure = true } = arg0;
+	let expires = "";
+	let milliseconds = 0;
+	switch (ttl.duration) {
+		case "seconds":
+			milliseconds = ttl.value * 1e3;
+			break;
+		case "minutes":
+			milliseconds = ttl.value * 60 * 1e3;
+			break;
+		case "hours":
+			milliseconds = ttl.value * 60 * 60 * 1e3;
+			break;
+		case "days":
+			milliseconds = ttl.value * 24 * 60 * 60 * 1e3;
+			break;
+	}
+	const date = /* @__PURE__ */ new Date();
+	date.setTime(date.getTime() + milliseconds);
+	expires = "; expires=" + date.toUTCString();
+	let cookieString = name + "=" + (value || "") + expires + "; path=/";
+	cookieString += "; SameSite=" + sameSite;
+	if (secure) cookieString += "; Secure";
+	document.cookie = cookieString;
+}
+/**
+* Gets a cookie value by name from the browser
+* @returns The cookie value if found, null otherwise
+*/
+function get_dom_cookie(name) {
+	const nameEQ = name + "=";
+	const cookies = document.cookie.split(";");
+	for (let i = 0; i < cookies.length; i++) {
+		let cookie = cookies[i];
+		if (!cookie) continue;
+		while (cookie.charAt(0) === " ") cookie = cookie.substring(1);
+		if (cookie.indexOf(nameEQ) === 0) return cookie.substring(nameEQ.length);
+	}
+	return null;
+}
+function F_is_fetch_response(obj) {
+	return obj && typeof obj.json === "function" && typeof obj.text === "function" && "ok" in obj && "status" in obj;
+}
+function F_update_page_title(newTitle) {
+	document.title = newTitle;
+}
+function F_update_meta_description(newDescription) {
+	const metaDescriptionTag = document.querySelector("meta[name=\"description\"]");
+	if (metaDescriptionTag) metaDescriptionTag.setAttribute("content", newDescription);
+	else {
+		const newMetaTag = document.createElement("meta");
+		newMetaTag.name = "description";
+		newMetaTag.content = newDescription;
+		document.head.appendChild(newMetaTag);
+	}
+}
+function F_update_open_graph_tags(metadata) {
+	const tags = {
+		"og:title": metadata.title,
+		"og:description": metadata.desc,
+		"og:image": metadata.image,
+		"og:image:alt": metadata.title && metadata.image && `${metadata.title} thumbnail`
+	};
+	for (const [property, content] of Object.entries(tags)) {
+		let element = content && document.querySelector(`meta[property="${property}"]`);
+		if (!element) continue;
+		if (content) element.setAttribute("content", content);
+	}
+}
+function F_get_inner_fn_content(arg0) {
+	const { fn } = arg0;
+	let FN_STRING = fn.toString();
+	FN_STRING = FN_STRING.slice(FN_STRING.indexOf("{") + 1, FN_STRING.lastIndexOf("}")).trim();
+	return FN_STRING;
+}
+/**
+* Converts an array of name/value pairs into a single object.
+*/
+function F_obj_array_to_object(arg0) {
+	const { obj_array } = arg0;
+	return obj_array.reduce((acc, { name, value }) => {
+		acc[name] = value;
+		return acc;
+	}, {});
+}
+function F_get_mime_type(arg0) {
+	const { ext } = arg0;
+	return { mime_type: {
+		".html": "text/html",
+		".txt": "text/plain",
+		".xml": "application/xml",
+		".json": "application/json",
+		".csv": "text/csv",
+		".pdf": "application/pdf",
+		".js": "application/javascript",
+		".mjs": "application/javascript",
+		".css": "text/css",
+		".map": "application/json",
+		".png": "image/png",
+		".jpg": "image/jpeg",
+		".jpeg": "image/jpeg",
+		".gif": "image/gif",
+		".svg": "image/svg+xml",
+		".webp": "image/webp",
+		".avif": "image/avif",
+		".ico": "image/x-icon",
+		".mp3": "audio/mpeg",
+		".wav": "audio/wav",
+		".ogg": "audio/ogg",
+		".mp4": "video/mp4",
+		".webm": "video/webm",
+		".ogv": "video/ogg",
+		".m3u8": "application/vnd.apple.mpegurl",
+		".ts": "video/mp2t",
+		".woff": "font/woff",
+		".woff2": "font/woff2",
+		".ttf": "font/ttf",
+		".otf": "font/otf",
+		".zip": "application/zip",
+		".tar": "application/x-tar",
+		".gz": "application/gzip",
+		".wasm": "application/wasm"
+	}[!`${ext}`.startsWith(".") ? `.${ext}` : `${ext}`] || "application/octet-stream" };
+}
+const NS_Misc = {
+	F_is_within_range,
+	F_scroll_to_top,
+	F_copy_to_clipboard,
+	console: {
+		log: F_console_log,
+		warn: F_console_warn,
+		error: F_console_error
+	},
+	F_handle_dynamic_link_nav,
+	F_is_even,
+	F_is_odd,
+	F_is_record,
+	F_create_dynamic_btn,
+	F_check_unique_obj_entry,
+	F_convert_circular_structure_to_twin_string,
+	add_zero_if_less_than_ten,
+	F_extract_numbers_from_string_pattern,
+	F_handle_dynamic_form,
+	F_lock_scroll,
+	F_unlock_scroll,
+	F_create_delay,
+	F_shuffle_array,
+	F_gen_placeholder_text,
+	equals_ignore_str_case,
+	F_extract_number_from_end_string,
+	flatten_object,
+	F_remove_last_array_element,
+	F_merge_arrays_by_keys,
+	F_extract_function_body,
+	cookies: {
+		set_dom_cookie,
+		get_dom_cookie
+	},
+	F_is_fetch_response,
+	F_update_meta_description,
+	F_update_open_graph_tags,
+	F_update_page_title,
+	F_get_inner_fn_content,
+	isUrlEncoded,
+	F_obj_array_to_object,
+	F_get_mime_type
+};
+
+//#endregion
+//#region ../../../packages/lib/helpers/client/error.ts
+function F_collect_error_status_n_message(arg0) {
+	const { ERR } = arg0;
+	try {
+		const is_axios_err = ERR instanceof AxiosError;
+		let status = ERR?.status_code || ERR?.status || is_axios_err && ERR.response?.status || 500;
+		let message = ERR?.status_message || is_axios_err && (ERR.response?.data?.message || ERR.response?.data?.status_message || ERR.response?.statusText) || ERR?.message || ERR?.error || ERR?.code || "Unexpected error";
+		if (typeof ERR == "string" && ERR.length > 0) message = ERR;
+		if (message === "ECONNREFUSED") message = "network connection refused";
+		if (is_axios_err) {
+			const headers = ERR.response?.headers;
+			if (headers) {
+				status = headers["x-error-status"] || status;
+				message = headers["x-error-message"] || message;
+			}
+		}
+		status = parseInt(`${status}`);
+		if (typeof message !== "string") message = JSON.stringify(message);
+		message = String(message).trim();
+		return {
+			status,
+			message
+		};
+	} catch (error) {
+		return {
+			status: 500,
+			message: "Oops! Unexpected system error"
+		};
+	}
+}
+function F_collect_error_message(arg0) {
+	const { ERR } = arg0;
+	const { message } = F_collect_error_status_n_message({ ERR });
+	return { message };
+}
+function F_create_error(arg0) {
+	const { status, message, ERR } = arg0;
+	if (!message) switch (status) {
+		case 400: return new createError.BadRequest();
+		case 401: return new createError.Unauthorized();
+		case 402: return new createError.PaymentRequired();
+		case 403: return new createError.Forbidden();
+		case 404: return new createError.NotFound();
+		case 405: return new createError.MethodNotAllowed();
+		case 406: return new createError.NotAcceptable();
+		case 407: return new createError.ProxyAuthenticationRequired();
+		case 408: return new createError.RequestTimeout();
+		case 409: return new createError.Conflict();
+		case 410: return new createError.Gone();
+		case 411: return new createError.LengthRequired();
+		case 412: return new createError.PreconditionFailed();
+		case 413: return new createError.PayloadTooLarge();
+		case 414: return new createError.URITooLong();
+		case 415: return new createError.UnsupportedMediaType();
+		case 416: return new createError.RangeNotSatisfiable();
+		case 417: return new createError.ExpectationFailed();
+		case 418: return new createError.ImATeapot();
+		case 421: return new createError.MisdirectedRequest();
+		case 422: return new createError.UnprocessableEntity();
+		case 423: return new createError.Locked();
+		case 424: return new createError.FailedDependency();
+		case 425: return new createError.TooEarly();
+		case 426: return new createError.UpgradeRequired();
+		case 428: return new createError.PreconditionRequired();
+		case 429: return new createError.TooManyRequests();
+		case 431: return new createError.RequestHeaderFieldsTooLarge();
+		case 451: return new createError.UnavailableForLegalReasons();
+		case 500: return new createError.InternalServerError();
+		case 501: return new createError.NotImplemented();
+		case 502: return new createError.BadGateway();
+		case 503: return new createError.ServiceUnavailable();
+		case 504: return new createError.GatewayTimeout();
+		case 505: return new createError.HTTPVersionNotSupported();
+		case 506: return new createError.VariantAlsoNegotiates();
+		case 507: return new createError.InsufficientStorage();
+		case 508: return new createError.LoopDetected();
+		case 509: return new createError.BandwidthLimitExceeded();
+		case 510: return new createError.NotExtended();
+		case 511: return new createError.NetworkAuthenticationRequire();
+	}
+	if (ERR && !message) {
+		const { message } = F_collect_error_message({ ERR });
+		return createError(status, message);
+	}
+	return createError(status, message);
+}
+const NS_error = {
+	F_collect_error_status_n_message,
+	F_collect_error_message,
+	F_create_error
+};
+
+//#endregion
+//#region ../../../packages/lib/helpers/server/routes-elysia.ts
+function F_public_origin(c) {
+	return `${c.headers["x-forwarded-proto"] ?? "http"}://${c.headers["x-forwarded-host"] ?? c.headers.host}`;
+}
+const NS_routes_elysia = { F_public_origin };
+
+//#endregion
+//#region ../../../packages/lib/helpers/client/promise.ts
+(IS_BUN || IS_NODE) && process?.env?.APP_ENV || NS_runtime.ENV_VAR_DB?.APP_ENV;
+function F_catch_promise(arg0) {
+	const { promise } = arg0;
+	if (!promise) return Promise.resolve([/* @__PURE__ */ new Error("No promise provided"), void 0]);
+	return promise.then((data) => {
+		return [void 0, data];
+	}).catch((error) => {
+		return [error, void 0];
+	});
+}
+async function F_try_catch(arg0) {
+	const { logic } = arg0;
+	try {
+		return [void 0, await logic()];
+	} catch (error) {
+		return [error, void 0];
+	}
+}
+async function F_catch_fetch(arg0) {
+	const { promise, parse } = arg0;
+	try {
+		const response = await promise;
+		if (!response) throw new Error("Response is undefined");
+		if (!response.ok) {
+			const x_message = response.headers.get("x-error-message");
+			const { status, message } = NS_error.F_collect_error_status_n_message({ ERR: parse && [
+				"json",
+				"text",
+				"html"
+			].includes(parse) ? await response.clone().text() : response });
+			NS_Misc.console.warn({
+				ENV: "dev",
+				_browser: false,
+				_log: ["FETCH RES NOT OK ==>", response],
+				_off: true
+			});
+			return [createError(status, x_message || message || `HTTP Error: ${response.status} ${response.statusText}`), void 0];
+		}
+		if (parse === void 0) return [void 0, response];
+		let content;
+		switch (parse) {
+			case "json":
+				content = await response.json();
+				break;
+			case "blob":
+				content = await response.blob();
+				break;
+			case "arrayBuffer":
+				content = await response.arrayBuffer();
+				break;
+			case "html":
+			case "text":
+				content = await response.text();
+				break;
+			default: {
+				const _exhaustive = parse;
+				throw new Error(`Unhandled parse type: ${_exhaustive}`);
+			}
+		}
+		return [void 0, content];
+	} catch (error) {
+		return [error instanceof Error ? error : new Error(String(error)), void 0];
+	}
+}
+async function F_first_come_fetch_promise(arg0) {
+	const { fetch_batch, response_parse } = arg0;
+	let { timeoutMs } = arg0;
+	if (!timeoutMs) timeoutMs = 5e3;
+	const controllers = fetch_batch.map(() => new AbortController());
+	const fetchPromises = fetch_batch.map(async (xx, index) => {
+		const controller = controllers[index];
+		const timeout = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			const [_E, _R] = await NS_promise.F_catch_fetch({
+				promise: fetch(xx.endpoint, {
+					...xx.config || {},
+					signal: controller.signal
+				}),
+				parse: response_parse
+			});
+			clearTimeout(timeout);
+			if (_E) {
+				const { message } = NS_error.F_collect_error_message({ ERR: _E });
+				NS_Misc.console.warn({
+					ENV: "dev",
+					_browser: false,
+					_log: [
+						"\n",
+						"FETCH RES NOT OK ==>",
+						xx.endpoint,
+						message,
+						"\n"
+					],
+					_off: true
+				});
+				throw new Error(`Bad status from ${xx.endpoint}: ${message}`);
+			}
+			const response = _R;
+			return {
+				endpoint: xx.endpoint,
+				[response_parse === "json" ? "json" : response_parse === "blob" ? "blob" : response_parse === "arrayBuffer" ? "arrayBuffer" : response_parse === "html" ? "html" : "text"]: response
+			};
+		} catch (err) {
+			clearTimeout(timeout);
+			throw err;
+		}
+	});
+	try {
+		const result = await Promise.any(fetchPromises);
+		controllers.forEach((controller) => controller.abort());
+		return result;
+	} catch (err) {
+		throw new Error("All endpoints failed or timed out.");
+	}
+}
+async function F_fetch_ping(arg0) {
+	const { url, options, timeout = 5e3 } = arg0;
+	const controller = new AbortController();
+	const id = setTimeout(() => controller.abort(), timeout);
+	try {
+		const response = await fetch(url, {
+			...options,
+			signal: controller.signal
+		});
+		clearTimeout(id);
+		if (!response.ok) return {
+			success: false,
+			error: `HTTP error: ${response.status}`
+		};
+		return { success: true };
+	} catch (err) {
+		clearTimeout(id);
+		if (err?.name === "AbortError") return {
+			success: false,
+			error: "Request timed out"
+		};
+		return {
+			success: false,
+			error: err.message
+		};
+	}
+}
+async function F_fetch_ping_v2(arg0) {
+	const { url, options, timeout = 5e3, method = "get" } = arg0;
+	try {
+		const response = await (async () => {
+			switch (method.toLowerCase()) {
+				case "get": return ky.get(url, {
+					...options,
+					timeout
+				});
+				case "post": return ky.post(url, {
+					...options,
+					timeout
+				});
+				case "head": return ky.head(url, {
+					...options,
+					timeout
+				});
+			}
+		})();
+		if (!response) return {
+			success: false,
+			error: `Response undefined`
+		};
+		if (!response.ok) return {
+			success: false,
+			error: `HTTP error: ${response.status}`
+		};
+		return { success: true };
+	} catch (error) {
+		if (error.name && ["AbortError", "TimeoutError"].includes(error.name)) return {
+			success: false,
+			error: "Request timed out"
+		};
+		const { message } = NS_error.F_collect_error_message({ ERR: error });
+		return {
+			success: false,
+			error: message
+		};
+	}
+}
+const NS_promise = {
+	F_catch_promise,
+	F_catch_fetch,
+	F_try_catch,
+	F_first_come_fetch_promise,
+	F_fetch_ping,
+	F_fetch_ping_v2
+};
+
+//#endregion
+//#region ../../../packages/lib/helpers/client/route.ts
+function F_flat_url_slash(url) {
+	const protocolMatch = url.match(/^(https?:\/\/)/);
+	let protocol = "";
+	let restOfUrl = url;
+	if (protocolMatch) {
+		protocol = protocolMatch[0];
+		restOfUrl = url.slice(protocol.length);
+	}
+	restOfUrl = restOfUrl.replace(/\/+/g, "/");
+	return (protocol + restOfUrl).trim();
+}
+function F_remove_protocol(url) {
+	const protocolMatch = url.match(/^(https?:\/\/)/);
+	let protocol = "";
+	let restOfUrl = url;
+	if (protocolMatch) {
+		protocol = protocolMatch[0];
+		restOfUrl = url.slice(protocol.length);
+	}
+	return restOfUrl;
+}
+function F_remove_url_params(arg0) {
+	const { url, paramsToRemove } = arg0;
+	try {
+		const urlObj = new URL(url);
+		paramsToRemove.forEach((param) => {
+			urlObj.searchParams.delete(param);
+		});
+		return urlObj.toString();
+	} catch (err) {
+		return url;
+	}
+}
+function F_update_search_params(arg0) {
+	const { url, params } = arg0;
+	try {
+		const url_obj = new URL(url);
+		params.forEach(({ key, value }) => {
+			if (value === null || value === void 0) url_obj.searchParams.delete(key);
+			else url_obj.searchParams.set(key, `${value}`);
+		});
+		return url_obj.toString();
+	} catch (error) {
+		return url;
+	}
+}
+function F_is_url(str) {
+	if (typeof str !== "string") {
+		if (!(str instanceof URL)) return;
+	}
+	try {
+		if (new URL(str.toString()).protocol.startsWith("http")) return true;
+		else return false;
+	} catch (error) {
+		return false;
+	}
+}
+function F_remove_origin(arg0) {
+	const { url } = arg0;
+	try {
+		const url_o = new URL(url);
+		const url_origin = url_o.origin;
+		return url_o.href.slice(url_origin.length);
+	} catch (error) {
+		return;
+	}
+}
+const NS_routes_c = {
+	F_flat_url_slash,
+	F_remove_protocol,
+	F_remove_url_params,
+	F_update_search_params,
+	F_is_url,
+	F_remove_origin
+};
+
+//#endregion
+//#region ../../../packages/lib/helpers/client/crypto.ts
+function F_generate_oslo_id(arg0) {
+	let { length } = arg0;
+	if (!length || typeof length !== "number") length = 20;
+	return generateRandomString(length, alphabet("a-z", "0-9"));
+}
+function F_gen_random_string(arg0) {
+	let { length, type } = arg0;
+	if (!length) length = 32;
+	if (!type) type = "alphanumeric";
+	if (typeof type === "object" && type.scoped) type = `scoped:${type.scoped}`;
+	return random(length, type);
+}
+function F_crypto_randomUUID(arg0) {
+	let { length } = arg0;
+	if (!length || length > 32) length = 36;
+	const uuid = crypto.randomUUID();
+	let newUUID = uuid.toString();
+	if (newUUID.length !== length) newUUID = uuid.split("-").join("").slice(0, length + 1);
+	return newUUID;
+}
+function F_base64_encode_unicode(arg0) {
+	const { data_str, url_safe } = arg0;
+	let _encode = btoa(encodeURIComponent(data_str).replace(/%([0-9A-F]{2})/g, (match, p1) => String.fromCharCode(parseInt(p1, 16))));
+	if (url_safe) _encode = F_to_url_safe_base64_encode(_encode);
+	return _encode;
+}
+function F_base64_decode_unicode(arg0) {
+	const { data_str, _is_url_safe } = arg0;
+	let _encode = data_str;
+	if (_is_url_safe) _encode = F_decode_from_url_safe_base64_encode(_encode);
+	return decodeURIComponent(atob(_encode).split("").map((c) => "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2)).join(""));
+}
+function F_b64_char_set() {
+	const _b64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	const _b64lookup = {};
+	for (let i = 0; i < 64; i++) _b64lookup[_b64chars[i]] = i;
+	return {
+		_b64chars,
+		_b64lookup
+	};
+}
+function F_base64_encode_unicode_v2(arg0) {
+	const { data_str, url_safe } = arg0;
+	const { _b64chars } = F_b64_char_set();
+	const bytes = new TextEncoder().encode(data_str);
+	let base64 = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const a = bytes[i];
+		const b = bytes[i + 1];
+		const c = bytes[i + 2];
+		if (a === void 0) continue;
+		const triplet = (a ?? 0) << 16 | (b ?? 0) << 8 | (c ?? 0);
+		base64 += (_b64chars[triplet >> 18 & 63] ?? "=") + (_b64chars[triplet >> 12 & 63] ?? "=") + (b !== void 0 ? _b64chars[triplet >> 6 & 63] ?? "=" : "=") + (c !== void 0 ? _b64chars[triplet & 63] ?? "=" : "=");
+	}
+	if (url_safe) base64 = F_to_url_safe_base64_encode(base64);
+	return base64;
+}
+function F_base64_decode_unicode_v2(arg0) {
+	let { data_str, _is_url_safe } = arg0;
+	const { _b64lookup } = F_b64_char_set();
+	if (_is_url_safe) data_str = F_decode_from_url_safe_base64_encode(data_str);
+	const clean = data_str;
+	const bytes = [];
+	for (let i = 0; i < clean.length; i += 4) {
+		const a = _b64lookup[clean[i] ?? ""] ?? 0;
+		const b = _b64lookup[clean[i + 1] ?? ""] ?? 0;
+		const c = _b64lookup[clean[i + 2] ?? ""] ?? 0;
+		const d = _b64lookup[clean[i + 3] ?? ""] ?? 0;
+		const triplet = a << 18 | b << 12 | (c ?? 0) << 6 | (d ?? 0);
+		bytes.push(triplet >> 16 & 255);
+		if (clean[i + 2] !== "=") bytes.push(triplet >> 8 & 255);
+		if (clean[i + 3] !== "=") bytes.push(triplet & 255);
+	}
+	return new TextDecoder().decode(new Uint8Array(bytes));
+}
+function F_encode_unicode_v1(arg0) {
+	const { data_payload, url_safe, encode } = arg0;
+	const data_str = devalue.stringify(data_payload);
+	if (!data_str || typeof data_str !== "string") throw new Error("data_str must be a string");
+	const u8Buffer = fflate.strToU8(data_str);
+	const compressed = fflate.compressSync(u8Buffer);
+	const compressed_str = String.fromCharCode(...compressed);
+	if (encode === "base64") return F_base64_encode_unicode_v2({
+		data_str: compressed_str,
+		url_safe
+	});
+	if (encode === "hex") {
+		const bytes = new TextEncoder().encode(compressed_str);
+		return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	let _ = compressed_str;
+	if (encode === "plain" && url_safe) _ = encodeURIComponent(_);
+	return _;
+}
+function F_decode_unicode_v1(arg0) {
+	let { data_str, _is_url_safe, encoded } = arg0;
+	const decoded = (() => {
+		if (encoded === "hex") {
+			const pairs = data_str.match(/.{1,2}/g) || [];
+			const bytes = new Uint8Array(pairs.map((byte) => parseInt(byte, 16)));
+			return new TextDecoder().decode(bytes);
+		}
+		if (encoded === "base64") return F_base64_decode_unicode_v2({
+			data_str,
+			_is_url_safe
+		});
+		if (encoded === "plain") {
+			let _ = data_str;
+			if (_is_url_safe) _ = decodeURIComponent(_);
+			return _;
+		}
+	})();
+	if (!decoded) return;
+	const len = decoded.length;
+	const bytes = new Uint8Array(len);
+	for (let i = 0; i < len; i++) bytes[i] = decoded.charCodeAt(i);
+	const decompressed = fflate.decompressSync(bytes);
+	const decompressed_str = fflate.strFromU8(decompressed);
+	return devalue.parse(decompressed_str);
+}
+function F_to_url_safe_base64_encode(base64Str) {
+	return base64Str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function F_decode_from_url_safe_base64_encode(urlSafeStr) {
+	let base64 = urlSafeStr.replace(/-/g, "+").replace(/_/g, "/");
+	while (base64.length % 4 !== 0) base64 += "=";
+	return base64;
+}
+function F_encode_to_light_URL(text) {
+	if (typeof text !== "string") throw new Error("Input must be a string");
+	const binary = text.split("").map((c) => c.charCodeAt(0).toString(2).padStart(16, "0")).join("");
+	const byteCount = Math.ceil(binary.length / 8);
+	const bytes = new Uint8Array(byteCount);
+	for (let i = 0; i < binary.length; i += 8) {
+		const byteString = binary.substr(i, 8);
+		bytes[i / 8] = parseInt(byteString, 2);
+	}
+	return btoa(String.fromCharCode(...bytes)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function F_decode_from_light_URL(encoded) {
+	if (!/^[A-Za-z0-9_-]*$/.test(encoded)) throw new Error("Invalid Base64URL format");
+	let base64 = encoded.replace(/-/g, "+").replace(/_/g, "/");
+	while (base64.length % 4) base64 += "=";
+	const str = atob(base64);
+	let binary = "";
+	for (let i = 0; i < str.length; i++) binary += str.charCodeAt(i).toString(2).padStart(8, "0");
+	const chunks = [];
+	for (let i = 0; i < binary.length; i += 16) {
+		const chunk = binary.substr(i, 16);
+		const codePoint = parseInt(chunk, 2);
+		if (isNaN(codePoint)) throw new Error("Invalid binary sequence detected");
+		chunks.push(String.fromCharCode(codePoint));
+	}
+	return chunks.join("");
+}
+const NS_crypto_client = {
+	F_generate_oslo_id,
+	F_gen_random_string,
+	F_crypto_randomUUID,
+	F_base64_encode_unicode,
+	F_base64_decode_unicode,
+	F_base64_encode_unicode_v2,
+	F_base64_decode_unicode_v2,
+	F_encode_unicode_v1,
+	F_decode_unicode_v1,
+	F_encode_to_light_URL,
+	F_decode_from_light_URL
+};
+
+//#endregion
+//#region ../../../packages/lib/helpers/server/playback.ts
+const M3U8_MAGIC_TAG = "#EXTM3U";
+/**
+* Return true if other resolutions are found, false if only 360p or 720p are found
+*/
+function F_m3u8_has_other_resolutions(m3u8) {
+	const regex360p = /\bRESOLUTION\s*=\s*[0-9]+x360\b/i;
+	const regex720p = /\bRESOLUTION\s*=\s*[0-9]+x720\b/i;
+	const regexOtherResolutions = /\bRESOLUTION\s*=\s*[0-9]+x(?!360|720)[0-9]+\b/i;
+	const has360p = regex360p.test(m3u8);
+	const has720p = regex720p.test(m3u8);
+	return regexOtherResolutions.test(m3u8) || !has360p && !has720p;
+}
+function F_get_adaptive_res_status(m3u8) {
+	const resRegex = /\bRESOLUTION\s*=\s*(\d+)x(\d+)\b/gi;
+	const resolutions = [];
+	let match;
+	while ((match = resRegex.exec(m3u8)) !== null) {
+		const width = parseInt(`${match[1] || 0}`, 10);
+		const height = parseInt(`${match[2] || 0}`, 10);
+		resolutions.push({
+			width,
+			height
+		});
+	}
+	return F_classify_rxd({ dx: resolutions });
+}
+function F_classify_rxd(arg0) {
+	const { dx } = arg0;
+	let hasHighRes = false;
+	let hasLowRes = false;
+	let hasMidRes = false;
+	for (let i = 0; i < dx.length; i++) {
+		const xx = dx[i];
+		const width = xx?.width;
+		const height = xx?.height;
+		if (typeof width !== "number" || typeof height !== "number") continue;
+		if (width >= 1920 || height >= 1080) hasHighRes = true;
+		if (height <= 700) hasLowRes = true;
+		if (height == 360 || width == 640) hasLowRes = true;
+		if (height > 700 && height < 1080 || width > 1e3 && width < 2e3) hasMidRes = true;
+	}
+	if (hasHighRes && hasMidRes && hasLowRes) return { fhd: true };
+	if (hasMidRes && hasLowRes || hasMidRes && hasHighRes || hasHighRes && hasLowRes) return { hd: true };
+}
+/**
+* Returns true if the manifest contains:
+* 1. At least one resolution >= 1080p (1920+ width OR 1080+ height)
+* 2. At least one resolution 480p >= 720p (1280+ width OR 720+ height OR 640+ width)
+* 3. At least one resolution <= 480p (480 height or less)
+*/
+function F_m3u8_has_high_mid_low_resolutions(m3u8) {
+	const resRegex = /\bRESOLUTION\s*=\s*(\d+)x(\d+)\b/gi;
+	let hasHighRes = false;
+	let hasLowRes = false;
+	let hasMidRes = false;
+	let match;
+	while ((match = resRegex.exec(m3u8)) !== null) {
+		const width = parseInt(`${match[1] || 0}`, 10);
+		const height = parseInt(`${match[2] || 0}`, 10);
+		if (width >= 1920 || height >= 1080) hasHighRes = true;
+		if (height <= 600) hasLowRes = true;
+		if (height == 360 || width == 640) hasLowRes = true;
+		if (height > 600 && height < 1080 || width > 640 && width < 1920) hasMidRes = true;
+		if (hasHighRes && hasLowRes && hasMidRes) return true;
+	}
+	return false;
+}
+function F_extract_resolutions_from_M3U8(arg0) {
+	const { m3u8Content, baseUrl } = arg0;
+	const results = [];
+	const lines = m3u8Content.trim().split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]?.trim() ?? "";
+		if (line.startsWith("#EXT-X-STREAM-INF:")) {
+			const streamInfo = {};
+			const resolutionMatch = line.match(/RESOLUTION=(\d+x\d+)/);
+			if (resolutionMatch) {
+				const resolution = resolutionMatch[1];
+				if (resolution) {
+					const [width, height] = resolution.split("x").map(Number);
+					streamInfo.resolution = resolution;
+					streamInfo.width = width;
+					streamInfo.height = height;
+				}
+			}
+			const bandwidthMatch = line.match(/BANDWIDTH=(\d+)/);
+			if (bandwidthMatch) {
+				const bandwidth = bandwidthMatch[1] ? parseInt(bandwidthMatch[1]) : 0;
+				streamInfo.bandwidth = bandwidth;
+				streamInfo.bitrateMbps = parseFloat((bandwidth / 1e6).toFixed(2));
+			}
+			const framerateMatch = line.match(/FRAME-RATE=([\d.]+)/);
+			if (framerateMatch) streamInfo.frameRate = parseFloat(framerateMatch[1] || "0");
+			const codecsMatch = line.match(/CODECS="([^"]+)"/);
+			if (codecsMatch) streamInfo.codecs = codecsMatch[1];
+			if (i + 1 < lines.length) {
+				const urlLine = lines[i + 1]?.trim();
+				if (urlLine && !urlLine.startsWith("#")) {
+					if (baseUrl && !urlLine.match(/^https?:\/\//)) streamInfo.url = new URL(urlLine, baseUrl).href;
+					else streamInfo.url = urlLine;
+					results.push(streamInfo);
+				}
+			}
+			const level = streamInfo;
+			streamInfo.qLevel = `${level.width}` === "3840" ? "4K" : `${level.width}` === "2048" ? "2K" : `${level.width}` === "1920" ? "1080P" : `${level.width}` === "1280" ? "720P" : `${level.width}` === "854" ? "480P" : `${level.width}` === "640" ? "360P" : `${level.height || level.quality}P`;
+		}
+	}
+	let data = { rxd: results };
+	if (results.length) {
+		const __ = F_classify_rxd({ dx: results.map((xx) => {
+			return {
+				width: xx.width,
+				height: xx.height
+			};
+		}) });
+		if (__) data = {
+			...data,
+			...__
+		};
+	}
+	return data;
+}
+async function F_transform_m3u8(arg0) {
+	const { content, true_origin, true_base, proxy_base, proxima_commands, search_params } = arg0;
+	if (!content || !content.trim() || !true_origin || !true_base || !proxy_base) return;
+	const [ERROR, RESULT] = await NS_promise.F_try_catch({ logic: function() {
+		return new URL(true_base, true_origin);
+	} });
+	if (ERROR || !RESULT) return;
+	const true_url_o = RESULT;
+	let line_array = content.split("\n");
+	const is_media_playlist = content.includes("#EXTINF");
+	line_array = await Promise.all(line_array.map(async (line, i) => {
+		line = line.trim();
+		if (line.startsWith("#") || line === "") return line;
+		if (line.startsWith("//")) line = NS_routes_c.F_flat_url_slash(true_url_o.protocol + "/" + line);
+		if (!line.startsWith("//") && !line.startsWith("http")) {
+			if (line.startsWith("./")) line = line.slice(1);
+			if (line.startsWith("/")) line = NS_routes_c.F_flat_url_slash(true_url_o.origin + "/" + line);
+			else line = NS_routes_c.F_flat_url_slash(true_url_o.href + "/" + line);
+		}
+		await (async () => {
+			if (RESULT && proxy_base.includes(RESULT.origin)) return;
+			const data = {
+				endpoint: line,
+				commands: {
+					...proxima_commands ? { ...proxima_commands } : {},
+					m3u8_playlist_child: true,
+					is_media_segment: is_media_playlist
+				}
+			};
+			const encoded_data = NS_crypto_client.F_base64_encode_unicode_v2({
+				data_str: devalue.stringify(data),
+				url_safe: true
+			});
+			line = NS_routes_c.F_flat_url_slash(proxy_base + "/" + encoded_data);
+		})();
+		if (NS_routes_c.F_is_url(line) && NS_Misc.F_is_record(search_params)) for (const [k, v] of Object.entries(search_params)) {
+			const _ = new URL(line);
+			if (typeof k === "string" && typeof v === "string") _.searchParams.set(k, v);
+			line = _.toString();
+		}
+		return line;
+	}));
+	return [...line_array].join("\n");
+}
+/**
+* Checks if a Response contains M3U8 content by inspecting its "magic" header.
+* Works even if Content-Type is missing or incorrect.
+*/
+async function F_is_M3U8_response(arg0) {
+	const { response } = arg0;
+	if (!response) return false;
+	try {
+		const reader = (typeof response.clone === "function" ? response.clone() : response).body?.getReader();
+		if (!reader) return false;
+		const { value, done } = await reader.read();
+		reader.releaseLock();
+		if (!value || done) return false;
+		return new TextDecoder().decode(value.slice(0, 10)).trim().startsWith(M3U8_MAGIC_TAG);
+	} catch (err) {
+		console.error("Error identifying manifest content:", err);
+		return false;
+	}
+}
+async function F_transform_m3u8_v2(arg0) {
+	const { content, true_origin, true_base, proxy_base, proxima_commands, search_params } = arg0;
+	if (!content || !content.trim() || !true_origin || !true_base || !proxy_base) return;
+	const [ERROR, RESULT] = await NS_promise.F_try_catch({ logic: function() {
+		return new URL(true_base, true_origin);
+	} });
+	if (ERROR || !RESULT) return;
+	const true_url_o = RESULT;
+	const is_media_playlist = content.includes("#EXTINF");
+	const transform_url = async (raw) => {
+		let line = raw.trim();
+		if (line.startsWith("//")) line = NS_routes_c.F_flat_url_slash(true_url_o.protocol + "/" + line);
+		if (!line.startsWith("//") && !line.startsWith("http")) {
+			if (line.startsWith("./")) line = line.slice(1);
+			if (line.startsWith("/")) line = NS_routes_c.F_flat_url_slash(true_url_o.origin + "/" + line);
+			else line = NS_routes_c.F_flat_url_slash(true_url_o.href + "/" + line);
+		}
+		if (!(RESULT && proxy_base.includes(RESULT.origin))) {
+			const data = {
+				endpoint: line,
+				commands: {
+					...proxima_commands ? { ...proxima_commands } : {},
+					m3u8_playlist_child: true,
+					is_media_segment: is_media_playlist
+				}
+			};
+			const encoded_data = NS_crypto_client.F_base64_encode_unicode_v2({
+				data_str: devalue.stringify(data),
+				url_safe: true
+			});
+			line = NS_routes_c.F_flat_url_slash(proxy_base + "/" + encoded_data);
+		}
+		if (NS_routes_c.F_is_url(line) && NS_Misc.F_is_record(search_params)) for (const [k, v] of Object.entries(search_params)) {
+			const _ = new URL(line);
+			if (typeof k === "string" && typeof v === "string") _.searchParams.set(k, v);
+			line = _.toString();
+		}
+		return line;
+	};
+	const URI_ATTR_RE = /URI="([^"]*)"/g;
+	const transform_tag_uris = async (line) => {
+		const matches = Array.from(line.matchAll(URI_ATTR_RE));
+		if (matches.length === 0) return line;
+		const replacements = await Promise.all(matches.map(async (m) => ({
+			index: m.index,
+			length: m[0].length,
+			new_uri: m[1] ? await transform_url(m[1]) : m[1]
+		})));
+		let result = "";
+		let cursor = 0;
+		for (const r of replacements) {
+			result += line.slice(cursor, r.index);
+			result += `URI="${r.new_uri}"`;
+			cursor = r.index + r.length;
+		}
+		result += line.slice(cursor);
+		return result;
+	};
+	return [...await Promise.all(content.split("\n").map(async (raw_line) => {
+		const line = raw_line.trim();
+		if (line === "") return line;
+		if (line.startsWith("#")) return line.includes("URI=") ? await transform_tag_uris(line) : line;
+		return await transform_url(line);
+	}))].join("\n");
+}
+function F_sbe_id(arg0) {
+	const { film_id, film_type } = arg0;
+	const title_id = `${film_type === "movie" ? "544" : film_type === "tv" ? "234" : film_type === "series" ? "651" : ""}${film_id}`;
+	title_id.startsWith("544") || title_id.startsWith("234") || title_id.startsWith("651");
+	return title_id;
+}
+const NS_playback_helper = {
+	F_m3u8_has_other_resolutions,
+	F_extract_resolutions_from_M3U8,
+	F_transform_m3u8,
+	M3U8_MAGIC_TAG,
+	F_is_M3U8_response,
+	F_m3u8_has_high_mid_low_resolutions,
+	F_get_adaptive_res_status,
+	F_transform_m3u8_v2,
+	F_sbe_id
+};
+
+//#endregion
+//#region ../../../packages/lib/helpers/server/proxima/unpack.ts
+const schema = v.object({
+	proxima_endpoint: v.pipe(v.string("Invalid proxy endpoint"), v.nonEmpty("proxima endpoint cannot be empty")),
+	proxima_commands: v.optional(v.pipe(v.string("Invalid proxima commands"), v.nonEmpty("proxima commands cannot be empty")))
+});
+const schema_2 = v.object({ proxima_encoded: v.pipe(v.string("Invalid proxy data"), v.nonEmpty("proxima data cannot be empty")) });
+async function F_unpack_proxima_endpoint(arg0) {
+	const { proxima_endpoint } = arg0;
+	const [E_, decoded_proxy_endpoint] = await NS_promise.F_catch_promise({ promise: (async () => {
+		if (!proxima_endpoint) return;
+		const fine_str = proxima_endpoint.replace(/[.:;|><?&$#@!]+$/g, "");
+		const raw = NS_crypto_client.F_base64_decode_unicode_v2({
+			data_str: fine_str.trim(),
+			_is_url_safe: true
+		});
+		return new URL(decodeURI(raw));
+	})() });
+	if (E_) throw E_;
+	if (!decoded_proxy_endpoint) throw Error("proxy endpoint failed validation");
+	return { decoded_proxy_endpoint };
+}
+async function F_unpack_proxima_commands(arg0) {
+	const { proxima_commands } = arg0;
+	if (!proxima_commands) return;
+	const [E_, decoded_proxy_commands] = await NS_promise.F_catch_promise({ promise: (async () => {
+		const fine_str = proxima_commands.replace(/[.:;|><?&$#@!]+$/g, "");
+		const data_str = NS_crypto_client.F_base64_decode_unicode_v2({
+			data_str: fine_str.trim(),
+			_is_url_safe: true
+		});
+		try {
+			return devalue.parse(data_str);
+		} catch (error) {
+			return JSON.parse(data_str);
+		}
+	})() });
+	if (E_) throw E_;
+	if (proxima_commands && !decoded_proxy_commands) throw Error("proxy commands failed validation");
+	return { decoded_proxy_commands };
+}
+async function F_unpack_proxima_encoded(arg0) {
+	const { proxima_encoded } = arg0;
+	if (!proxima_encoded) return;
+	let [E_, decoded_proxima_data] = await NS_promise.F_catch_promise({ promise: (async () => {
+		const fine_str = proxima_encoded.replace(/[.:;|><?&$#@!]+$/g, "");
+		const data_str = NS_crypto_client.F_base64_decode_unicode_v2({
+			data_str: fine_str.trim(),
+			_is_url_safe: true
+		});
+		try {
+			return devalue.parse(data_str);
+		} catch (error) {
+			return JSON.parse(data_str);
+		}
+	})() });
+	if (E_) try {
+		const decoded_payload = NS_crypto_client.F_decode_unicode_v1({
+			data_str: proxima_encoded,
+			_is_url_safe: true,
+			encoded: "base64"
+		});
+		if (decoded_payload) decoded_proxima_data = decoded_payload;
+		else throw E_;
+	} catch {
+		throw E_;
+	}
+	if (typeof decoded_proxima_data !== "object" || !decoded_proxima_data.endpoint || typeof decoded_proxima_data.endpoint !== "string" || decoded_proxima_data.commands && typeof decoded_proxima_data.commands !== "object") throw Error("proxy data failed validation");
+	return {
+		decoded_proxy_endpoint: new URL(decoded_proxima_data.endpoint),
+		decoded_proxy_commands: decoded_proxima_data?.commands && NS_Misc.F_is_record(decoded_proxima_data.commands) ? decoded_proxima_data.commands : {}
+	};
+}
+async function F_unpack_proxima_endpoint_n_commands(arg0) {
+	const { proxima_encoded } = arg0;
+	const [E_, decoded_proxima_data] = await NS_promise.F_catch_promise({ promise: NS_unpack_proxima.F_unpack_proxima_encoded({ proxima_encoded }) });
+	if (E_) throw E_;
+	return decoded_proxima_data;
+}
+const NS_unpack_proxima = {
+	F_unpack_proxima_endpoint,
+	F_unpack_proxima_commands,
+	F_unpack_proxima_endpoint_n_commands,
+	F_unpack_proxima_encoded,
+	schema,
+	schema_2
+};
+
+//#endregion
+//#region ../../../packages/lib/helpers/client/proxy.ts
+const proxy_list_webshare_wootan = [
+	"http://yeilvlkp:l2qdqued8u6d@31.59.20.176:6754",
+	"http://yeilvlkp:l2qdqued8u6d@23.95.150.145:6114",
+	"http://yeilvlkp:l2qdqued8u6d@198.23.239.134:6540",
+	"http://yeilvlkp:l2qdqued8u6d@45.38.107.97:6014",
+	"http://yeilvlkp:l2qdqued8u6d@107.172.163.27:6543",
+	"http://yeilvlkp:l2qdqued8u6d@198.105.121.200:6462",
+	"http://yeilvlkp:l2qdqued8u6d@64.137.96.74:6641",
+	"http://yeilvlkp:l2qdqued8u6d@216.10.27.159:6837",
+	"http://yeilvlkp:l2qdqued8u6d@142.111.67.146:5611",
+	"http://yeilvlkp:l2qdqued8u6d@194.39.32.164:6461"
+];
+const F_get_random_proxy = (arg0) => {
+	const { proxyList } = arg0;
+	if (!proxyList || proxyList.length === 0) return null;
+	let rawProxy = proxyList[Math.floor(Math.random() * proxyList.length)];
+	if (!rawProxy) return;
+	return F_breakdown_proxy_url(rawProxy);
+};
+function F_breakdown_proxy_url(proxy_string) {
+	if (!proxy_string) return;
+	proxy_string = proxy_string.replace(/^,+|,+$/g, "").trim();
+	try {
+		const parsed = new URL(proxy_string);
+		return {
+			server: `${parsed.protocol}//${parsed.host}`,
+			username: decodeURIComponent(parsed.username),
+			password: decodeURIComponent(parsed.password)
+		};
+	} catch (e) {
+		console.error("Invalid Proxy URL:", proxy_string);
+		return null;
+	}
+}
+function F_get_random_proxy_auto() {
+	const proxyList = proxy_list_webshare_wootan;
+	if (!proxyList || proxyList.length === 0) return null;
+	return F_get_random_proxy({ proxyList });
+}
+function modify_request_headers(arg0) {
+	let { req_headers, new_headers, avoid_cert_val } = arg0;
+	let req0_headers = { ...req_headers };
+	const normalized_new_headers = Object.keys(new_headers).reduce((acc, key) => {
+		acc[key.toLowerCase()] = new_headers[key];
+		return acc;
+	}, {});
+	delete req0_headers["x-forwarded-for"];
+	delete req0_headers["true-client-ip"];
+	delete req0_headers["cf-ipcountry"];
+	delete req0_headers["cf-connecting-ip"];
+	delete req0_headers["x-request-start"];
+	delete req0_headers["rndr-id"];
+	delete req0_headers["render-proxy-ttl"];
+	delete req0_headers["x-real-ip"];
+	delete req0_headers["forwarded"];
+	delete req0_headers["x-forwarded-host"];
+	delete req0_headers["x-ip-token"];
+	delete req0_headers["cf-visitor"];
+	delete req0_headers["cf-ray"];
+	delete req0_headers["cdn-loop"];
+	delete req0_headers["x-invocation-id"];
+	delete req0_headers["x-amzn-trace-id"];
+	delete req0_headers["x-direct-url"];
+	delete req0_headers["x-forwarded-port"];
+	delete req0_headers["x-forwarded-proto"];
+	delete req0_headers["x-request-id"];
+	delete req0_headers["connection"];
+	delete req0_headers["accept-encoding"];
+	for (const [key, value] of Object.entries(req0_headers)) {
+		const lower_key = key.toLowerCase();
+		if (lower_key.startsWith("x-vercel")) delete req0_headers[key];
+		if (lower_key.toLowerCase().startsWith("x-")) delete req0_headers[key];
+		if (lower_key.toLowerCase().startsWith("eo-")) delete req0_headers[key];
+	}
+	if (avoid_cert_val) {
+		delete req0_headers["referer"];
+		delete req0_headers["origin"];
+		delete req0_headers["host"];
+		return req0_headers;
+	}
+	for (const [key, value] of Object.entries(req0_headers)) {
+		const lower_key = key.toLowerCase();
+		if ([
+			"host",
+			"origin",
+			"referer"
+		].includes(lower_key) && !normalized_new_headers[lower_key]) delete req0_headers[key];
+	}
+	new_headers = {
+		...req0_headers,
+		...normalized_new_headers
+	};
+	return new_headers;
+}
+const NS_proxy = {
+	F_get_random_proxy,
+	proxy_list_webshare_wootan,
+	F_get_random_proxy_auto,
+	modify_request_headers
+};
+
+//#endregion
+//#region ../../../packages/lib/helpers/server/proxima/html.ts
+const REPO_ORIGIN$1 = () => NS_runtime.ENV_VAR_DB?.REPO_ORIGIN || (NS_runtime.IS_BUN || NS_runtime.IS_DENO || NS_runtime.IS_NODE ? process?.env?.REPO_ORIGIN : void 0);
+async function F_transform_html_content(arg0) {
+	const cheerio = await import("cheerio");
+	const { html, target_endpoint, proxima_commands, REQ_ORIGIN } = arg0;
+	const $ = cheerio.load(html);
+	$(`[href]`).each((i, el) => {
+		const href = $(el).attr("href")?.trim();
+		if (href && !href.startsWith("//") && !href.startsWith("http")) {
+			const new_href = NS_routes_c.F_flat_url_slash(target_endpoint.origin + "/" + href);
+			$(el).attr("href", new_href);
+		}
+	});
+	$(`[src]`).each((i, el) => {
+		const src = $(el).attr("src")?.trim();
+		if (src && !src.startsWith("//") && !src.startsWith("http")) {
+			const new_src = NS_routes_c.F_flat_url_slash(target_endpoint.origin + "/" + src);
+			$(el).attr("src", new_src);
+		}
+	});
+	if (proxima_commands?.monkey_patch && NS_Misc.F_is_record(proxima_commands.monkey_patch)) {
+		const [ERROR, RESULT] = await NS_promise.F_catch_promise({ promise: axios({
+			method: "POST",
+			baseURL: REPO_ORIGIN$1(),
+			url: "/sd/monkey-patch",
+			data: {
+				filename: "client-monkey-patch.ts",
+				obfuscate: true,
+				proxy_origin: proxima_commands.monkey_patch?.alpha_proxy || REQ_ORIGIN,
+				monkey_config: proxima_commands.monkey_patch,
+				use_fs: true,
+				tool: "esbuild"
+			}
+		}) });
+		if (ERROR) console.error({ ERROR });
+		const data = RESULT?.data;
+		if (typeof data === "string") $("head").prepend(`<script>${data}<\/script>`);
+	}
+	return prettify($.html());
+}
+const NS_html_proxima = { F_transform_html_content };
+
+//#endregion
+//#region src/sub-router/proxima.ts
+process.env.X_OFFLINE;
+const APP_ORIGIN = () => NS_runtime.ENV_VAR_DB?.APP_ORIGIN || process?.env?.APP_ORIGIN;
+const REPO_ORIGIN = () => NS_runtime.ENV_VAR_DB?.REPO_ORIGIN || process.env.REPO_ORIGIN;
+const sub_router = new Hono().basePath("/proxima");
+sub_router.get("/:proxima_encoded", sValidator("param", NS_unpack_proxima.schema_2, (result, c) => {
+	if (!result.success) {
+		const message = result.error[0].message;
+		return c.text(message, 400);
+	}
+}), async (ctx) => {
+	const params = ctx.req.valid("param");
+	const query = ctx.req.query();
+	const REQ0 = new URL(ctx.req.url);
+	const REQ_ORIGIN = APP_ORIGIN() || REQ0.origin;
+	const REQ_headers = ctx.req.raw.headers;
+	const { proxima_encoded } = params;
+	const _is_proxima_h = REQ0.pathname.includes("/proxima-h/");
+	const [E_, R_] = await NS_promise.F_catch_promise({ promise: NS_unpack_proxima.F_unpack_proxima_endpoint_n_commands({ proxima_encoded }) });
+	if (E_ || !R_) {
+		const { status, message } = NS_error.F_collect_error_status_n_message({ ERR: E_ });
+		return ctx.text(message, status);
+	}
+	const { decoded_proxy_endpoint, decoded_proxy_commands } = R_;
+	decoded_proxy_commands?.iMovie_id || decoded_proxy_commands?.iFilm_id;
+	decoded_proxy_commands?.season;
+	decoded_proxy_commands?.episode;
+	decoded_proxy_commands?.picture_quality;
+	const og_endpoint = decoded_proxy_endpoint.href;
+	if (query?.ops === "decode") return ctx.json({
+		decoded_proxy_endpoint: og_endpoint,
+		decoded_proxy_commands
+	});
+	const replace_response_content_with = decoded_proxy_commands?.replace_response_content_with;
+	if (decoded_proxy_commands) delete decoded_proxy_commands.replace_response_content_with;
+	const req0_headers_object = Object.fromEntries(REQ_headers.entries());
+	const upstream_url = decoded_proxy_endpoint.href;
+	const send_headers = NS_proxy.modify_request_headers({
+		req_headers: req0_headers_object,
+		new_headers: decoded_proxy_commands?.headers || decoded_proxy_commands?.header || {},
+		avoid_cert_val: false
+	});
+	const fallback_env = "cloudflare";
+	const fallback_proxy = await (async () => {
+		if (REPO_ORIGIN() === REQ_ORIGIN) return;
+		const _ = new URL("/proxima/multiverse/next", REPO_ORIGIN());
+		_.searchParams.set("service_env", fallback_env);
+		const [E_, R_] = await NS_promise.F_catch_promise({ promise: ky.get(_.toString()).json() });
+		const proxy = R_?.data?.url;
+		if (!proxy) return;
+		const _u = new URL(REQ0.pathname, proxy);
+		if (query?.ops) _u.searchParams.set("ops", query.ops);
+		return _u.toString().replace("/proxima-h", "/proxima");
+	})();
+	const upstream_v2 = async () => {
+		const _1 = await proxy(upstream_url, {
+			headers: send_headers,
+			method: decoded_proxy_commands?.method || "GET",
+			body: decoded_proxy_commands?.upstream_payload ? JSON.stringify(decoded_proxy_commands.upstream_payload) : void 0
+		});
+		if (!_1 || !fallback_proxy) return _1;
+		const content_length = _1.headers.get("content-length");
+		if (_1.ok && content_length && parseInt(content_length) > 0) return _1;
+		if (query?.ch !== "1") return _1;
+		return _1;
+	};
+	const upstream = await upstream_v2();
+	if (!upstream) return new Response("upstream undefined", { status: 500 });
+	if (query?.ops === "raw") return upstream;
+	if (query?.ops === "raw2") {
+		const data = {
+			app: "hono",
+			REPO_ORIGIN: REPO_ORIGIN(),
+			APP_ORIGIN: APP_ORIGIN(),
+			fallback_env,
+			fallback_proxy,
+			status: upstream.status,
+			headers: Object.fromEntries(upstream.headers.entries()),
+			ok: upstream.ok
+		};
+		return ctx.json(data);
+	}
+	const content_length = upstream.headers.get("content-length");
+	if (decoded_proxy_commands?.redirect_origin && ([
+		"403",
+		"500",
+		"503",
+		"429",
+		"401",
+		"404"
+	].includes(`${upstream.status}`) || content_length && !parseInt(content_length)) && fallback_proxy) return ctx.redirect(fallback_proxy, 308);
+	upstream.headers.delete("content-security-policy");
+	upstream.headers.delete("x-frame-options");
+	upstream.headers.delete("link");
+	upstream.headers.delete("x-proxied-path");
+	upstream.headers.delete("x-proxied-host");
+	const resHeaders = new Headers(upstream.headers);
+	const res_headers_obj = Object.fromEntries(resHeaders.entries());
+	const content_type = resHeaders.get("content-type") ?? "";
+	if (!upstream.ok) return upstream;
+	if (replace_response_content_with) upstream.headers.delete("content-length");
+	const is_part_m3u8 = decoded_proxy_commands?.m3u8_playlist_child || await NS_playback_helper.F_is_M3U8_response({ response: upstream.clone() }) || content_type?.includes("application/vnd.apple.mpegurl") || content_type?.includes("application/x-mpegurl") || decoded_proxy_endpoint.toString().includes(".m3u8");
+	const is_m3u8 = content_type?.includes("application/vnd.apple.mpegurl") || content_type?.includes("application/x-mpegurl") || decoded_proxy_endpoint.toString().includes(".m3u8");
+	if (!decoded_proxy_commands?.m3u8_playlist_child && content_type?.includes("text/html") && !is_part_m3u8) return stream(ctx, async (stream) => {
+		ctx.header("Content-Encoding", "Identity");
+		ctx.status(upstream.status);
+		for (const key in res_headers_obj) if (Object.prototype.hasOwnProperty.call(res_headers_obj, key)) {
+			const element = res_headers_obj[key];
+			ctx.header(key, element);
+		}
+		set_manual_response_headers();
+		stream.onAbort(() => {
+			console.log("Aborted!");
+		});
+		await stream.write(await (async () => {
+			let html = replace_response_content_with || await upstream.text();
+			const [E_, rewritten] = await NS_promise.F_catch_promise({ promise: NS_html_proxima.F_transform_html_content({
+				html,
+				target_endpoint: decoded_proxy_endpoint,
+				proxima_commands: decoded_proxy_commands,
+				REQ_ORIGIN
+			}) });
+			return rewritten || "";
+		})());
+	});
+	if (is_m3u8) {
+		let m3u8_content = replace_response_content_with || await upstream.text();
+		const [E_, R_] = await NS_promise.F_catch_promise({ promise: NS_playback_helper.F_transform_m3u8_v2({
+			content: m3u8_content,
+			true_origin: decoded_proxy_endpoint.origin,
+			true_base: (() => {
+				const _ = NS_Misc.F_remove_last_array_element({ arr: decoded_proxy_endpoint.pathname.split("/") }).join("/");
+				if (!_ && decoded_proxy_endpoint.pathname) return "/";
+				return _;
+			})(),
+			proxy_base: NS_routes_c.F_flat_url_slash(REQ_ORIGIN + (_is_proxima_h ? "/proxima-h" : "/proxima")),
+			proxima_commands: decoded_proxy_commands ? { ...decoded_proxy_commands } : {},
+			search_params: query.ch ? { ch: query.ch } : {}
+		}) });
+		m3u8_content = R_ || m3u8_content || "";
+		if (query.ops === "get-master-resolutions") {
+			const _ = NS_playback_helper.F_extract_resolutions_from_M3U8({ m3u8Content: m3u8_content });
+			const play_resolutions = _?.rxd || [];
+			const is_fhd = _?.fhd;
+			const is_hd = _?.hd;
+			return ctx.json({
+				is_fhd,
+				is_hd,
+				resolutions: play_resolutions,
+				content: m3u8_content
+			});
+		}
+		ctx.status(upstream.status);
+		for (const key in res_headers_obj) if (key in res_headers_obj) {
+			const element = res_headers_obj[key];
+			if (`${key}`.toLowerCase() == "content-length") continue;
+			ctx.header(key, element);
+		}
+		set_manual_response_headers();
+		return ctx.body(m3u8_content);
+	}
+	set_manual_response_headers();
+	return upstream;
+	function set_manual_response_headers() {
+		if (decoded_proxy_commands.response_headers && NS_Misc.F_is_record(decoded_proxy_commands.response_headers)) for (const k in decoded_proxy_commands.response_headers) {
+			const v = decoded_proxy_commands.response_headers[k];
+			ctx.header(k, v);
+		}
+	}
+});
+const ProximaRouter = sub_router;
+
+//#endregion
+//#region src/sub-router/hono.index.ts
+const app$1 = new Hono({ strict: true });
+app$1.use(trimTrailingSlash(), logger$1(), cors$1({
+	origin: "*",
+	allowHeaders: ["*"],
+	exposeHeaders: ["*"]
+}));
+app$1.route("/", ProximaRouter);
+const HonoRouter = app$1;
+
+//#endregion
+//#region src/index.ts
+await NS_runtime.set_env_var_db();
+const PORT = process.env.PORT;
+const app = new Elysia().use(cors({
+	origin: "*",
+	allowedHeaders: "*",
+	methods: [
+		"GET",
+		"POST",
+		"PUT",
+		"DELETE",
+		"OPTIONS",
+		"HEAD"
+	],
+	exposeHeaders: "*"
+})).derive((ctx) => ({ publicOrigin: NS_routes_elysia.F_public_origin(ctx) })).use(logger()).onError(async ({ code, error }) => {
+	let e_message = "";
+	if (code === "VALIDATION") {
+		e_message = error.message;
+		try {
+			e_message = JSON.parse(e_message).summary;
+		} catch (err) {}
+	}
+	const err_d = NS_error.F_collect_error_status_n_message({ ERR: error });
+	NS_Misc.console.error({
+		ENV: "dev",
+		_browser: false,
+		_log: ["\n"]
+	});
+	NS_Misc.console.error({
+		ENV: "dev",
+		_browser: false,
+		_log: [{
+			code,
+			e_message,
+			...err_d
+		}, "\n"]
+	});
+	return new Response(err_d.message, {
+		status: err_d.status,
+		headers: {
+			"x-error-message": JSON.stringify(err_d.message),
+			"x-error-status": err_d.status
+		}
+	});
+}).mount("/", HonoRouter.fetch).get("/", () => {
+	return "🦊 Hello Rafiki 🍿";
+}).get("/foo", (ctx) => {
+	const REQ_headers = ctx?.request?.headers;
+	console.log("\n", "REQ_headers", REQ_headers, "\n");
+	return "🦊 Hello Rafiki 🍿";
+}).listen({
+	port: PORT || 7860,
+	...NS_runtime.IS_PROD && { hostname: "0.0.0.0" },
+	idleTimeout: 120
+});
+console.log(`🦊 Elysia is running at ${app.server?.hostname}:${app.server?.port}`);
+
+//#endregion
+export {  };