likec4 1.48.0 → 1.49.0

package/dist/_chunks/libs/hono.mjs

@@ -1,1829 +0,0 @@
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/compose.js
-var compose = (middleware, onError, onNotFound) => {
-	return (context, next) => {
-		let index = -1;
-		return dispatch(0);
-		async function dispatch(i) {
-			if (i <= index) throw new Error("next() called multiple times");
-			index = i;
-			let res;
-			let isError = false;
-			let handler;
-			if (middleware[i]) {
-				handler = middleware[i][0][0];
-				context.req.routeIndex = i;
-			} else handler = i === middleware.length && next || void 0;
-			if (handler) try {
-				res = await handler(context, () => dispatch(i + 1));
-			} catch (err) {
-				if (err instanceof Error && onError) {
-					context.error = err;
-					res = await onError(err, context);
-					isError = true;
-				} else throw err;
-			}
-			else if (context.finalized === false && onNotFound) res = await onNotFound(context);
-			if (res && (context.finalized === false || isError)) context.res = res;
-			return context;
-		}
-	};
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/request/constants.js
-var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/utils/body.js
-var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
-	const { all = false, dot = false } = options;
-	const contentType = (request instanceof HonoRequest ? request.raw.headers : request.headers).get("Content-Type");
-	if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) return parseFormData(request, {
-		all,
-		dot
-	});
-	return {};
-};
-async function parseFormData(request, options) {
-	const formData = await request.formData();
-	if (formData) return convertFormDataToBodyData(formData, options);
-	return {};
-}
-function convertFormDataToBodyData(formData, options) {
-	const form = /* @__PURE__ */ Object.create(null);
-	formData.forEach((value, key) => {
-		if (!(options.all || key.endsWith("[]"))) form[key] = value;
-		else handleParsingAllValues(form, key, value);
-	});
-	if (options.dot) Object.entries(form).forEach(([key, value]) => {
-		if (key.includes(".")) {
-			handleParsingNestedValues(form, key, value);
-			delete form[key];
-		}
-	});
-	return form;
-}
-var handleParsingAllValues = (form, key, value) => {
-	if (form[key] !== void 0) if (Array.isArray(form[key])) form[key].push(value);
-	else form[key] = [form[key], value];
-	else if (!key.endsWith("[]")) form[key] = value;
-	else form[key] = [value];
-};
-var handleParsingNestedValues = (form, key, value) => {
-	let nestedForm = form;
-	const keys = key.split(".");
-	keys.forEach((key2, index) => {
-		if (index === keys.length - 1) nestedForm[key2] = value;
-		else {
-			if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) nestedForm[key2] = /* @__PURE__ */ Object.create(null);
-			nestedForm = nestedForm[key2];
-		}
-	});
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/utils/url.js
-var splitPath = (path) => {
-	const paths = path.split("/");
-	if (paths[0] === "") paths.shift();
-	return paths;
-};
-var splitRoutingPath = (routePath) => {
-	const { groups, path } = extractGroupsFromPath(routePath);
-	return replaceGroupMarks(splitPath(path), groups);
-};
-var extractGroupsFromPath = (path) => {
-	const groups = [];
-	path = path.replace(/\{[^}]+\}/g, (match, index) => {
-		const mark = `@${index}`;
-		groups.push([mark, match]);
-		return mark;
-	});
-	return {
-		groups,
-		path
-	};
-};
-var replaceGroupMarks = (paths, groups) => {
-	for (let i = groups.length - 1; i >= 0; i--) {
-		const [mark] = groups[i];
-		for (let j = paths.length - 1; j >= 0; j--) if (paths[j].includes(mark)) {
-			paths[j] = paths[j].replace(mark, groups[i][1]);
-			break;
-		}
-	}
-	return paths;
-};
-var patternCache = {};
-var getPattern = (label, next) => {
-	if (label === "*") return "*";
-	const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-	if (match) {
-		const cacheKey = `${label}#${next}`;
-		if (!patternCache[cacheKey]) if (match[2]) patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [
-			cacheKey,
-			match[1],
-			new RegExp(`^${match[2]}(?=/${next})`)
-		] : [
-			label,
-			match[1],
-			new RegExp(`^${match[2]}$`)
-		];
-		else patternCache[cacheKey] = [
-			label,
-			match[1],
-			true
-		];
-		return patternCache[cacheKey];
-	}
-	return null;
-};
-var tryDecode = (str, decoder) => {
-	try {
-		return decoder(str);
-	} catch {
-		return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
-			try {
-				return decoder(match);
-			} catch {
-				return match;
-			}
-		});
-	}
-};
-var tryDecodeURI = (str) => tryDecode(str, decodeURI);
-var getPath = (request) => {
-	const url = request.url;
-	const start = url.indexOf("/", url.indexOf(":") + 4);
-	let i = start;
-	for (; i < url.length; i++) {
-		const charCode = url.charCodeAt(i);
-		if (charCode === 37) {
-			const queryIndex = url.indexOf("?", i);
-			const path = url.slice(start, queryIndex === -1 ? void 0 : queryIndex);
-			return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
-		} else if (charCode === 63) break;
-	}
-	return url.slice(start, i);
-};
-var getPathNoStrict = (request) => {
-	const result = getPath(request);
-	return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
-};
-var mergePath = (base, sub, ...rest) => {
-	if (rest.length) sub = mergePath(sub, ...rest);
-	return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
-};
-var checkOptionalParameter = (path) => {
-	if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) return null;
-	const segments = path.split("/");
-	const results = [];
-	let basePath = "";
-	segments.forEach((segment) => {
-		if (segment !== "" && !/\:/.test(segment)) basePath += "/" + segment;
-		else if (/\:/.test(segment)) if (/\?/.test(segment)) {
-			if (results.length === 0 && basePath === "") results.push("/");
-			else results.push(basePath);
-			const optionalSegment = segment.replace("?", "");
-			basePath += "/" + optionalSegment;
-			results.push(basePath);
-		} else basePath += "/" + segment;
-	});
-	return results.filter((v, i, a) => a.indexOf(v) === i);
-};
-var _decodeURI = (value) => {
-	if (!/[%+]/.test(value)) return value;
-	if (value.indexOf("+") !== -1) value = value.replace(/\+/g, " ");
-	return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
-};
-var _getQueryParam = (url, key, multiple) => {
-	let encoded;
-	if (!multiple && key && !/[%+]/.test(key)) {
-		let keyIndex2 = url.indexOf("?", 8);
-		if (keyIndex2 === -1) return;
-		if (!url.startsWith(key, keyIndex2 + 1)) keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-		while (keyIndex2 !== -1) {
-			const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
-			if (trailingKeyCode === 61) {
-				const valueIndex = keyIndex2 + key.length + 2;
-				const endIndex = url.indexOf("&", valueIndex);
-				return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
-			} else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) return "";
-			keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
-		}
-		encoded = /[%+]/.test(url);
-		if (!encoded) return;
-	}
-	const results = {};
-	encoded ??= /[%+]/.test(url);
-	let keyIndex = url.indexOf("?", 8);
-	while (keyIndex !== -1) {
-		const nextKeyIndex = url.indexOf("&", keyIndex + 1);
-		let valueIndex = url.indexOf("=", keyIndex);
-		if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) valueIndex = -1;
-		let name = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex);
-		if (encoded) name = _decodeURI(name);
-		keyIndex = nextKeyIndex;
-		if (name === "") continue;
-		let value;
-		if (valueIndex === -1) value = "";
-		else {
-			value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
-			if (encoded) value = _decodeURI(value);
-		}
-		if (multiple) {
-			if (!(results[name] && Array.isArray(results[name]))) results[name] = [];
-			results[name].push(value);
-		} else results[name] ??= value;
-	}
-	return key ? results[key] : results;
-};
-var getQueryParam = _getQueryParam;
-var getQueryParams = (url, key) => {
-	return _getQueryParam(url, key, true);
-};
-var decodeURIComponent_ = decodeURIComponent;
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/request.js
-var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
-var HonoRequest = class {
-	/**
-	* `.raw` can get the raw Request object.
-	*
-	* @see {@link https://hono.dev/docs/api/request#raw}
-	*
-	* @example
-	* ```ts
-	* // For Cloudflare Workers
-	* app.post('/', async (c) => {
-	*   const metadata = c.req.raw.cf?.hostMetadata?
-	*   ...
-	* })
-	* ```
-	*/
-	raw;
-	#validatedData;
-	#matchResult;
-	routeIndex = 0;
-	/**
-	* `.path` can get the pathname of the request.
-	*
-	* @see {@link https://hono.dev/docs/api/request#path}
-	*
-	* @example
-	* ```ts
-	* app.get('/about/me', (c) => {
-	*   const pathname = c.req.path // `/about/me`
-	* })
-	* ```
-	*/
-	path;
-	bodyCache = {};
-	constructor(request, path = "/", matchResult = [[]]) {
-		this.raw = request;
-		this.path = path;
-		this.#matchResult = matchResult;
-		this.#validatedData = {};
-	}
-	param(key) {
-		return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
-	}
-	#getDecodedParam(key) {
-		const paramKey = this.#matchResult[0][this.routeIndex][1][key];
-		const param = this.#getParamValue(paramKey);
-		return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
-	}
-	#getAllDecodedParams() {
-		const decoded = {};
-		const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
-		for (const key of keys) {
-			const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-			if (value !== void 0) decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
-		}
-		return decoded;
-	}
-	#getParamValue(paramKey) {
-		return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
-	}
-	query(key) {
-		return getQueryParam(this.url, key);
-	}
-	queries(key) {
-		return getQueryParams(this.url, key);
-	}
-	header(name) {
-		if (name) return this.raw.headers.get(name) ?? void 0;
-		const headerData = {};
-		this.raw.headers.forEach((value, key) => {
-			headerData[key] = value;
-		});
-		return headerData;
-	}
-	async parseBody(options) {
-		return this.bodyCache.parsedBody ??= await parseBody(this, options);
-	}
-	#cachedBody = (key) => {
-		const { bodyCache, raw } = this;
-		const cachedBody = bodyCache[key];
-		if (cachedBody) return cachedBody;
-		const anyCachedKey = Object.keys(bodyCache)[0];
-		if (anyCachedKey) return bodyCache[anyCachedKey].then((body) => {
-			if (anyCachedKey === "json") body = JSON.stringify(body);
-			return new Response(body)[key]();
-		});
-		return bodyCache[key] = raw[key]();
-	};
-	/**
-	* `.json()` can parse Request body of type `application/json`
-	*
-	* @see {@link https://hono.dev/docs/api/request#json}
-	*
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.json()
-	* })
-	* ```
-	*/
-	json() {
-		return this.#cachedBody("text").then((text) => JSON.parse(text));
-	}
-	/**
-	* `.text()` can parse Request body of type `text/plain`
-	*
-	* @see {@link https://hono.dev/docs/api/request#text}
-	*
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.text()
-	* })
-	* ```
-	*/
-	text() {
-		return this.#cachedBody("text");
-	}
-	/**
-	* `.arrayBuffer()` parse Request body as an `ArrayBuffer`
-	*
-	* @see {@link https://hono.dev/docs/api/request#arraybuffer}
-	*
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.arrayBuffer()
-	* })
-	* ```
-	*/
-	arrayBuffer() {
-		return this.#cachedBody("arrayBuffer");
-	}
-	/**
-	* Parses the request body as a `Blob`.
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.blob();
-	* });
-	* ```
-	* @see https://hono.dev/docs/api/request#blob
-	*/
-	blob() {
-		return this.#cachedBody("blob");
-	}
-	/**
-	* Parses the request body as `FormData`.
-	* @example
-	* ```ts
-	* app.post('/entry', async (c) => {
-	*   const body = await c.req.formData();
-	* });
-	* ```
-	* @see https://hono.dev/docs/api/request#formdata
-	*/
-	formData() {
-		return this.#cachedBody("formData");
-	}
-	/**
-	* Adds validated data to the request.
-	*
-	* @param target - The target of the validation.
-	* @param data - The validated data to add.
-	*/
-	addValidatedData(target, data) {
-		this.#validatedData[target] = data;
-	}
-	valid(target) {
-		return this.#validatedData[target];
-	}
-	/**
-	* `.url()` can get the request url strings.
-	*
-	* @see {@link https://hono.dev/docs/api/request#url}
-	*
-	* @example
-	* ```ts
-	* app.get('/about/me', (c) => {
-	*   const url = c.req.url // `http://localhost:8787/about/me`
-	*   ...
-	* })
-	* ```
-	*/
-	get url() {
-		return this.raw.url;
-	}
-	/**
-	* `.method()` can get the method name of the request.
-	*
-	* @see {@link https://hono.dev/docs/api/request#method}
-	*
-	* @example
-	* ```ts
-	* app.get('/about/me', (c) => {
-	*   const method = c.req.method // `GET`
-	* })
-	* ```
-	*/
-	get method() {
-		return this.raw.method;
-	}
-	get [GET_MATCH_RESULT]() {
-		return this.#matchResult;
-	}
-	/**
-	* `.matchedRoutes()` can return a matched route in the handler
-	*
-	* @deprecated
-	*
-	* Use matchedRoutes helper defined in "hono/route" instead.
-	*
-	* @see {@link https://hono.dev/docs/api/request#matchedroutes}
-	*
-	* @example
-	* ```ts
-	* app.use('*', async function logger(c, next) {
-	*   await next()
-	*   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
-	*     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
-	*     console.log(
-	*       method,
-	*       ' ',
-	*       path,
-	*       ' '.repeat(Math.max(10 - path.length, 0)),
-	*       name,
-	*       i === c.req.routeIndex ? '<- respond from here' : ''
-	*     )
-	*   })
-	* })
-	* ```
-	*/
-	get matchedRoutes() {
-		return this.#matchResult[0].map(([[, route]]) => route);
-	}
-	/**
-	* `routePath()` can retrieve the path registered within the handler
-	*
-	* @deprecated
-	*
-	* Use routePath helper defined in "hono/route" instead.
-	*
-	* @see {@link https://hono.dev/docs/api/request#routepath}
-	*
-	* @example
-	* ```ts
-	* app.get('/posts/:id', (c) => {
-	*   return c.json({ path: c.req.routePath })
-	* })
-	* ```
-	*/
-	get routePath() {
-		return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/utils/html.js
-var HtmlEscapedCallbackPhase = {
-	Stringify: 1,
-	BeforeStream: 2,
-	Stream: 3
-};
-var raw = (value, callbacks) => {
-	const escapedString = new String(value);
-	escapedString.isEscaped = true;
-	escapedString.callbacks = callbacks;
-	return escapedString;
-};
-var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
-	if (typeof str === "object" && !(str instanceof String)) {
-		if (!(str instanceof Promise)) str = str.toString();
-		if (str instanceof Promise) str = await str;
-	}
-	const callbacks = str.callbacks;
-	if (!callbacks?.length) return Promise.resolve(str);
-	if (buffer) buffer[0] += str;
-	else buffer = [str];
-	const resStr = Promise.all(callbacks.map((c) => c({
-		phase,
-		buffer,
-		context
-	}))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
-	if (preserveCallbacks) return raw(await resStr, callbacks);
-	else return resStr;
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/context.js
-var TEXT_PLAIN = "text/plain; charset=UTF-8";
-var setDefaultContentType = (contentType, headers) => {
-	return {
-		"Content-Type": contentType,
-		...headers
-	};
-};
-var Context = class {
-	#rawRequest;
-	#req;
-	/**
-	* `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
-	*
-	* @see {@link https://hono.dev/docs/api/context#env}
-	*
-	* @example
-	* ```ts
-	* // Environment object for Cloudflare Workers
-	* app.get('*', async c => {
-	*   const counter = c.env.COUNTER
-	* })
-	* ```
-	*/
-	env = {};
-	#var;
-	finalized = false;
-	/**
-	* `.error` can get the error object from the middleware if the Handler throws an error.
-	*
-	* @see {@link https://hono.dev/docs/api/context#error}
-	*
-	* @example
-	* ```ts
-	* app.use('*', async (c, next) => {
-	*   await next()
-	*   if (c.error) {
-	*     // do something...
-	*   }
-	* })
-	* ```
-	*/
-	error;
-	#status;
-	#executionCtx;
-	#res;
-	#layout;
-	#renderer;
-	#notFoundHandler;
-	#preparedHeaders;
-	#matchResult;
-	#path;
-	/**
-	* Creates an instance of the Context class.
-	*
-	* @param req - The Request object.
-	* @param options - Optional configuration options for the context.
-	*/
-	constructor(req, options) {
-		this.#rawRequest = req;
-		if (options) {
-			this.#executionCtx = options.executionCtx;
-			this.env = options.env;
-			this.#notFoundHandler = options.notFoundHandler;
-			this.#path = options.path;
-			this.#matchResult = options.matchResult;
-		}
-	}
-	/**
-	* `.req` is the instance of {@link HonoRequest}.
-	*/
-	get req() {
-		this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
-		return this.#req;
-	}
-	/**
-	* @see {@link https://hono.dev/docs/api/context#event}
-	* The FetchEvent associated with the current request.
-	*
-	* @throws Will throw an error if the context does not have a FetchEvent.
-	*/
-	get event() {
-		if (this.#executionCtx && "respondWith" in this.#executionCtx) return this.#executionCtx;
-		else throw Error("This context has no FetchEvent");
-	}
-	/**
-	* @see {@link https://hono.dev/docs/api/context#executionctx}
-	* The ExecutionContext associated with the current request.
-	*
-	* @throws Will throw an error if the context does not have an ExecutionContext.
-	*/
-	get executionCtx() {
-		if (this.#executionCtx) return this.#executionCtx;
-		else throw Error("This context has no ExecutionContext");
-	}
-	/**
-	* @see {@link https://hono.dev/docs/api/context#res}
-	* The Response object for the current request.
-	*/
-	get res() {
-		return this.#res ||= new Response(null, { headers: this.#preparedHeaders ??= new Headers() });
-	}
-	/**
-	* Sets the Response object for the current request.
-	*
-	* @param _res - The Response object to set.
-	*/
-	set res(_res) {
-		if (this.#res && _res) {
-			_res = new Response(_res.body, _res);
-			for (const [k, v] of this.#res.headers.entries()) {
-				if (k === "content-type") continue;
-				if (k === "set-cookie") {
-					const cookies = this.#res.headers.getSetCookie();
-					_res.headers.delete("set-cookie");
-					for (const cookie of cookies) _res.headers.append("set-cookie", cookie);
-				} else _res.headers.set(k, v);
-			}
-		}
-		this.#res = _res;
-		this.finalized = true;
-	}
-	/**
-	* `.render()` can create a response within a layout.
-	*
-	* @see {@link https://hono.dev/docs/api/context#render-setrenderer}
-	*
-	* @example
-	* ```ts
-	* app.get('/', (c) => {
-	*   return c.render('Hello!')
-	* })
-	* ```
-	*/
-	render = (...args) => {
-		this.#renderer ??= (content) => this.html(content);
-		return this.#renderer(...args);
-	};
-	/**
-	* Sets the layout for the response.
-	*
-	* @param layout - The layout to set.
-	* @returns The layout function.
-	*/
-	setLayout = (layout) => this.#layout = layout;
-	/**
-	* Gets the current layout for the response.
-	*
-	* @returns The current layout function.
-	*/
-	getLayout = () => this.#layout;
-	/**
-	* `.setRenderer()` can set the layout in the custom middleware.
-	*
-	* @see {@link https://hono.dev/docs/api/context#render-setrenderer}
-	*
-	* @example
-	* ```tsx
-	* app.use('*', async (c, next) => {
-	*   c.setRenderer((content) => {
-	*     return c.html(
-	*       <html>
-	*         <body>
-	*           <p>{content}</p>
-	*         </body>
-	*       </html>
-	*     )
-	*   })
-	*   await next()
-	* })
-	* ```
-	*/
-	setRenderer = (renderer) => {
-		this.#renderer = renderer;
-	};
-	/**
-	* `.header()` can set headers.
-	*
-	* @see {@link https://hono.dev/docs/api/context#header}
-	*
-	* @example
-	* ```ts
-	* app.get('/welcome', (c) => {
-	*   // Set headers
-	*   c.header('X-Message', 'Hello!')
-	*   c.header('Content-Type', 'text/plain')
-	*
-	*   return c.body('Thank you for coming')
-	* })
-	* ```
-	*/
-	header = (name, value, options) => {
-		if (this.finalized) this.#res = new Response(this.#res.body, this.#res);
-		const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers();
-		if (value === void 0) headers.delete(name);
-		else if (options?.append) headers.append(name, value);
-		else headers.set(name, value);
-	};
-	status = (status) => {
-		this.#status = status;
-	};
-	/**
-	* `.set()` can set the value specified by the key.
-	*
-	* @see {@link https://hono.dev/docs/api/context#set-get}
-	*
-	* @example
-	* ```ts
-	* app.use('*', async (c, next) => {
-	*   c.set('message', 'Hono is hot!!')
-	*   await next()
-	* })
-	* ```
-	*/
-	set = (key, value) => {
-		this.#var ??= /* @__PURE__ */ new Map();
-		this.#var.set(key, value);
-	};
-	/**
-	* `.get()` can use the value specified by the key.
-	*
-	* @see {@link https://hono.dev/docs/api/context#set-get}
-	*
-	* @example
-	* ```ts
-	* app.get('/', (c) => {
-	*   const message = c.get('message')
-	*   return c.text(`The message is "${message}"`)
-	* })
-	* ```
-	*/
-	get = (key) => {
-		return this.#var ? this.#var.get(key) : void 0;
-	};
-	/**
-	* `.var` can access the value of a variable.
-	*
-	* @see {@link https://hono.dev/docs/api/context#var}
-	*
-	* @example
-	* ```ts
-	* const result = c.var.client.oneMethod()
-	* ```
-	*/
-	get var() {
-		if (!this.#var) return {};
-		return Object.fromEntries(this.#var);
-	}
-	#newResponse(data, arg, headers) {
-		const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers();
-		if (typeof arg === "object" && "headers" in arg) {
-			const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
-			for (const [key, value] of argHeaders) if (key.toLowerCase() === "set-cookie") responseHeaders.append(key, value);
-			else responseHeaders.set(key, value);
-		}
-		if (headers) for (const [k, v] of Object.entries(headers)) if (typeof v === "string") responseHeaders.set(k, v);
-		else {
-			responseHeaders.delete(k);
-			for (const v2 of v) responseHeaders.append(k, v2);
-		}
-		const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
-		return new Response(data, {
-			status,
-			headers: responseHeaders
-		});
-	}
-	newResponse = (...args) => this.#newResponse(...args);
-	/**
-	* `.body()` can return the HTTP response.
-	* You can set headers with `.header()` and set HTTP status code with `.status`.
-	* This can also be set in `.text()`, `.json()` and so on.
-	*
-	* @see {@link https://hono.dev/docs/api/context#body}
-	*
-	* @example
-	* ```ts
-	* app.get('/welcome', (c) => {
-	*   // Set headers
-	*   c.header('X-Message', 'Hello!')
-	*   c.header('Content-Type', 'text/plain')
-	*   // Set HTTP status code
-	*   c.status(201)
-	*
-	*   // Return the response body
-	*   return c.body('Thank you for coming')
-	* })
-	* ```
-	*/
-	body = (data, arg, headers) => this.#newResponse(data, arg, headers);
-	/**
-	* `.text()` can render text as `Content-Type:text/plain`.
-	*
-	* @see {@link https://hono.dev/docs/api/context#text}
-	*
-	* @example
-	* ```ts
-	* app.get('/say', (c) => {
-	*   return c.text('Hello!')
-	* })
-	* ```
-	*/
-	text = (text, arg, headers) => {
-		return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
-	};
-	/**
-	* `.json()` can render JSON as `Content-Type:application/json`.
-	*
-	* @see {@link https://hono.dev/docs/api/context#json}
-	*
-	* @example
-	* ```ts
-	* app.get('/api', (c) => {
-	*   return c.json({ message: 'Hello!' })
-	* })
-	* ```
-	*/
-	json = (object, arg, headers) => {
-		return this.#newResponse(JSON.stringify(object), arg, setDefaultContentType("application/json", headers));
-	};
-	html = (html, arg, headers) => {
-		const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
-		return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
-	};
-	/**
-	* `.redirect()` can Redirect, default status code is 302.
-	*
-	* @see {@link https://hono.dev/docs/api/context#redirect}
-	*
-	* @example
-	* ```ts
-	* app.get('/redirect', (c) => {
-	*   return c.redirect('/')
-	* })
-	* app.get('/redirect-permanently', (c) => {
-	*   return c.redirect('/', 301)
-	* })
-	* ```
-	*/
-	redirect = (location, status) => {
-		const locationString = String(location);
-		this.header("Location", !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString));
-		return this.newResponse(null, status ?? 302);
-	};
-	/**
-	* `.notFound()` can return the Not Found Response.
-	*
-	* @see {@link https://hono.dev/docs/api/context#notfound}
-	*
-	* @example
-	* ```ts
-	* app.get('/notfound', (c) => {
-	*   return c.notFound()
-	* })
-	* ```
-	*/
-	notFound = () => {
-		this.#notFoundHandler ??= () => new Response();
-		return this.#notFoundHandler(this);
-	};
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/router.js
-var METHOD_NAME_ALL = "ALL";
-var METHOD_NAME_ALL_LOWERCASE = "all";
-var METHODS = [
-	"get",
-	"post",
-	"put",
-	"delete",
-	"options",
-	"patch"
-];
-var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
-var UnsupportedPathError = class extends Error {};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/utils/constants.js
-var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/hono-base.js
-var notFoundHandler = (c) => {
-	return c.text("404 Not Found", 404);
-};
-var errorHandler = (err, c) => {
-	if ("getResponse" in err) {
-		const res = err.getResponse();
-		return c.newResponse(res.body, res);
-	}
-	console.error(err);
-	return c.text("Internal Server Error", 500);
-};
-var Hono$1 = class _Hono {
-	get;
-	post;
-	put;
-	delete;
-	options;
-	patch;
-	all;
-	on;
-	use;
-	router;
-	getPath;
-	_basePath = "/";
-	#path = "/";
-	routes = [];
-	constructor(options = {}) {
-		[...METHODS, METHOD_NAME_ALL_LOWERCASE].forEach((method) => {
-			this[method] = (args1, ...args) => {
-				if (typeof args1 === "string") this.#path = args1;
-				else this.#addRoute(method, this.#path, args1);
-				args.forEach((handler) => {
-					this.#addRoute(method, this.#path, handler);
-				});
-				return this;
-			};
-		});
-		this.on = (method, path, ...handlers) => {
-			for (const p of [path].flat()) {
-				this.#path = p;
-				for (const m of [method].flat()) handlers.map((handler) => {
-					this.#addRoute(m.toUpperCase(), this.#path, handler);
-				});
-			}
-			return this;
-		};
-		this.use = (arg1, ...handlers) => {
-			if (typeof arg1 === "string") this.#path = arg1;
-			else {
-				this.#path = "*";
-				handlers.unshift(arg1);
-			}
-			handlers.forEach((handler) => {
-				this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
-			});
-			return this;
-		};
-		const { strict, ...optionsWithoutStrict } = options;
-		Object.assign(this, optionsWithoutStrict);
-		this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
-	}
-	#clone() {
-		const clone = new _Hono({
-			router: this.router,
-			getPath: this.getPath
-		});
-		clone.errorHandler = this.errorHandler;
-		clone.#notFoundHandler = this.#notFoundHandler;
-		clone.routes = this.routes;
-		return clone;
-	}
-	#notFoundHandler = notFoundHandler;
-	errorHandler = errorHandler;
-	/**
-	* `.route()` allows grouping other Hono instance in routes.
-	*
-	* @see {@link https://hono.dev/docs/api/routing#grouping}
-	*
-	* @param {string} path - base Path
-	* @param {Hono} app - other Hono instance
-	* @returns {Hono} routed Hono instance
-	*
-	* @example
-	* ```ts
-	* const app = new Hono()
-	* const app2 = new Hono()
-	*
-	* app2.get("/user", (c) => c.text("user"))
-	* app.route("/api", app2) // GET /api/user
-	* ```
-	*/
-	route(path, app) {
-		const subApp = this.basePath(path);
-		app.routes.map((r) => {
-			let handler;
-			if (app.errorHandler === errorHandler) handler = r.handler;
-			else {
-				handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
-				handler[COMPOSED_HANDLER] = r.handler;
-			}
-			subApp.#addRoute(r.method, r.path, handler);
-		});
-		return this;
-	}
-	/**
-	* `.basePath()` allows base paths to be specified.
-	*
-	* @see {@link https://hono.dev/docs/api/routing#base-path}
-	*
-	* @param {string} path - base Path
-	* @returns {Hono} changed Hono instance
-	*
-	* @example
-	* ```ts
-	* const api = new Hono().basePath('/api')
-	* ```
-	*/
-	basePath(path) {
-		const subApp = this.#clone();
-		subApp._basePath = mergePath(this._basePath, path);
-		return subApp;
-	}
-	/**
-	* `.onError()` handles an error and returns a customized Response.
-	*
-	* @see {@link https://hono.dev/docs/api/hono#error-handling}
-	*
-	* @param {ErrorHandler} handler - request Handler for error
-	* @returns {Hono} changed Hono instance
-	*
-	* @example
-	* ```ts
-	* app.onError((err, c) => {
-	*   console.error(`${err}`)
-	*   return c.text('Custom Error Message', 500)
-	* })
-	* ```
-	*/
-	onError = (handler) => {
-		this.errorHandler = handler;
-		return this;
-	};
-	/**
-	* `.notFound()` allows you to customize a Not Found Response.
-	*
-	* @see {@link https://hono.dev/docs/api/hono#not-found}
-	*
-	* @param {NotFoundHandler} handler - request handler for not-found
-	* @returns {Hono} changed Hono instance
-	*
-	* @example
-	* ```ts
-	* app.notFound((c) => {
-	*   return c.text('Custom 404 Message', 404)
-	* })
-	* ```
-	*/
-	notFound = (handler) => {
-		this.#notFoundHandler = handler;
-		return this;
-	};
-	/**
-	* `.mount()` allows you to mount applications built with other frameworks into your Hono application.
-	*
-	* @see {@link https://hono.dev/docs/api/hono#mount}
-	*
-	* @param {string} path - base Path
-	* @param {Function} applicationHandler - other Request Handler
-	* @param {MountOptions} [options] - options of `.mount()`
-	* @returns {Hono} mounted Hono instance
-	*
-	* @example
-	* ```ts
-	* import { Router as IttyRouter } from 'itty-router'
-	* import { Hono } from 'hono'
-	* // Create itty-router application
-	* const ittyRouter = IttyRouter()
-	* // GET /itty-router/hello
-	* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
-	*
-	* const app = new Hono()
-	* app.mount('/itty-router', ittyRouter.handle)
-	* ```
-	*
-	* @example
-	* ```ts
-	* const app = new Hono()
-	* // Send the request to another application without modification.
-	* app.mount('/app', anotherApp, {
-	*   replaceRequest: (req) => req,
-	* })
-	* ```
-	*/
-	mount(path, applicationHandler, options) {
-		let replaceRequest;
-		let optionHandler;
-		if (options) if (typeof options === "function") optionHandler = options;
-		else {
-			optionHandler = options.optionHandler;
-			if (options.replaceRequest === false) replaceRequest = (request) => request;
-			else replaceRequest = options.replaceRequest;
-		}
-		const getOptions = optionHandler ? (c) => {
-			const options2 = optionHandler(c);
-			return Array.isArray(options2) ? options2 : [options2];
-		} : (c) => {
-			let executionContext = void 0;
-			try {
-				executionContext = c.executionCtx;
-			} catch {}
-			return [c.env, executionContext];
-		};
-		replaceRequest ||= (() => {
-			const mergedPath = mergePath(this._basePath, path);
-			const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
-			return (request) => {
-				const url = new URL(request.url);
-				url.pathname = url.pathname.slice(pathPrefixLength) || "/";
-				return new Request(url, request);
-			};
-		})();
-		const handler = async (c, next) => {
-			const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
-			if (res) return res;
-			await next();
-		};
-		this.#addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
-		return this;
-	}
-	#addRoute(method, path, handler) {
-		method = method.toUpperCase();
-		path = mergePath(this._basePath, path);
-		const r = {
-			basePath: this._basePath,
-			path,
-			method,
-			handler
-		};
-		this.router.add(method, path, [handler, r]);
-		this.routes.push(r);
-	}
-	#handleError(err, c) {
-		if (err instanceof Error) return this.errorHandler(err, c);
-		throw err;
-	}
-	#dispatch(request, executionCtx, env, method) {
-		if (method === "HEAD") return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
-		const path = this.getPath(request, { env });
-		const matchResult = this.router.match(method, path);
-		const c = new Context(request, {
-			path,
-			matchResult,
-			env,
-			executionCtx,
-			notFoundHandler: this.#notFoundHandler
-		});
-		if (matchResult[0].length === 1) {
-			let res;
-			try {
-				res = matchResult[0][0][0][0](c, async () => {
-					c.res = await this.#notFoundHandler(c);
-				});
-			} catch (err) {
-				return this.#handleError(err, c);
-			}
-			return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
-		}
-		const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
-		return (async () => {
-			try {
-				const context = await composed(c);
-				if (!context.finalized) throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
-				return context.res;
-			} catch (err) {
-				return this.#handleError(err, c);
-			}
-		})();
-	}
-	/**
-	* `.fetch()` will be entry point of your app.
-	*
-	* @see {@link https://hono.dev/docs/api/hono#fetch}
-	*
-	* @param {Request} request - request Object of request
-	* @param {Env} Env - env Object
-	* @param {ExecutionContext} - context of execution
-	* @returns {Response | Promise<Response>} response of request
-	*
-	*/
-	fetch = (request, ...rest) => {
-		return this.#dispatch(request, rest[1], rest[0], request.method);
-	};
-	/**
-	* `.request()` is a useful method for testing.
-	* You can pass a URL or pathname to send a GET request.
-	* app will return a Response object.
-	* ```ts
-	* test('GET /hello is ok', async () => {
-	*   const res = await app.request('/hello')
-	*   expect(res.status).toBe(200)
-	* })
-	* ```
-	* @see https://hono.dev/docs/api/hono#request
-	*/
-	request = (input, requestInit, Env, executionCtx) => {
-		if (input instanceof Request) return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
-		input = input.toString();
-		return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
-	};
-	/**
-	* `.fire()` automatically adds a global fetch event listener.
-	* This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
-	* @deprecated
-	* Use `fire` from `hono/service-worker` instead.
-	* ```ts
-	* import { Hono } from 'hono'
-	* import { fire } from 'hono/service-worker'
-	*
-	* const app = new Hono()
-	* // ...
-	* fire(app)
-	* ```
-	* @see https://hono.dev/docs/api/hono#fire
-	* @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
-	* @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
-	*/
-	fire = () => {
-		addEventListener("fetch", (event) => {
-			event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
-		});
-	};
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/router/reg-exp-router/matcher.js
-var emptyParam = [];
-function match(method, path) {
-	const matchers = this.buildAllMatchers();
-	const match2 = ((method2, path2) => {
-		const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-		const staticMatch = matcher[2][path2];
-		if (staticMatch) return staticMatch;
-		const match3 = path2.match(matcher[0]);
-		if (!match3) return [[], emptyParam];
-		const index = match3.indexOf("", 1);
-		return [matcher[1][index], match3];
-	});
-	this.match = match2;
-	return match2(method, path);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/router/reg-exp-router/node.js
-var LABEL_REG_EXP_STR = "[^/]+";
-var ONLY_WILDCARD_REG_EXP_STR = ".*";
-var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-var PATH_ERROR = /* @__PURE__ */ Symbol();
-var regExpMetaChars = /* @__PURE__ */ new Set(".\\+*[^]$()");
-function compareKey(a, b) {
-	if (a.length === 1) return b.length === 1 ? a < b ? -1 : 1 : -1;
-	if (b.length === 1) return 1;
-	if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) return 1;
-	else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) return -1;
-	if (a === LABEL_REG_EXP_STR) return 1;
-	else if (b === LABEL_REG_EXP_STR) return -1;
-	return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
-}
-var Node$1 = class _Node {
-	#index;
-	#varIndex;
-	#children = /* @__PURE__ */ Object.create(null);
-	insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
-		if (tokens.length === 0) {
-			if (this.#index !== void 0) throw PATH_ERROR;
-			if (pathErrorCheckOnly) return;
-			this.#index = index;
-			return;
-		}
-		const [token, ...restTokens] = tokens;
-		const pattern = token === "*" ? restTokens.length === 0 ? [
-			"",
-			"",
-			ONLY_WILDCARD_REG_EXP_STR
-		] : [
-			"",
-			"",
-			LABEL_REG_EXP_STR
-		] : token === "/*" ? [
-			"",
-			"",
-			TAIL_WILDCARD_REG_EXP_STR
-		] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-		let node;
-		if (pattern) {
-			const name = pattern[1];
-			let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
-			if (name && pattern[2]) {
-				if (regexpStr === ".*") throw PATH_ERROR;
-				regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
-				if (/\((?!\?:)/.test(regexpStr)) throw PATH_ERROR;
-			}
-			node = this.#children[regexpStr];
-			if (!node) {
-				if (Object.keys(this.#children).some((k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
-				if (pathErrorCheckOnly) return;
-				node = this.#children[regexpStr] = new _Node();
-				if (name !== "") node.#varIndex = context.varIndex++;
-			}
-			if (!pathErrorCheckOnly && name !== "") paramMap.push([name, node.#varIndex]);
-		} else {
-			node = this.#children[token];
-			if (!node) {
-				if (Object.keys(this.#children).some((k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) throw PATH_ERROR;
-				if (pathErrorCheckOnly) return;
-				node = this.#children[token] = new _Node();
-			}
-		}
-		node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
-	}
-	buildRegExpStr() {
-		const strList = Object.keys(this.#children).sort(compareKey).map((k) => {
-			const c = this.#children[k];
-			return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
-		});
-		if (typeof this.#index === "number") strList.unshift(`#${this.#index}`);
-		if (strList.length === 0) return "";
-		if (strList.length === 1) return strList[0];
-		return "(?:" + strList.join("|") + ")";
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/router/reg-exp-router/trie.js
-var Trie = class {
-	#context = { varIndex: 0 };
-	#root = new Node$1();
-	insert(path, index, pathErrorCheckOnly) {
-		const paramAssoc = [];
-		const groups = [];
-		for (let i = 0;;) {
-			let replaced = false;
-			path = path.replace(/\{[^}]+\}/g, (m) => {
-				const mark = `@\\${i}`;
-				groups[i] = [mark, m];
-				i++;
-				replaced = true;
-				return mark;
-			});
-			if (!replaced) break;
-		}
-		const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
-		for (let i = groups.length - 1; i >= 0; i--) {
-			const [mark] = groups[i];
-			for (let j = tokens.length - 1; j >= 0; j--) if (tokens[j].indexOf(mark) !== -1) {
-				tokens[j] = tokens[j].replace(mark, groups[i][1]);
-				break;
-			}
-		}
-		this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
-		return paramAssoc;
-	}
-	buildRegExp() {
-		let regexp = this.#root.buildRegExpStr();
-		if (regexp === "") return [
-			/^$/,
-			[],
-			[]
-		];
-		let captureIndex = 0;
-		const indexReplacementMap = [];
-		const paramReplacementMap = [];
-		regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
-			if (handlerIndex !== void 0) {
-				indexReplacementMap[++captureIndex] = Number(handlerIndex);
-				return "$()";
-			}
-			if (paramIndex !== void 0) {
-				paramReplacementMap[Number(paramIndex)] = ++captureIndex;
-				return "";
-			}
-			return "";
-		});
-		return [
-			new RegExp(`^${regexp}`),
-			indexReplacementMap,
-			paramReplacementMap
-		];
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/router/reg-exp-router/router.js
-var nullMatcher = [
-	/^$/,
-	[],
-	/* @__PURE__ */ Object.create(null)
-];
-var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-function buildWildcardRegExp(path) {
-	return wildcardRegExpCache[path] ??= new RegExp(path === "*" ? "" : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
-}
-function clearWildcardRegExpCache() {
-	wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
-}
-function buildMatcherFromPreprocessedRoutes(routes) {
-	const trie = new Trie();
-	const handlerData = [];
-	if (routes.length === 0) return nullMatcher;
-	const routesWithStaticPathFlag = routes.map((route) => [!/\*|\/:/.test(route[0]), ...route]).sort(([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
-	const staticMap = /* @__PURE__ */ Object.create(null);
-	for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
-		const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
-		if (pathErrorCheckOnly) staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
-		else j++;
-		let paramAssoc;
-		try {
-			paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
-		} catch (e) {
-			throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
-		}
-		if (pathErrorCheckOnly) continue;
-		handlerData[j] = handlers.map(([h, paramCount]) => {
-			const paramIndexMap = /* @__PURE__ */ Object.create(null);
-			paramCount -= 1;
-			for (; paramCount >= 0; paramCount--) {
-				const [key, value] = paramAssoc[paramCount];
-				paramIndexMap[key] = value;
-			}
-			return [h, paramIndexMap];
-		});
-	}
-	const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
-	for (let i = 0, len = handlerData.length; i < len; i++) for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
-		const map = handlerData[i][j]?.[1];
-		if (!map) continue;
-		const keys = Object.keys(map);
-		for (let k = 0, len3 = keys.length; k < len3; k++) map[keys[k]] = paramReplacementMap[map[keys[k]]];
-	}
-	const handlerMap = [];
-	for (const i in indexReplacementMap) handlerMap[i] = handlerData[indexReplacementMap[i]];
-	return [
-		regexp,
-		handlerMap,
-		staticMap
-	];
-}
-function findMiddleware(middleware, path) {
-	if (!middleware) return;
-	for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) if (buildWildcardRegExp(k).test(path)) return [...middleware[k]];
-}
-var RegExpRouter = class {
-	name = "RegExpRouter";
-	#middleware;
-	#routes;
-	constructor() {
-		this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-		this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
-	}
-	add(method, path, handler) {
-		const middleware = this.#middleware;
-		const routes = this.#routes;
-		if (!middleware || !routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-		if (!middleware[method]) [middleware, routes].forEach((handlerMap) => {
-			handlerMap[method] = /* @__PURE__ */ Object.create(null);
-			Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
-				handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
-			});
-		});
-		if (path === "/*") path = "*";
-		const paramCount = (path.match(/\/:/g) || []).length;
-		if (/\*$/.test(path)) {
-			const re = buildWildcardRegExp(path);
-			if (method === METHOD_NAME_ALL) Object.keys(middleware).forEach((m) => {
-				middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-			});
-			else middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
-			Object.keys(middleware).forEach((m) => {
-				if (method === METHOD_NAME_ALL || method === m) Object.keys(middleware[m]).forEach((p) => {
-					re.test(p) && middleware[m][p].push([handler, paramCount]);
-				});
-			});
-			Object.keys(routes).forEach((m) => {
-				if (method === METHOD_NAME_ALL || method === m) Object.keys(routes[m]).forEach((p) => re.test(p) && routes[m][p].push([handler, paramCount]));
-			});
-			return;
-		}
-		const paths = checkOptionalParameter(path) || [path];
-		for (let i = 0, len = paths.length; i < len; i++) {
-			const path2 = paths[i];
-			Object.keys(routes).forEach((m) => {
-				if (method === METHOD_NAME_ALL || method === m) {
-					routes[m][path2] ||= [...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []];
-					routes[m][path2].push([handler, paramCount - len + i + 1]);
-				}
-			});
-		}
-	}
-	match = match;
-	buildAllMatchers() {
-		const matchers = /* @__PURE__ */ Object.create(null);
-		Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
-			matchers[method] ||= this.#buildMatcher(method);
-		});
-		this.#middleware = this.#routes = void 0;
-		clearWildcardRegExpCache();
-		return matchers;
-	}
-	#buildMatcher(method) {
-		const routes = [];
-		let hasOwnRoute = method === METHOD_NAME_ALL;
-		[this.#middleware, this.#routes].forEach((r) => {
-			const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
-			if (ownRoute.length !== 0) {
-				hasOwnRoute ||= true;
-				routes.push(...ownRoute);
-			} else if (method !== METHOD_NAME_ALL) routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]]));
-		});
-		if (!hasOwnRoute) return null;
-		else return buildMatcherFromPreprocessedRoutes(routes);
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/router/smart-router/router.js
-var SmartRouter = class {
-	name = "SmartRouter";
-	#routers = [];
-	#routes = [];
-	constructor(init) {
-		this.#routers = init.routers;
-	}
-	add(method, path, handler) {
-		if (!this.#routes) throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
-		this.#routes.push([
-			method,
-			path,
-			handler
-		]);
-	}
-	match(method, path) {
-		if (!this.#routes) throw new Error("Fatal error");
-		const routers = this.#routers;
-		const routes = this.#routes;
-		const len = routers.length;
-		let i = 0;
-		let res;
-		for (; i < len; i++) {
-			const router = routers[i];
-			try {
-				for (let i2 = 0, len2 = routes.length; i2 < len2; i2++) router.add(...routes[i2]);
-				res = router.match(method, path);
-			} catch (e) {
-				if (e instanceof UnsupportedPathError) continue;
-				throw e;
-			}
-			this.match = router.match.bind(router);
-			this.#routers = [router];
-			this.#routes = void 0;
-			break;
-		}
-		if (i === len) throw new Error("Fatal error");
-		this.name = `SmartRouter + ${this.activeRouter.name}`;
-		return res;
-	}
-	get activeRouter() {
-		if (this.#routes || this.#routers.length !== 1) throw new Error("No active router has been determined yet.");
-		return this.#routers[0];
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/router/trie-router/node.js
-var emptyParams = /* @__PURE__ */ Object.create(null);
-var Node = class _Node {
-	#methods;
-	#children;
-	#patterns;
-	#order = 0;
-	#params = emptyParams;
-	constructor(method, handler, children) {
-		this.#children = children || /* @__PURE__ */ Object.create(null);
-		this.#methods = [];
-		if (method && handler) {
-			const m = /* @__PURE__ */ Object.create(null);
-			m[method] = {
-				handler,
-				possibleKeys: [],
-				score: 0
-			};
-			this.#methods = [m];
-		}
-		this.#patterns = [];
-	}
-	insert(method, path, handler) {
-		this.#order = ++this.#order;
-		let curNode = this;
-		const parts = splitRoutingPath(path);
-		const possibleKeys = [];
-		for (let i = 0, len = parts.length; i < len; i++) {
-			const p = parts[i];
-			const nextP = parts[i + 1];
-			const pattern = getPattern(p, nextP);
-			const key = Array.isArray(pattern) ? pattern[0] : p;
-			if (key in curNode.#children) {
-				curNode = curNode.#children[key];
-				if (pattern) possibleKeys.push(pattern[1]);
-				continue;
-			}
-			curNode.#children[key] = new _Node();
-			if (pattern) {
-				curNode.#patterns.push(pattern);
-				possibleKeys.push(pattern[1]);
-			}
-			curNode = curNode.#children[key];
-		}
-		curNode.#methods.push({ [method]: {
-			handler,
-			possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
-			score: this.#order
-		} });
-		return curNode;
-	}
-	#getHandlerSets(node, method, nodeParams, params) {
-		const handlerSets = [];
-		for (let i = 0, len = node.#methods.length; i < len; i++) {
-			const m = node.#methods[i];
-			const handlerSet = m[method] || m[METHOD_NAME_ALL];
-			const processedSet = {};
-			if (handlerSet !== void 0) {
-				handlerSet.params = /* @__PURE__ */ Object.create(null);
-				handlerSets.push(handlerSet);
-				if (nodeParams !== emptyParams || params && params !== emptyParams) for (let i2 = 0, len2 = handlerSet.possibleKeys.length; i2 < len2; i2++) {
-					const key = handlerSet.possibleKeys[i2];
-					const processed = processedSet[handlerSet.score];
-					handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
-					processedSet[handlerSet.score] = true;
-				}
-			}
-		}
-		return handlerSets;
-	}
-	search(method, path) {
-		const handlerSets = [];
-		this.#params = emptyParams;
-		let curNodes = [this];
-		const parts = splitPath(path);
-		const curNodesQueue = [];
-		for (let i = 0, len = parts.length; i < len; i++) {
-			const part = parts[i];
-			const isLast = i === len - 1;
-			const tempNodes = [];
-			for (let j = 0, len2 = curNodes.length; j < len2; j++) {
-				const node = curNodes[j];
-				const nextNode = node.#children[part];
-				if (nextNode) {
-					nextNode.#params = node.#params;
-					if (isLast) {
-						if (nextNode.#children["*"]) handlerSets.push(...this.#getHandlerSets(nextNode.#children["*"], method, node.#params));
-						handlerSets.push(...this.#getHandlerSets(nextNode, method, node.#params));
-					} else tempNodes.push(nextNode);
-				}
-				for (let k = 0, len3 = node.#patterns.length; k < len3; k++) {
-					const pattern = node.#patterns[k];
-					const params = node.#params === emptyParams ? {} : { ...node.#params };
-					if (pattern === "*") {
-						const astNode = node.#children["*"];
-						if (astNode) {
-							handlerSets.push(...this.#getHandlerSets(astNode, method, node.#params));
-							astNode.#params = params;
-							tempNodes.push(astNode);
-						}
-						continue;
-					}
-					const [key, name, matcher] = pattern;
-					if (!part && !(matcher instanceof RegExp)) continue;
-					const child = node.#children[key];
-					const restPathString = parts.slice(i).join("/");
-					if (matcher instanceof RegExp) {
-						const m = matcher.exec(restPathString);
-						if (m) {
-							params[name] = m[0];
-							handlerSets.push(...this.#getHandlerSets(child, method, node.#params, params));
-							if (Object.keys(child.#children).length) {
-								child.#params = params;
-								const componentCount = m[0].match(/\//)?.length ?? 0;
-								(curNodesQueue[componentCount] ||= []).push(child);
-							}
-							continue;
-						}
-					}
-					if (matcher === true || matcher.test(part)) {
-						params[name] = part;
-						if (isLast) {
-							handlerSets.push(...this.#getHandlerSets(child, method, params, node.#params));
-							if (child.#children["*"]) handlerSets.push(...this.#getHandlerSets(child.#children["*"], method, params, node.#params));
-						} else {
-							child.#params = params;
-							tempNodes.push(child);
-						}
-					}
-				}
-			}
-			curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
-		}
-		if (handlerSets.length > 1) handlerSets.sort((a, b) => {
-			return a.score - b.score;
-		});
-		return [handlerSets.map(({ handler, params }) => [handler, params])];
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/router/trie-router/router.js
-var TrieRouter = class {
-	name = "TrieRouter";
-	#node;
-	constructor() {
-		this.#node = new Node();
-	}
-	add(method, path, handler) {
-		const results = checkOptionalParameter(path);
-		if (results) {
-			for (let i = 0, len = results.length; i < len; i++) this.#node.insert(method, results[i], handler);
-			return;
-		}
-		this.#node.insert(method, path, handler);
-	}
-	match(method, path) {
-		return this.#node.search(method, path);
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/hono.js
-var Hono = class extends Hono$1 {
-	/**
-	* Creates an instance of the Hono class.
-	*
-	* @param options - Optional configuration options for the Hono instance.
-	*/
-	constructor(options = {}) {
-		super(options);
-		this.router = options.router ?? new SmartRouter({ routers: [new RegExpRouter(), new TrieRouter()] });
-	}
-};
-
-//#endregion
-//#region ../../node_modules/.pnpm/hono@4.11.6/node_modules/hono/dist/middleware/cors/index.js
-var cors = (options) => {
-	const opts = {
-		origin: "*",
-		allowMethods: [
-			"GET",
-			"HEAD",
-			"PUT",
-			"POST",
-			"DELETE",
-			"PATCH"
-		],
-		allowHeaders: [],
-		exposeHeaders: [],
-		...options
-	};
-	const findAllowOrigin = ((optsOrigin) => {
-		if (typeof optsOrigin === "string") if (optsOrigin === "*") return () => optsOrigin;
-		else return (origin) => optsOrigin === origin ? origin : null;
-		else if (typeof optsOrigin === "function") return optsOrigin;
-		else return (origin) => optsOrigin.includes(origin) ? origin : null;
-	})(opts.origin);
-	const findAllowMethods = ((optsAllowMethods) => {
-		if (typeof optsAllowMethods === "function") return optsAllowMethods;
-		else if (Array.isArray(optsAllowMethods)) return () => optsAllowMethods;
-		else return () => [];
-	})(opts.allowMethods);
-	return async function cors2(c, next) {
-		function set(key, value) {
-			c.res.headers.set(key, value);
-		}
-		const allowOrigin = await findAllowOrigin(c.req.header("origin") || "", c);
-		if (allowOrigin) set("Access-Control-Allow-Origin", allowOrigin);
-		if (opts.credentials) set("Access-Control-Allow-Credentials", "true");
-		if (opts.exposeHeaders?.length) set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
-		if (c.req.method === "OPTIONS") {
-			if (opts.origin !== "*") set("Vary", "Origin");
-			if (opts.maxAge != null) set("Access-Control-Max-Age", opts.maxAge.toString());
-			const allowMethods = await findAllowMethods(c.req.header("origin") || "", c);
-			if (allowMethods.length) set("Access-Control-Allow-Methods", allowMethods.join(","));
-			let headers = opts.allowHeaders;
-			if (!headers?.length) {
-				const requestHeaders = c.req.header("Access-Control-Request-Headers");
-				if (requestHeaders) headers = requestHeaders.split(/\s*,\s*/);
-			}
-			if (headers?.length) {
-				set("Access-Control-Allow-Headers", headers.join(","));
-				c.res.headers.append("Vary", "Access-Control-Request-Headers");
-			}
-			c.res.headers.delete("Content-Length");
-			c.res.headers.delete("Content-Type");
-			return new Response(null, {
-				headers: c.res.headers,
-				status: 204,
-				statusText: "No Content"
-			});
-		}
-		await next();
-		if (opts.origin !== "*") c.header("Vary", "Origin", { append: true });
-	};
-};
-
-//#endregion
-export { Hono as n, cors as t };