acrylblends 0.7.3 → 0.7.5

package/lib/index-CseujaYI.d.ts

@@ -0,0 +1,31 @@
+import { L as MiddlewareHandler, i as Data, t as Context, v as Env } from "./context-DS3fYyG-.js";
+
+//#region ../../plugins/acryl-router/src/core/middleware/serve-static/index.d.ts
+type ServeStaticOptions<E extends Env = Env> = {
+  root?: string;
+  path?: string;
+  precompressed?: boolean; /** Allow percent signs in the routed request path. Defaults to false. */
+  allowPercentInPath?: boolean;
+  mimes?: Record<string, string>;
+  rewriteRequestPath?: (path: string) => string;
+  onFound?: (path: string, c: Context<E>) => void | Promise<void>;
+  onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
+};
+/**
+ * This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
+ */
+declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E> & {
+  getContent: (path: string, c: Context<E>) => Promise<Data | Response | null>;
+  /**
+   *
+   * `join` option according to the runtime. Example `import { join } from 'node:path`. If not specified, it will fall back to the default join function.`
+   */
+  join?: (...paths: string[]) => string;
+  /**
+   * @deprecated Currently, `pathResolve` is no longer used.
+   */
+  pathResolve?: (path: string) => string;
+  isDir?: (path: string) => boolean | undefined | Promise<boolean | undefined>;
+}) => MiddlewareHandler;
+//#endregion
+export { serveStatic as n, ServeStaticOptions as t };

package/lib/index-D4FAsBZu.d.ts

@@ -0,0 +1,85 @@
+//#region ../../plugins/acryl-db/src/facade/database.d.ts
+/** Values supported by the portable SQL drivers. */
+type SqlValue = null | number | bigint | string | Uint8Array;
+/**
+ * Asynchronous SQL operations shared by a database and its transaction handles.
+ *
+ * `exec` runs SQL text without bindings and may contain several statements. `run`, `get`, and `all`
+ * execute one statement with positional bindings. Adapters may cache prepared statements by SQL text,
+ * so callers pass values as bindings instead of interpolating them. `run` resolves the number of rows
+ * the statement changed.
+ */
+interface DbExecutor {
+  exec(sql: string): Promise<void>;
+  run(sql: string, ...params: SqlValue[]): Promise<{
+    readonly changes: number;
+  }>;
+  get<T extends object>(sql: string, ...params: SqlValue[]): Promise<T | undefined>;
+  all<T extends object>(sql: string, ...params: SqlValue[]): Promise<T[]>;
+}
+/**
+ * Minimal portable SQL database facade.
+ *
+ * All operations are asynchronous so adapters may execute outside the caller's runtime.
+ *
+ * `transaction` passes the callback a transaction handle. All work in the transaction
+ * must use that handle; the handle is invalid after the callback settles. Adapters must
+ * queue unrelated operations and other transactions until the transaction finishes. The
+ * returned promise settles after commit or rollback. Calling the database itself (including
+ * `transaction`) from inside a callback therefore waits for that transaction and
+ * never settles.
+ *
+ * When the callback rejects, the adapter must roll the transaction back before rejecting
+ * with that same error. If rollback fails, it must reject with a different error (for
+ * example an `AggregateError`) so callers cannot mistake the callback error for a
+ * guaranteed rollback.
+ *
+ * Closing is the adapter's: the plugin that opened a database closes it, so the facade an
+ * app receives has no `close`.
+ */
+interface Db extends DbExecutor {
+  transaction<T>(callback: (transaction: DbExecutor) => Promise<T>): Promise<T>;
+}
+//#endregion
+//#region ../../plugins/acryl-db/src/facade/migrations.d.ts
+type Migration = {
+  readonly version: number;
+  readonly statements: readonly string[];
+};
+/**
+ * Apply all pending migrations atomically, tracking their version in the named metadata table.
+ *
+ * The bookkeeping SQL runs unchanged on SQLite and Postgres: no `STRICT` table, `ON CONFLICT DO NOTHING`
+ * instead of `INSERT OR IGNORE`, and the version written as a checked integer rather than a binding,
+ * since the two dialects spell placeholders differently.
+ */
+declare function applyMigrations(database: Db, migrations: readonly Migration[], options: {
+  readonly table: string;
+}): Promise<void>;
+//#endregion
+//#region ../../plugins/acryl-db/src/facade/schema.d.ts
+/** Validate a prefix before using it as part of a SQL identifier. */
+declare function validateSchemaPrefix(prefix: string): void;
+//#endregion
+//#region ../../plugins/acryl-db/src/migration-files.d.ts
+/**
+ * Read every `NNN-name.sql` file of a folder, in number order.
+ * @throws when a `.sql` file is not named `NNN-name.sql`, or the numbers do not run 1, 2, 3, ... without gaps or repeats.
+ */
+declare function readMigrationFiles(folder: string | URL): Promise<Migration[]>;
+//#endregion
+//#region ../../plugins/acryl-db/src/index.d.ts
+/**
+ * The `db` port: what an app's code sees of its relational database, whichever provider (`acryl-db-sqlite`, `acryl-db-postgres`) serves
+ * it. Plain code (an acrylblends app) opens a database with a provider's `openDb`; a Cordis plugin declares `inject: ['db']`, imports
+ * `acryl-db/cordis` for the `ctx.db` type, and never imports a driver.
+ *
+ * Bindings are positional `?` placeholders on every provider; a provider whose database spells them differently translates them.
+ * This entry imports nothing from Cordis, at runtime or in its types.
+ */
+/** The service name every `db` provider registers. */
+declare const DB_SERVICE = "db";
+/** The table that records an app's migration version. */
+declare const MIGRATIONS_TABLE = "_migrations";
+//#endregion
+export { Migration as a, DbExecutor as c, validateSchemaPrefix as i, SqlValue as l, MIGRATIONS_TABLE as n, applyMigrations as o, readMigrationFiles as r, Db as s, DB_SERVICE as t };

