acrylblends 0.4.1 → 0.5.0

package/lib/bearer-auth.d.ts

@@ -0,0 +1,89 @@
+import { I as MiddlewareHandler, _ as Env, t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/bearer-auth/index.d.ts
+type MessageFunction = (c: Context) => string | object | Promise<string | object>;
+type CustomizedErrorResponseOptions = {
+  wwwAuthenticateHeader?: string | object | MessageFunction;
+  message?: string | object | MessageFunction;
+};
+type BearerAuthOptions<E extends Env = Env> = {
+  token: string | string[];
+  realm?: string;
+  prefix?: string;
+  headerName?: string;
+  hashFunction?: Function;
+  /**
+   * @deprecated Use noAuthenticationHeader.message instead
+   */
+  noAuthenticationHeaderMessage?: string | object | MessageFunction;
+  noAuthenticationHeader?: CustomizedErrorResponseOptions;
+  /**
+   * @deprecated Use invalidAuthenticationHeader.message instead
+   */
+  invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
+  invalidAuthenticationHeader?: CustomizedErrorResponseOptions;
+  /**
+   * @deprecated Use invalidToken.message instead
+   */
+  invalidTokenMessage?: string | object | MessageFunction;
+  invalidToken?: CustomizedErrorResponseOptions;
+} | {
+  realm?: string;
+  prefix?: string;
+  headerName?: string;
+  verifyToken: (token: string, c: Context<E>) => boolean | Promise<boolean>;
+  hashFunction?: Function;
+  /**
+   * @deprecated Use noAuthenticationHeader.message instead
+   */
+  noAuthenticationHeaderMessage?: string | object | MessageFunction;
+  noAuthenticationHeader?: CustomizedErrorResponseOptions;
+  /**
+   * @deprecated Use invalidAuthenticationHeader.message instead
+   */
+  invalidAuthenticationHeaderMessage?: string | object | MessageFunction;
+  invalidAuthenticationHeader?: CustomizedErrorResponseOptions;
+  /**
+   * @deprecated Use invalidToken.message instead
+   */
+  invalidTokenMessage?: string | object | MessageFunction;
+  invalidToken?: CustomizedErrorResponseOptions;
+};
+/**
+ * Bearer Auth Middleware for Acryl.
+ *
+ *
+ * @template E - The environment type.
+ * @param {BearerAuthOptions} options - The options for the bearer authentication middleware.
+ * @param {string | string[]} [options.token] - The string or array of strings to validate the incoming bearer token against.
+ * @param {Function} [options.verifyToken] - The function to verify the token.
+ * @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
+ * @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
+ * @param {string} [options.headerName=Authorization] - The header name.
+ * @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
+ * @param {string | object | MessageFunction} [options.noAuthenticationHeader.message="Unauthorized"] - The no authentication header message.
+ * @param {string | object | MessageFunction} [options.noAuthenticationHeader.wwwAuthenticateHeader="Bearer realm=\"\""] - The response header value for the WWW-Authenticate header when no authentication header is provided.
+ * @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.message="Bad Request"] - The invalid authentication header message.
+ * @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.wwwAuthenticateHeader="Bearer error=\"invalid_request\""] - The response header value for the WWW-Authenticate header when authentication header is invalid.
+ * @param {string | object | MessageFunction} [options.invalidToken.message="Unauthorized"] - The invalid token message.
+ * @param {string | object | MessageFunction} [options.invalidToken.wwwAuthenticateHeader="Bearer error=\"invalid_token\""] - The response header value for the WWW-Authenticate header when token is invalid.
+ * @returns {MiddlewareHandler<E>} The middleware handler function.
+ * @throws {Error} If neither "token" nor "verifyToken" options are provided.
+ * @throws {HTTPException} If authentication fails, with 401 status code for missing or invalid token, or 400 status code for invalid request.
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ *
+ * const token = process.env.API_TOKEN // never a literal in source
+ *
+ * app.use('/api/*', bearerAuth({ token }))
+ *
+ * app.get('/api/page', (c) => {
+ *   return c.json({ message: 'You are authorized' })
+ * })
+ * ```
+ */
+declare const bearerAuth: <E extends Env = Env>(options: BearerAuthOptions<E>) => MiddlewareHandler<E>;
+//#endregion
+export { bearerAuth };

package/lib/bearer-auth.js

@@ -0,0 +1,94 @@
+import { HTTPException } from "./http-exception.js";
+import { timingSafeEqual } from "./utils/buffer.js";
+//#region ../../plugins/acryl-router/src/core/middleware/bearer-auth/index.ts
+const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
+const PREFIX = "Bearer";
+const HEADER = "Authorization";
+/**
+* Bearer Auth Middleware for Acryl.
+*
+*
+* @template E - The environment type.
+* @param {BearerAuthOptions} options - The options for the bearer authentication middleware.
+* @param {string | string[]} [options.token] - The string or array of strings to validate the incoming bearer token against.
+* @param {Function} [options.verifyToken] - The function to verify the token.
+* @param {string} [options.realm=""] - The domain name of the realm, as part of the returned WWW-Authenticate challenge header.
+* @param {string} [options.prefix="Bearer"] - The prefix (or known as `schema`) for the Authorization header value. If set to the empty string, no prefix is expected.
+* @param {string} [options.headerName=Authorization] - The header name.
+* @param {Function} [options.hashFunction] - A function to handle hashing for safe comparison of authentication tokens.
+* @param {string | object | MessageFunction} [options.noAuthenticationHeader.message="Unauthorized"] - The no authentication header message.
+* @param {string | object | MessageFunction} [options.noAuthenticationHeader.wwwAuthenticateHeader="Bearer realm=\"\""] - The response header value for the WWW-Authenticate header when no authentication header is provided.
+* @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.message="Bad Request"] - The invalid authentication header message.
+* @param {string | object | MessageFunction} [options.invalidAuthenticationHeader.wwwAuthenticateHeader="Bearer error=\"invalid_request\""] - The response header value for the WWW-Authenticate header when authentication header is invalid.
+* @param {string | object | MessageFunction} [options.invalidToken.message="Unauthorized"] - The invalid token message.
+* @param {string | object | MessageFunction} [options.invalidToken.wwwAuthenticateHeader="Bearer error=\"invalid_token\""] - The response header value for the WWW-Authenticate header when token is invalid.
+* @returns {MiddlewareHandler<E>} The middleware handler function.
+* @throws {Error} If neither "token" nor "verifyToken" options are provided.
+* @throws {HTTPException} If authentication fails, with 401 status code for missing or invalid token, or 400 status code for invalid request.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* const token = process.env.API_TOKEN // never a literal in source
+*
+* app.use('/api/*', bearerAuth({ token }))
+*
+* app.get('/api/page', (c) => {
+*   return c.json({ message: 'You are authorized' })
+* })
+* ```
+*/
+const bearerAuth = (options) => {
+	if (!("token" in options || "verifyToken" in options)) throw new Error("bearer auth middleware requires options for \"token\" or \"verifyToken\"");
+	if (!options.realm) options.realm = "";
+	if (options.prefix === void 0) options.prefix = PREFIX;
+	const realm = options.realm?.replace(/"/g, "\\\"");
+	const prefix = options.prefix;
+	const tokenRegexp = new RegExp(`^${TOKEN_STRINGS}$`);
+	const wwwAuthenticatePrefix = prefix === "" ? "" : `${prefix} `;
+	const throwHTTPException = async (c, status, wwwAuthenticateHeader, messageOption) => {
+		const wwwAuthenticateHeaderValue = typeof wwwAuthenticateHeader === "function" ? await wwwAuthenticateHeader(c) : wwwAuthenticateHeader;
+		const headers = { "WWW-Authenticate": typeof wwwAuthenticateHeaderValue === "string" ? wwwAuthenticateHeaderValue : `${wwwAuthenticatePrefix}${Object.entries(wwwAuthenticateHeaderValue).map(([key, value]) => `${key}="${value}"`).join(",")}` };
+		const responseMessage = typeof messageOption === "function" ? await messageOption(c) : messageOption;
+		throw new HTTPException(status, { res: typeof responseMessage === "string" ? new Response(responseMessage, {
+			status,
+			headers
+		}) : new Response(JSON.stringify(responseMessage), {
+			status,
+			headers: {
+				...headers,
+				"content-type": "application/json"
+			}
+		}) });
+	};
+	return async function bearerAuth(c, next) {
+		const headerToken = c.req.header(options.headerName || HEADER);
+		if (!headerToken) await throwHTTPException(c, 401, options.noAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}realm="${realm}"`, options.noAuthenticationHeader?.message || options.noAuthenticationHeaderMessage || "Unauthorized");
+		else {
+			let tokenValue;
+			if (prefix === "") tokenValue = headerToken;
+			else {
+				const headerLower = headerToken.toLowerCase();
+				const prefixLower = prefix.toLowerCase();
+				if (headerLower.startsWith(prefixLower) && headerToken[prefix.length] === " ") tokenValue = headerToken.slice(prefix.length).trimStart();
+			}
+			if (!tokenValue || !tokenRegexp.test(tokenValue)) await throwHTTPException(c, 400, options.invalidAuthenticationHeader?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_request"`, options.invalidAuthenticationHeader?.message || options.invalidAuthenticationHeaderMessage || "Bad Request");
+			else {
+				let equal = false;
+				if ("verifyToken" in options) equal = await options.verifyToken(tokenValue, c);
+				else if (typeof options.token === "string") equal = await timingSafeEqual(options.token, tokenValue, options.hashFunction);
+				else if (Array.isArray(options.token) && options.token.length > 0) {
+					for (const token of options.token) if (await timingSafeEqual(token, tokenValue, options.hashFunction)) {
+						equal = true;
+						break;
+					}
+				}
+				if (!equal) await throwHTTPException(c, 401, options.invalidToken?.wwwAuthenticateHeader || `${wwwAuthenticatePrefix}error="invalid_token"`, options.invalidToken?.message || options.invalidTokenMessage || "Unauthorized");
+			}
+		}
+		await next();
+	};
+};
+//#endregion
+export { bearerAuth };

