s3db.js 12.0.0 → 12.1.0

package/dist/s3db.es.js

@@ -1,25 +1,27 @@
 import crypto$1, { createHash } from 'crypto';
 import { customAlphabet, urlAlphabet } from 'nanoid';
 import EventEmitter from 'events';
-import { createServer, Agent } from 'http';
-import { Http2ServerRequest } from 'http2';
-import require$$3, { Readable, Transform, Writable } from 'stream';
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { swaggerUI } from '@hono/swagger-ui';
 import { mkdir, copyFile, unlink, stat, access, readdir, writeFile, readFile, rm, watch } from 'fs/promises';
 import fs, { createReadStream, createWriteStream, realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$2, lstatSync, existsSync } from 'fs';
 import { pipeline } from 'stream/promises';
 import path$1, { join } from 'path';
+import { Transform, Writable } from 'stream';
 import zlib from 'node:zlib';
 import os from 'os';
 import jsonStableStringify from 'json-stable-stringify';
 import os$1 from 'node:os';
 import { PromisePool } from '@supercharge/promise-pool';
 import { chunk, merge, isString, isEmpty, invert, uniq, cloneDeep, get, set, isObject, isFunction } from 'lodash-es';
+import { Agent } from 'http';
 import { Agent as Agent$1 } from 'https';
 import { NodeHttpHandler } from '@smithy/node-http-handler';
 import { S3Client, PutObjectCommand, GetObjectCommand, HeadObjectCommand, CopyObjectCommand, DeleteObjectCommand, DeleteObjectsCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
 import { flatten, unflatten } from 'flat';
 import FastestValidator from 'fastest-validator';
-import { ReadableStream as ReadableStream$1 } from 'node:stream/web';
+import { ReadableStream } from 'node:stream/web';
 import { fileURLToPath } from 'node:url';
 import { win32, posix } from 'node:path';
 import * as actualFS from 'node:fs';
@@ -27,24 +29,6 @@ import { realpath, readlink, readdir as readdir$1, lstat } from 'node:fs/promise
 import { EventEmitter as EventEmitter$1 } from 'node:events';
 import Stream from 'node:stream';
 import { StringDecoder } from 'node:string_decoder';
-import require$$0 from 'node:crypto';
-import require$$1 from 'child_process';
-import require$$5 from 'url';
-
-function _mergeNamespaces(n, m) {
-  m.forEach(function (e) {
-    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-      if (k !== 'default' && !(k in n)) {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  });
-  return Object.freeze(n);
-}
 
 const alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 const base = alphabet.length;
@@ -1963,44 +1947,31 @@ class PluginStorage {
    * @returns {Promise<boolean>} True if extended, false if not found or no TTL
    */
   async touch(key, additionalSeconds) {
-    const [ok, err, response] = await tryFn(() => this.client.getObject(key));
+    const [ok, err, response] = await tryFn(() => this.client.headObject(key));
     if (!ok) {
       return false;
     }
     const metadata = response.Metadata || {};
     const parsedMetadata = this._parseMetadataValues(metadata);
-    let data = parsedMetadata;
-    if (response.Body) {
-      const [ok2, err2, result] = await tryFn(async () => {
-        const bodyContent = await response.Body.transformToString();
-        if (bodyContent && bodyContent.trim()) {
-          const body = JSON.parse(bodyContent);
-          return { ...parsedMetadata, ...body };
-        }
-        return parsedMetadata;
-      });
-      if (!ok2) {
-        return false;
-      }
-      data = result;
-    }
-    const expiresAt = data._expiresat || data._expiresAt;
+    const expiresAt = parsedMetadata._expiresat || parsedMetadata._expiresAt;
     if (!expiresAt) {
       return false;
     }
-    data._expiresAt = expiresAt + additionalSeconds * 1e3;
-    delete data._expiresat;
-    const { metadata: newMetadata, body: newBody } = this._applyBehavior(data, "body-overflow");
-    const putParams = {
-      key,
-      metadata: newMetadata,
-      contentType: "application/json"
-    };
-    if (newBody !== null) {
-      putParams.body = JSON.stringify(newBody);
-    }
-    const [putOk] = await tryFn(() => this.client.putObject(putParams));
-    return putOk;
+    parsedMetadata._expiresAt = expiresAt + additionalSeconds * 1e3;
+    delete parsedMetadata._expiresat;
+    const encodedMetadata = {};
+    for (const [metaKey, metaValue] of Object.entries(parsedMetadata)) {
+      const { encoded } = metadataEncode(metaValue);
+      encodedMetadata[metaKey] = encoded;
+    }
+    const [copyOk] = await tryFn(() => this.client.copyObject({
+      from: key,
+      to: key,
+      metadata: encodedMetadata,
+      metadataDirective: "REPLACE",
+      contentType: response.ContentType || "application/json"
+    }));
+    return copyOk;
   }
   /**
    * Delete a single object
@@ -2135,12 +2106,41 @@ class PluginStorage {
   /**
    * Increment a counter value
    *
+   * Optimization: Uses HEAD + COPY for existing counters to avoid body transfer.
+   * Falls back to GET + PUT for non-existent counters or those with additional data.
+   *
    * @param {string} key - S3 key
    * @param {number} amount - Amount to increment (default: 1)
    * @param {Object} options - Options (e.g., ttl)
    * @returns {Promise<number>} New value
    */
   async increment(key, amount = 1, options = {}) {
+    const [headOk, headErr, headResponse] = await tryFn(() => this.client.headObject(key));
+    if (headOk && headResponse.Metadata) {
+      const metadata = headResponse.Metadata || {};
+      const parsedMetadata = this._parseMetadataValues(metadata);
+      const currentValue = parsedMetadata.value || 0;
+      const newValue = currentValue + amount;
+      parsedMetadata.value = newValue;
+      if (options.ttl) {
+        parsedMetadata._expiresAt = Date.now() + options.ttl * 1e3;
+      }
+      const encodedMetadata = {};
+      for (const [metaKey, metaValue] of Object.entries(parsedMetadata)) {
+        const { encoded } = metadataEncode(metaValue);
+        encodedMetadata[metaKey] = encoded;
+      }
+      const [copyOk] = await tryFn(() => this.client.copyObject({
+        from: key,
+        to: key,
+        metadata: encodedMetadata,
+        metadataDirective: "REPLACE",
+        contentType: headResponse.ContentType || "application/json"
+      }));
+      if (copyOk) {
+        return newValue;
+      }
+    }
     const data = await this.get(key);
     const value = (data?.value || 0) + amount;
     await this.set(key, { value }, options);
@@ -2360,6 +2360,9 @@ class Plugin extends EventEmitter {
    * - Pode modificar argumentos/resultados.
    */
   addMiddleware(resource, methodName, middleware) {
+    if (typeof resource[methodName] !== "function") {
+      throw new Error(`Cannot add middleware to "${methodName}": method does not exist on resource "${resource.name || "unknown"}"`);
+    }
     if (!resource._pluginMiddlewares) {
       resource._pluginMiddlewares = {};
     }
@@ -2451,2291 +2454,6 @@ const PluginObject = {
   }
 };
 
-// src/compose.ts
-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;
-    }
-  };
-};
-
-// src/request/constants.ts
-var GET_MATCH_RESULT = Symbol();
-
-// src/utils/body.ts
-var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
-  const { all = false, dot = false } = options;
-  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
-  const contentType = 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) => {
-    const shouldParseAllValues = options.all || key.endsWith("[]");
-    if (!shouldParseAllValues) {
-      form[key] = value;
-    } else {
-      handleParsingAllValues(form, key, value);
-    }
-  });
-  if (options.dot) {
-    Object.entries(form).forEach(([key, value]) => {
-      const shouldParseDotValues = key.includes(".");
-      if (shouldParseDotValues) {
-        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];
-    }
-  });
-};
-
-// src/utils/url.ts
-var splitPath = (path) => {
-  const paths = path.split("/");
-  if (paths[0] === "") {
-    paths.shift();
-  }
-  return paths;
-};
-var splitRoutingPath = (routePath) => {
-  const { groups, path } = extractGroupsFromPath(routePath);
-  const paths = splitPath(path);
-  return replaceGroupMarks(paths, 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(`?${key}`, 8);
-    if (keyIndex2 === -1) {
-      keyIndex2 = url.indexOf(`&${key}`, 8);
-    }
-    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 void 0;
-    }
-  }
-  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;
-
-// src/request.ts
-var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
-var HonoRequest = class {
-  raw;
-  #validatedData;
-  #matchResult;
-  routeIndex = 0;
-  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() {
-    return this.#cachedBody("text").then((text) => JSON.parse(text));
-  }
-  text() {
-    return this.#cachedBody("text");
-  }
-  arrayBuffer() {
-    return this.#cachedBody("arrayBuffer");
-  }
-  blob() {
-    return this.#cachedBody("blob");
-  }
-  formData() {
-    return this.#cachedBody("formData");
-  }
-  addValidatedData(target, data) {
-    this.#validatedData[target] = data;
-  }
-  valid(target) {
-    return this.#validatedData[target];
-  }
-  get url() {
-    return this.raw.url;
-  }
-  get method() {
-    return this.raw.method;
-  }
-  get [GET_MATCH_RESULT]() {
-    return this.#matchResult;
-  }
-  get matchedRoutes() {
-    return this.#matchResult[0].map(([[, route]]) => route);
-  }
-  get routePath() {
-    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
-  }
-};
-
-// src/utils/html.ts
-var HtmlEscapedCallbackPhase = {
-  Stringify: 1};
-var raw = (value, callbacks) => {
-  const escapedString = new String(value);
-  escapedString.isEscaped = true;
-  escapedString.callbacks = callbacks;
-  return escapedString;
-};
-var escapeRe = /[&<>'"]/;
-var stringBufferToString = async (buffer, callbacks) => {
-  let str = "";
-  callbacks ||= [];
-  const resolvedBuffer = await Promise.all(buffer);
-  for (let i = resolvedBuffer.length - 1; ; i--) {
-    str += resolvedBuffer[i];
-    i--;
-    if (i < 0) {
-      break;
-    }
-    let r = resolvedBuffer[i];
-    if (typeof r === "object") {
-      callbacks.push(...r.callbacks || []);
-    }
-    const isEscaped = r.isEscaped;
-    r = await (typeof r === "object" ? r.toString() : r);
-    if (typeof r === "object") {
-      callbacks.push(...r.callbacks || []);
-    }
-    if (r.isEscaped ?? isEscaped) {
-      str += r;
-    } else {
-      const buf = [str];
-      escapeToBuffer(r, buf);
-      str = buf[0];
-    }
-  }
-  return raw(str, callbacks);
-};
-var escapeToBuffer = (str, buffer) => {
-  const match = str.search(escapeRe);
-  if (match === -1) {
-    buffer[0] += str;
-    return;
-  }
-  let escape;
-  let index;
-  let lastIndex = 0;
-  for (index = match; index < str.length; index++) {
-    switch (str.charCodeAt(index)) {
-      case 34:
-        escape = "&quot;";
-        break;
-      case 39:
-        escape = "&#39;";
-        break;
-      case 38:
-        escape = "&amp;";
-        break;
-      case 60:
-        escape = "&lt;";
-        break;
-      case 62:
-        escape = "&gt;";
-        break;
-      default:
-        continue;
-    }
-    buffer[0] += str.substring(lastIndex, index) + escape;
-    lastIndex = index + 1;
-  }
-  buffer[0] += str.substring(lastIndex, index);
-};
-var resolveCallbackSync = (str) => {
-  const callbacks = str.callbacks;
-  if (!callbacks?.length) {
-    return str;
-  }
-  const buffer = [str];
-  const context = {};
-  callbacks.forEach((c) => c({ phase: HtmlEscapedCallbackPhase.Stringify, buffer, context }));
-  return buffer[0];
-};
-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])
-  );
-  {
-    return resStr;
-  }
-};
-
-// src/context.ts
-var TEXT_PLAIN = "text/plain; charset=UTF-8";
-var setDefaultContentType = (contentType, headers) => {
-  return {
-    "Content-Type": contentType,
-    ...headers
-  };
-};
-var Context = class {
-  #rawRequest;
-  #req;
-  env = {};
-  #var;
-  finalized = false;
-  error;
-  #status;
-  #executionCtx;
-  #res;
-  #layout;
-  #renderer;
-  #notFoundHandler;
-  #preparedHeaders;
-  #matchResult;
-  #path;
-  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;
-    }
-  }
-  get req() {
-    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
-    return this.#req;
-  }
-  get event() {
-    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
-      return this.#executionCtx;
-    } else {
-      throw Error("This context has no FetchEvent");
-    }
-  }
-  get executionCtx() {
-    if (this.#executionCtx) {
-      return this.#executionCtx;
-    } else {
-      throw Error("This context has no ExecutionContext");
-    }
-  }
-  get res() {
-    return this.#res ||= new Response(null, {
-      headers: this.#preparedHeaders ??= new Headers()
-    });
-  }
-  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 = (...args) => {
-    this.#renderer ??= (content) => this.html(content);
-    return this.#renderer(...args);
-  };
-  setLayout = (layout) => this.#layout = layout;
-  getLayout = () => this.#layout;
-  setRenderer = (renderer) => {
-    this.#renderer = renderer;
-  };
-  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 = (key, value) => {
-    this.#var ??= /* @__PURE__ */ new Map();
-    this.#var.set(key, value);
-  };
-  get = (key) => {
-    return this.#var ? this.#var.get(key) : void 0;
-  };
-  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 = (data, arg, headers) => this.#newResponse(data, arg, headers);
-  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 = (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 = (location, status) => {
-    const locationString = String(location);
-    this.header(
-      "Location",
-      !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString)
-    );
-    return this.newResponse(null, status ?? 302);
-  };
-  notFound = () => {
-    this.#notFoundHandler ??= () => new Response();
-    return this.#notFoundHandler(this);
-  };
-};
-
-// src/router.ts
-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 {
-};
-
-// src/utils/constants.ts
-var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
-
-// src/hono-base.ts
-var notFoundHandler = (c) => {
-  return c.text("404 Not Found", 404);
-};
-var errorHandler$1 = (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 = {}) {
-    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
-    allMethods.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$1({
-      router: this.router,
-      getPath: this.getPath
-    });
-    clone.errorHandler = this.errorHandler;
-    clone.#notFoundHandler = this.#notFoundHandler;
-    clone.routes = this.routes;
-    return clone;
-  }
-  #notFoundHandler = notFoundHandler;
-  errorHandler = errorHandler$1;
-  route(path, app) {
-    const subApp = this.basePath(path);
-    app.routes.map((r) => {
-      let handler;
-      if (app.errorHandler === errorHandler$1) {
-        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(path) {
-    const subApp = this.#clone();
-    subApp._basePath = mergePath(this._basePath, path);
-    return subApp;
-  }
-  onError = (handler) => {
-    this.errorHandler = handler;
-    return this;
-  };
-  notFound = (handler) => {
-    this.#notFoundHandler = handler;
-    return this;
-  };
-  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 = (request, ...rest) => {
-    return this.#dispatch(request, rest[1], rest[0], request.method);
-  };
-  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 = () => {
-    addEventListener("fetch", (event) => {
-      event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
-    });
-  };
-};
-
-// src/router/reg-exp-router/matcher.ts
-var emptyParam = [];
-function match$1(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);
-}
-
-// src/router/reg-exp-router/node.ts
-var LABEL_REG_EXP_STR = "[^/]+";
-var ONLY_WILDCARD_REG_EXP_STR = ".*";
-var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-var PATH_ERROR = Symbol();
-var regExpMetaChars = 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$1();
-        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$1();
-      }
-    }
-    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
-  }
-  buildRegExpStr() {
-    const childKeys = Object.keys(this.#children).sort(compareKey);
-    const strList = childKeys.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("|") + ")";
-  }
-};
-
-// src/router/reg-exp-router/trie.ts
-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];
-  }
-};
-
-// src/router/reg-exp-router/router.ts
-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 void 0;
-  }
-  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
-    if (buildWildcardRegExp(k).test(path)) {
-      return [...middleware[k]];
-    }
-  }
-  return void 0;
-}
-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$1;
-  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);
-    }
-  }
-};
-
-// src/router/smart-router/router.ts
-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];
-  }
-};
-
-// src/router/trie-router/node.ts
-var emptyParams = /* @__PURE__ */ Object.create(null);
-var Node = class {
-  #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;
-    const curNode = this;
-    let curNodes = [curNode];
-    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;
-                const targetCurNodes = curNodesQueue[componentCount] ||= [];
-                targetCurNodes.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])];
-  }
-};
-
-// src/router/trie-router/router.ts
-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);
-  }
-};
-
-// src/hono.ts
-var Hono = class extends Hono$1 {
-  constructor(options = {}) {
-    super(options);
-    this.router = options.router ?? new SmartRouter({
-      routers: [new RegExpRouter(), new TrieRouter()]
-    });
-  }
-};
-
-// src/server.ts
-var RequestError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "RequestError";
-  }
-};
-var toRequestError = (e) => {
-  if (e instanceof RequestError) {
-    return e;
-  }
-  return new RequestError(e.message, { cause: e });
-};
-var GlobalRequest = global.Request;
-var Request$1 = class Request extends GlobalRequest {
-  constructor(input, options) {
-    if (typeof input === "object" && getRequestCache in input) {
-      input = input[getRequestCache]();
-    }
-    if (typeof options?.body?.getReader !== "undefined") {
-      options.duplex ??= "half";
-    }
-    super(input, options);
-  }
-};
-var newHeadersFromIncoming = (incoming) => {
-  const headerRecord = [];
-  const rawHeaders = incoming.rawHeaders;
-  for (let i = 0; i < rawHeaders.length; i += 2) {
-    const { [i]: key, [i + 1]: value } = rawHeaders;
-    if (key.charCodeAt(0) !== /*:*/
-    58) {
-      headerRecord.push([key, value]);
-    }
-  }
-  return new Headers(headerRecord);
-};
-var wrapBodyStream = Symbol("wrapBodyStream");
-var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
-  const init = {
-    method,
-    headers,
-    signal: abortController.signal
-  };
-  if (method === "TRACE") {
-    init.method = "GET";
-    const req = new Request$1(url, init);
-    Object.defineProperty(req, "method", {
-      get() {
-        return "TRACE";
-      }
-    });
-    return req;
-  }
-  if (!(method === "GET" || method === "HEAD")) {
-    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
-      init.body = new ReadableStream({
-        start(controller) {
-          controller.enqueue(incoming.rawBody);
-          controller.close();
-        }
-      });
-    } else if (incoming[wrapBodyStream]) {
-      let reader;
-      init.body = new ReadableStream({
-        async pull(controller) {
-          try {
-            reader ||= Readable.toWeb(incoming).getReader();
-            const { done, value } = await reader.read();
-            if (done) {
-              controller.close();
-            } else {
-              controller.enqueue(value);
-            }
-          } catch (error) {
-            controller.error(error);
-          }
-        }
-      });
-    } else {
-      init.body = Readable.toWeb(incoming);
-    }
-  }
-  return new Request$1(url, init);
-};
-var getRequestCache = Symbol("getRequestCache");
-var requestCache = Symbol("requestCache");
-var incomingKey = Symbol("incomingKey");
-var urlKey = Symbol("urlKey");
-var headersKey = Symbol("headersKey");
-var abortControllerKey = Symbol("abortControllerKey");
-var getAbortController = Symbol("getAbortController");
-var requestPrototype = {
-  get method() {
-    return this[incomingKey].method || "GET";
-  },
-  get url() {
-    return this[urlKey];
-  },
-  get headers() {
-    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
-  },
-  [getAbortController]() {
-    this[getRequestCache]();
-    return this[abortControllerKey];
-  },
-  [getRequestCache]() {
-    this[abortControllerKey] ||= new AbortController();
-    return this[requestCache] ||= newRequestFromIncoming(
-      this.method,
-      this[urlKey],
-      this.headers,
-      this[incomingKey],
-      this[abortControllerKey]
-    );
-  }
-};
-[
-  "body",
-  "bodyUsed",
-  "cache",
-  "credentials",
-  "destination",
-  "integrity",
-  "mode",
-  "redirect",
-  "referrer",
-  "referrerPolicy",
-  "signal",
-  "keepalive"
-].forEach((k) => {
-  Object.defineProperty(requestPrototype, k, {
-    get() {
-      return this[getRequestCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(requestPrototype, k, {
-    value: function() {
-      return this[getRequestCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(requestPrototype, Request$1.prototype);
-var newRequest = (incoming, defaultHostname) => {
-  const req = Object.create(requestPrototype);
-  req[incomingKey] = incoming;
-  const incomingUrl = incoming.url || "";
-  if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
-  (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
-    if (incoming instanceof Http2ServerRequest) {
-      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
-    }
-    try {
-      const url2 = new URL(incomingUrl);
-      req[urlKey] = url2.href;
-    } catch (e) {
-      throw new RequestError("Invalid absolute URL", { cause: e });
-    }
-    return req;
-  }
-  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
-  if (!host) {
-    throw new RequestError("Missing host header");
-  }
-  let scheme;
-  if (incoming instanceof Http2ServerRequest) {
-    scheme = incoming.scheme;
-    if (!(scheme === "http" || scheme === "https")) {
-      throw new RequestError("Unsupported scheme");
-    }
-  } else {
-    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
-  }
-  const url = new URL(`${scheme}://${host}${incomingUrl}`);
-  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
-    throw new RequestError("Invalid host header");
-  }
-  req[urlKey] = url.href;
-  return req;
-};
-
-// src/response.ts
-var responseCache = Symbol("responseCache");
-var getResponseCache = Symbol("getResponseCache");
-var cacheKey = Symbol("cache");
-var GlobalResponse = global.Response;
-var Response2 = class _Response {
-  #body;
-  #init;
-  [getResponseCache]() {
-    delete this[cacheKey];
-    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
-  }
-  constructor(body, init) {
-    let headers;
-    this.#body = body;
-    if (init instanceof _Response) {
-      const cachedGlobalResponse = init[responseCache];
-      if (cachedGlobalResponse) {
-        this.#init = cachedGlobalResponse;
-        this[getResponseCache]();
-        return;
-      } else {
-        this.#init = init.#init;
-        headers = new Headers(init.#init.headers);
-      }
-    } else {
-      this.#init = init;
-    }
-    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
-      headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
-      this[cacheKey] = [init?.status || 200, body, headers];
-    }
-  }
-  get headers() {
-    const cache = this[cacheKey];
-    if (cache) {
-      if (!(cache[2] instanceof Headers)) {
-        cache[2] = new Headers(cache[2]);
-      }
-      return cache[2];
-    }
-    return this[getResponseCache]().headers;
-  }
-  get status() {
-    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
-  }
-  get ok() {
-    const status = this.status;
-    return status >= 200 && status < 300;
-  }
-};
-["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    get() {
-      return this[getResponseCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(Response2.prototype, k, {
-    value: function() {
-      return this[getResponseCache]()[k]();
-    }
-  });
-});
-Object.setPrototypeOf(Response2, GlobalResponse);
-Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
-
-// src/utils.ts
-async function readWithoutBlocking(readPromise) {
-  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
-}
-function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
-  const cancel = (error) => {
-    reader.cancel(error).catch(() => {
-    });
-  };
-  writable.on("close", cancel);
-  writable.on("error", cancel);
-  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
-  return reader.closed.finally(() => {
-    writable.off("close", cancel);
-    writable.off("error", cancel);
-  });
-  function handleStreamError(error) {
-    if (error) {
-      writable.destroy(error);
-    }
-  }
-  function onDrain() {
-    reader.read().then(flow, handleStreamError);
-  }
-  function flow({ done, value }) {
-    try {
-      if (done) {
-        writable.end();
-      } else if (!writable.write(value)) {
-        writable.once("drain", onDrain);
-      } else {
-        return reader.read().then(flow, handleStreamError);
-      }
-    } catch (e) {
-      handleStreamError(e);
-    }
-  }
-}
-function writeFromReadableStream(stream, writable) {
-  if (stream.locked) {
-    throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
-    return;
-  }
-  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
-}
-var buildOutgoingHttpHeaders = (headers) => {
-  const res = {};
-  if (!(headers instanceof Headers)) {
-    headers = new Headers(headers ?? void 0);
-  }
-  const cookies = [];
-  for (const [k, v] of headers) {
-    if (k === "set-cookie") {
-      cookies.push(v);
-    } else {
-      res[k] = v;
-    }
-  }
-  if (cookies.length > 0) {
-    res["set-cookie"] = cookies;
-  }
-  res["content-type"] ??= "text/plain; charset=UTF-8";
-  return res;
-};
-
-// src/utils/response/constants.ts
-var X_ALREADY_SENT = "x-hono-already-sent";
-var webFetch = global.fetch;
-if (typeof global.crypto === "undefined") {
-  global.crypto = crypto$1;
-}
-global.fetch = (info, init) => {
-  init = {
-    // Disable compression handling so people can return the result of a fetch
-    // directly in the loader without messing with the Content-Encoding header.
-    compress: false,
-    ...init
-  };
-  return webFetch(info, init);
-};
-
-// src/listener.ts
-var outgoingEnded = Symbol("outgoingEnded");
-var handleRequestError = () => new Response(null, {
-  status: 400
-});
-var handleFetchError = (e) => new Response(null, {
-  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
-});
-var handleResponseError = (e, outgoing) => {
-  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
-  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
-    console.info("The user aborted a request.");
-  } else {
-    console.error(e);
-    if (!outgoing.headersSent) {
-      outgoing.writeHead(500, { "Content-Type": "text/plain" });
-    }
-    outgoing.end(`Error: ${err.message}`);
-    outgoing.destroy(err);
-  }
-};
-var flushHeaders = (outgoing) => {
-  if ("flushHeaders" in outgoing && outgoing.writable) {
-    outgoing.flushHeaders();
-  }
-};
-var responseViaCache = async (res, outgoing) => {
-  let [status, body, header] = res[cacheKey];
-  if (header instanceof Headers) {
-    header = buildOutgoingHttpHeaders(header);
-  }
-  if (typeof body === "string") {
-    header["Content-Length"] = Buffer.byteLength(body);
-  } else if (body instanceof Uint8Array) {
-    header["Content-Length"] = body.byteLength;
-  } else if (body instanceof Blob) {
-    header["Content-Length"] = body.size;
-  }
-  outgoing.writeHead(status, header);
-  if (typeof body === "string" || body instanceof Uint8Array) {
-    outgoing.end(body);
-  } else if (body instanceof Blob) {
-    outgoing.end(new Uint8Array(await body.arrayBuffer()));
-  } else {
-    flushHeaders(outgoing);
-    await writeFromReadableStream(body, outgoing)?.catch(
-      (e) => handleResponseError(e, outgoing)
-    );
-  }
-  outgoing[outgoingEnded]?.();
-};
-var isPromise = (res) => typeof res.then === "function";
-var responseViaResponseObject = async (res, outgoing, options = {}) => {
-  if (isPromise(res)) {
-    if (options.errorHandler) {
-      try {
-        res = await res;
-      } catch (err) {
-        const errRes = await options.errorHandler(err);
-        if (!errRes) {
-          return;
-        }
-        res = errRes;
-      }
-    } else {
-      res = await res.catch(handleFetchError);
-    }
-  }
-  if (cacheKey in res) {
-    return responseViaCache(res, outgoing);
-  }
-  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
-  if (res.body) {
-    const reader = res.body.getReader();
-    const values = [];
-    let done = false;
-    let currentReadPromise = void 0;
-    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
-      let maxReadCount = 2;
-      for (let i = 0; i < maxReadCount; i++) {
-        currentReadPromise ||= reader.read();
-        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
-          console.error(e);
-          done = true;
-        });
-        if (!chunk) {
-          if (i === 1) {
-            await new Promise((resolve) => setTimeout(resolve));
-            maxReadCount = 3;
-            continue;
-          }
-          break;
-        }
-        currentReadPromise = void 0;
-        if (chunk.value) {
-          values.push(chunk.value);
-        }
-        if (chunk.done) {
-          done = true;
-          break;
-        }
-      }
-      if (done && !("content-length" in resHeaderRecord)) {
-        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
-      }
-    }
-    outgoing.writeHead(res.status, resHeaderRecord);
-    values.forEach((value) => {
-      outgoing.write(value);
-    });
-    if (done) {
-      outgoing.end();
-    } else {
-      if (values.length === 0) {
-        flushHeaders(outgoing);
-      }
-      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
-    }
-  } else if (resHeaderRecord[X_ALREADY_SENT]) ; else {
-    outgoing.writeHead(res.status, resHeaderRecord);
-    outgoing.end();
-  }
-  outgoing[outgoingEnded]?.();
-};
-var getRequestListener = (fetchCallback, options = {}) => {
-  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-  if (options.overrideGlobalObjects !== false && global.Request !== Request$1) {
-    Object.defineProperty(global, "Request", {
-      value: Request$1
-    });
-    Object.defineProperty(global, "Response", {
-      value: Response2
-    });
-  }
-  return async (incoming, outgoing) => {
-    let res, req;
-    try {
-      req = newRequest(incoming, options.hostname);
-      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
-      if (!incomingEnded) {
-        ;
-        incoming[wrapBodyStream] = true;
-        incoming.on("end", () => {
-          incomingEnded = true;
-        });
-        if (incoming instanceof Http2ServerRequest) {
-          ;
-          outgoing[outgoingEnded] = () => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                if (!incomingEnded) {
-                  setTimeout(() => {
-                    incoming.destroy();
-                    outgoing.destroy();
-                  });
-                }
-              });
-            }
-          };
-        }
-      }
-      outgoing.on("close", () => {
-        const abortController = req[abortControllerKey];
-        if (abortController) {
-          if (incoming.errored) {
-            req[abortControllerKey].abort(incoming.errored.toString());
-          } else if (!outgoing.writableFinished) {
-            req[abortControllerKey].abort("Client connection prematurely closed.");
-          }
-        }
-        if (!incomingEnded) {
-          setTimeout(() => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                incoming.destroy();
-              });
-            }
-          });
-        }
-      });
-      res = fetchCallback(req, { incoming, outgoing });
-      if (cacheKey in res) {
-        return responseViaCache(res, outgoing);
-      }
-    } catch (e) {
-      if (!res) {
-        if (options.errorHandler) {
-          res = await options.errorHandler(req ? e : toRequestError(e));
-          if (!res) {
-            return;
-          }
-        } else if (!req) {
-          res = handleRequestError();
-        } else {
-          res = handleFetchError(e);
-        }
-      } else {
-        return handleResponseError(e, outgoing);
-      }
-    }
-    try {
-      return await responseViaResponseObject(res, outgoing, options);
-    } catch (e) {
-      return handleResponseError(e, outgoing);
-    }
-  };
-};
-
-// src/server.ts
-var createAdaptorServer = (options) => {
-  const fetchCallback = options.fetch;
-  const requestListener = getRequestListener(fetchCallback, {
-    hostname: options.hostname,
-    overrideGlobalObjects: options.overrideGlobalObjects,
-    autoCleanupIncoming: options.autoCleanupIncoming
-  });
-  const createServer$1 = options.createServer || createServer;
-  const server = createServer$1(options.serverOptions || {}, requestListener);
-  return server;
-};
-var serve = (options, listeningListener) => {
-  const server = createAdaptorServer(options);
-  server.listen(options?.port ?? 3e3, options.hostname, () => {
-    const serverInfo = server.address();
-    listeningListener && listeningListener(serverInfo);
-  });
-  return server;
-};
-
-// src/helper/html/index.ts
-var html = (strings, ...values) => {
-  const buffer = [""];
-  for (let i = 0, len = strings.length - 1; i < len; i++) {
-    buffer[0] += strings[i];
-    const children = Array.isArray(values[i]) ? values[i].flat(Infinity) : [values[i]];
-    for (let i2 = 0, len2 = children.length; i2 < len2; i2++) {
-      const child = children[i2];
-      if (typeof child === "string") {
-        escapeToBuffer(child, buffer);
-      } else if (typeof child === "number") {
-        buffer[0] += child;
-      } else if (typeof child === "boolean" || child === null || child === void 0) {
-        continue;
-      } else if (typeof child === "object" && child.isEscaped) {
-        if (child.callbacks) {
-          buffer.unshift("", child);
-        } else {
-          const tmp = child.toString();
-          if (tmp instanceof Promise) {
-            buffer.unshift("", tmp);
-          } else {
-            buffer[0] += tmp;
-          }
-        }
-      } else if (child instanceof Promise) {
-        buffer.unshift("", child);
-      } else {
-        escapeToBuffer(child.toString(), buffer);
-      }
-    }
-  }
-  buffer[0] += strings.at(-1);
-  return buffer.length === 1 ? "callbacks" in buffer ? raw(resolveCallbackSync(raw(buffer[0], buffer.callbacks))) : raw(buffer[0]) : stringBufferToString(buffer, buffer.callbacks);
-};
-
-// src/index.ts
-
-// src/swagger/renderer.ts
-var RENDER_TYPE = {
-  STRING_ARRAY: "string_array",
-  STRING: "string",
-  JSON_STRING: "json_string",
-  RAW: "raw"
-};
-var RENDER_TYPE_MAP = {
-  configUrl: RENDER_TYPE.STRING,
-  deepLinking: RENDER_TYPE.RAW,
-  presets: RENDER_TYPE.STRING_ARRAY,
-  plugins: RENDER_TYPE.STRING_ARRAY,
-  spec: RENDER_TYPE.JSON_STRING,
-  url: RENDER_TYPE.STRING,
-  urls: RENDER_TYPE.JSON_STRING,
-  layout: RENDER_TYPE.STRING,
-  docExpansion: RENDER_TYPE.STRING,
-  maxDisplayedTags: RENDER_TYPE.RAW,
-  operationsSorter: RENDER_TYPE.RAW,
-  requestInterceptor: RENDER_TYPE.RAW,
-  responseInterceptor: RENDER_TYPE.RAW,
-  persistAuthorization: RENDER_TYPE.RAW,
-  defaultModelsExpandDepth: RENDER_TYPE.RAW,
-  defaultModelExpandDepth: RENDER_TYPE.RAW,
-  defaultModelRendering: RENDER_TYPE.STRING,
-  displayRequestDuration: RENDER_TYPE.RAW,
-  filter: RENDER_TYPE.RAW,
-  showExtensions: RENDER_TYPE.RAW,
-  showCommonExtensions: RENDER_TYPE.RAW,
-  queryConfigEnabled: RENDER_TYPE.RAW,
-  displayOperationId: RENDER_TYPE.RAW,
-  tagsSorter: RENDER_TYPE.RAW,
-  onComplete: RENDER_TYPE.RAW,
-  syntaxHighlight: RENDER_TYPE.JSON_STRING,
-  tryItOutEnabled: RENDER_TYPE.RAW,
-  requestSnippetsEnabled: RENDER_TYPE.RAW,
-  requestSnippets: RENDER_TYPE.JSON_STRING,
-  oauth2RedirectUrl: RENDER_TYPE.STRING,
-  showMutabledRequest: RENDER_TYPE.RAW,
-  request: RENDER_TYPE.JSON_STRING,
-  supportedSubmitMethods: RENDER_TYPE.JSON_STRING,
-  validatorUrl: RENDER_TYPE.STRING,
-  withCredentials: RENDER_TYPE.RAW,
-  modelPropertyMacro: RENDER_TYPE.RAW,
-  parameterMacro: RENDER_TYPE.RAW
-};
-var renderSwaggerUIOptions = (options) => {
-  const optionsStrings = Object.entries(options).map(([k, v]) => {
-    const key = k;
-    if (!RENDER_TYPE_MAP[key] || v === void 0) {
-      return "";
-    }
-    switch (RENDER_TYPE_MAP[key]) {
-      case RENDER_TYPE.STRING:
-        return `${key}: '${v}'`;
-      case RENDER_TYPE.STRING_ARRAY:
-        if (!Array.isArray(v)) {
-          return "";
-        }
-        return `${key}: [${v.map((ve) => `${ve}`).join(",")}]`;
-      case RENDER_TYPE.JSON_STRING:
-        return `${key}: ${JSON.stringify(v)}`;
-      case RENDER_TYPE.RAW:
-        return `${key}: ${v}`;
-      default:
-        return "";
-    }
-  }).filter((item) => item !== "").join(",");
-  return optionsStrings;
-};
-
-// src/swagger/resource.ts
-var remoteAssets = ({ version }) => {
-  const url = `https://cdn.jsdelivr.net/npm/swagger-ui-dist${version !== void 0 ? `@${version}` : ""}`;
-  return {
-    css: [`${url}/swagger-ui.css`],
-    js: [`${url}/swagger-ui-bundle.js`]
-  };
-};
-
-// src/index.ts
-var SwaggerUI = (options) => {
-  const asset = remoteAssets({ version: options?.version });
-  delete options.version;
-  if (options.manuallySwaggerUIHtml) {
-    return options.manuallySwaggerUIHtml(asset);
-  }
-  const optionsStrings = renderSwaggerUIOptions(options);
-  return `
-    <div>
-      <div id="swagger-ui"></div>
-      ${asset.css.map((url) => html`<link rel="stylesheet" href="${url}" />`)}
-      ${asset.js.map((url) => html`<script src="${url}" crossorigin="anonymous"></script>`)}
-      <script>
-        window.onload = () => {
-          window.ui = SwaggerUIBundle({
-            dom_id: '#swagger-ui',${optionsStrings},
-          })
-        }
-      </script>
-    </div>
-  `;
-};
-var middleware = (options) => async (c) => {
-  const title = options?.title ?? "SwaggerUI";
-  return c.html(
-    /* html */
-    `
-      <html lang="en">
-        <head>
-          <meta charset="utf-8" />
-          <meta name="viewport" content="width=device-width, initial-scale=1" />
-          <meta name="description" content="SwaggerUI" />
-          <title>${title}</title>
-        </head>
-        <body>
-          ${SwaggerUI(options)}
-        </body>
-      </html>
-    `
-  );
-};
-
 function success(data, options = {}) {
   const { status = 200, meta = {} } = options;
   return {
@@ -6300,7 +4018,7 @@ class ApiServer {
         return c.json(this.openAPISpec);
       });
       if (this.options.docsUI === "swagger") {
-        this.app.get("/docs", middleware({
+        this.app.get("/docs", swaggerUI({
           url: "/openapi.json"
         }));
       } else {
@@ -15619,6 +13337,9 @@ class RelationPlugin extends Plugin {
     this.batchSize = config.batchSize || 100;
     this.preventN1 = config.preventN1 !== void 0 ? config.preventN1 : true;
     this.verbose = config.verbose || false;
+    this.fallbackLimit = config.fallbackLimit !== void 0 ? config.fallbackLimit : null;
+    this.cascadeBatchSize = config.cascadeBatchSize || 10;
+    this.cascadeTransactions = config.cascadeTransactions !== void 0 ? config.cascadeTransactions : false;
     this._loaderCache = /* @__PURE__ */ new Map();
     this._partitionCache = /* @__PURE__ */ new Map();
     this.stats = {
@@ -15627,7 +13348,8 @@ class RelationPlugin extends Plugin {
       batchLoads: 0,
       cascadeOperations: 0,
       partitionCacheHits: 0,
-      deduplicatedQueries: 0
+      deduplicatedQueries: 0,
+      fallbackLimitWarnings: 0
     };
   }
   /**
@@ -15892,13 +13614,7 @@ class RelationPlugin extends Plugin {
         localKeys
       );
     } else {
-      if (this.verbose) {
-        console.log(
-          `[RelationPlugin] No partition found for ${relatedResource.name}.${config.foreignKey}, using full scan`
-        );
-      }
-      const allRelated = await relatedResource.list({ limit: 1e4 });
-      relatedRecords = allRelated.filter((r) => localKeys.includes(r[config.foreignKey]));
+      relatedRecords = await this._fallbackLoad(relatedResource, config.foreignKey, localKeys);
     }
     const relatedMap = /* @__PURE__ */ new Map();
     relatedRecords.forEach((related) => {
@@ -15937,13 +13653,7 @@ class RelationPlugin extends Plugin {
         localKeys
       );
     } else {
-      if (this.verbose) {
-        console.log(
-          `[RelationPlugin] No partition found for ${relatedResource.name}.${config.foreignKey}, using full scan`
-        );
-      }
-      const allRelated = await relatedResource.list({ limit: 1e4 });
-      relatedRecords = allRelated.filter((r) => localKeys.includes(r[config.foreignKey]));
+      relatedRecords = await this._fallbackLoad(relatedResource, config.foreignKey, localKeys);
     }
     const relatedMap = /* @__PURE__ */ new Map();
     relatedRecords.forEach((related) => {
@@ -15989,13 +13699,7 @@ class RelationPlugin extends Plugin {
           foreignKeys
         );
       } else {
-        if (this.verbose) {
-          console.log(
-            `[RelationPlugin] No partition found for ${relatedResource.name}.${config.localKey}, using full scan`
-          );
-        }
-        const allRelated = await relatedResource.list({ limit: 1e4 });
-        return allRelated.filter((r) => foreignKeys.includes(r[config.localKey]));
+        return await this._fallbackLoad(relatedResource, config.localKey, foreignKeys);
       }
     });
     if (!ok) {
@@ -16052,13 +13756,7 @@ class RelationPlugin extends Plugin {
         localKeys
       );
     } else {
-      if (this.verbose) {
-        console.log(
-          `[RelationPlugin] No partition found for ${junctionResource.name}.${config.foreignKey}, using full scan`
-        );
-      }
-      const allJunction = await junctionResource.list({ limit: 1e4 });
-      junctionRecords = allJunction.filter((j) => localKeys.includes(j[config.foreignKey]));
+      junctionRecords = await this._fallbackLoad(junctionResource, config.foreignKey, localKeys);
     }
     if (junctionRecords.length === 0) {
       records.forEach((r) => r[relationName] = []);
@@ -16075,13 +13773,7 @@ class RelationPlugin extends Plugin {
         otherKeys
       );
     } else {
-      if (this.verbose) {
-        console.log(
-          `[RelationPlugin] No partition found for ${relatedResource.name}.${config.localKey}, using full scan`
-        );
-      }
-      const allRelated = await relatedResource.list({ limit: 1e4 });
-      relatedRecords = allRelated.filter((r) => otherKeys.includes(r[config.localKey]));
+      relatedRecords = await this._fallbackLoad(relatedResource, config.localKey, otherKeys);
     }
     const relatedMap = /* @__PURE__ */ new Map();
     relatedRecords.forEach((related) => {
@@ -16105,6 +13797,47 @@ class RelationPlugin extends Plugin {
     }
     return records;
   }
+  /**
+   * Batch process operations with controlled parallelism
+   * @private
+   */
+  async _batchProcess(items, operation, batchSize = null) {
+    if (items.length === 0) return [];
+    const actualBatchSize = batchSize || this.cascadeBatchSize;
+    const results = [];
+    for (let i = 0; i < items.length; i += actualBatchSize) {
+      const chunk = items.slice(i, i + actualBatchSize);
+      const chunkPromises = chunk.map((item) => operation(item));
+      const chunkResults = await Promise.all(chunkPromises);
+      results.push(...chunkResults);
+    }
+    return results;
+  }
+  /**
+   * Load records using fallback (full scan) when no partition is available
+   * Issues warnings when limit is reached to prevent silent data loss
+   * @private
+   */
+  async _fallbackLoad(resource, fieldName, filterValues) {
+    const options = this.fallbackLimit !== null ? { limit: this.fallbackLimit } : {};
+    if (this.verbose) {
+      console.log(
+        `[RelationPlugin] No partition found for ${resource.name}.${fieldName}, using full scan` + (this.fallbackLimit ? ` (limited to ${this.fallbackLimit} records)` : " (no limit)")
+      );
+    }
+    const allRecords = await resource.list(options);
+    const filteredRecords = allRecords.filter((r) => filterValues.includes(r[fieldName]));
+    if (this.fallbackLimit && allRecords.length >= this.fallbackLimit) {
+      this.stats.fallbackLimitWarnings++;
+      console.warn(
+        `[RelationPlugin] WARNING: Fallback query for ${resource.name}.${fieldName} hit the limit of ${this.fallbackLimit} records. Some related records may be missing! Consider:
+  1. Adding a partition on field "${fieldName}" for better performance
+  2. Increasing fallbackLimit in plugin config (or set to null for no limit)
+  Partition example: partitions: { by${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}: { fields: { ${fieldName}: 'string' } } }`
+      );
+    }
+    return filteredRecords;
+  }
   /**
    * Find partition by field name (for efficient relation loading)
    * Uses cache to avoid repeated lookups
@@ -16180,6 +13913,7 @@ class RelationPlugin extends Plugin {
   /**
    * Cascade delete operation
    * Uses partitions when available for efficient cascade
+   * Supports transaction/rollback when enabled
    * @private
    */
   async _cascadeDelete(record, resource, relationName, config) {
@@ -16191,6 +13925,8 @@ class RelationPlugin extends Plugin {
         relation: relationName
       });
     }
+    const deletedRecords = [];
+    config.type === "belongsToMany" ? this.database.resource(config.through) : null;
     try {
       if (config.type === "hasMany") {
         let relatedRecords;
@@ -16210,12 +13946,15 @@ class RelationPlugin extends Plugin {
             [config.foreignKey]: record[config.localKey]
           });
         }
-        for (const related of relatedRecords) {
-          await relatedResource.delete(related.id);
+        if (this.cascadeTransactions) {
+          deletedRecords.push(...relatedRecords.map((r) => ({ type: "delete", resource: relatedResource, record: r })));
         }
+        await this._batchProcess(relatedRecords, async (related) => {
+          return await relatedResource.delete(related.id);
+        });
         if (this.verbose) {
           console.log(
-            `[RelationPlugin] Cascade deleted ${relatedRecords.length} ${config.resource} for ${resource.name}:${record.id}`
+            `[RelationPlugin] Cascade deleted ${relatedRecords.length} ${config.resource} for ${resource.name}:${record.id} (batched in ${Math.ceil(relatedRecords.length / this.cascadeBatchSize)} chunks)`
           );
         }
       } else if (config.type === "hasOne") {
@@ -16232,15 +13971,18 @@ class RelationPlugin extends Plugin {
           });
         }
         if (relatedRecords.length > 0) {
+          if (this.cascadeTransactions) {
+            deletedRecords.push({ type: "delete", resource: relatedResource, record: relatedRecords[0] });
+          }
           await relatedResource.delete(relatedRecords[0].id);
         }
       } else if (config.type === "belongsToMany") {
-        const junctionResource = this.database.resource(config.through);
-        if (junctionResource) {
+        const junctionResource2 = this.database.resource(config.through);
+        if (junctionResource2) {
           let junctionRecords;
-          const partitionName = this._findPartitionByField(junctionResource, config.foreignKey);
+          const partitionName = this._findPartitionByField(junctionResource2, config.foreignKey);
           if (partitionName) {
-            junctionRecords = await junctionResource.list({
+            junctionRecords = await junctionResource2.list({
               partition: partitionName,
               partitionValues: { [config.foreignKey]: record[config.localKey] }
             });
@@ -16250,21 +13992,45 @@ class RelationPlugin extends Plugin {
               );
             }
           } else {
-            junctionRecords = await junctionResource.query({
+            junctionRecords = await junctionResource2.query({
               [config.foreignKey]: record[config.localKey]
             });
           }
-          for (const junction of junctionRecords) {
-            await junctionResource.delete(junction.id);
+          if (this.cascadeTransactions) {
+            deletedRecords.push(...junctionRecords.map((j) => ({ type: "delete", resource: junctionResource2, record: j })));
           }
+          await this._batchProcess(junctionRecords, async (junction) => {
+            return await junctionResource2.delete(junction.id);
+          });
           if (this.verbose) {
             console.log(
-              `[RelationPlugin] Cascade deleted ${junctionRecords.length} junction records from ${config.through}`
+              `[RelationPlugin] Cascade deleted ${junctionRecords.length} junction records from ${config.through} (batched in ${Math.ceil(junctionRecords.length / this.cascadeBatchSize)} chunks)`
             );
           }
         }
       }
     } catch (error) {
+      if (this.cascadeTransactions && deletedRecords.length > 0) {
+        console.error(
+          `[RelationPlugin] Cascade delete failed, attempting rollback of ${deletedRecords.length} records...`
+        );
+        const rollbackErrors = [];
+        for (const { resource: res, record: rec } of deletedRecords.reverse()) {
+          try {
+            await res.insert(rec);
+          } catch (rollbackError) {
+            rollbackErrors.push({ record: rec.id, error: rollbackError.message });
+          }
+        }
+        if (rollbackErrors.length > 0) {
+          console.error(
+            `[RelationPlugin] Rollback partially failed for ${rollbackErrors.length} records:`,
+            rollbackErrors
+          );
+        } else if (this.verbose) {
+          console.log(`[RelationPlugin] Rollback successful, restored ${deletedRecords.length} records`);
+        }
+      }
       throw new CascadeError("delete", resource.name, record.id, error, {
         relation: relationName,
         relatedResource: config.resource
@@ -16274,6 +14040,7 @@ class RelationPlugin extends Plugin {
   /**
    * Cascade update operation (update foreign keys when local key changes)
    * Uses partitions when available for efficient cascade
+   * Supports transaction/rollback when enabled
    * @private
    */
   async _cascadeUpdate(record, changes, resource, relationName, config) {
@@ -16282,6 +14049,7 @@ class RelationPlugin extends Plugin {
     if (!relatedResource) {
       return;
     }
+    const updatedRecords = [];
     try {
       const oldLocalKeyValue = record[config.localKey];
       const newLocalKeyValue = changes[config.localKey];
@@ -16305,17 +14073,48 @@ class RelationPlugin extends Plugin {
           [config.foreignKey]: oldLocalKeyValue
         });
       }
-      for (const related of relatedRecords) {
-        await relatedResource.update(related.id, {
+      if (this.cascadeTransactions) {
+        updatedRecords.push(...relatedRecords.map((r) => ({
+          type: "update",
+          resource: relatedResource,
+          id: r.id,
+          oldValue: r[config.foreignKey],
+          newValue: newLocalKeyValue,
+          field: config.foreignKey
+        })));
+      }
+      await this._batchProcess(relatedRecords, async (related) => {
+        return await relatedResource.update(related.id, {
           [config.foreignKey]: newLocalKeyValue
         }, { skipCascade: true });
-      }
+      });
       if (this.verbose) {
         console.log(
-          `[RelationPlugin] Cascade updated ${relatedRecords.length} ${config.resource} records`
+          `[RelationPlugin] Cascade updated ${relatedRecords.length} ${config.resource} records (batched in ${Math.ceil(relatedRecords.length / this.cascadeBatchSize)} chunks)`
         );
       }
     } catch (error) {
+      if (this.cascadeTransactions && updatedRecords.length > 0) {
+        console.error(
+          `[RelationPlugin] Cascade update failed, attempting rollback of ${updatedRecords.length} records...`
+        );
+        const rollbackErrors = [];
+        for (const { resource: res, id, field, oldValue } of updatedRecords.reverse()) {
+          try {
+            await res.update(id, { [field]: oldValue }, { skipCascade: true });
+          } catch (rollbackError) {
+            rollbackErrors.push({ id, error: rollbackError.message });
+          }
+        }
+        if (rollbackErrors.length > 0) {
+          console.error(
+            `[RelationPlugin] Rollback partially failed for ${rollbackErrors.length} records:`,
+            rollbackErrors
+          );
+        } else if (this.verbose) {
+          console.log(`[RelationPlugin] Rollback successful, restored ${updatedRecords.length} records`);
+        }
+      }
       throw new CascadeError("update", resource.name, record.id, error, {
         relation: relationName,
         relatedResource: config.resource
@@ -19140,7 +16939,17 @@ class Client extends EventEmitter {
       Bucket: this.config.bucket,
       Key: keyPrefix ? path$1.join(keyPrefix, key) : key
     };
-    const [ok, err, response] = await tryFn(() => this.sendCommand(new HeadObjectCommand(options)));
+    const [ok, err, response] = await tryFn(async () => {
+      const res = await this.sendCommand(new HeadObjectCommand(options));
+      if (res.Metadata) {
+        const decodedMetadata = {};
+        for (const [key2, value] of Object.entries(res.Metadata)) {
+          decodedMetadata[key2] = metadataDecode(value);
+        }
+        res.Metadata = decodedMetadata;
+      }
+      return res;
+    });
     this.emit("headObject", err || response, { key });
     if (!ok) {
       throw mapAwsError(err, {
@@ -19152,14 +16961,29 @@ class Client extends EventEmitter {
     }
     return response;
   }
-  async copyObject({ from, to }) {
+  async copyObject({ from, to, metadata, metadataDirective, contentType }) {
+    const keyPrefix = typeof this.config.keyPrefix === "string" ? this.config.keyPrefix : "";
     const options = {
       Bucket: this.config.bucket,
-      Key: this.config.keyPrefix ? path$1.join(this.config.keyPrefix, to) : to,
-      CopySource: path$1.join(this.config.bucket, this.config.keyPrefix ? path$1.join(this.config.keyPrefix, from) : from)
+      Key: keyPrefix ? path$1.join(keyPrefix, to) : to,
+      CopySource: path$1.join(this.config.bucket, keyPrefix ? path$1.join(keyPrefix, from) : from)
     };
+    if (metadataDirective) {
+      options.MetadataDirective = metadataDirective;
+    }
+    if (metadata && typeof metadata === "object") {
+      const encodedMetadata = {};
+      for (const [key, value] of Object.entries(metadata)) {
+        const { encoded } = metadataEncode(value);
+        encodedMetadata[key] = encoded;
+      }
+      options.Metadata = encodedMetadata;
+    }
+    if (contentType) {
+      options.ContentType = contentType;
+    }
     const [ok, err, response] = await tryFn(() => this.sendCommand(new CopyObjectCommand(options)));
-    this.emit("copyObject", err || response, { from, to });
+    this.emit("copyObject", err || response, { from, to, metadataDirective });
     if (!ok) {
       throw mapAwsError(err, {
         bucket: this.config.bucket,
@@ -20740,7 +18564,7 @@ class ResourceIdsReader extends EventEmitter {
     super();
     this.resource = resource;
     this.client = resource.client;
-    this.stream = new ReadableStream$1({
+    this.stream = new ReadableStream({
       highWaterMark: this.client.parallelism * 3,
       start: this._start.bind(this),
       pull: this._pull.bind(this),
@@ -22362,6 +20186,235 @@ ${errorDetails}`,
       return finalResult;
     }
   }
+  /**
+   * Patch resource (partial update optimized for metadata-only behaviors)
+   *
+   * This method provides an optimized update path for resources using metadata-only behaviors
+   * (enforce-limits, truncate-data). It uses HeadObject + CopyObject for atomic updates without
+   * body transfer, eliminating race conditions and reducing latency by ~50%.
+   *
+   * For behaviors that store data in body (body-overflow, body-only), it automatically falls
+   * back to the standard update() method.
+   *
+   * @param {string} id - Resource ID
+   * @param {Object} fields - Fields to update (partial data)
+   * @param {Object} options - Update options
+   * @param {string} options.partition - Partition name (if using partitions)
+   * @param {Object} options.partitionValues - Partition values (if using partitions)
+   * @returns {Promise<Object>} Updated resource data
+   *
+   * @example
+   * // Fast atomic update (enforce-limits behavior)
+   * await resource.patch('user-123', { status: 'active', loginCount: 42 });
+   *
+   * @example
+   * // With partitions
+   * await resource.patch('order-456', { status: 'shipped' }, {
+   *   partition: 'byRegion',
+   *   partitionValues: { region: 'US' }
+   * });
+   */
+  async patch(id, fields, options = {}) {
+    if (isEmpty(id)) {
+      throw new Error("id cannot be empty");
+    }
+    if (!fields || typeof fields !== "object") {
+      throw new Error("fields must be a non-empty object");
+    }
+    const behavior = this.behavior;
+    const hasNestedFields = Object.keys(fields).some((key) => key.includes("."));
+    if ((behavior === "enforce-limits" || behavior === "truncate-data") && !hasNestedFields) {
+      return await this._patchViaCopyObject(id, fields, options);
+    }
+    return await this.update(id, fields, options);
+  }
+  /**
+   * Internal helper: Optimized patch using HeadObject + CopyObject
+   * Only works for metadata-only behaviors (enforce-limits, truncate-data)
+   * Only for simple field updates (no nested fields with dot notation)
+   * @private
+   */
+  async _patchViaCopyObject(id, fields, options = {}) {
+    const { partition, partitionValues } = options;
+    const key = this.getResourceKey(id);
+    const headResponse = await this.client.headObject(key);
+    const currentMetadata = headResponse.Metadata || {};
+    let currentData = await this.schema.unmapper(currentMetadata);
+    if (!currentData.id) {
+      currentData.id = id;
+    }
+    const fieldsClone = cloneDeep(fields);
+    let mergedData = cloneDeep(currentData);
+    for (const [key2, value] of Object.entries(fieldsClone)) {
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        mergedData[key2] = merge({}, mergedData[key2], value);
+      } else {
+        mergedData[key2] = cloneDeep(value);
+      }
+    }
+    if (this.config.timestamps) {
+      mergedData.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    const validationResult = await this.schema.validate(mergedData);
+    if (validationResult !== true) {
+      throw new ValidationError("Validation failed during patch", validationResult);
+    }
+    const newMetadata = await this.schema.mapper(mergedData);
+    newMetadata._v = String(this.version);
+    await this.client.copyObject({
+      from: key,
+      to: key,
+      metadataDirective: "REPLACE",
+      metadata: newMetadata
+    });
+    if (this.config.partitions && Object.keys(this.config.partitions).length > 0) {
+      const oldData = { ...currentData, id };
+      const newData = { ...mergedData, id };
+      if (this.config.asyncPartitions) {
+        setImmediate(() => {
+          this.handlePartitionReferenceUpdates(oldData, newData).catch((err) => {
+            this.emit("partitionIndexError", {
+              operation: "patch",
+              id,
+              error: err
+            });
+          });
+        });
+      } else {
+        await this.handlePartitionReferenceUpdates(oldData, newData);
+      }
+    }
+    return mergedData;
+  }
+  /**
+   * Replace resource (full object replacement without GET)
+   *
+   * This method performs a direct PUT operation without fetching the current object.
+   * Use this when you already have the complete object and want to replace it entirely,
+   * saving 1 S3 request (GET).
+   *
+   * ⚠️ Warning: You must provide ALL required fields. Missing fields will NOT be preserved
+   * from the current object. This method does not merge with existing data.
+   *
+   * @param {string} id - Resource ID
+   * @param {Object} fullData - Complete object data (all required fields)
+   * @param {Object} options - Update options
+   * @param {string} options.partition - Partition name (if using partitions)
+   * @param {Object} options.partitionValues - Partition values (if using partitions)
+   * @returns {Promise<Object>} Replaced resource data
+   *
+   * @example
+   * // Replace entire object (must include ALL required fields)
+   * await resource.replace('user-123', {
+   *   name: 'John Doe',
+   *   email: 'john@example.com',
+   *   status: 'active',
+   *   loginCount: 42
+   * });
+   *
+   * @example
+   * // With partitions
+   * await resource.replace('order-456', fullOrderData, {
+   *   partition: 'byRegion',
+   *   partitionValues: { region: 'US' }
+   * });
+   */
+  async replace(id, fullData, options = {}) {
+    if (isEmpty(id)) {
+      throw new Error("id cannot be empty");
+    }
+    if (!fullData || typeof fullData !== "object") {
+      throw new Error("fullData must be a non-empty object");
+    }
+    const { partition, partitionValues } = options;
+    const dataClone = cloneDeep(fullData);
+    const attributesWithDefaults = this.applyDefaults(dataClone);
+    if (this.config.timestamps) {
+      if (!attributesWithDefaults.createdAt) {
+        attributesWithDefaults.createdAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      attributesWithDefaults.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    const completeData = { id, ...attributesWithDefaults };
+    const {
+      errors,
+      isValid,
+      data: validated
+    } = await this.validate(completeData);
+    if (!isValid) {
+      const errorMsg = errors && errors.length && errors[0].message ? errors[0].message : "Replace failed";
+      throw new InvalidResourceItem({
+        bucket: this.client.config.bucket,
+        resourceName: this.name,
+        attributes: completeData,
+        validation: errors,
+        message: errorMsg
+      });
+    }
+    const { id: validatedId, ...validatedAttributes } = validated;
+    const mappedMetadata = await this.schema.mapper(validatedAttributes);
+    mappedMetadata._v = String(this.version);
+    const behaviorImpl = getBehavior(this.behavior);
+    const { mappedData: finalMetadata, body } = await behaviorImpl.handleInsert({
+      resource: this,
+      data: validatedAttributes,
+      mappedData: mappedMetadata,
+      originalData: completeData
+    });
+    const key = this.getResourceKey(id);
+    let contentType = void 0;
+    if (body && body !== "") {
+      const [okParse] = await tryFn(() => Promise.resolve(JSON.parse(body)));
+      if (okParse) contentType = "application/json";
+    }
+    if (this.behavior === "body-only" && (!body || body === "")) {
+      throw new Error(`[Resource.replace] Attempt to save object without body! Data: id=${id}, resource=${this.name}`);
+    }
+    const [okPut, errPut] = await tryFn(() => this.client.putObject({
+      key,
+      body,
+      contentType,
+      metadata: finalMetadata
+    }));
+    if (!okPut) {
+      const msg = errPut && errPut.message ? errPut.message : "";
+      if (msg.includes("metadata headers exceed") || msg.includes("Replace failed")) {
+        const totalSize = calculateTotalSize(finalMetadata);
+        const effectiveLimit = calculateEffectiveLimit({
+          s3Limit: 2047,
+          systemConfig: {
+            version: this.version,
+            timestamps: this.config.timestamps,
+            id
+          }
+        });
+        const excess = totalSize - effectiveLimit;
+        errPut.totalSize = totalSize;
+        errPut.limit = 2047;
+        errPut.effectiveLimit = effectiveLimit;
+        errPut.excess = excess;
+        throw new ResourceError("metadata headers exceed", { resourceName: this.name, operation: "replace", id, totalSize, effectiveLimit, excess, suggestion: "Reduce metadata size or number of fields." });
+      }
+      throw errPut;
+    }
+    const replacedObject = { id, ...validatedAttributes };
+    if (this.config.partitions && Object.keys(this.config.partitions).length > 0) {
+      if (this.config.asyncPartitions) {
+        setImmediate(() => {
+          this.handlePartitionReferenceUpdates({}, replacedObject).catch((err) => {
+            this.emit("partitionIndexError", {
+              operation: "replace",
+              id,
+              error: err
+            });
+          });
+        });
+      } else {
+        await this.handlePartitionReferenceUpdates({}, replacedObject);
+      }
+    }
+    return replacedObject;
+  }
   /**
    * Update with conditional check (If-Match ETag)
    * @param {string} id - Resource ID
@@ -23710,29 +21763,6 @@ ${errorDetails}`,
     }
     return filtered;
   }
-  async replace(id, attributes) {
-    await this.delete(id);
-    await new Promise((r) => setTimeout(r, 100));
-    const maxWait = 5e3;
-    const interval = 50;
-    const start = Date.now();
-    while (Date.now() - start < maxWait) {
-      const exists = await this.exists(id);
-      if (!exists) {
-        break;
-      }
-      await new Promise((r) => setTimeout(r, interval));
-    }
-    const [ok, err, result] = await tryFn(() => this.insert({ ...attributes, id }));
-    if (!ok) {
-      if (err && err.message && err.message.includes("already exists")) {
-        const updateResult = await this.update(id, attributes);
-        return updateResult;
-      }
-      throw err;
-    }
-    return result;
-  }
   // --- MIDDLEWARE SYSTEM ---
   _initMiddleware() {
     this._middlewares = /* @__PURE__ */ new Map();
@@ -23934,7 +21964,7 @@ class Database extends EventEmitter {
     this.id = idGenerator(7);
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "12.0.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "12.1.0" : "latest");
       return ok ? version : "latest";
     })();
     this.resources = {};
@@ -26804,7 +24834,7 @@ class ReplicatorPlugin extends Plugin {
   async updateReplicatorLog(logId, updates) {
     if (!this.replicatorLog) return;
     const [ok, err] = await tryFn(async () => {
-      await this.replicatorLog.update(logId, {
+      await this.replicatorLog.patch(logId, {
         ...updates,
         lastAttempt: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -38075,7 +36105,7 @@ class TfStatePlugin extends Plugin {
       console.log(`[TfStatePlugin] Setting up cron monitoring: ${this.monitorCron}`);
     }
     await requirePluginDependency("tfstate-plugin");
-    const [ok, err, cronModule] = await tryFn(() => Promise.resolve().then(function () { return nodeCron$1; }));
+    const [ok, err, cronModule] = await tryFn(() => import('node-cron'));
     if (!ok) {
       throw new TfStateError(`Failed to import node-cron: ${err.message}`);
     }
@@ -39772,1415 +37802,6 @@ var prometheusFormatter = /*#__PURE__*/Object.freeze({
   formatPrometheusMetrics: formatPrometheusMetrics
 });
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var nodeCron$2 = {};
-
-var inlineScheduledTask = {};
-
-var runner = {};
-
-var createId = {};
-
-var hasRequiredCreateId;
-
-function requireCreateId () {
-	if (hasRequiredCreateId) return createId;
-	hasRequiredCreateId = 1;
-	var __importDefault = (createId && createId.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(createId, "__esModule", { value: true });
-	createId.createID = createID;
-	const node_crypto_1 = __importDefault(require$$0);
-	function createID(prefix = '', length = 16) {
-	    const charset = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-	    const values = node_crypto_1.default.randomBytes(length);
-	    const id = Array.from(values, v => charset[v % charset.length]).join('');
-	    return prefix ? `${prefix}-${id}` : id;
-	}
-	
-	return createId;
-}
-
-var logger = {};
-
-var hasRequiredLogger;
-
-function requireLogger () {
-	if (hasRequiredLogger) return logger;
-	hasRequiredLogger = 1;
-	Object.defineProperty(logger, "__esModule", { value: true });
-	const levelColors = {
-	    INFO: '\x1b[36m',
-	    WARN: '\x1b[33m',
-	    ERROR: '\x1b[31m',
-	    DEBUG: '\x1b[35m',
-	};
-	const GREEN = '\x1b[32m';
-	const RESET = '\x1b[0m';
-	function log(level, message, extra) {
-	    const timestamp = new Date().toISOString();
-	    const color = levelColors[level] ?? '';
-	    const prefix = `[${timestamp}] [PID: ${process.pid}] ${GREEN}[NODE-CRON]${GREEN} ${color}[${level}]${RESET}`;
-	    const output = `${prefix} ${message}`;
-	    switch (level) {
-	        case 'ERROR':
-	            console.error(output, extra ?? '');
-	            break;
-	        case 'DEBUG':
-	            console.debug(output, extra ?? '');
-	            break;
-	        case 'WARN':
-	            console.warn(output);
-	            break;
-	        case 'INFO':
-	        default:
-	            console.info(output);
-	            break;
-	    }
-	}
-	const logger$1 = {
-	    info(message) {
-	        log('INFO', message);
-	    },
-	    warn(message) {
-	        log('WARN', message);
-	    },
-	    error(message, err) {
-	        if (message instanceof Error) {
-	            log('ERROR', message.message, message);
-	        }
-	        else {
-	            log('ERROR', message, err);
-	        }
-	    },
-	    debug(message, err) {
-	        if (message instanceof Error) {
-	            log('DEBUG', message.message, message);
-	        }
-	        else {
-	            log('DEBUG', message, err);
-	        }
-	    },
-	};
-	logger.default = logger$1;
-	
-	return logger;
-}
-
-var trackedPromise = {};
-
-var hasRequiredTrackedPromise;
-
-function requireTrackedPromise () {
-	if (hasRequiredTrackedPromise) return trackedPromise;
-	hasRequiredTrackedPromise = 1;
-	Object.defineProperty(trackedPromise, "__esModule", { value: true });
-	trackedPromise.TrackedPromise = void 0;
-	class TrackedPromise {
-	    promise;
-	    error;
-	    state;
-	    value;
-	    constructor(executor) {
-	        this.state = 'pending';
-	        this.promise = new Promise((resolve, reject) => {
-	            executor((value) => {
-	                this.state = 'fulfilled';
-	                this.value = value;
-	                resolve(value);
-	            }, (error) => {
-	                this.state = 'rejected';
-	                this.error = error;
-	                reject(error);
-	            });
-	        });
-	    }
-	    getPromise() {
-	        return this.promise;
-	    }
-	    getState() {
-	        return this.state;
-	    }
-	    isPending() {
-	        return this.state === 'pending';
-	    }
-	    isFulfilled() {
-	        return this.state === 'fulfilled';
-	    }
-	    isRejected() {
-	        return this.state === 'rejected';
-	    }
-	    getValue() {
-	        return this.value;
-	    }
-	    getError() {
-	        return this.error;
-	    }
-	    then(onfulfilled, onrejected) {
-	        return this.promise.then(onfulfilled, onrejected);
-	    }
-	    catch(onrejected) {
-	        return this.promise.catch(onrejected);
-	    }
-	    finally(onfinally) {
-	        return this.promise.finally(onfinally);
-	    }
-	}
-	trackedPromise.TrackedPromise = TrackedPromise;
-	
-	return trackedPromise;
-}
-
-var hasRequiredRunner;
-
-function requireRunner () {
-	if (hasRequiredRunner) return runner;
-	hasRequiredRunner = 1;
-	var __importDefault = (runner && runner.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(runner, "__esModule", { value: true });
-	runner.Runner = void 0;
-	const create_id_1 = requireCreateId();
-	const logger_1 = __importDefault(requireLogger());
-	const tracked_promise_1 = requireTrackedPromise();
-	function emptyOnFn() { }
-	function emptyHookFn() { return true; }
-	function defaultOnError(date, error) {
-	    logger_1.default.error('Task failed with error!', error);
-	}
-	class Runner {
-	    timeMatcher;
-	    onMatch;
-	    noOverlap;
-	    maxExecutions;
-	    maxRandomDelay;
-	    runCount;
-	    running;
-	    heartBeatTimeout;
-	    onMissedExecution;
-	    onOverlap;
-	    onError;
-	    beforeRun;
-	    onFinished;
-	    onMaxExecutions;
-	    constructor(timeMatcher, onMatch, options) {
-	        this.timeMatcher = timeMatcher;
-	        this.onMatch = onMatch;
-	        this.noOverlap = options == undefined || options.noOverlap === undefined ? false : options.noOverlap;
-	        this.maxExecutions = options?.maxExecutions;
-	        this.maxRandomDelay = options?.maxRandomDelay || 0;
-	        this.onMissedExecution = options?.onMissedExecution || emptyOnFn;
-	        this.onOverlap = options?.onOverlap || emptyOnFn;
-	        this.onError = options?.onError || defaultOnError;
-	        this.onFinished = options?.onFinished || emptyHookFn;
-	        this.beforeRun = options?.beforeRun || emptyHookFn;
-	        this.onMaxExecutions = options?.onMaxExecutions || emptyOnFn;
-	        this.runCount = 0;
-	        this.running = false;
-	    }
-	    start() {
-	        this.running = true;
-	        let lastExecution;
-	        let expectedNextExecution;
-	        const scheduleNextHeartBeat = (currentDate) => {
-	            if (this.running) {
-	                clearTimeout(this.heartBeatTimeout);
-	                this.heartBeatTimeout = setTimeout(heartBeat, getDelay(this.timeMatcher, currentDate));
-	            }
-	        };
-	        const runTask = (date) => {
-	            return new Promise(async (resolve) => {
-	                const execution = {
-	                    id: (0, create_id_1.createID)('exec'),
-	                    reason: 'scheduled'
-	                };
-	                const shouldExecute = await this.beforeRun(date, execution);
-	                const randomDelay = Math.floor(Math.random() * this.maxRandomDelay);
-	                if (shouldExecute) {
-	                    setTimeout(async () => {
-	                        try {
-	                            this.runCount++;
-	                            execution.startedAt = new Date();
-	                            const result = await this.onMatch(date, execution);
-	                            execution.finishedAt = new Date();
-	                            execution.result = result;
-	                            this.onFinished(date, execution);
-	                            if (this.maxExecutions && this.runCount >= this.maxExecutions) {
-	                                this.onMaxExecutions(date);
-	                                this.stop();
-	                            }
-	                        }
-	                        catch (error) {
-	                            execution.finishedAt = new Date();
-	                            execution.error = error;
-	                            this.onError(date, error, execution);
-	                        }
-	                        resolve(true);
-	                    }, randomDelay);
-	                }
-	            });
-	        };
-	        const checkAndRun = (date) => {
-	            return new tracked_promise_1.TrackedPromise(async (resolve, reject) => {
-	                try {
-	                    if (this.timeMatcher.match(date)) {
-	                        await runTask(date);
-	                    }
-	                    resolve(true);
-	                }
-	                catch (err) {
-	                    reject(err);
-	                }
-	            });
-	        };
-	        const heartBeat = async () => {
-	            const currentDate = nowWithoutMs();
-	            if (expectedNextExecution && expectedNextExecution.getTime() < currentDate.getTime()) {
-	                while (expectedNextExecution.getTime() < currentDate.getTime()) {
-	                    logger_1.default.warn(`missed execution at ${expectedNextExecution}! Possible blocking IO or high CPU user at the same process used by node-cron.`);
-	                    expectedNextExecution = this.timeMatcher.getNextMatch(expectedNextExecution);
-	                    runAsync(this.onMissedExecution, expectedNextExecution, defaultOnError);
-	                }
-	            }
-	            if (lastExecution && lastExecution.getState() === 'pending') {
-	                runAsync(this.onOverlap, currentDate, defaultOnError);
-	                if (this.noOverlap) {
-	                    logger_1.default.warn('task still running, new execution blocked by overlap prevention!');
-	                    expectedNextExecution = this.timeMatcher.getNextMatch(currentDate);
-	                    scheduleNextHeartBeat(currentDate);
-	                    return;
-	                }
-	            }
-	            lastExecution = checkAndRun(currentDate);
-	            expectedNextExecution = this.timeMatcher.getNextMatch(currentDate);
-	            scheduleNextHeartBeat(currentDate);
-	        };
-	        this.heartBeatTimeout = setTimeout(() => {
-	            heartBeat();
-	        }, getDelay(this.timeMatcher, nowWithoutMs()));
-	    }
-	    nextRun() {
-	        return this.timeMatcher.getNextMatch(new Date());
-	    }
-	    stop() {
-	        this.running = false;
-	        if (this.heartBeatTimeout) {
-	            clearTimeout(this.heartBeatTimeout);
-	            this.heartBeatTimeout = undefined;
-	        }
-	    }
-	    isStarted() {
-	        return !!this.heartBeatTimeout && this.running;
-	    }
-	    isStopped() {
-	        return !this.isStarted();
-	    }
-	    async execute() {
-	        const date = new Date();
-	        const execution = {
-	            id: (0, create_id_1.createID)('exec'),
-	            reason: 'invoked'
-	        };
-	        try {
-	            const shouldExecute = await this.beforeRun(date, execution);
-	            if (shouldExecute) {
-	                this.runCount++;
-	                execution.startedAt = new Date();
-	                const result = await this.onMatch(date, execution);
-	                execution.finishedAt = new Date();
-	                execution.result = result;
-	                this.onFinished(date, execution);
-	            }
-	        }
-	        catch (error) {
-	            execution.finishedAt = new Date();
-	            execution.error = error;
-	            this.onError(date, error, execution);
-	        }
-	    }
-	}
-	runner.Runner = Runner;
-	async function runAsync(fn, date, onError) {
-	    try {
-	        await fn(date);
-	    }
-	    catch (error) {
-	        onError(date, error);
-	    }
-	}
-	function getDelay(timeMatcher, currentDate) {
-	    const maxDelay = 86400000;
-	    const nextRun = timeMatcher.getNextMatch(currentDate);
-	    const now = new Date();
-	    const delay = nextRun.getTime() - now.getTime();
-	    if (delay > maxDelay) {
-	        return maxDelay;
-	    }
-	    return Math.max(0, delay);
-	}
-	function nowWithoutMs() {
-	    const date = new Date();
-	    date.setMilliseconds(0);
-	    return date;
-	}
-	
-	return runner;
-}
-
-var timeMatcher = {};
-
-var convertion = {};
-
-var monthNamesConversion = {};
-
-var hasRequiredMonthNamesConversion;
-
-function requireMonthNamesConversion () {
-	if (hasRequiredMonthNamesConversion) return monthNamesConversion;
-	hasRequiredMonthNamesConversion = 1;
-	Object.defineProperty(monthNamesConversion, "__esModule", { value: true });
-	monthNamesConversion.default = (() => {
-	    const months = ['january', 'february', 'march', 'april', 'may', 'june', 'july',
-	        'august', 'september', 'october', 'november', 'december'];
-	    const shortMonths = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
-	        'sep', 'oct', 'nov', 'dec'];
-	    function convertMonthName(expression, items) {
-	        for (let i = 0; i < items.length; i++) {
-	            expression = expression.replace(new RegExp(items[i], 'gi'), i + 1);
-	        }
-	        return expression;
-	    }
-	    function interprete(monthExpression) {
-	        monthExpression = convertMonthName(monthExpression, months);
-	        monthExpression = convertMonthName(monthExpression, shortMonths);
-	        return monthExpression;
-	    }
-	    return interprete;
-	})();
-	
-	return monthNamesConversion;
-}
-
-var weekDayNamesConversion = {};
-
-var hasRequiredWeekDayNamesConversion;
-
-function requireWeekDayNamesConversion () {
-	if (hasRequiredWeekDayNamesConversion) return weekDayNamesConversion;
-	hasRequiredWeekDayNamesConversion = 1;
-	Object.defineProperty(weekDayNamesConversion, "__esModule", { value: true });
-	weekDayNamesConversion.default = (() => {
-	    const weekDays = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
-	        'friday', 'saturday'];
-	    const shortWeekDays = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
-	    function convertWeekDayName(expression, items) {
-	        for (let i = 0; i < items.length; i++) {
-	            expression = expression.replace(new RegExp(items[i], 'gi'), i);
-	        }
-	        return expression;
-	    }
-	    function convertWeekDays(expression) {
-	        expression = expression.replace('7', '0');
-	        expression = convertWeekDayName(expression, weekDays);
-	        return convertWeekDayName(expression, shortWeekDays);
-	    }
-	    return convertWeekDays;
-	})();
-	
-	return weekDayNamesConversion;
-}
-
-var asteriskToRangeConversion = {};
-
-var hasRequiredAsteriskToRangeConversion;
-
-function requireAsteriskToRangeConversion () {
-	if (hasRequiredAsteriskToRangeConversion) return asteriskToRangeConversion;
-	hasRequiredAsteriskToRangeConversion = 1;
-	Object.defineProperty(asteriskToRangeConversion, "__esModule", { value: true });
-	asteriskToRangeConversion.default = (() => {
-	    function convertAsterisk(expression, replecement) {
-	        if (expression.indexOf('*') !== -1) {
-	            return expression.replace('*', replecement);
-	        }
-	        return expression;
-	    }
-	    function convertAsterisksToRanges(expressions) {
-	        expressions[0] = convertAsterisk(expressions[0], '0-59');
-	        expressions[1] = convertAsterisk(expressions[1], '0-59');
-	        expressions[2] = convertAsterisk(expressions[2], '0-23');
-	        expressions[3] = convertAsterisk(expressions[3], '1-31');
-	        expressions[4] = convertAsterisk(expressions[4], '1-12');
-	        expressions[5] = convertAsterisk(expressions[5], '0-6');
-	        return expressions;
-	    }
-	    return convertAsterisksToRanges;
-	})();
-	
-	return asteriskToRangeConversion;
-}
-
-var rangeConversion = {};
-
-var hasRequiredRangeConversion;
-
-function requireRangeConversion () {
-	if (hasRequiredRangeConversion) return rangeConversion;
-	hasRequiredRangeConversion = 1;
-	Object.defineProperty(rangeConversion, "__esModule", { value: true });
-	rangeConversion.default = (() => {
-	    function replaceWithRange(expression, text, init, end, stepTxt) {
-	        const step = parseInt(stepTxt);
-	        const numbers = [];
-	        let last = parseInt(end);
-	        let first = parseInt(init);
-	        if (first > last) {
-	            last = parseInt(init);
-	            first = parseInt(end);
-	        }
-	        for (let i = first; i <= last; i += step) {
-	            numbers.push(i);
-	        }
-	        return expression.replace(new RegExp(text, 'i'), numbers.join());
-	    }
-	    function convertRange(expression) {
-	        const rangeRegEx = /(\d+)-(\d+)(\/(\d+)|)/;
-	        let match = rangeRegEx.exec(expression);
-	        while (match !== null && match.length > 0) {
-	            expression = replaceWithRange(expression, match[0], match[1], match[2], match[4] || '1');
-	            match = rangeRegEx.exec(expression);
-	        }
-	        return expression;
-	    }
-	    function convertAllRanges(expressions) {
-	        for (let i = 0; i < expressions.length; i++) {
-	            expressions[i] = convertRange(expressions[i]);
-	        }
-	        return expressions;
-	    }
-	    return convertAllRanges;
-	})();
-	
-	return rangeConversion;
-}
-
-var hasRequiredConvertion;
-
-function requireConvertion () {
-	if (hasRequiredConvertion) return convertion;
-	hasRequiredConvertion = 1;
-	var __importDefault = (convertion && convertion.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(convertion, "__esModule", { value: true });
-	const month_names_conversion_1 = __importDefault(requireMonthNamesConversion());
-	const week_day_names_conversion_1 = __importDefault(requireWeekDayNamesConversion());
-	const asterisk_to_range_conversion_1 = __importDefault(requireAsteriskToRangeConversion());
-	const range_conversion_1 = __importDefault(requireRangeConversion());
-	convertion.default = (() => {
-	    function appendSeccondExpression(expressions) {
-	        if (expressions.length === 5) {
-	            return ['0'].concat(expressions);
-	        }
-	        return expressions;
-	    }
-	    function removeSpaces(str) {
-	        return str.replace(/\s{2,}/g, ' ').trim();
-	    }
-	    function normalizeIntegers(expressions) {
-	        for (let i = 0; i < expressions.length; i++) {
-	            const numbers = expressions[i].split(',');
-	            for (let j = 0; j < numbers.length; j++) {
-	                numbers[j] = parseInt(numbers[j]);
-	            }
-	            expressions[i] = numbers;
-	        }
-	        return expressions;
-	    }
-	    function interprete(expression) {
-	        let expressions = removeSpaces(`${expression}`).split(' ');
-	        expressions = appendSeccondExpression(expressions);
-	        expressions[4] = (0, month_names_conversion_1.default)(expressions[4]);
-	        expressions[5] = (0, week_day_names_conversion_1.default)(expressions[5]);
-	        expressions = (0, asterisk_to_range_conversion_1.default)(expressions);
-	        expressions = (0, range_conversion_1.default)(expressions);
-	        expressions = normalizeIntegers(expressions);
-	        return expressions;
-	    }
-	    return interprete;
-	})();
-	
-	return convertion;
-}
-
-var localizedTime = {};
-
-var hasRequiredLocalizedTime;
-
-function requireLocalizedTime () {
-	if (hasRequiredLocalizedTime) return localizedTime;
-	hasRequiredLocalizedTime = 1;
-	Object.defineProperty(localizedTime, "__esModule", { value: true });
-	localizedTime.LocalizedTime = void 0;
-	class LocalizedTime {
-	    timestamp;
-	    parts;
-	    timezone;
-	    constructor(date, timezone) {
-	        this.timestamp = date.getTime();
-	        this.timezone = timezone;
-	        this.parts = buildDateParts(date, timezone);
-	    }
-	    toDate() {
-	        return new Date(this.timestamp);
-	    }
-	    toISO() {
-	        const gmt = this.parts.gmt.replace(/^GMT/, '');
-	        const offset = gmt ? gmt : 'Z';
-	        const pad = (n) => String(n).padStart(2, '0');
-	        return `${this.parts.year}-${pad(this.parts.month)}-${pad(this.parts.day)}`
-	            + `T${pad(this.parts.hour)}:${pad(this.parts.minute)}:${pad(this.parts.second)}`
-	            + `.${String(this.parts.milisecond).padStart(3, '0')}`
-	            + offset;
-	    }
-	    getParts() {
-	        return this.parts;
-	    }
-	    set(field, value) {
-	        this.parts[field] = value;
-	        const newDate = new Date(this.toISO());
-	        this.timestamp = newDate.getTime();
-	        this.parts = buildDateParts(newDate, this.timezone);
-	    }
-	}
-	localizedTime.LocalizedTime = LocalizedTime;
-	function buildDateParts(date, timezone) {
-	    const dftOptions = {
-	        year: 'numeric',
-	        month: '2-digit',
-	        day: '2-digit',
-	        hour: '2-digit',
-	        minute: '2-digit',
-	        second: '2-digit',
-	        weekday: 'short',
-	        hour12: false
-	    };
-	    if (timezone) {
-	        dftOptions.timeZone = timezone;
-	    }
-	    const dateFormat = new Intl.DateTimeFormat('en-US', dftOptions);
-	    const parts = dateFormat.formatToParts(date).filter(part => {
-	        return part.type !== 'literal';
-	    }).reduce((acc, part) => {
-	        acc[part.type] = part.value;
-	        return acc;
-	    }, {});
-	    return {
-	        day: parseInt(parts.day),
-	        month: parseInt(parts.month),
-	        year: parseInt(parts.year),
-	        hour: parts.hour === '24' ? 0 : parseInt(parts.hour),
-	        minute: parseInt(parts.minute),
-	        second: parseInt(parts.second),
-	        milisecond: date.getMilliseconds(),
-	        weekday: parts.weekday,
-	        gmt: getTimezoneGMT(date, timezone)
-	    };
-	}
-	function getTimezoneGMT(date, timezone) {
-	    const utcDate = new Date(date.toLocaleString('en-US', { timeZone: 'UTC' }));
-	    const tzDate = new Date(date.toLocaleString('en-US', { timeZone: timezone }));
-	    let offsetInMinutes = (utcDate.getTime() - tzDate.getTime()) / 60000;
-	    const sign = offsetInMinutes <= 0 ? '+' : '-';
-	    offsetInMinutes = Math.abs(offsetInMinutes);
-	    if (offsetInMinutes === 0)
-	        return 'Z';
-	    const hours = Math.floor(offsetInMinutes / 60).toString().padStart(2, '0');
-	    const minutes = Math.floor(offsetInMinutes % 60).toString().padStart(2, '0');
-	    return `GMT${sign}${hours}:${minutes}`;
-	}
-	
-	return localizedTime;
-}
-
-var matcherWalker = {};
-
-var hasRequiredMatcherWalker;
-
-function requireMatcherWalker () {
-	if (hasRequiredMatcherWalker) return matcherWalker;
-	hasRequiredMatcherWalker = 1;
-	var __importDefault = (matcherWalker && matcherWalker.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(matcherWalker, "__esModule", { value: true });
-	matcherWalker.MatcherWalker = void 0;
-	const convertion_1 = __importDefault(requireConvertion());
-	const localized_time_1 = requireLocalizedTime();
-	const time_matcher_1 = requireTimeMatcher();
-	const week_day_names_conversion_1 = __importDefault(requireWeekDayNamesConversion());
-	class MatcherWalker {
-	    cronExpression;
-	    baseDate;
-	    pattern;
-	    expressions;
-	    timeMatcher;
-	    timezone;
-	    constructor(cronExpression, baseDate, timezone) {
-	        this.cronExpression = cronExpression;
-	        this.baseDate = baseDate;
-	        this.timeMatcher = new time_matcher_1.TimeMatcher(cronExpression, timezone);
-	        this.timezone = timezone;
-	        this.expressions = (0, convertion_1.default)(cronExpression);
-	    }
-	    isMatching() {
-	        return this.timeMatcher.match(this.baseDate);
-	    }
-	    matchNext() {
-	        const findNextDateIgnoringWeekday = () => {
-	            const baseDate = new Date(this.baseDate.getTime());
-	            baseDate.setMilliseconds(0);
-	            const localTime = new localized_time_1.LocalizedTime(baseDate, this.timezone);
-	            const dateParts = localTime.getParts();
-	            const date = new localized_time_1.LocalizedTime(localTime.toDate(), this.timezone);
-	            const seconds = this.expressions[0];
-	            const nextSecond = availableValue(seconds, dateParts.second);
-	            if (nextSecond) {
-	                date.set('second', nextSecond);
-	                if (this.timeMatcher.match(date.toDate())) {
-	                    return date;
-	                }
-	            }
-	            date.set('second', seconds[0]);
-	            const minutes = this.expressions[1];
-	            const nextMinute = availableValue(minutes, dateParts.minute);
-	            if (nextMinute) {
-	                date.set('minute', nextMinute);
-	                if (this.timeMatcher.match(date.toDate())) {
-	                    return date;
-	                }
-	            }
-	            date.set('minute', minutes[0]);
-	            const hours = this.expressions[2];
-	            const nextHour = availableValue(hours, dateParts.hour);
-	            if (nextHour) {
-	                date.set('hour', nextHour);
-	                if (this.timeMatcher.match(date.toDate())) {
-	                    return date;
-	                }
-	            }
-	            date.set('hour', hours[0]);
-	            const days = this.expressions[3];
-	            const nextDay = availableValue(days, dateParts.day);
-	            if (nextDay) {
-	                date.set('day', nextDay);
-	                if (this.timeMatcher.match(date.toDate())) {
-	                    return date;
-	                }
-	            }
-	            date.set('day', days[0]);
-	            const months = this.expressions[4];
-	            const nextMonth = availableValue(months, dateParts.month);
-	            if (nextMonth) {
-	                date.set('month', nextMonth);
-	                if (this.timeMatcher.match(date.toDate())) {
-	                    return date;
-	                }
-	            }
-	            date.set('year', date.getParts().year + 1);
-	            date.set('month', months[0]);
-	            return date;
-	        };
-	        const date = findNextDateIgnoringWeekday();
-	        const weekdays = this.expressions[5];
-	        let currentWeekday = parseInt((0, week_day_names_conversion_1.default)(date.getParts().weekday));
-	        while (!(weekdays.indexOf(currentWeekday) > -1)) {
-	            date.set('year', date.getParts().year + 1);
-	            currentWeekday = parseInt((0, week_day_names_conversion_1.default)(date.getParts().weekday));
-	        }
-	        return date;
-	    }
-	}
-	matcherWalker.MatcherWalker = MatcherWalker;
-	function availableValue(values, currentValue) {
-	    const availableValues = values.sort((a, b) => a - b).filter(s => s > currentValue);
-	    if (availableValues.length > 0)
-	        return availableValues[0];
-	    return false;
-	}
-	
-	return matcherWalker;
-}
-
-var hasRequiredTimeMatcher;
-
-function requireTimeMatcher () {
-	if (hasRequiredTimeMatcher) return timeMatcher;
-	hasRequiredTimeMatcher = 1;
-	var __importDefault = (timeMatcher && timeMatcher.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(timeMatcher, "__esModule", { value: true });
-	timeMatcher.TimeMatcher = void 0;
-	const index_1 = __importDefault(requireConvertion());
-	const week_day_names_conversion_1 = __importDefault(requireWeekDayNamesConversion());
-	const localized_time_1 = requireLocalizedTime();
-	const matcher_walker_1 = requireMatcherWalker();
-	function matchValue(allowedValues, value) {
-	    return allowedValues.indexOf(value) !== -1;
-	}
-	class TimeMatcher {
-	    timezone;
-	    pattern;
-	    expressions;
-	    constructor(pattern, timezone) {
-	        this.timezone = timezone;
-	        this.pattern = pattern;
-	        this.expressions = (0, index_1.default)(pattern);
-	    }
-	    match(date) {
-	        const localizedTime = new localized_time_1.LocalizedTime(date, this.timezone);
-	        const parts = localizedTime.getParts();
-	        const runOnSecond = matchValue(this.expressions[0], parts.second);
-	        const runOnMinute = matchValue(this.expressions[1], parts.minute);
-	        const runOnHour = matchValue(this.expressions[2], parts.hour);
-	        const runOnDay = matchValue(this.expressions[3], parts.day);
-	        const runOnMonth = matchValue(this.expressions[4], parts.month);
-	        const runOnWeekDay = matchValue(this.expressions[5], parseInt((0, week_day_names_conversion_1.default)(parts.weekday)));
-	        return runOnSecond && runOnMinute && runOnHour && runOnDay && runOnMonth && runOnWeekDay;
-	    }
-	    getNextMatch(date) {
-	        const walker = new matcher_walker_1.MatcherWalker(this.pattern, date, this.timezone);
-	        const next = walker.matchNext();
-	        return next.toDate();
-	    }
-	}
-	timeMatcher.TimeMatcher = TimeMatcher;
-	
-	return timeMatcher;
-}
-
-var stateMachine = {};
-
-var hasRequiredStateMachine;
-
-function requireStateMachine () {
-	if (hasRequiredStateMachine) return stateMachine;
-	hasRequiredStateMachine = 1;
-	Object.defineProperty(stateMachine, "__esModule", { value: true });
-	stateMachine.StateMachine = void 0;
-	const allowedTransitions = {
-	    'stopped': ['stopped', 'idle', 'destroyed'],
-	    'idle': ['idle', 'running', 'stopped', 'destroyed'],
-	    'running': ['running', 'idle', 'stopped', 'destroyed'],
-	    'destroyed': ['destroyed']
-	};
-	class StateMachine {
-	    state;
-	    constructor(initial = 'stopped') {
-	        this.state = initial;
-	    }
-	    changeState(state) {
-	        if (allowedTransitions[this.state].includes(state)) {
-	            this.state = state;
-	        }
-	        else {
-	            throw new Error(`invalid transition from ${this.state} to ${state}`);
-	        }
-	    }
-	}
-	stateMachine.StateMachine = StateMachine;
-	
-	return stateMachine;
-}
-
-var hasRequiredInlineScheduledTask;
-
-function requireInlineScheduledTask () {
-	if (hasRequiredInlineScheduledTask) return inlineScheduledTask;
-	hasRequiredInlineScheduledTask = 1;
-	var __importDefault = (inlineScheduledTask && inlineScheduledTask.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(inlineScheduledTask, "__esModule", { value: true });
-	inlineScheduledTask.InlineScheduledTask = void 0;
-	const events_1 = __importDefault(EventEmitter);
-	const runner_1 = requireRunner();
-	const time_matcher_1 = requireTimeMatcher();
-	const create_id_1 = requireCreateId();
-	const state_machine_1 = requireStateMachine();
-	const logger_1 = __importDefault(requireLogger());
-	const localized_time_1 = requireLocalizedTime();
-	class TaskEmitter extends events_1.default {
-	}
-	class InlineScheduledTask {
-	    emitter;
-	    cronExpression;
-	    timeMatcher;
-	    runner;
-	    id;
-	    name;
-	    stateMachine;
-	    timezone;
-	    constructor(cronExpression, taskFn, options) {
-	        this.emitter = new TaskEmitter();
-	        this.cronExpression = cronExpression;
-	        this.id = (0, create_id_1.createID)('task', 12);
-	        this.name = options?.name || this.id;
-	        this.timezone = options?.timezone;
-	        this.timeMatcher = new time_matcher_1.TimeMatcher(cronExpression, options?.timezone);
-	        this.stateMachine = new state_machine_1.StateMachine();
-	        const runnerOptions = {
-	            timezone: options?.timezone,
-	            noOverlap: options?.noOverlap,
-	            maxExecutions: options?.maxExecutions,
-	            maxRandomDelay: options?.maxRandomDelay,
-	            beforeRun: (date, execution) => {
-	                if (execution.reason === 'scheduled') {
-	                    this.changeState('running');
-	                }
-	                this.emitter.emit('execution:started', this.createContext(date, execution));
-	                return true;
-	            },
-	            onFinished: (date, execution) => {
-	                if (execution.reason === 'scheduled') {
-	                    this.changeState('idle');
-	                }
-	                this.emitter.emit('execution:finished', this.createContext(date, execution));
-	                return true;
-	            },
-	            onError: (date, error, execution) => {
-	                logger_1.default.error(error);
-	                this.emitter.emit('execution:failed', this.createContext(date, execution));
-	                this.changeState('idle');
-	            },
-	            onOverlap: (date) => {
-	                this.emitter.emit('execution:overlap', this.createContext(date));
-	            },
-	            onMissedExecution: (date) => {
-	                this.emitter.emit('execution:missed', this.createContext(date));
-	            },
-	            onMaxExecutions: (date) => {
-	                this.emitter.emit('execution:maxReached', this.createContext(date));
-	                this.destroy();
-	            }
-	        };
-	        this.runner = new runner_1.Runner(this.timeMatcher, (date, execution) => {
-	            return taskFn(this.createContext(date, execution));
-	        }, runnerOptions);
-	    }
-	    getNextRun() {
-	        if (this.stateMachine.state !== 'stopped') {
-	            return this.runner.nextRun();
-	        }
-	        return null;
-	    }
-	    changeState(state) {
-	        if (this.runner.isStarted()) {
-	            this.stateMachine.changeState(state);
-	        }
-	    }
-	    start() {
-	        if (this.runner.isStopped()) {
-	            this.runner.start();
-	            this.stateMachine.changeState('idle');
-	            this.emitter.emit('task:started', this.createContext(new Date()));
-	        }
-	    }
-	    stop() {
-	        if (this.runner.isStarted()) {
-	            this.runner.stop();
-	            this.stateMachine.changeState('stopped');
-	            this.emitter.emit('task:stopped', this.createContext(new Date()));
-	        }
-	    }
-	    getStatus() {
-	        return this.stateMachine.state;
-	    }
-	    destroy() {
-	        if (this.stateMachine.state === 'destroyed')
-	            return;
-	        this.stop();
-	        this.stateMachine.changeState('destroyed');
-	        this.emitter.emit('task:destroyed', this.createContext(new Date()));
-	    }
-	    execute() {
-	        return new Promise((resolve, reject) => {
-	            const onFail = (context) => {
-	                this.off('execution:finished', onFail);
-	                reject(context.execution?.error);
-	            };
-	            const onFinished = (context) => {
-	                this.off('execution:failed', onFail);
-	                resolve(context.execution?.result);
-	            };
-	            this.once('execution:finished', onFinished);
-	            this.once('execution:failed', onFail);
-	            this.runner.execute();
-	        });
-	    }
-	    on(event, fun) {
-	        this.emitter.on(event, fun);
-	    }
-	    off(event, fun) {
-	        this.emitter.off(event, fun);
-	    }
-	    once(event, fun) {
-	        this.emitter.once(event, fun);
-	    }
-	    createContext(executionDate, execution) {
-	        const localTime = new localized_time_1.LocalizedTime(executionDate, this.timezone);
-	        const ctx = {
-	            date: localTime.toDate(),
-	            dateLocalIso: localTime.toISO(),
-	            triggeredAt: new Date(),
-	            task: this,
-	            execution: execution
-	        };
-	        return ctx;
-	    }
-	}
-	inlineScheduledTask.InlineScheduledTask = InlineScheduledTask;
-	
-	return inlineScheduledTask;
-}
-
-var taskRegistry = {};
-
-var hasRequiredTaskRegistry;
-
-function requireTaskRegistry () {
-	if (hasRequiredTaskRegistry) return taskRegistry;
-	hasRequiredTaskRegistry = 1;
-	Object.defineProperty(taskRegistry, "__esModule", { value: true });
-	taskRegistry.TaskRegistry = void 0;
-	const tasks = new Map();
-	class TaskRegistry {
-	    add(task) {
-	        if (this.has(task.id)) {
-	            throw Error(`task ${task.id} already registred!`);
-	        }
-	        tasks.set(task.id, task);
-	        task.on('task:destroyed', () => {
-	            this.remove(task);
-	        });
-	    }
-	    get(taskId) {
-	        return tasks.get(taskId);
-	    }
-	    remove(task) {
-	        if (this.has(task.id)) {
-	            task?.destroy();
-	            tasks.delete(task.id);
-	        }
-	    }
-	    all() {
-	        return tasks;
-	    }
-	    has(taskId) {
-	        return tasks.has(taskId);
-	    }
-	    killAll() {
-	        tasks.forEach(id => this.remove(id));
-	    }
-	}
-	taskRegistry.TaskRegistry = TaskRegistry;
-	
-	return taskRegistry;
-}
-
-var patternValidation = {};
-
-var hasRequiredPatternValidation;
-
-function requirePatternValidation () {
-	if (hasRequiredPatternValidation) return patternValidation;
-	hasRequiredPatternValidation = 1;
-	var __importDefault = (patternValidation && patternValidation.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(patternValidation, "__esModule", { value: true });
-	const index_1 = __importDefault(requireConvertion());
-	const validationRegex = /^(?:\d+|\*|\*\/\d+)$/;
-	function isValidExpression(expression, min, max) {
-	    const options = expression;
-	    for (const option of options) {
-	        const optionAsInt = parseInt(option, 10);
-	        if ((!Number.isNaN(optionAsInt) &&
-	            (optionAsInt < min || optionAsInt > max)) ||
-	            !validationRegex.test(option))
-	            return false;
-	    }
-	    return true;
-	}
-	function isInvalidSecond(expression) {
-	    return !isValidExpression(expression, 0, 59);
-	}
-	function isInvalidMinute(expression) {
-	    return !isValidExpression(expression, 0, 59);
-	}
-	function isInvalidHour(expression) {
-	    return !isValidExpression(expression, 0, 23);
-	}
-	function isInvalidDayOfMonth(expression) {
-	    return !isValidExpression(expression, 1, 31);
-	}
-	function isInvalidMonth(expression) {
-	    return !isValidExpression(expression, 1, 12);
-	}
-	function isInvalidWeekDay(expression) {
-	    return !isValidExpression(expression, 0, 7);
-	}
-	function validateFields(patterns, executablePatterns) {
-	    if (isInvalidSecond(executablePatterns[0]))
-	        throw new Error(`${patterns[0]} is a invalid expression for second`);
-	    if (isInvalidMinute(executablePatterns[1]))
-	        throw new Error(`${patterns[1]} is a invalid expression for minute`);
-	    if (isInvalidHour(executablePatterns[2]))
-	        throw new Error(`${patterns[2]} is a invalid expression for hour`);
-	    if (isInvalidDayOfMonth(executablePatterns[3]))
-	        throw new Error(`${patterns[3]} is a invalid expression for day of month`);
-	    if (isInvalidMonth(executablePatterns[4]))
-	        throw new Error(`${patterns[4]} is a invalid expression for month`);
-	    if (isInvalidWeekDay(executablePatterns[5]))
-	        throw new Error(`${patterns[5]} is a invalid expression for week day`);
-	}
-	function validate(pattern) {
-	    if (typeof pattern !== 'string')
-	        throw new TypeError('pattern must be a string!');
-	    const patterns = pattern.split(' ');
-	    const executablePatterns = (0, index_1.default)(pattern);
-	    if (patterns.length === 5)
-	        patterns.unshift('0');
-	    validateFields(patterns, executablePatterns);
-	}
-	patternValidation.default = validate;
-	
-	return patternValidation;
-}
-
-var backgroundScheduledTask = {};
-
-var hasRequiredBackgroundScheduledTask;
-
-function requireBackgroundScheduledTask () {
-	if (hasRequiredBackgroundScheduledTask) return backgroundScheduledTask;
-	hasRequiredBackgroundScheduledTask = 1;
-	var __importDefault = (backgroundScheduledTask && backgroundScheduledTask.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
-	Object.defineProperty(backgroundScheduledTask, "__esModule", { value: true });
-	const path_1 = path$1;
-	const child_process_1 = require$$1;
-	const create_id_1 = requireCreateId();
-	const stream_1 = require$$3;
-	const state_machine_1 = requireStateMachine();
-	const localized_time_1 = requireLocalizedTime();
-	const logger_1 = __importDefault(requireLogger());
-	const time_matcher_1 = requireTimeMatcher();
-	const daemonPath = (0, path_1.resolve)(__dirname, 'daemon.js');
-	class TaskEmitter extends stream_1.EventEmitter {
-	}
-	class BackgroundScheduledTask {
-	    emitter;
-	    id;
-	    name;
-	    cronExpression;
-	    taskPath;
-	    options;
-	    forkProcess;
-	    stateMachine;
-	    constructor(cronExpression, taskPath, options) {
-	        this.cronExpression = cronExpression;
-	        this.taskPath = taskPath;
-	        this.options = options;
-	        this.id = (0, create_id_1.createID)('task');
-	        this.name = options?.name || this.id;
-	        this.emitter = new TaskEmitter();
-	        this.stateMachine = new state_machine_1.StateMachine('stopped');
-	        this.on('task:stopped', () => {
-	            this.forkProcess?.kill();
-	            this.forkProcess = undefined;
-	            this.stateMachine.changeState('stopped');
-	        });
-	        this.on('task:destroyed', () => {
-	            this.forkProcess?.kill();
-	            this.forkProcess = undefined;
-	            this.stateMachine.changeState('destroyed');
-	        });
-	    }
-	    getNextRun() {
-	        if (this.stateMachine.state !== 'stopped') {
-	            const timeMatcher = new time_matcher_1.TimeMatcher(this.cronExpression, this.options?.timezone);
-	            return timeMatcher.getNextMatch(new Date());
-	        }
-	        return null;
-	    }
-	    start() {
-	        return new Promise((resolve, reject) => {
-	            if (this.forkProcess) {
-	                return resolve(undefined);
-	            }
-	            const timeout = setTimeout(() => {
-	                reject(new Error('Start operation timed out'));
-	            }, 5000);
-	            try {
-	                this.forkProcess = (0, child_process_1.fork)(daemonPath);
-	                this.forkProcess.on('error', (err) => {
-	                    clearTimeout(timeout);
-	                    reject(new Error(`Error on daemon: ${err.message}`));
-	                });
-	                this.forkProcess.on('exit', (code, signal) => {
-	                    if (code !== 0 && signal !== 'SIGTERM') {
-	                        const erro = new Error(`node-cron daemon exited with code ${code || signal}`);
-	                        logger_1.default.error(erro);
-	                        clearTimeout(timeout);
-	                        reject(erro);
-	                    }
-	                });
-	                this.forkProcess.on('message', (message) => {
-	                    if (message.jsonError) {
-	                        if (message.context?.execution) {
-	                            message.context.execution.error = deserializeError(message.jsonError);
-	                            delete message.jsonError;
-	                        }
-	                    }
-	                    if (message.context?.task?.state) {
-	                        this.stateMachine.changeState(message.context?.task?.state);
-	                    }
-	                    if (message.context) {
-	                        const execution = message.context?.execution;
-	                        delete execution?.hasError;
-	                        const context = this.createContext(new Date(message.context.date), execution);
-	                        this.emitter.emit(message.event, context);
-	                    }
-	                });
-	                this.once('task:started', () => {
-	                    this.stateMachine.changeState('idle');
-	                    clearTimeout(timeout);
-	                    resolve(undefined);
-	                });
-	                this.forkProcess.send({
-	                    command: 'task:start',
-	                    path: this.taskPath,
-	                    cron: this.cronExpression,
-	                    options: this.options
-	                });
-	            }
-	            catch (error) {
-	                reject(error);
-	            }
-	        });
-	    }
-	    stop() {
-	        return new Promise((resolve, reject) => {
-	            if (!this.forkProcess) {
-	                return resolve(undefined);
-	            }
-	            const timeoutId = setTimeout(() => {
-	                clearTimeout(timeoutId);
-	                reject(new Error('Stop operation timed out'));
-	            }, 5000);
-	            const cleanupAndResolve = () => {
-	                clearTimeout(timeoutId);
-	                this.off('task:stopped', onStopped);
-	                this.forkProcess = undefined;
-	                resolve(undefined);
-	            };
-	            const onStopped = () => {
-	                cleanupAndResolve();
-	            };
-	            this.once('task:stopped', onStopped);
-	            this.forkProcess.send({
-	                command: 'task:stop'
-	            });
-	        });
-	    }
-	    getStatus() {
-	        return this.stateMachine.state;
-	    }
-	    destroy() {
-	        return new Promise((resolve, reject) => {
-	            if (!this.forkProcess) {
-	                return resolve(undefined);
-	            }
-	            const timeoutId = setTimeout(() => {
-	                clearTimeout(timeoutId);
-	                reject(new Error('Destroy operation timed out'));
-	            }, 5000);
-	            const onDestroy = () => {
-	                clearTimeout(timeoutId);
-	                this.off('task:destroyed', onDestroy);
-	                resolve(undefined);
-	            };
-	            this.once('task:destroyed', onDestroy);
-	            this.forkProcess.send({
-	                command: 'task:destroy'
-	            });
-	        });
-	    }
-	    execute() {
-	        return new Promise((resolve, reject) => {
-	            if (!this.forkProcess) {
-	                return reject(new Error('Cannot execute background task because it hasn\'t been started yet. Please initialize the task using the start() method before attempting to execute it.'));
-	            }
-	            const timeoutId = setTimeout(() => {
-	                cleanupListeners();
-	                reject(new Error('Execution timeout exceeded'));
-	            }, 5000);
-	            const cleanupListeners = () => {
-	                clearTimeout(timeoutId);
-	                this.off('execution:finished', onFinished);
-	                this.off('execution:failed', onFail);
-	            };
-	            const onFinished = (context) => {
-	                cleanupListeners();
-	                resolve(context.execution?.result);
-	            };
-	            const onFail = (context) => {
-	                cleanupListeners();
-	                reject(context.execution?.error || new Error('Execution failed without specific error'));
-	            };
-	            this.once('execution:finished', onFinished);
-	            this.once('execution:failed', onFail);
-	            this.forkProcess.send({
-	                command: 'task:execute'
-	            });
-	        });
-	    }
-	    on(event, fun) {
-	        this.emitter.on(event, fun);
-	    }
-	    off(event, fun) {
-	        this.emitter.off(event, fun);
-	    }
-	    once(event, fun) {
-	        this.emitter.once(event, fun);
-	    }
-	    createContext(executionDate, execution) {
-	        const localTime = new localized_time_1.LocalizedTime(executionDate, this.options?.timezone);
-	        const ctx = {
-	            date: localTime.toDate(),
-	            dateLocalIso: localTime.toISO(),
-	            triggeredAt: new Date(),
-	            task: this,
-	            execution: execution
-	        };
-	        return ctx;
-	    }
-	}
-	function deserializeError(str) {
-	    const data = JSON.parse(str);
-	    const Err = globalThis[data.name] || Error;
-	    const err = new Err(data.message);
-	    if (data.stack) {
-	        err.stack = data.stack;
-	    }
-	    Object.keys(data).forEach(key => {
-	        if (!['name', 'message', 'stack'].includes(key)) {
-	            err[key] = data[key];
-	        }
-	    });
-	    return err;
-	}
-	backgroundScheduledTask.default = BackgroundScheduledTask;
-	
-	return backgroundScheduledTask;
-}
-
-var hasRequiredNodeCron;
-
-function requireNodeCron () {
-	if (hasRequiredNodeCron) return nodeCron$2;
-	hasRequiredNodeCron = 1;
-	(function (exports) {
-		var __importDefault = (nodeCron$2 && nodeCron$2.__importDefault) || function (mod) {
-		    return (mod && mod.__esModule) ? mod : { "default": mod };
-		};
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.nodeCron = exports.getTask = exports.getTasks = void 0;
-		exports.schedule = schedule;
-		exports.createTask = createTask;
-		exports.solvePath = solvePath;
-		exports.validate = validate;
-		const inline_scheduled_task_1 = requireInlineScheduledTask();
-		const task_registry_1 = requireTaskRegistry();
-		const pattern_validation_1 = __importDefault(requirePatternValidation());
-		const background_scheduled_task_1 = __importDefault(requireBackgroundScheduledTask());
-		const path_1 = __importDefault(path$1);
-		const url_1 = require$$5;
-		const registry = new task_registry_1.TaskRegistry();
-		function schedule(expression, func, options) {
-		    const task = createTask(expression, func, options);
-		    task.start();
-		    return task;
-		}
-		function createTask(expression, func, options) {
-		    let task;
-		    if (func instanceof Function) {
-		        task = new inline_scheduled_task_1.InlineScheduledTask(expression, func, options);
-		    }
-		    else {
-		        const taskPath = solvePath(func);
-		        task = new background_scheduled_task_1.default(expression, taskPath, options);
-		    }
-		    registry.add(task);
-		    return task;
-		}
-		function solvePath(filePath) {
-		    if (path_1.default.isAbsolute(filePath))
-		        return (0, url_1.pathToFileURL)(filePath).href;
-		    if (filePath.startsWith('file://'))
-		        return filePath;
-		    const stackLines = new Error().stack?.split('\n');
-		    if (stackLines) {
-		        stackLines?.shift();
-		        const callerLine = stackLines?.find((line) => { return line.indexOf(__filename) === -1; });
-		        const match = callerLine?.match(/(file:\/\/)?(((\/?)(\w:))?([/\\].+)):\d+:\d+/);
-		        if (match) {
-		            const dir = `${match[5] ?? ""}${path_1.default.dirname(match[6])}`;
-		            return (0, url_1.pathToFileURL)(path_1.default.resolve(dir, filePath)).href;
-		        }
-		    }
-		    throw new Error(`Could not locate task file ${filePath}`);
-		}
-		function validate(expression) {
-		    try {
-		        (0, pattern_validation_1.default)(expression);
-		        return true;
-		    }
-		    catch (e) {
-		        return false;
-		    }
-		}
-		exports.getTasks = registry.all;
-		exports.getTask = registry.get;
-		exports.nodeCron = {
-		    schedule,
-		    createTask,
-		    validate,
-		    getTasks: exports.getTasks,
-		    getTask: exports.getTask,
-		};
-		exports.default = exports.nodeCron;
-		
-	} (nodeCron$2));
-	return nodeCron$2;
-}
-
-var nodeCronExports = requireNodeCron();
-var nodeCron = /*@__PURE__*/getDefaultExportFromCjs(nodeCronExports);
-
-var nodeCron$1 = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  default: nodeCron
-}, [nodeCronExports]);
-
 function silhouetteScore(vectors, assignments, centroids, distanceFn = euclideanDistance) {
   const k = centroids.length;
   const n = vectors.length;