acrylblends 0.6.3 → 0.6.4

package/lib/ssg-BwjcA-Ge.js

@@ -0,0 +1,389 @@
+import "./router.js";
+import { html } from "./html.js";
+import { getExtension } from "./utils/mime.js";
+import { findTargetHandler, isMiddleware } from "./utils/handler.js";
+import { o as replaceUrlParam } from "./utils-Cx61GFMC.js";
+import { createPool } from "./utils/concurrent.js";
+//#region ../../plugins/acryl-router/src/core/helper/ssg/utils.ts
+/**
+* Get dirname
+* @param path File Path
+* @returns Parent dir path
+*/
+const dirname = (path) => {
+	return path.split(/[\/\\]/).slice(0, -1).join("/");
+};
+const normalizePath = (path) => {
+	return path.replace(/(\\)/g, "/").replace(/\/$/g, "");
+};
+const getUncRoot = (path) => {
+	const uncRoot = path.replace(/\\/g, "/").match(/^\/\/([^/]+)\/([^/]+)/);
+	if (uncRoot) return `${uncRoot[1].toLowerCase()}/${uncRoot[2].toLowerCase()}`;
+};
+const handleParent = (resultPaths) => {
+	if (resultPaths.length === 0 || resultPaths[resultPaths.length - 1] === "..") resultPaths.push("..");
+	else resultPaths.pop();
+};
+const handleNonDot = (path, resultPaths) => {
+	path = path.replace(/^\.(?!.)/, "");
+	if (path !== "") resultPaths.push(path);
+};
+const handleSegments = (paths, resultPaths) => {
+	for (const path of paths) if (path === "..") handleParent(resultPaths);
+	else handleNonDot(path, resultPaths);
+};
+const joinPaths = (...paths) => {
+	const hasUncPrefix = getUncRoot(paths[0]) !== void 0;
+	paths = paths.map(normalizePath);
+	const resultPaths = [];
+	handleSegments(paths.join("/").split("/"), resultPaths);
+	return (hasUncPrefix ? "//" : paths[0][0] === "/" ? "/" : "") + resultPaths.join("/");
+};
+const filterStaticGenerateRoutes = (acryl) => {
+	return acryl.routes.reduce((acc, { method, handler, path }) => {
+		const targetHandler = findTargetHandler(handler);
+		if (["GET", "ALL"].includes(method) && !isMiddleware(targetHandler)) acc.push({ path });
+		return acc;
+	}, []);
+};
+const isDynamicRoute = (path) => {
+	return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
+};
+const toSegments = (path) => path === "" ? [] : path.split("/");
+const getPathRoot = (path) => {
+	const normalizedPath = path.replace(/\\/g, "/");
+	const uncRoot = getUncRoot(normalizedPath);
+	if (uncRoot) return `unc:${uncRoot}`;
+	const driveRoot = normalizedPath.match(/^([A-Za-z]):/);
+	if (driveRoot) return `${normalizedPath[2] === "/" ? "drive-absolute" : "drive-relative"}:${driveRoot[1].toLowerCase()}`;
+	return normalizedPath.startsWith("/") ? "absolute" : "relative";
+};
+const ensureWithinOutDir = (outDir, filePath) => {
+	const outDirSegments = toSegments(joinPaths(outDir));
+	const filePathSegments = toSegments(joinPaths(filePath));
+	const hasMismatchedPathRoot = getPathRoot(outDir) !== getPathRoot(filePath);
+	const climbsAboveOutDir = filePathSegments[outDirSegments.length] === "..";
+	if (hasMismatchedPathRoot || filePathSegments.length <= outDirSegments.length || !outDirSegments.every((segment, i) => segment === filePathSegments[i]) || climbsAboveOutDir) throw new Error(`Path traversal detected: "${filePath}" is outside the output directory`);
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/helper/ssg/middleware.ts
+const SSG_CONTEXT = "ACRYL_SSG_CONTEXT";
+const X_ACRYL_DISABLE_SSG_HEADER_KEY = "x-acryl-disable-ssg";
+(() => {
+	try {
+		return new Response("SSG is disabled", {
+			status: 404,
+			headers: { [X_ACRYL_DISABLE_SSG_HEADER_KEY]: "true" }
+		});
+	} catch {
+		return null;
+	}
+})();
+/**
+* Define SSG Route
+*/
+const ssgParams = (params) => async (c, next) => {
+	if (isDynamicRoute(c.req.path)) {
+		c.req.raw.ssgParams = Array.isArray(params) ? params : await params(c);
+		return c.notFound();
+	}
+	await next();
+};
+/**
+* @experimental
+* `isSSGContext` is an experimental feature.
+* The API might be changed.
+*/
+const isSSGContext = (c) => !!c.env?.[SSG_CONTEXT];
+/**
+* @experimental
+* `disableSSG` is an experimental feature.
+* The API might be changed.
+*/
+const disableSSG = () => async function disableSSG(c, next) {
+	if (isSSGContext(c)) {
+		c.header(X_ACRYL_DISABLE_SSG_HEADER_KEY, "true");
+		return c.notFound();
+	}
+	await next();
+};
+/**
+* @experimental
+* `onlySSG` is an experimental feature.
+* The API might be changed.
+*/
+const onlySSG = () => async function onlySSG(c, next) {
+	if (!isSSGContext(c)) return c.notFound();
+	await next();
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/helper/ssg/plugins.ts
+/**
+* The default plugin that defines the recommended behavior.
+*
+* @experimental
+* `defaultPlugin` is an experimental feature.
+* The API might be changed.
+*/
+const defaultPlugin = () => {
+	return { afterResponseHook: (res) => {
+		if (res.status !== 200) return false;
+		return res;
+	} };
+};
+const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const generateRedirectHtml = (location) => {
+	return html`<!DOCTYPE html>
+<title>Redirecting to: ${location}</title>
+<meta http-equiv="refresh" content="0;url=${location}" />
+<meta name="robots" content="noindex" />
+<link rel="canonical" href="${location}" />
+<body>
+<a href="${location}">Redirecting to <code>${location}</code></a>
+</body>
+`.toString().replace(/\n/g, "");
+};
+/**
+* The redirect plugin that generates HTML redirect pages for HTTP redirect responses for status codes 301, 302, 303, 307 and 308.
+*
+* When used with `defaultPlugin`, place `redirectPlugin` before it, because `defaultPlugin` skips non-200 responses.
+*
+* ```ts
+* // ✅ Will work as expected
+* toSSG(app, fs, { plugins: [redirectPlugin(), defaultPlugin()] })
+*
+* // ❌ Will not work as expected
+* toSSG(app, fs, { plugins: [defaultPlugin(), redirectPlugin()] })
+* ```
+*
+* @experimental
+* `redirectPlugin` is an experimental feature.
+* The API might be changed.
+*/
+const redirectPlugin = () => {
+	return { afterResponseHook: (res) => {
+		if (REDIRECT_STATUS_CODES.has(res.status)) {
+			const location = res.headers.get("Location");
+			if (!location) return false;
+			const htmlBody = generateRedirectHtml(location);
+			return new Response(htmlBody, {
+				status: 200,
+				headers: { "Content-Type": "text/html; charset=utf-8" }
+			});
+		}
+		return res;
+	} };
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/helper/ssg/ssg.ts
+const DEFAULT_CONCURRENCY = 2;
+const DEFAULT_CONTENT_TYPE = "text/plain";
+const DEFAULT_OUTPUT_DIR = "./static";
+const generateFilePath = (routePath, outDir, mimeType, extensionMap) => {
+	const extension = determineExtension(mimeType, extensionMap);
+	let filePath;
+	if (routePath.endsWith(`.${extension}`)) filePath = joinPaths(outDir, routePath);
+	else if (routePath === "/") filePath = joinPaths(outDir, `index.${extension}`);
+	else if (routePath.endsWith("/")) filePath = joinPaths(outDir, routePath, `index.${extension}`);
+	else filePath = joinPaths(outDir, `${routePath}.${extension}`);
+	ensureWithinOutDir(outDir, filePath);
+	return filePath;
+};
+const parseResponseContent = async (response) => {
+	const contentType = response.headers.get("Content-Type");
+	try {
+		if (contentType?.includes("text") || contentType?.includes("json")) return await response.text();
+		else return await response.arrayBuffer();
+	} catch (error) {
+		throw new Error(`Error processing response: ${error instanceof Error ? error.message : "Unknown error"}`);
+	}
+};
+const defaultExtensionMap = {
+	"text/html": "html",
+	"text/xml": "xml",
+	"application/xml": "xml",
+	"application/atom+xml": "xml",
+	"application/rss+xml": "xml",
+	"application/yaml": "yaml"
+};
+const determineExtension = (mimeType, userExtensionMap) => {
+	const extensionMap = userExtensionMap || defaultExtensionMap;
+	if (mimeType in extensionMap) return extensionMap[mimeType];
+	return getExtension(mimeType) || "html";
+};
+const combineBeforeRequestHooks = (hooks) => {
+	if (!Array.isArray(hooks)) return hooks;
+	return async (req) => {
+		let currentReq = req;
+		for (const hook of hooks) {
+			const result = await hook(currentReq);
+			if (result === false) return false;
+			if (result instanceof Request) currentReq = result;
+		}
+		return currentReq;
+	};
+};
+const combineAfterResponseHooks = (hooks) => {
+	if (!Array.isArray(hooks)) return hooks;
+	return async (res) => {
+		let currentRes = res;
+		for (const hook of hooks) {
+			const result = await hook(currentRes);
+			if (result === false) return false;
+			if (result instanceof Response) currentRes = result;
+		}
+		return currentRes;
+	};
+};
+const combineAfterGenerateHooks = (hooks, fsModule, options) => {
+	if (!Array.isArray(hooks)) return hooks;
+	return async (result) => {
+		for (const hook of hooks) await hook(result, fsModule, options);
+	};
+};
+/**
+* @experimental
+* `fetchRoutesContent` is an experimental feature.
+* The API might be changed.
+*/
+const fetchRoutesContent = function* (app, beforeRequestHook, afterResponseHook, concurrency) {
+	const baseURL = "http://localhost";
+	const pool = createPool({ concurrency });
+	for (const route of filterStaticGenerateRoutes(app)) {
+		const thisRouteBaseURL = new URL(route.path, baseURL).toString();
+		let forGetInfoURLRequest = new Request(thisRouteBaseURL);
+		yield new Promise(async (resolveGetInfo, rejectGetInfo) => {
+			try {
+				if (beforeRequestHook) {
+					const maybeRequest = await beforeRequestHook(forGetInfoURLRequest);
+					if (!maybeRequest) {
+						resolveGetInfo(void 0);
+						return;
+					}
+					forGetInfoURLRequest = maybeRequest;
+				}
+				await pool.run(() => app.fetch(forGetInfoURLRequest, { [SSG_CONTEXT]: true }));
+				if (!forGetInfoURLRequest.ssgParams) {
+					if (isDynamicRoute(route.path)) {
+						resolveGetInfo(void 0);
+						return;
+					}
+					forGetInfoURLRequest.ssgParams = [{}];
+				}
+				const requestInit = {
+					method: forGetInfoURLRequest.method,
+					headers: forGetInfoURLRequest.headers
+				};
+				resolveGetInfo((function* () {
+					for (const param of forGetInfoURLRequest.ssgParams) yield new Promise(async (resolveReq, rejectReq) => {
+						try {
+							const replacedUrlParam = replaceUrlParam(route.path, param);
+							let response = await pool.run(() => app.request(replacedUrlParam, requestInit, { [SSG_CONTEXT]: true }));
+							if (response.headers.get("x-acryl-disable-ssg")) {
+								resolveReq(void 0);
+								return;
+							}
+							if (afterResponseHook) {
+								const maybeResponse = await afterResponseHook(response);
+								if (!maybeResponse) {
+									resolveReq(void 0);
+									return;
+								}
+								response = maybeResponse;
+							}
+							resolveReq({
+								routePath: replacedUrlParam,
+								mimeType: response.headers.get("Content-Type")?.split(";")[0] || DEFAULT_CONTENT_TYPE,
+								content: await parseResponseContent(response)
+							});
+						} catch (error) {
+							rejectReq(error);
+						}
+					});
+				})());
+			} catch (error) {
+				rejectGetInfo(error);
+			}
+		});
+	}
+};
+/**
+* @experimental
+* `saveContentToFile` is an experimental feature.
+* The API might be changed.
+*/
+const createdDirs = /* @__PURE__ */ new Set();
+const saveContentToFile = async (data, fsModule, outDir, extensionMap) => {
+	const awaitedData = await data;
+	if (!awaitedData) return;
+	const { routePath, content, mimeType } = awaitedData;
+	const filePath = generateFilePath(routePath, outDir, mimeType, extensionMap);
+	const dirPath = dirname(filePath);
+	if (dirPath !== "" && !createdDirs.has(dirPath)) {
+		await fsModule.mkdir(dirPath, { recursive: true });
+		createdDirs.add(dirPath);
+	}
+	if (typeof content === "string") await fsModule.writeFile(filePath, content);
+	else if (content instanceof ArrayBuffer) await fsModule.writeFile(filePath, new Uint8Array(content));
+	return filePath;
+};
+/**
+* @experimental
+* `toSSG` is an experimental feature.
+* The API might be changed.
+*/
+const toSSG = async (app, fs, options) => {
+	let result;
+	const getInfoPromises = [];
+	const savePromises = [];
+	const plugins = options?.plugins || [defaultPlugin()];
+	const beforeRequestHooks = [];
+	const afterResponseHooks = [];
+	const afterGenerateHooks = [];
+	if (options?.beforeRequestHook) beforeRequestHooks.push(...Array.isArray(options.beforeRequestHook) ? options.beforeRequestHook : [options.beforeRequestHook]);
+	if (options?.afterResponseHook) afterResponseHooks.push(...Array.isArray(options.afterResponseHook) ? options.afterResponseHook : [options.afterResponseHook]);
+	if (options?.afterGenerateHook) afterGenerateHooks.push(...Array.isArray(options.afterGenerateHook) ? options.afterGenerateHook : [options.afterGenerateHook]);
+	for (const plugin of plugins) {
+		if (plugin.beforeRequestHook) beforeRequestHooks.push(...Array.isArray(plugin.beforeRequestHook) ? plugin.beforeRequestHook : [plugin.beforeRequestHook]);
+		if (plugin.afterResponseHook) afterResponseHooks.push(...Array.isArray(plugin.afterResponseHook) ? plugin.afterResponseHook : [plugin.afterResponseHook]);
+		if (plugin.afterGenerateHook) afterGenerateHooks.push(...Array.isArray(plugin.afterGenerateHook) ? plugin.afterGenerateHook : [plugin.afterGenerateHook]);
+	}
+	try {
+		const outputDir = options?.dir ?? "./static";
+		const concurrency = options?.concurrency ?? DEFAULT_CONCURRENCY;
+		const combinedBeforeRequestHook = combineBeforeRequestHooks(beforeRequestHooks.length > 0 ? beforeRequestHooks : [(req) => req]);
+		const combinedAfterResponseHook = combineAfterResponseHooks(afterResponseHooks.length > 0 ? afterResponseHooks : [(req) => req]);
+		const getInfoGen = fetchRoutesContent(app, combinedBeforeRequestHook, combinedAfterResponseHook, concurrency);
+		for (const getInfo of getInfoGen) getInfoPromises.push(getInfo.then((getContentGen) => {
+			if (!getContentGen) return;
+			for (const content of getContentGen) savePromises.push(saveContentToFile(content, fs, outputDir, options?.extensionMap).catch((e) => e));
+		}));
+		await Promise.all(getInfoPromises);
+		const files = [];
+		for (const savePromise of savePromises) {
+			const fileOrError = await savePromise;
+			if (typeof fileOrError === "string") files.push(fileOrError);
+			else if (fileOrError) throw fileOrError;
+		}
+		result = {
+			success: true,
+			files
+		};
+	} catch (error) {
+		result = {
+			success: false,
+			files: [],
+			error: error instanceof Error ? error : new Error(String(error))
+		};
+	}
+	if (afterGenerateHooks.length > 0) await combineAfterGenerateHooks(afterGenerateHooks, fs, options)(result, fs, options);
+	return result;
+};
+//#endregion
+export { defaultExtensionMap as a, toSSG as c, X_ACRYL_DISABLE_SSG_HEADER_KEY as d, disableSSG as f, ssgParams as h, combineBeforeRequestHooks as i, defaultPlugin as l, onlySSG as m, combineAfterGenerateHooks as n, fetchRoutesContent as o, isSSGContext as p, combineAfterResponseHooks as r, saveContentToFile as s, DEFAULT_OUTPUT_DIR as t, redirectPlugin as u };

package/lib/ssg.d.ts

@@ -0,0 +1,156 @@
+import { L as MiddlewareHandler, Y as Schema, t as Context, v as Env } from "./context-DS3fYyG-.js";
+import { t as Acryl } from "./app-D8riatvv.js";
+
+//#region ../../plugins/acryl-router/src/core/helper/ssg/ssg.d.ts
+declare const DEFAULT_OUTPUT_DIR = "./static";
+/**
+ * @experimental
+ * `FileSystemModule` is an experimental feature.
+ * The API might be changed.
+ */
+interface FileSystemModule {
+  writeFile(path: string, data: string | Uint8Array): Promise<void>;
+  mkdir(path: string, options: {
+    recursive: boolean;
+  }): Promise<void | string>;
+}
+/**
+ * @experimental
+ * `ToSSGResult` is an experimental feature.
+ * The API might be changed.
+ */
+interface ToSSGResult {
+  success: boolean;
+  files: string[];
+  error?: Error;
+}
+declare const defaultExtensionMap: Record<string, string>;
+type BeforeRequestHook = (req: Request) => Request | false | Promise<Request | false>;
+type AfterResponseHook = (res: Response) => Response | false | Promise<Response | false>;
+type AfterGenerateHook = (result: ToSSGResult, fsModule: FileSystemModule, options?: ToSSGOptions) => void | Promise<void>;
+declare const combineBeforeRequestHooks: (hooks: BeforeRequestHook | BeforeRequestHook[]) => BeforeRequestHook;
+declare const combineAfterResponseHooks: (hooks: AfterResponseHook | AfterResponseHook[]) => AfterResponseHook;
+declare const combineAfterGenerateHooks: (hooks: AfterGenerateHook | AfterGenerateHook[], fsModule: FileSystemModule, options?: ToSSGOptions) => AfterGenerateHook;
+interface SSGPlugin {
+  beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
+  afterResponseHook?: AfterResponseHook | AfterResponseHook[];
+  afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
+}
+interface ToSSGOptions {
+  dir?: string;
+  /**
+   * @deprecated Use plugins[].beforeRequestHook instead.
+   */
+  beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
+  /**
+   * @deprecated Use plugins[].afterResponseHook instead.
+   */
+  afterResponseHook?: AfterResponseHook | AfterResponseHook[];
+  /**
+   * @deprecated Use plugins[].afterGenerateHook instead.
+   */
+  afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
+  concurrency?: number;
+  extensionMap?: Record<string, string>;
+  plugins?: SSGPlugin[];
+}
+/**
+ * @experimental
+ * `fetchRoutesContent` is an experimental feature.
+ * The API might be changed.
+ */
+declare const fetchRoutesContent: <E extends Env = Env, S extends Schema = {}, BasePath extends string = "/">(app: Acryl<E, S, BasePath>, beforeRequestHook?: BeforeRequestHook, afterResponseHook?: AfterResponseHook, concurrency?: number) => Generator<Promise<Generator<Promise<{
+  routePath: string;
+  mimeType: string;
+  content: string | ArrayBuffer;
+} | undefined>> | undefined>>;
+declare const saveContentToFile: (data: Promise<{
+  routePath: string;
+  content: string | ArrayBuffer;
+  mimeType: string;
+} | undefined>, fsModule: FileSystemModule, outDir: string, extensionMap?: Record<string, string>) => Promise<string | undefined>;
+/**
+ * @experimental
+ * `ToSSGInterface` is an experimental feature.
+ * The API might be changed.
+ */
+interface ToSSGInterface {
+  (app: Acryl<any, any, any>, fsModule: FileSystemModule, options?: ToSSGOptions): Promise<ToSSGResult>;
+}
+/**
+ * @experimental
+ * `ToSSGAdaptorInterface` is an experimental feature.
+ * The API might be changed.
+ */
+interface ToSSGAdaptorInterface<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
+  (app: Acryl<E, S, BasePath>, options?: ToSSGOptions): Promise<ToSSGResult>;
+}
+/**
+ * @experimental
+ * `toSSG` is an experimental feature.
+ * The API might be changed.
+ */
+declare const toSSG: ToSSGInterface;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/helper/ssg/middleware.d.ts
+declare const X_ACRYL_DISABLE_SSG_HEADER_KEY = "x-acryl-disable-ssg";
+interface SSGParam {
+  [key: string]: string;
+}
+type SSGParams = SSGParam[];
+interface SSGParamsMiddleware {
+  <E extends Env = Env>(generateParams: (c: Context<E>) => SSGParams | Promise<SSGParams>): MiddlewareHandler<E>;
+  <E extends Env = Env>(params: SSGParams): MiddlewareHandler<E>;
+}
+/**
+ * Define SSG Route
+ */
+declare const ssgParams: SSGParamsMiddleware;
+/**
+ * @experimental
+ * `isSSGContext` is an experimental feature.
+ * The API might be changed.
+ */
+declare const isSSGContext: (c: Context) => boolean;
+/**
+ * @experimental
+ * `disableSSG` is an experimental feature.
+ * The API might be changed.
+ */
+declare const disableSSG: () => MiddlewareHandler;
+/**
+ * @experimental
+ * `onlySSG` is an experimental feature.
+ * The API might be changed.
+ */
+declare const onlySSG: () => MiddlewareHandler;
+//#endregion
+//#region ../../plugins/acryl-router/src/core/helper/ssg/plugins.d.ts
+/**
+ * The default plugin that defines the recommended behavior.
+ *
+ * @experimental
+ * `defaultPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+declare const defaultPlugin: () => SSGPlugin;
+/**
+ * The redirect plugin that generates HTML redirect pages for HTTP redirect responses for status codes 301, 302, 303, 307 and 308.
+ *
+ * When used with `defaultPlugin`, place `redirectPlugin` before it, because `defaultPlugin` skips non-200 responses.
+ *
+ * ```ts
+ * // ✅ Will work as expected
+ * toSSG(app, fs, { plugins: [redirectPlugin(), defaultPlugin()] })
+ *
+ * // ❌ Will not work as expected
+ * toSSG(app, fs, { plugins: [defaultPlugin(), redirectPlugin()] })
+ * ```
+ *
+ * @experimental
+ * `redirectPlugin` is an experimental feature.
+ * The API might be changed.
+ */
+declare const redirectPlugin: () => SSGPlugin;
+//#endregion
+export { AfterGenerateHook, AfterResponseHook, BeforeRequestHook, DEFAULT_OUTPUT_DIR, FileSystemModule, SSGPlugin, ToSSGAdaptorInterface, ToSSGInterface, ToSSGOptions, ToSSGResult, X_ACRYL_DISABLE_SSG_HEADER_KEY, combineAfterGenerateHooks, combineAfterResponseHooks, combineBeforeRequestHooks, defaultExtensionMap, defaultPlugin, disableSSG, fetchRoutesContent, isSSGContext, onlySSG, redirectPlugin, saveContentToFile, ssgParams, toSSG };

package/lib/ssg.js

@@ -0,0 +1,2 @@
+import { a as defaultExtensionMap, c as toSSG, d as X_ACRYL_DISABLE_SSG_HEADER_KEY, f as disableSSG, h as ssgParams, i as combineBeforeRequestHooks, l as defaultPlugin, m as onlySSG, n as combineAfterGenerateHooks, o as fetchRoutesContent, p as isSSGContext, r as combineAfterResponseHooks, s as saveContentToFile, t as DEFAULT_OUTPUT_DIR, u as redirectPlugin } from "./ssg-BwjcA-Ge.js";
+export { DEFAULT_OUTPUT_DIR, X_ACRYL_DISABLE_SSG_HEADER_KEY, combineAfterGenerateHooks, combineAfterResponseHooks, combineBeforeRequestHooks, defaultExtensionMap, defaultPlugin, disableSSG, fetchRoutesContent, isSSGContext, onlySSG, redirectPlugin, saveContentToFile, ssgParams, toSSG };

package/lib/streaming.d.ts

@@ -1,4 +1,4 @@
-import { t as Context } from "./context-DVQBjuns.js";
+import { t as Context } from "./context-DS3fYyG-.js";
 import { t as StreamingApi } from "./stream-CPdqZ0Fp.js";
 
 //#region ../../plugins/acryl-router/src/core/helper/streaming/stream.d.ts

package/lib/testing.d.ts

@@ -1,7 +1,7 @@
-import { J as Schema, a as ExecutionContext } from "./context-DVQBjuns.js";
+import { Y as Schema, a as ExecutionContext } from "./context-DS3fYyG-.js";
 import { D as UnionToIntersection } from "./types-Lqx5BxQF.js";
-import { t as Acryl } from "./app-wFwpg-bt.js";
-import { i as ClientRequestOptions, n as Client } from "./types-CQiGmsWW.js";
+import { t as Acryl } from "./app-D8riatvv.js";
+import { i as ClientRequestOptions, n as Client } from "./types-zNxyEpG2.js";
 
 //#region ../../plugins/acryl-router/src/core/helper/testing/index.d.ts
 type ExtractEnv<T> = T extends Acryl<infer E, Schema, string> ? E : never;

package/lib/testing.js

@@ -1,4 +1,4 @@
-import { t as hc } from "./client-BHTr318g.js";
+import { t as hc } from "./client-DDLXwhBo.js";
 //#region ../../plugins/acryl-router/src/core/helper/testing/index.ts
 /**
 * @module

package/lib/timeout.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-DVQBjuns.js";
+import { L as MiddlewareHandler, t as Context } from "./context-DS3fYyG-.js";
 import { HTTPException } from "./http-exception.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/timeout/index.d.ts

package/lib/timing.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler, t as Context } from "./context-DVQBjuns.js";
+import { L as MiddlewareHandler, t as Context } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/timing/timing.d.ts
 type TimingVariables = {

package/lib/tiny.d.ts

@@ -1,4 +1,4 @@
-import { $ as Acryl$1, J as Schema, _ as Env, et as AcrylOptions, h as BlankSchema, p as BlankEnv } from "./context-DVQBjuns.js";
+import { Y as Schema, et as Acryl$1, g as BlankSchema, m as BlankEnv, tt as AcrylOptions, v as Env } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/core/preset/tiny.d.ts
 declare class Acryl<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends Acryl$1<E, S, BasePath> {

package/lib/trailing-slash.d.ts

@@ -1,4 +1,4 @@
-import { I as MiddlewareHandler } from "./context-DVQBjuns.js";
+import { L as MiddlewareHandler } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/core/middleware/trailing-slash/index.d.ts
 type TrimTrailingSlashOptions = {

package/lib/{types-nEL8VPDC.d.ts → types-Dv_nV2cv.d.ts}

@@ -1,4 +1,4 @@
-import { t as Context } from "./context-DVQBjuns.js";
+import { t as Context } from "./context-DS3fYyG-.js";
 
 //#region ../../plugins/acryl-router/src/core/helper/conninfo/types.d.ts
 type AddressType = 'IPv6' | 'IPv4' | undefined;

package/lib/{types-CQiGmsWW.d.ts → types-zNxyEpG2.d.ts}

@@ -1,8 +1,8 @@
-import { $ as Acryl, J as Schema, K as ResponseFormat, N as KnownResponseFormat, g as Endpoint, x as ExtractSchema } from "./context-DVQBjuns.js";
+import { P as KnownResponseFormat, S as ExtractSchema, Y as Schema, _ as Endpoint, et as Acryl, q as ResponseFormat } from "./context-DS3fYyG-.js";
 import { i as METHOD_NAME_ALL_LOWERCASE, n as METHODS } from "./router-CvUxUTOq.js";
 import { c as StatusCode, l as SuccessStatusCode } from "./http-status-DaAwGAFL.js";
 import { c as HasRequiredKeys } from "./types-Lqx5BxQF.js";
-import { t as Acryl$1 } from "./app-wFwpg-bt.js";
+import { t as Acryl$1 } from "./app-D8riatvv.js";
 
 //#region ../../plugins/acryl-router/src/core/client/types.d.ts
 /**

package/lib/types.d.ts

@@ -1,2 +1,2 @@
-import { A as Input, B as NotFoundResponse, C as FetchEventLike, D as Handler, E as HTTPResponseError, F as MergeSchemaPath, G as RemoveQuestion, H as ParamKeyToRecord, I as MiddlewareHandler, J as Schema, K as ResponseFormat, L as MiddlewareHandlerInterface, M as IntersectNonAnyTypes, N as KnownResponseFormat, O as HandlerInterface, P as MergePath, Q as Variables, R as Next, S as ExtractSchemaForStatusCode, T as H, U as ParamKeys, V as OnHandlerInterface, W as ParsedFormValue, X as TypedResponse, Y as ToSchema, Z as ValidationTargets, _ as Env, b as ExtractInput, d as AddParam, f as Bindings, g as Endpoint, h as BlankSchema, j as InputToDataByTarget, k as HandlerResponse, m as BlankInput, p as BlankEnv, q as RouterRoute, v as ErrorHandler, w as FormValue, x as ExtractSchema, y as ExtractHandlerResponse, z as NotFoundHandler } from "./context-DVQBjuns.js";
+import { $ as Variables, A as HandlerResponse, B as NotFoundHandler, C as ExtractSchemaForStatusCode, D as HTTPResponseError, E as H, F as MergePath, G as ParsedFormValue, H as OnHandlerInterface, I as MergeSchemaPath, J as RouterRoute, K as RemoveQuestion, L as MiddlewareHandler, M as InputToDataByTarget, N as IntersectNonAnyTypes, O as Handler, P as KnownResponseFormat, Q as ValidationTargets, R as MiddlewareHandlerInterface, S as ExtractSchema, T as FormValue, U as ParamKeyToRecord, V as NotFoundResponse, W as ParamKeys, X as ToSchema, Y as Schema, Z as TypedResponse, _ as Endpoint, b as ExtractHandlerResponse, f as AddParam, g as BlankSchema, h as BlankInput, j as Input, k as HandlerInterface, m as BlankEnv, p as Bindings, q as ResponseFormat, v as Env, w as FetchEventLike, x as ExtractInput, y as ErrorHandler, z as Next } from "./context-DS3fYyG-.js";
 export { AddParam, Bindings, BlankEnv, BlankInput, BlankSchema, Endpoint, Env, ErrorHandler, ExtractHandlerResponse, ExtractInput, ExtractSchema, ExtractSchemaForStatusCode, FetchEventLike, FormValue, H, HTTPResponseError, Handler, HandlerInterface, HandlerResponse, Input, InputToDataByTarget, IntersectNonAnyTypes, KnownResponseFormat, MergePath, MergeSchemaPath, MiddlewareHandler, MiddlewareHandlerInterface, Next, NotFoundHandler, NotFoundResponse, OnHandlerInterface, ParamKeyToRecord, ParamKeys, ParsedFormValue, RemoveQuestion, ResponseFormat, RouterRoute, Schema, ToSchema, TypedResponse, ValidationTargets, Variables };

package/lib/utils/body.d.ts

@@ -1,2 +1,2 @@
-import { c as BodyData, l as ParseBodyOptions, u as parseBody } from "../context-DVQBjuns.js";
+import { d as parseBody, l as BodyData, u as ParseBodyOptions } from "../context-DS3fYyG-.js";
 export { BodyData, ParseBodyOptions, parseBody };

package/lib/utils/ipaddr.d.ts

@@ -1,4 +1,4 @@
-import { t as AddressType } from "../types-nEL8VPDC.js";
+import { t as AddressType } from "../types-Dv_nV2cv.js";
 
 //#region ../../plugins/acryl-router/src/core/utils/ipaddr.d.ts
 /**