package/lib/body-limit.d.ts

@@ -0,0 +1,42 @@
+import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/body-limit/index.d.ts
+type OnError = (c: Context) => Response | Promise<Response>;
+type BodyLimitOptions = {
+  maxSize: number;
+  onError?: OnError;
+};
+/**
+ * Body Limit Middleware for Acryl.
+ *
+ *
+ * @param {BodyLimitOptions} options - The options for the body limit middleware.
+ * @param {number} options.maxSize - The maximum body size allowed.
+ * @param {OnError} [options.onError] - The error handler to be invoked if the specified body size is exceeded.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Acryl()
+ *
+ * app.post(
+ *   '/upload',
+ *   bodyLimit({
+ *     maxSize: 50 * 1024, // 50kb
+ *     onError: (c) => {
+ *       return c.text('overflow :(', 413)
+ *     },
+ *   }),
+ *   async (c) => {
+ *     const body = await c.req.parseBody()
+ *     if (body['file'] instanceof File) {
+ *       console.log(`Got file sized: ${body['file'].size}`)
+ *     }
+ *     return c.text('pass :)')
+ *   }
+ * )
+ * ```
+ */
+declare const bodyLimit: (options: BodyLimitOptions) => MiddlewareHandler;
+//#endregion
+export { bodyLimit };