package/lib/index-DaJtL7ci.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 { saveContentToFile as C, fetchRoutesContent as S, ToSSGResult as _, isSSGContext as a, combineBeforeRequestHooks as b, AfterGenerateHook as c, DEFAULT_OUTPUT_DIR as d, FileSystemModule as f, ToSSGOptions as g, ToSSGInterface as h, disableSSG as i, AfterResponseHook as l, ToSSGAdaptorInterface as m, redirectPlugin as n, onlySSG as o, SSGPlugin as p, X_ACRYL_DISABLE_SSG_HEADER_KEY as r, ssgParams as s, defaultPlugin as t, BeforeRequestHook as u, combineAfterGenerateHooks as v, toSSG as w, defaultExtensionMap as x, combineAfterResponseHooks as y };

package/lib/lambda-edge.d.ts

@@ -0,0 +1,92 @@
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { t as Acryl } from "./app-D8riatvv.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/lambda-edge/handler.d.ts
+interface CloudFrontHeader {
+  key: string;
+  value: string;
+}
+interface CloudFrontHeaders {
+  [name: string]: CloudFrontHeader[];
+}
+interface CloudFrontCustomOrigin {
+  customHeaders: CloudFrontHeaders;
+  domainName: string;
+  keepaliveTimeout: number;
+  path: string;
+  port: number;
+  protocol: string;
+  readTimeout: number;
+  sslProtocols: string[];
+}
+interface CloudFrontS3Origin {
+  authMethod: 'origin-access-identity' | 'none';
+  customHeaders: CloudFrontHeaders;
+  domainName: string;
+  path: string;
+  region: string;
+}
+type CloudFrontOrigin = {
+  s3: CloudFrontS3Origin;
+  custom?: never;
+} | {
+  custom: CloudFrontCustomOrigin;
+  s3?: never;
+};
+interface CloudFrontRequest {
+  clientIp: string;
+  headers: CloudFrontHeaders;
+  method: string;
+  querystring: string;
+  uri: string;
+  body?: {
+    inputTruncated: boolean;
+    action: string;
+    encoding: string;
+    data: string;
+  };
+  origin?: CloudFrontOrigin;
+}
+interface CloudFrontResponse {
+  headers: CloudFrontHeaders;
+  status: string;
+  statusDescription?: string;
+}
+interface CloudFrontConfig {
+  distributionDomainName: string;
+  distributionId: string;
+  eventType: string;
+  requestId: string;
+}
+interface CloudFrontEvent {
+  cf: {
+    config: CloudFrontConfig;
+    request: CloudFrontRequest;
+    response?: CloudFrontResponse;
+  };
+}
+interface CloudFrontEdgeEvent {
+  Records: CloudFrontEvent[];
+}
+type CloudFrontContext = {};
+interface Callback {
+  (err: Error | null, result?: CloudFrontRequest | CloudFrontResult): void;
+}
+interface CloudFrontResult {
+  status: string;
+  statusDescription?: string;
+  headers?: {
+    [header: string]: {
+      key: string;
+      value: string;
+    }[];
+  };
+  body?: string;
+  bodyEncoding?: 'text' | 'base64';
+}
+declare const handle: (app: Acryl<any>) => ((event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult | CloudFrontRequest>);
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/lambda-edge/conninfo.d.ts
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { type Callback, type CloudFrontConfig, type CloudFrontEdgeEvent, type CloudFrontRequest, type CloudFrontResponse, getConnInfo, handle };

package/lib/lambda-edge.js

@@ -0,0 +1,105 @@
+import { decodeBase64, encodeBase64 } from "./utils/encode.js";
+import crypto from "node:crypto";
+//#region ../../plugins/acryl-router/src/core/adapter/lambda-edge/handler.ts
+globalThis.crypto ??= crypto;
+/**
+* Accepts events from 'Lambda@Edge' event
+* https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html
+*/
+const convertHeaders = (headers) => {
+	const cfHeaders = {};
+	headers.forEach((value, key) => {
+		cfHeaders[key.toLowerCase()] = [...cfHeaders[key.toLowerCase()] || [], {
+			key: key.toLowerCase(),
+			value
+		}];
+	});
+	return cfHeaders;
+};
+const handle = (app) => {
+	return async (event, ...args) => {
+		const [context, callback] = args;
+		let callbackError = null;
+		let callbackResult;
+		const cf = getCloudFrontRecord(event);
+		const res = await app.fetch(createRequest(cf), {
+			event,
+			context,
+			callback: (err, result) => {
+				if (!callbackError && !callbackResult) {
+					callbackError = err;
+					callbackResult = result;
+				}
+				callback?.(err, result);
+			},
+			config: cf.config,
+			request: cf.request,
+			response: cf.response
+		});
+		if (callbackError) throw callbackError;
+		return callbackResult ?? createResult(res);
+	};
+};
+const createResult = async (res) => {
+	const contentEncoding = res.headers.get("content-encoding");
+	const isBase64Encoded = isContentTypeBinary(res.headers.get("content-type") || "") || !!contentEncoding && !/^identity$/i.test(contentEncoding);
+	const body = isBase64Encoded ? encodeBase64(await res.arrayBuffer()) : await res.text();
+	return {
+		status: res.status.toString(),
+		headers: convertHeaders(res.headers),
+		body,
+		...isBase64Encoded && { bodyEncoding: "base64" }
+	};
+};
+/**
+* Reads the CloudFront record out of a Lambda@Edge event.
+*
+* The event is supplied by the runtime, so a malformed one means the function
+* was invoked with something other than a Lambda@Edge event. Fail with a
+* message naming the adapter and the missing field, rather than letting an
+* unattributable property access error escape.
+*/
+const getCloudFrontRecord = (event) => {
+	const cf = event?.Records?.[0]?.cf;
+	if (!cf?.request) throw new TypeError("Unable to map the CloudFront event to a Request: expected `Records[0].cf.request` in the Lambda@Edge event.");
+	return cf;
+};
+const createRequest = (cf) => {
+	const request = cf.request;
+	const queryString = request.querystring;
+	const urlPath = `https://${request.headers?.host?.[0]?.value || cf.config?.distributionDomainName}${request.uri}`;
+	const url = queryString ? `${urlPath}?${queryString}` : urlPath;
+	const headers = new Headers();
+	Object.entries(request.headers ?? {}).forEach(([k, v]) => {
+		v.forEach((header) => headers.append(k, header.value));
+	});
+	const requestBody = request.body;
+	const method = request.method;
+	const rawBody = createBody(method, requestBody);
+	let body = rawBody;
+	if (rawBody !== void 0) {
+		const bytes = typeof rawBody === "string" ? new TextEncoder().encode(rawBody) : rawBody;
+		body = bytes;
+		headers.set("content-length", bytes.length.toString());
+	}
+	return new Request(url, {
+		headers,
+		method,
+		body
+	});
+};
+const createBody = (method, requestBody) => {
+	if (!requestBody || !requestBody.data) return;
+	if (method === "GET" || method === "HEAD") return;
+	if (requestBody.encoding === "base64") return decodeBase64(requestBody.data);
+	return requestBody.data;
+};
+const isContentTypeBinary = (contentType) => {
+	if (/^application\/vnd\.(?:apple\.installer|mozilla\.xul)\+xml\s*(?:;|$)/i.test(contentType)) return true;
+	return !/^text\/(?:plain|html|css|javascript|csv)|(?:\/|\+)(?:json|xml)\s*(?:;|$)/i.test(contentType);
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/lambda-edge/conninfo.ts
+const getConnInfo = (c) => ({ remote: { address: c.env.event.Records[0].cf.request.clientIp } });
+//#endregion
+export { getConnInfo, handle };

package/lib/netlify.d.ts

@@ -0,0 +1,29 @@
+import { r as GetConnInfo } from "./types-Dv_nV2cv.js";
+import { t as Acryl } from "./app-D8riatvv.js";
+
+//#region ../../plugins/acryl-router/src/core/adapter/netlify/handler.d.ts
+declare const handle: (app: Acryl<any, any>) => ((req: Request, context: any) => Response | Promise<Response>);
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/netlify/conninfo.d.ts
+/**
+ * Get connection information from Netlify
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Acryl } from 'acrylblends'
+ * import { handle, getConnInfo } from 'acrylblends/netlify'
+ *
+ * const app = new Acryl()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export default handle(app)
+ * ```
+ */
+declare const getConnInfo: GetConnInfo;
+//#endregion
+export { getConnInfo, handle };

package/lib/netlify.js

@@ -0,0 +1,30 @@
+//#region ../../plugins/acryl-router/src/core/adapter/netlify/handler.ts
+const handle = (app) => {
+	return (req, context) => {
+		return app.fetch(req, { context });
+	};
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/adapter/netlify/conninfo.ts
+/**
+* Get connection information from Netlify
+* @param c - Context
+* @returns Connection information including remote address
+* @example
+* ```ts
+* import { Acryl } from 'acrylblends'
+* import { handle, getConnInfo } from 'acrylblends/netlify'
+*
+* const app = new Acryl()
+*
+* app.get('/', (c) => {
+*   const info = getConnInfo(c)
+*   return c.text(`Your IP: ${info.remote.address}`)
+* })
+*
+* export default handle(app)
+* ```
+*/
+const getConnInfo = (c) => ({ remote: { address: c.env.context?.ip } });
+//#endregion
+export { getConnInfo, handle };

package/lib/node-server/register.js

@@ -1,4 +1,4 @@
-import { n as compileModule } from "../transpile-CTnWof4z.js";
+import { n as compileModule } from "../transpile-QUK9b3eG.js";
 import { registerHooks } from "node:module";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";

package/lib/node-server/serve-static.js

@@ -1,2 +1,2 @@
-import { t as serveStatic } from "../serve-static-B14MF1Va.js";
+import { t as serveStatic } from "../serve-static-B849HlX2.js";
 export { serveStatic };

package/lib/node-server.js

@@ -1,14 +1,14 @@
 import { t as Acryl } from "./app-BM0rTCp7.js";
 import { basePath } from "./route.js";
 import { defineWebSocketHelper } from "./ws.js";
-import { t as serveStatic } from "./serve-static-B14MF1Va.js";
+import { t as serveStatic } from "./serve-static-B849HlX2.js";
 import { getConnInfo } from "./node-server/conninfo.js";
-import { n as compileModule, t as MissingTypeScriptError } from "./transpile-CTnWof4z.js";
+import { n as compileModule, t as MissingTypeScriptError } from "./transpile-QUK9b3eG.js";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { STATUS_CODES, ServerResponse, createServer } from "node:http";
 import { Http2ServerRequest, constants } from "node:http2";
 import { Readable } from "node:stream";
 import { copyFileSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region ../../plugins/acryl-node-server/src/adapter/error.ts
 var RequestError = class extends Error {

package/lib/serve-static-Cp5adzGo.js

@@ -0,0 +1,77 @@
+import { tryDecodeURI } from "./utils/url.js";
+import { parseAccept } from "./utils/accept.js";
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "./utils/compress.js";
+import { getMimeType } from "./utils/mime.js";
+//#region ../../plugins/acryl-router/src/core/middleware/serve-static/path.ts
+/**
+* `defaultJoin` does not support Windows paths and always uses `/` separators.
+* If you need Windows path support, please use `join` exported from `node:path` etc. instead.
+*/
+const defaultJoin = (...paths) => {
+	let result = paths.filter((p) => p !== "").join("/");
+	result = result.replace(/(?<=\/)\/+/g, "");
+	const segments = result.split("/");
+	const resolved = [];
+	for (const segment of segments) if (segment === ".." && resolved.length > 0 && resolved.at(-1) !== "..") resolved.pop();
+	else if (segment !== ".") resolved.push(segment);
+	return resolved.join("/") || ".";
+};
+//#endregion
+//#region ../../plugins/acryl-router/src/core/middleware/serve-static/index.ts
+const ENCODINGS = {
+	br: ".br",
+	zstd: ".zst",
+	gzip: ".gz"
+};
+const ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+const DEFAULT_DOCUMENT = "index.html";
+/**
+* This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
+*/
+const serveStatic = (options) => {
+	const root = options.root ?? "./";
+	const optionPath = options.path;
+	const join = options.join ?? defaultJoin;
+	return async (c, next) => {
+		if (c.finalized) return next();
+		if (c.req.method !== "GET" && c.req.method !== "HEAD") return next();
+		let filename;
+		if (options.path) filename = options.path;
+		else try {
+			if (!options.allowPercentInPath && c.req.path.includes("%")) throw new Error();
+			filename = tryDecodeURI(c.req.path);
+			if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) throw new Error();
+		} catch {
+			await options.onNotFound?.(c.req.path, c);
+			return next();
+		}
+		let path = join(root, !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename);
+		if (options.isDir && await options.isDir(path)) path = join(path, DEFAULT_DOCUMENT);
+		const getContent = options.getContent;
+		let content = await getContent(path, c);
+		if (content instanceof Response) return c.newResponse(content.body, content);
+		if (content != null) {
+			const mimeType = options.mimes && getMimeType(path, options.mimes) || getMimeType(path);
+			c.header("Content-Type", mimeType || "application/octet-stream");
+			if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+				const acceptEncodingSet = new Set(parseAccept(c.req.header("Accept-Encoding") ?? "").filter((encoding) => encoding.q > 0).map((encoding) => encoding.type));
+				for (const encoding of ENCODINGS_ORDERED_KEYS) {
+					if (!acceptEncodingSet.has(encoding)) continue;
+					const compressedContent = await getContent(path + ENCODINGS[encoding], c);
+					if (compressedContent) {
+						content = compressedContent;
+						c.header("Content-Encoding", encoding);
+						c.header("Vary", "Accept-Encoding", { append: true });
+						break;
+					}
+				}
+			}
+			await options.onFound?.(path, c);
+			return c.body(content);
+		}
+		await options.onNotFound?.(path, c);
+		await next();
+	};
+};
+//#endregion
+export { serveStatic as t };

package/lib/serve-static.d.ts

@@ -1,31 +1,2 @@
-import { L as MiddlewareHandler, i as Data, t as Context, v as Env } from "./context-DS3fYyG-.js";
-
-//#region ../../plugins/acryl-router/src/core/middleware/serve-static/index.d.ts
-type ServeStaticOptions<E extends Env = Env> = {
-  root?: string;
-  path?: string;
-  precompressed?: boolean; /** Allow percent signs in the routed request path. Defaults to false. */
-  allowPercentInPath?: boolean;
-  mimes?: Record<string, string>;
-  rewriteRequestPath?: (path: string) => string;
-  onFound?: (path: string, c: Context<E>) => void | Promise<void>;
-  onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
-};
-/**
- * This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
- */
-declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E> & {
-  getContent: (path: string, c: Context<E>) => Promise<Data | Response | null>;
-  /**
-   *
-   * `join` option according to the runtime. Example `import { join } from 'node:path`. If not specified, it will fall back to the default join function.`
-   */
-  join?: (...paths: string[]) => string;
-  /**
-   * @deprecated Currently, `pathResolve` is no longer used.
-   */
-  pathResolve?: (path: string) => string;
-  isDir?: (path: string) => boolean | undefined | Promise<boolean | undefined>;
-}) => MiddlewareHandler;
-//#endregion
+import { n as serveStatic, t as ServeStaticOptions } from "./index-CseujaYI.js";
 export { ServeStaticOptions, serveStatic };