@psnext/slingcli 3.3.20260924-1 → 3.3.20261002-1

package/node_modules/hono/dist/middleware/basic-auth/index.js

@@ -1,66 +1,99 @@
-// src/middleware/basic-auth/index.ts
 import { HTTPException } from "../../http-exception.js";
-import { auth } from "../../utils/basic-auth.js";
 import { timingSafeEqual } from "../../utils/buffer.js";
-var basicAuth = (options, ...users) => {
-  const usernamePasswordInOptions = "username" in options && "password" in options;
-  const verifyUserInOptions = "verifyUser" in options;
-  if (!(usernamePasswordInOptions || verifyUserInOptions)) {
-    throw new Error(
-      'basic auth middleware requires options for "username and password" or "verifyUser"'
-    );
-  }
-  if (!options.realm) {
-    options.realm = "Secure Area";
-  }
-  if (!options.invalidUserMessage) {
-    options.invalidUserMessage = "Unauthorized";
-  }
-  if (usernamePasswordInOptions) {
-    users.unshift({ username: options.username, password: options.password });
-  }
-  return async function basicAuth2(ctx, next) {
-    const requestUser = auth(ctx.req.raw);
-    if (requestUser) {
-      if (verifyUserInOptions) {
-        if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
-          if (options.onAuthSuccess) {
-            await options.onAuthSuccess(ctx, requestUser.username);
-          }
-          await next();
-          return;
-        }
-      } else {
-        for (const user of users) {
-          const [usernameEqual, passwordEqual] = await Promise.all([
-            timingSafeEqual(user.username, requestUser.username, options.hashFunction),
-            timingSafeEqual(user.password, requestUser.password, options.hashFunction)
-          ]);
-          if (usernameEqual && passwordEqual) {
-            if (options.onAuthSuccess) {
-              await options.onAuthSuccess(ctx, requestUser.username);
-            }
-            await next();
-            return;
-          }
-        }
-      }
-    }
-    const status = 401;
-    const headers = {
-      "WWW-Authenticate": 'Basic realm="' + options.realm?.replace(/"/g, '\\"') + '"'
-    };
-    const responseMessage = typeof options.invalidUserMessage === "function" ? await options.invalidUserMessage(ctx) : options.invalidUserMessage;
-    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
-      status,
-      headers: {
-        ...headers,
-        "content-type": "application/json"
-      }
-    });
-    throw new HTTPException(status, { res });
-  };
-};
-export {
-  basicAuth
+import { auth } from "../../utils/basic-auth.js";
+//#region src/middleware/basic-auth/index.ts
+/**
+* Basic Auth Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/basic-auth}
+*
+* @param {BasicAuthOptions} options - The options for the basic authentication middleware.
+* @param {string} options.username - The username for authentication.
+* @param {string} options.password - The password for authentication.
+* @param {string} [options.realm="Secure Area"] - The realm attribute for the WWW-Authenticate header.
+* @param {Function} [options.hashFunction] - The hash function used for secure comparison.
+* @param {Function} [options.verifyUser] - The function to verify user credentials.
+* @param {string | object | MessageFunction} [options.invalidUserMessage="Unauthorized"] - The invalid user message.
+* @param {Function} [options.onAuthSuccess] - Callback function called on successful authentication.
+* @returns {MiddlewareHandler} The middleware handler function.
+* @throws {HTTPException} If neither "username and password" nor "verifyUser" options are provided.
+*
+* @example
+* ```ts
+* const app = new Hono()
+*
+* app.use(
+*   '/auth/*',
+*   basicAuth({
+*     username: 'hono',
+*     password: 'ahotproject',
+*   })
+* )
+*
+* app.get('/auth/page', (c) => {
+*   return c.text('You are authorized')
+* })
+* ```
+*
+* @example
+* ```ts
+* // With onAuthSuccess callback
+* app.use(
+*   '/auth/*',
+*   basicAuth({
+*     username: 'hono',
+*     password: 'ahotproject',
+*     onAuthSuccess: (c, username) => {
+*       c.set('user', { name: username, role: 'admin' })
+*       console.log(`User ${username} authenticated`)
+*     },
+*   })
+* )
+* ```
+*/
+const basicAuth = (options, ...users) => {
+	const usernamePasswordInOptions = "username" in options && "password" in options;
+	const verifyUserInOptions = "verifyUser" in options;
+	if (!(usernamePasswordInOptions || verifyUserInOptions)) throw new Error("basic auth middleware requires options for \"username and password\" or \"verifyUser\"");
+	if (!options.realm) options.realm = "Secure Area";
+	if (!options.invalidUserMessage) options.invalidUserMessage = "Unauthorized";
+	if (usernamePasswordInOptions) users.unshift({
+		username: options.username,
+		password: options.password
+	});
+	return async function basicAuth(ctx, next) {
+		const requestUser = auth(ctx.req.raw);
+		if (requestUser) {
+			if (verifyUserInOptions) {
+				if (await options.verifyUser(requestUser.username, requestUser.password, ctx)) {
+					if (options.onAuthSuccess) await options.onAuthSuccess(ctx, requestUser.username);
+					await next();
+					return;
+				}
+			} else for (const user of users) {
+				const [usernameEqual, passwordEqual] = await Promise.all([timingSafeEqual(user.username, requestUser.username, options.hashFunction), timingSafeEqual(user.password, requestUser.password, options.hashFunction)]);
+				if (usernameEqual && passwordEqual) {
+					if (options.onAuthSuccess) await options.onAuthSuccess(ctx, requestUser.username);
+					await next();
+					return;
+				}
+			}
+		}
+		const status = 401;
+		const headers = { "WWW-Authenticate": "Basic realm=\"" + options.realm?.replace(/"/g, "\\\"") + "\"" };
+		const responseMessage = typeof options.invalidUserMessage === "function" ? await options.invalidUserMessage(ctx) : options.invalidUserMessage;
+		const res = typeof responseMessage === "string" ? new Response(responseMessage, {
+			status,
+			headers
+		}) : new Response(JSON.stringify(responseMessage), {
+			status,
+			headers: {
+				...headers,
+				"content-type": "application/json"
+			}
+		});
+		throw new HTTPException(status, { res });
+	};
 };
+//#endregion
+export { basicAuth };

package/node_modules/hono/dist/middleware/bearer-auth/index.js

@@ -1,92 +1,96 @@
-// src/middleware/bearer-auth/index.ts
 import { HTTPException } from "../../http-exception.js";
 import { timingSafeEqual } from "../../utils/buffer.js";
-var TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
-var PREFIX = "Bearer";
-var HEADER = "Authorization";
-var 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;
-    const res = typeof responseMessage === "string" ? new Response(responseMessage, { status, headers }) : new Response(JSON.stringify(responseMessage), {
-      status,
-      headers: {
-        ...headers,
-        "content-type": "application/json"
-      }
-    });
-    throw new HTTPException(status, { res });
-  };
-  return async function bearerAuth2(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();
-  };
-};
-export {
-  bearerAuth
+//#region src/middleware/bearer-auth/index.ts
+const TOKEN_STRINGS = "[A-Za-z0-9._~+/-]+=*";
+const PREFIX = "Bearer";
+const HEADER = "Authorization";
+/**
+* Bearer Auth Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/bearer-auth}
+*
+* @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 Hono()
+*
+* const token = 'honoishot'
+*
+* 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;
+		const res = typeof responseMessage === "string" ? new Response(responseMessage, {
+			status,
+			headers
+		}) : new Response(JSON.stringify(responseMessage), {
+			status,
+			headers: {
+				...headers,
+				"content-type": "application/json"
+			}
+		});
+		throw new HTTPException(status, { res });
+	};
+	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/node_modules/hono/dist/middleware/body-limit/index.js

@@ -1,53 +1,68 @@
-// src/middleware/body-limit/index.ts
 import { HTTPException } from "../../http-exception.js";
-var ERROR_MESSAGE = "Payload Too Large";
-var bodyLimit = (options) => {
-  const onError = options.onError || (() => {
-    const res = new Response(ERROR_MESSAGE, {
-      status: 413
-    });
-    throw new HTTPException(413, { res });
-  });
-  const maxSize = options.maxSize;
-  return async function bodyLimit2(c, next) {
-    if (!c.req.raw.body) {
-      return next();
-    }
-    const hasTransferEncoding = c.req.raw.headers.has("transfer-encoding");
-    const hasContentLength = c.req.raw.headers.has("content-length");
-    if (hasContentLength && !hasTransferEncoding) {
-      const contentLength = parseInt(c.req.raw.headers.get("content-length") || "0", 10);
-      return contentLength > 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();
-  };
-};
-export {
-  bodyLimit
+//#region src/middleware/body-limit/index.ts
+const ERROR_MESSAGE = "Payload Too Large";
+/**
+* Body Limit Middleware for Hono.
+*
+* @see {@link https://hono.dev/docs/middleware/builtin/body-limit}
+*
+* @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 Hono()
+*
+* 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 || (() => {
+		const res = new Response(ERROR_MESSAGE, { status: 413 });
+		throw new HTTPException(413, { res });
+	});
+	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 };