package/lib/body-limit.js

@@ -0,0 +1,66 @@
+import { HTTPException } from "./http-exception.js";
+//#region ../../plugins/acryl-router/src/core/middleware/body-limit/index.ts
+const ERROR_MESSAGE = "Payload Too Large";
+/**
+* Body Limit Middleware for Acryl.
+*
+*
+* @param {BodyLimitOptions} options - The options for the body limit middleware.
+* @param {number} options.maxSize - The maximum body size allowed.
+* @param {OnError} [options.onError] - The error handler to be invoked if the specified body size is exceeded.
+* @returns {MiddlewareHandler} The middleware handler function.
+*
+* @example
+* ```ts
+* const app = new Acryl()
+*
+* app.post(
+*   '/upload',
+*   bodyLimit({
+*     maxSize: 50 * 1024, // 50kb
+*     onError: (c) => {
+*       return c.text('overflow :(', 413)
+*     },
+*   }),
+*   async (c) => {
+*     const body = await c.req.parseBody()
+*     if (body['file'] instanceof File) {
+*       console.log(`Got file sized: ${body['file'].size}`)
+*     }
+*     return c.text('pass :)')
+*   }
+* )
+* ```
+*/
+const bodyLimit = (options) => {
+	const onError = options.onError || (() => {
+		throw new HTTPException(413, { res: new Response(ERROR_MESSAGE, { status: 413 }) });
+	});
+	const maxSize = options.maxSize;
+	return async function bodyLimit(c, next) {
+		if (!c.req.raw.body) return next();
+		const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
+		if (c.req.raw.headers.has("content-length") && !hasTransferEncoding) return parseInt(c.req.raw.headers.get("content-length") || "0", 10) > maxSize ? onError(c) : next();
+		let size = 0;
+		const chunks = [];
+		const rawReader = c.req.raw.body.getReader();
+		for (;;) {
+			const { done, value } = await rawReader.read();
+			if (done) break;
+			size += value.length;
+			if (size > maxSize) return onError(c);
+			chunks.push(value);
+		}
+		const requestInit = {
+			body: new ReadableStream({ start(controller) {
+				for (const chunk of chunks) controller.enqueue(chunk);
+				controller.close();
+			} }),
+			duplex: "half"
+		};
+		c.req.raw = new Request(c.req.raw, requestInit);
+		return next();
+	};
+};
+//#endregion
+export { bodyLimit };

package/lib/client-BHTr318g.js

@@ -0,0 +1,266 @@
+import { serialize } from "./utils/cookie.js";
+//#region ../../plugins/acryl-router/src/core/client/fetch-result-please.ts
+/**
+* @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Acryl's custom needs.
+*
+* @link https://www.npmjs.com/package/fetch-result-please
+*/
+const nullBodyResponses = /* @__PURE__ */ new Set([
+	101,
+	204,
+	205,
+	304
+]);
+/**
+* Smartly parses and return the consumable result from a fetch `Response`.
+*
+* Throwing a structured error if the response is not `ok`. ({@link DetailedError})
+*/
+async function fetchRP(fetchRes) {
+	const _fetchRes = await fetchRes;
+	if ((_fetchRes.body || _fetchRes._bodyInit) && !nullBodyResponses.has(_fetchRes.status)) _fetchRes._data = await _fetchRes[detectResponseType(_fetchRes)]();
+	if (!_fetchRes.ok) throw new DetailedError(`${_fetchRes.status} ${_fetchRes.statusText}`, {
+		statusCode: _fetchRes?.status,
+		detail: {
+			data: _fetchRes?._data,
+			statusText: _fetchRes?.statusText
+		}
+	});
+	return _fetchRes._data;
+}
+var DetailedError = class extends Error {
+	/**
+	* Additional `message` that will be logged AND returned to client
+	*/
+	detail;
+	/**
+	* Additional `code` that will be logged AND returned to client
+	*/
+	code;
+	/**
+	* Additional value that will be logged AND NOT returned to client
+	*/
+	log;
+	/**
+	* Optionally set the status code to return, in a web server context
+	*/
+	statusCode;
+	constructor(message, options = {}) {
+		super(message);
+		this.name = "DetailedError";
+		this.log = options.log;
+		this.detail = options.detail;
+		this.code = options.code;
+		this.statusCode = options.statusCode;
+	}
+};
+const jsonRegex = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(?:;.+)?$/i;
+function detectResponseType(response) {
+	const _contentType = response.headers.get("content-type");
+	if (!_contentType) return "text";
+	const contentType = _contentType.split(";").shift();
+	if (jsonRegex.test(contentType)) return "json";
+	return "text";
+}
+//#endregion
+//#region ../../plugins/acryl-router/src/core/client/utils.ts
+const mergePath = (base, path) => {
+	base = base.replace(/\/+$/, "");
+	base = base + "/";
+	path = path.replace(/^\/+/, "");
+	return base + path;
+};
+const replaceUrlParam = (urlString, params) => {
+	for (const [k, v] of Object.entries(params)) {
+		const reg = new RegExp("/:" + k + "(?:{[^/]+})?\\??(?=/|$)");
+		urlString = urlString.replace(reg, () => v ? `/${v}` : "");
+	}
+	return urlString;
+};
+const buildSearchParams = (query) => {
+	const searchParams = new URLSearchParams();
+	for (const [k, v] of Object.entries(query)) {
+		if (v === void 0) continue;
+		if (Array.isArray(v)) for (const v2 of v) {
+			if (v2 === void 0) continue;
+			searchParams.append(k, v2);
+		}
+		else searchParams.set(k, v);
+	}
+	return searchParams;
+};
+const replaceUrlProtocol = (urlString, protocol) => {
+	switch (protocol) {
+		case "ws": return urlString.replace(/^http/, "ws");
+		case "http": return urlString.replace(/^ws/, "http");
+	}
+};
+const removeIndexString = (urlString) => {
+	if (/^https?:\/\/[^\/]+?\/index(?=\?|$)/.test(urlString)) return urlString.replace(/\/index(?=\?|$)/, "/");
+	return urlString.replace(/\/index(?=\?|$)/, "");
+};
+function isObject(item) {
+	return typeof item === "object" && item !== null && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+	if (!isObject(target) && !isObject(source)) return source;
+	const merged = { ...target };
+	for (const key in source) {
+		const value = source[key];
+		if (isObject(merged[key]) && isObject(value)) merged[key] = deepMerge(merged[key], value);
+		else merged[key] = value;
+	}
+	return merged;
+}
+/**
+* Shortcut to get a consumable response from `hc`'s fetch calls (Response), with types inference.
+*
+* Smartly parse the response data, throwing a structured error if the response is not `ok`. ({@link DetailedError})
+*
+* @example const result = await parseResponse(client.posts.$get())
+*/
+async function parseResponse(fetchRes) {
+	return fetchRP(fetchRes);
+}
+//#endregion
+//#region ../../plugins/acryl-router/src/core/client/client.ts
+const createProxy = (callback, path) => {
+	return new Proxy(() => {}, {
+		get(_obj, key) {
+			if (typeof key !== "string" || key === "then") return;
+			return createProxy(callback, [...path, key]);
+		},
+		apply(_1, _2, args) {
+			return callback({
+				path,
+				args
+			});
+		}
+	});
+};
+const appendQueryParams = (url, searchParams) => {
+	const queryString = searchParams.toString();
+	return queryString ? `${url}?${queryString}` : url;
+};
+var ClientRequestImpl = class {
+	url;
+	method;
+	buildSearchParams;
+	queryParams = void 0;
+	pathParams = {};
+	rBody;
+	cType = void 0;
+	constructor(url, method, options) {
+		this.url = url;
+		this.method = method;
+		this.buildSearchParams = options.buildSearchParams;
+	}
+	fetch = async (args, opt) => {
+		if (args) {
+			if (args.query) this.queryParams = this.buildSearchParams(args.query);
+			if (args.form) {
+				const form = new FormData();
+				for (const [k, v] of Object.entries(args.form)) {
+					if (v === void 0) continue;
+					if (Array.isArray(v)) for (const v2 of v) {
+						if (v2 === void 0) continue;
+						form.append(k, v2);
+					}
+					else form.append(k, v);
+				}
+				this.rBody = form;
+			}
+			if (args.json !== void 0) {
+				this.rBody = JSON.stringify(args.json);
+				this.cType = "application/json";
+			}
+			if (args.param) this.pathParams = args.param;
+		}
+		let methodUpperCase = this.method.toUpperCase();
+		const headerValues = {
+			...args?.header,
+			...typeof opt?.headers === "function" ? await opt.headers() : opt?.headers
+		};
+		if (args?.cookie) {
+			const cookies = [];
+			for (const [key, value] of Object.entries(args.cookie)) {
+				if (value === void 0) continue;
+				cookies.push(serialize(key, value));
+			}
+			if (cookies.length > 0) headerValues["Cookie"] = cookies.join("; ");
+		}
+		if (this.cType) headerValues["Content-Type"] = this.cType;
+		const headers = new Headers();
+		for (const [key, value] of Object.entries(headerValues)) if (value !== void 0) headers.set(key, value);
+		let url = this.url;
+		url = removeIndexString(url);
+		url = replaceUrlParam(url, this.pathParams);
+		if (this.queryParams) url = appendQueryParams(url, this.queryParams);
+		methodUpperCase = this.method.toUpperCase();
+		const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+		return (opt?.fetch || fetch)(url, {
+			body: setBody ? this.rBody : void 0,
+			method: methodUpperCase,
+			headers,
+			...opt?.init
+		});
+	};
+};
+const hc = (baseUrl, options) => createProxy(function proxyCallback(opts) {
+	const buildSearchParamsOption = options?.buildSearchParams ?? buildSearchParams;
+	const parts = [...opts.path];
+	const lastParts = parts.slice(-3).reverse();
+	if (lastParts[0] === "toString") {
+		if (lastParts[1] === "name") return lastParts[2] || "";
+		return proxyCallback.toString();
+	}
+	if (lastParts[0] === "valueOf") {
+		if (lastParts[1] === "name") return lastParts[2] || "";
+		return proxyCallback;
+	}
+	let method = "";
+	if (/^\$/.test(lastParts[0])) {
+		const last = parts.pop();
+		if (last) method = last.replace(/^\$/, "");
+	}
+	const url = mergePath(baseUrl, parts.join("/"));
+	if (method === "url" || method === "path") {
+		let result = removeIndexString(url);
+		if (opts.args[0]) {
+			if (opts.args[0].param) result = replaceUrlParam(result, opts.args[0].param);
+			if (opts.args[0].query) result = appendQueryParams(result, buildSearchParamsOption(opts.args[0].query));
+		}
+		if (method === "url") return new URL(result);
+		return result.slice(baseUrl.replace(/\/+$/, "").length).replace(/^\/?/, "/");
+	}
+	if (method === "ws") {
+		const normalizedUrl = removeIndexString(url);
+		const webSocketUrl = replaceUrlProtocol(opts.args[0]?.param ? replaceUrlParam(normalizedUrl, opts.args[0].param) : normalizedUrl, "ws");
+		const targetUrl = new URL(webSocketUrl);
+		const queryParams = opts.args[0]?.query;
+		if (queryParams) buildSearchParamsOption(queryParams).forEach((value, key) => {
+			targetUrl.searchParams.append(key, value);
+		});
+		const establishWebSocket = (...args) => {
+			if (options?.webSocket !== void 0 && typeof options.webSocket === "function") return options.webSocket(...args);
+			return new WebSocket(...args);
+		};
+		return establishWebSocket(targetUrl.toString());
+	}
+	const req = new ClientRequestImpl(url, method, { buildSearchParams: buildSearchParamsOption });
+	if (method) {
+		options ??= {};
+		const reqOptions = { ...opts.args[1] };
+		const baseHeaders = options.headers;
+		const reqHeaders = reqOptions.headers;
+		if (baseHeaders && reqHeaders) reqOptions.headers = async () => ({
+			...typeof baseHeaders === "function" ? await baseHeaders() : baseHeaders,
+			...typeof reqHeaders === "function" ? await reqHeaders() : reqHeaders
+		});
+		const args = deepMerge(options, reqOptions);
+		return req.fetch(opts.args[0], args);
+	}
+	return req;
+}, []);
+//#endregion
+export { parseResponse as n, DetailedError as r, hc as t };

package/lib/client.d.ts

@@ -0,0 +1,3 @@
+import { a as ClientResponse, c as InferRequestType, i as ClientRequestOptions, l as InferResponseType, o as Fetch, r as ClientRequest, t as ApplyGlobalResponse, u as PickResponseByStatusCode } from "./types-CHesD1KG.js";
+import { n as DetailedError, r as hc, t as parseResponse } from "./index-oOClm_Xk.js";
+export { type ApplyGlobalResponse, type ClientRequest, type ClientRequestOptions, type ClientResponse, DetailedError, type Fetch, type InferRequestType, type InferResponseType, type PickResponseByStatusCode, hc, parseResponse };

package/lib/client.js

@@ -0,0 +1,2 @@
+import { n as parseResponse, r as DetailedError, t as hc } from "./client-BHTr318g.js";
+export { DetailedError, hc, parseResponse };

package/lib/combine.d.ts

@@ -0,0 +1,85 @@
+import { I as MiddlewareHandler, t as Context } from "./context-Bm7rI-oK.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/combine/index.d.ts
+type Condition = (c: Context) => boolean;
+/**
+ * Create a composed middleware that runs the first middleware that returns true.
+ *
+ * @param middleware - An array of MiddlewareHandler or Condition functions.
+ * Middleware is applied in the order it is passed, and if any middleware exits without returning
+ * an exception first, subsequent middleware will not be executed.
+ * You can also pass a condition function that returns a boolean value. If returns true
+ * the evaluation will be halted, and rest of the middleware will not be executed.
+ * @returns A composed middleware.
+ *
+ * @example
+ * ```ts
+ * import { some } from 'acrylblends/combine'
+ * import { bearerAuth } from 'acrylblends/bearer-auth'
+ * import { myRateLimit } from '@/rate-limit'
+ *
+ * // If client has a valid token, then skip rate limiting.
+ * // Otherwise, apply rate limiting.
+ * app.use('/api/*', some(
+ *   bearerAuth({ token }),
+ *   myRateLimit({ limit: 100 }),
+ * ));
+ * ```
+ */
+declare const some: (...middleware: (MiddlewareHandler | Condition)[]) => MiddlewareHandler;
+/**
+ * Create a composed middleware that runs all middleware and throws an error if any of them fail.
+ *
+ * @param middleware - An array of MiddlewareHandler or Condition functions.
+ * Middleware is applied in the order it is passed, and if any middleware throws an error,
+ * subsequent middleware will not be executed.
+ * You can also pass a condition function that returns a boolean value. If returns false
+ * the evaluation will be halted, and rest of the middleware will not be executed.
+ * @returns A composed middleware.
+ *
+ * @example
+ * ```ts
+ * import { some, every } from 'acrylblends/combine'
+ * import { bearerAuth } from 'acrylblends/bearer-auth'
+ * import { myCheckLocalNetwork } from '@/check-local-network'
+ * import { myRateLimit } from '@/rate-limit'
+ *
+ * // If client is in local network, then skip authentication and rate limiting.
+ * // Otherwise, apply authentication and rate limiting.
+ * app.use('/api/*', some(
+ *   myCheckLocalNetwork(),
+ *   every(
+ *     bearerAuth({ token }),
+ *     myRateLimit({ limit: 100 }),
+ *   ),
+ * ));
+ * ```
+ */
+declare const every: (...middleware: (MiddlewareHandler | Condition)[]) => MiddlewareHandler;
+/**
+ * Create a composed middleware that runs all middleware except when the condition is met.
+ *
+ * @param condition - A string or Condition function.
+ * If there are multiple targets to match any of them, they can be passed as an array.
+ * If a string is passed, it will be treated as a path pattern to match.
+ * If a Condition function is passed, it will be evaluated against the request context.
+ * @param middleware - Middleware to run when the condition is not met.
+ * Multiple middleware can be passed, and they are applied in the order they are passed.
+ * @returns A composed middleware.
+ *
+ * @example
+ * ```ts
+ * import { except } from 'acrylblends/combine'
+ * import { bearerAuth } from 'acrylblends/bearer-auth'
+ *
+ * // If client is accessing public API, then skip authentication.
+ * // Otherwise, require a valid token.
+ * app.use('/api/*', except(
+ *   '/api/public/*',
+ *   bearerAuth({ token }),
+ * ));
+ * ```
+ */
+declare const except: (condition: string | Condition | (string | Condition)[], ...middleware: MiddlewareHandler[]) => MiddlewareHandler;
+//#endregion
+export { every, except, some };