@adonix.org/cloud-spark 0.0.94 → 0.0.97

package/dist/index.js

@@ -15,14 +15,15 @@ var CacheControl = {
 var HttpHeader;
 ((HttpHeader2) => {
   HttpHeader2.VARY = "Vary";
+  HttpHeader2.ALLOW = "Allow";
   HttpHeader2.CONTENT_TYPE = "Content-Type";
   HttpHeader2.CACHE_CONTROL = "Cache-Control";
-  HttpHeader2.X_CONTENT_TYPE_OPTIONS = "X-Content-Type-Options";
   HttpHeader2.X_FRAME_OPTIONS = "X-Frame-Options";
-  HttpHeader2.STRICT_TRANSPORT_SECURITY = "Strict-Transport-Security";
-  HttpHeader2.CONTENT_SECURITY_POLICY = "Content-Security-Policy";
+  HttpHeader2.X_CONTENT_TYPE_OPTIONS = "X-Content-Type-Options";
   HttpHeader2.REFERRER_POLICY = "Referrer-Policy";
   HttpHeader2.PERMISSIONS_POLICY = "Permissions-Policy";
+  HttpHeader2.CONTENT_SECURITY_POLICY = "Content-Security-Policy";
+  HttpHeader2.STRICT_TRANSPORT_SECURITY = "Strict-Transport-Security";
   HttpHeader2.NOSNIFF = "nosniff";
   HttpHeader2.ORIGIN = "Origin";
 })(HttpHeader || (HttpHeader = {}));
@@ -43,10 +44,10 @@ var Time = {
 var Method = /* @__PURE__ */ ((Method4) => {
   Method4["GET"] = "GET";
   Method4["PUT"] = "PUT";
+  Method4["HEAD"] = "HEAD";
   Method4["POST"] = "POST";
   Method4["PATCH"] = "PATCH";
   Method4["DELETE"] = "DELETE";
-  Method4["HEAD"] = "HEAD";
   Method4["OPTIONS"] = "OPTIONS";
   return Method4;
 })(Method || {});
@@ -107,22 +108,22 @@ var MediaType = /* @__PURE__ */ ((MediaType2) => {
   return MediaType2;
 })(MediaType || {});
 var ADD_CHARSET = /* @__PURE__ */ new Set([
-  "text/plain" /* PLAIN_TEXT */,
-  "text/html" /* HTML */,
   "text/css" /* CSS */,
   "text/csv" /* CSV */,
-  "text/markdown" /* MARKDOWN */,
   "text/xml" /* XML */,
+  "image/svg+xml" /* SVG */,
+  "text/html" /* HTML */,
   "application/json" /* JSON */,
-  "application/xml" /* XML_APP */,
-  "application/x-www-form-urlencoded" /* FORM_URLENCODED */,
   "application/x-ndjson" /* NDJSON */,
+  "application/xml" /* XML_APP */,
+  "text/markdown" /* MARKDOWN */,
   "text/richtext" /* RICH_TEXT */,
-  "image/svg+xml" /* SVG */
+  "text/plain" /* PLAIN_TEXT */,
+  "application/x-www-form-urlencoded" /* FORM_URLENCODED */
 ]);
 function setHeader(headers, key, value) {
   const raw = Array.isArray(value) ? value : [value];
-  const values = Array.from(new Set(raw.map((v) => v.trim()))).filter((v) => v.length);
+  const values = Array.from(new Set(raw.map((v) => v.trim()))).filter((v) => v.length).sort();
   if (!values.length) {
     headers.delete(key);
     return;
@@ -156,217 +157,79 @@ function getOrigin(request) {
 // src/cors.ts
 var Cors;
 ((Cors2) => {
+  Cors2.MAX_AGE = "Access-Control-Max-Age";
   Cors2.ALLOW_ORIGIN = "Access-Control-Allow-Origin";
-  Cors2.ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
-  Cors2.EXPOSE_HEADERS = "Access-Control-Expose-Headers";
   Cors2.ALLOW_HEADERS = "Access-Control-Allow-Headers";
   Cors2.ALLOW_METHODS = "Access-Control-Allow-Methods";
-  Cors2.MAX_AGE = "Access-Control-Max-Age";
+  Cors2.EXPOSE_HEADERS = "Access-Control-Expose-Headers";
+  Cors2.ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
   Cors2.ALLOW_ALL_ORIGINS = "*";
 })(Cors || (Cors = {}));
 function addCorsHeaders(origin, cors, headers) {
   deleteCorsHeaders(headers);
-  if (!origin) return;
+  if (!origin || origin.trim() === "") return;
   if (cors.allowAnyOrigin()) {
     setHeader(headers, Cors.ALLOW_ORIGIN, Cors.ALLOW_ALL_ORIGINS);
   } else if (cors.getAllowOrigins().includes(origin)) {
     setHeader(headers, Cors.ALLOW_ORIGIN, origin);
     setHeader(headers, Cors.ALLOW_CREDENTIALS, "true");
-    mergeHeader(headers, HttpHeader.VARY, HttpHeader.ORIGIN);
   }
-  mergeHeader(headers, Cors.EXPOSE_HEADERS, cors.getExposeHeaders());
-  setHeader(headers, Cors.ALLOW_HEADERS, cors.getAllowHeaders());
-  setHeader(headers, Cors.ALLOW_METHODS, cors.getAllowMethods());
   setHeader(headers, Cors.MAX_AGE, String(cors.getMaxAge()));
+  setHeader(headers, Cors.ALLOW_METHODS, cors.getAllowMethods());
+  setHeader(headers, Cors.ALLOW_HEADERS, cors.getAllowHeaders());
+  mergeHeader(headers, Cors.EXPOSE_HEADERS, cors.getExposeHeaders());
 }
 function deleteCorsHeaders(headers) {
+  headers.delete(Cors.MAX_AGE);
   headers.delete(Cors.ALLOW_ORIGIN);
-  headers.delete(Cors.ALLOW_CREDENTIALS);
-  headers.delete(Cors.EXPOSE_HEADERS);
+  headers.delete(Cors.ALLOW_HEADERS);
   headers.delete(Cors.ALLOW_METHODS);
-  headers.delete(Cors.MAX_AGE);
+  headers.delete(Cors.EXPOSE_HEADERS);
+  headers.delete(Cors.ALLOW_CREDENTIALS);
 }
 
-// src/base-worker.ts
-var BaseWorker = class {
-  constructor(_request, _env, _ctx) {
-    this._request = _request;
-    this._env = _env;
-    this._ctx = _ctx;
-  }
-  /** The Request object associated with this worker invocation */
-  get request() {
-    return this._request;
-  }
-  /** Environment bindings (e.g., KV, secrets, or other globals) */
-  get env() {
-    return this._env;
-  }
-  /** Optional execution context for background tasks or `waitUntil` */
-  get ctx() {
-    return this._ctx;
-  }
-  /**
-   * Creates a new instance of the current Worker subclass.
-   *
-   * @param request - The request to pass to the new worker instance.
-   * @returns A new worker instance of the same subclass as `this`.
-   */
-  createWorker(request) {
-    const ctor = this.constructor;
-    return new ctor(request, this.env, this.ctx);
-  }
+// src/routes.ts
+var Route = class {
   /**
-   * **Ignite** your `Worker` implementation into a Cloudflare-compatible handler.
-   *
-   * @returns A `FetchHandler` that launches a new worker instance for each request.
-   *
-   * @example
-   * ```ts
-   * export default MyWorker.ignite();
-   * ```
+   * @param pattern - A RegExp or string used to match the request path
+   * @param callback - Function to handle requests matching the pattern
    */
-  static ignite() {
-    return {
-      fetch: (req, env, ctx) => new this(req, env, ctx).fetch()
-    };
-  }
-};
-
-// src/cors-worker.ts
-var CorsWorker = class extends BaseWorker {
-  getAllowOrigins() {
-    return ["*"];
-  }
-  allowAnyOrigin() {
-    return this.getAllowOrigins().includes("*");
-  }
-  getAllowMethods() {
-    return ["GET" /* GET */, "OPTIONS" /* OPTIONS */, "HEAD" /* HEAD */];
-  }
-  getAllowHeaders() {
-    return ["Content-Type"];
-  }
-  getExposeHeaders() {
-    return [];
-  }
-  getMaxAge() {
-    return Time.Week;
+  constructor(pattern, callback) {
+    this.callback = callback;
+    this.pattern = new RegExp(pattern);
   }
+  pattern;
 };
-
-// src/cache-worker.ts
-var CacheWorker = class extends CorsWorker {
-  /**
-   * Returns the cache key for the current request.
-   *
-   * Behavior:
-   * - By default, returns the normalized request URL.
-   * - Query parameters are normalized so that the order does not affect the cache key.
-   *   For example, `?a=1&b=2` and `?b=2&a=1` produce the same cache key.
-   *
-   * Subclasses may override this method to implement custom cache key strategies.
-   *
-   * @returns {URL | RequestInfo} The URL or RequestInfo used as the cache key.
-   */
-  getCacheKey() {
-    return normalizeUrl(this.request.url);
-  }
-  /**
-   * Retrieves a cached Response for the current request, if one exists.
-   *
-   * Behavior:
-   * - Only GET requests are considered.
-   * - Returns a new Response with dynamic CORS headers applied via `addCacheHeaders`.
-   * - Returns `undefined` if no cached response is found.
-   * - Cloudflare dynamic headers (`CF-Cache-Status`, `Age`, `Connection`, etc.) will
-   *   always be present on the returned response, even though they are not stored in the cache.
-   *
-   * @param {string} [cacheName] Optional named cache; defaults to `caches.default`.
-   * @returns {Promise<Response | undefined>} A Response with CORS headers, or undefined.
-   * @see {@link setCachedResponse}
-   * @see {@link getCacheKey}
-   */
-  async getCachedResponse(cacheName) {
-    if (this.request.method !== "GET" /* GET */) return;
-    const cache = cacheName ? await caches.open(cacheName) : caches.default;
-    const response = await cache.match(this.getCacheKey());
-    return response ? this.addCacheHeaders(response) : void 0;
-  }
-  /**
-   * Stores a Response in the cache for the current request.
-   *
-   * Behavior:
-   * - Only caches successful GET responses (`response.ok === true`).
-   * - Strips headers via `removeCacheHeaders` before storing.
-   * - Uses `ctx.waitUntil` to perform caching asynchronously without blocking the response.
-   * - All other origin headers (e.g., Cache-Control, Expires) are preserved.
-   *
-   * @param {Response} response The Response to cache.
-   * @param {string} [cacheName] Optional named cache; defaults to `caches.default`.
-   * @see {@link getCachedResponse}
-   * @see {@link getCacheKey}
-   */
-  async setCachedResponse(response, cacheName) {
-    if (!response.ok) return;
-    if (this.request.method !== "GET" /* GET */) return;
-    const cache = cacheName ? await caches.open(cacheName) : caches.default;
-    this.ctx.waitUntil(
-      cache.put(this.getCacheKey(), this.removeCacheHeaders(response.clone()))
-    );
-  }
-  /**
-   * Adds headers to a cached response.
-   *
-   * @param {Response} cached The cached Response.
-   * @returns {Response} A new Response with dynamic CORS headers applied.
-   * @see {@link removeCacheHeaders}
-   */
-  addCacheHeaders(cached) {
-    const headers = new Headers(cached.headers);
-    addCorsHeaders(getOrigin(this.request), this, headers);
-    return new Response(cached.body, {
-      status: cached.status,
-      statusText: cached.statusText,
-      headers
-    });
-  }
+var Routes = class {
+  map = /* @__PURE__ */ new Map();
   /**
-   * Removes headers that should not be stored in the cache (currently only CORS headers).
+   * Adds a route to the collection under the given HTTP method.
    *
-   * @param {Response} response The Response to clean before caching.
-   * @returns {Response} A new Response with excluded headers removed.
-   * @see {@link addCacheHeaders}
+   * @param method - HTTP method (GET, POST, etc.)
+   * @param route - Route instance to add
+   * @returns The Routes instance (for chaining)
    */
-  removeCacheHeaders(response) {
-    const excludeSet = new Set(this.excludeCacheHeaders().map((h) => h.toLowerCase()));
-    const headers = new Headers();
-    for (const [key, value] of response.headers) {
-      if (!excludeSet.has(key)) {
-        headers.set(key, value);
-      }
+  add(method, route) {
+    const existing = this.map.get(method);
+    if (existing) {
+      existing.push(route);
+    } else {
+      this.map.set(method, [route]);
     }
-    return new Response(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers
-    });
+    return this;
   }
   /**
-   * Returns the list of headers to exclude from the cached response.
-   * By default, excludes only dynamic CORS headers.
+   * Finds the first route that matches the given method and URL.
    *
-   * @returns {string[]} Array of header names to exclude.
-   * @see {@link removeCacheHeaders}
+   * @param method - HTTP method of the request
+   * @param url - Full URL string of the request
+   * @returns The first matching Route, or undefined if none match
    */
-  excludeCacheHeaders() {
-    return [
-      Cors.ALLOW_ORIGIN,
-      Cors.ALLOW_CREDENTIALS,
-      Cors.EXPOSE_HEADERS,
-      Cors.ALLOW_METHODS,
-      Cors.MAX_AGE
-    ];
+  get(method, url) {
+    const routes = this.map.get(method);
+    if (!routes) return void 0;
+    const pathname = new URL(url).pathname;
+    return routes.find(({ pattern }) => pattern.test(pathname));
   }
 };
 
@@ -407,6 +270,9 @@ var CorsResponse = class extends BaseResponse {
   }
   addCorsHeaders() {
     addCorsHeaders(this.getOrigin(), this.worker, this.headers);
+    if (!this.worker.allowAnyOrigin()) {
+      mergeHeader(this.headers, HttpHeader.VARY, HttpHeader.ORIGIN);
+    }
   }
   getOrigin() {
     return getOrigin(this.worker.request);
@@ -478,7 +344,7 @@ var Head = class extends WorkerResponse {
 var Options = class extends SuccessResponse {
   constructor(worker) {
     super(worker, null, void 0, StatusCodes2.NO_CONTENT);
-    this.setHeader("Allow", this.worker.getAllowMethods());
+    this.setHeader(HttpHeader.ALLOW, this.worker.getAllowMethods());
   }
 };
 var HttpError = class extends JsonResponse {
@@ -519,9 +385,13 @@ var NotFound = class extends HttpError {
   }
 };
 var MethodNotAllowed = class extends HttpError {
-  constructor(worker, method) {
-    super(worker, StatusCodes2.METHOD_NOT_ALLOWED, `${method} method not allowed.`);
-    this.setHeader("Allow", this.worker.getAllowMethods());
+  constructor(worker) {
+    super(
+      worker,
+      StatusCodes2.METHOD_NOT_ALLOWED,
+      `${worker.request.method} method not allowed.`
+    );
+    this.setHeader(HttpHeader.ALLOW, this.worker.getAllowMethods());
   }
   get json() {
     return {
@@ -541,8 +411,8 @@ var NotImplemented = class extends HttpError {
   }
 };
 var MethodNotImplemented = class extends NotImplemented {
-  constructor(worker, method) {
-    super(worker, `${method} method not implemented.`);
+  constructor(worker) {
+    super(worker, `${worker.request.method} method not implemented.`);
   }
 };
 var ServiceUnavailable = class extends HttpError {
@@ -551,11 +421,194 @@ var ServiceUnavailable = class extends HttpError {
   }
 };
 
+// src/base-worker.ts
+var BaseWorker = class {
+  constructor(_request, _env, _ctx) {
+    this._request = _request;
+    this._env = _env;
+    this._ctx = _ctx;
+  }
+  /** The Request object associated with this worker invocation */
+  get request() {
+    return this._request;
+  }
+  /** Environment bindings (e.g., KV, secrets, or other globals) */
+  get env() {
+    return this._env;
+  }
+  /** Execution context for background tasks or `waitUntil` */
+  get ctx() {
+    return this._ctx;
+  }
+  /**
+   * Creates a new instance of the current Worker subclass.
+   *
+   * @param request - The {@link Request} to pass to the new worker instance.
+   * @returns A new worker instance of the same subclass as `this`.
+   */
+  createWorker(request) {
+    const ctor = this.constructor;
+    return new ctor(request, this.env, this.ctx);
+  }
+  /**
+   * **Ignite** your `Worker` implementation into a Cloudflare-compatible handler.
+   *
+   * @returns A `FetchHandler` that launches a new worker instance for each request.
+   *
+   * @example
+   * ```ts
+   * export default MyWorker.ignite();
+   * ```
+   */
+  static ignite() {
+    return {
+      fetch: (req, env, ctx) => new this(req, env, ctx).fetch()
+    };
+  }
+};
+
+// src/cors-worker.ts
+var CorsWorker = class extends BaseWorker {
+  getAllowOrigins() {
+    return ["*"];
+  }
+  allowAnyOrigin() {
+    return this.getAllowOrigins().includes("*");
+  }
+  getAllowMethods() {
+    return ["GET" /* GET */, "HEAD" /* HEAD */, "OPTIONS" /* OPTIONS */];
+  }
+  getAllowHeaders() {
+    return ["Content-Type"];
+  }
+  getExposeHeaders() {
+    return [];
+  }
+  getMaxAge() {
+    return Time.Week;
+  }
+};
+
+// src/cache-worker.ts
+var CacheWorker = class extends CorsWorker {
+  /**
+   * Returns the cache key for the current request.
+   *
+   * Behavior:
+   * - By default, returns the normalized request URL.
+   * - Query parameters are normalized so that the order does not affect the cache key.
+   *   For example, `?a=1&b=2` and `?b=2&a=1` produce the same cache key.
+   *
+   * Subclasses may override this method to implement custom cache key strategies.
+   *
+   * @returns {URL | RequestInfo} The URL or RequestInfo used as the cache key.
+   */
+  getCacheKey() {
+    return normalizeUrl(this.request.url);
+  }
+  /**
+   * Retrieves a cached Response for the current request, if one exists.
+   *
+   * Behavior:
+   * - Only GET requests are considered.
+   * - Returns a new Response with dynamic CORS headers applied via `addCacheHeaders`.
+   * - Returns `undefined` if no cached response is found.
+   * - Cloudflare dynamic headers (`CF-Cache-Status`, `Age`, `Connection`, etc.) will
+   *   always be present on the returned response, even though they are not stored in the cache.
+   *
+   * @param {string} [cacheName] Optional named cache; defaults to `caches.default`.
+   * @returns {Promise<Response | undefined>} A Response with CORS headers, or undefined.
+   * @see {@link setCachedResponse}
+   * @see {@link getCacheKey}
+   */
+  async getCachedResponse(cacheName) {
+    if (this.request.method !== "GET" /* GET */) return;
+    const cache = cacheName ? await caches.open(cacheName) : caches.default;
+    const response = await cache.match(this.getCacheKey());
+    return response ? this.addCacheHeaders(response) : void 0;
+  }
+  /**
+   * Stores a Response in the cache for the current request.
+   *
+   * Behavior:
+   * - Only caches successful GET responses (`response.ok === true`).
+   * - Strips headers via `removeCacheHeaders` before storing.
+   * - Uses `ctx.waitUntil` to perform caching asynchronously without blocking the response.
+   * - All other origin headers (e.g., Cache-Control, Expires) are preserved.
+   *
+   * @param {Response} response The Response to cache.
+   * @param {string} [cacheName] Optional named cache; defaults to `caches.default`.
+   * @see {@link getCachedResponse}
+   * @see {@link getCacheKey}
+   */
+  async setCachedResponse(response, cacheName) {
+    if (!response.ok) return;
+    if (this.request.method !== "GET" /* GET */) return;
+    const cache = cacheName ? await caches.open(cacheName) : caches.default;
+    this.ctx.waitUntil(
+      cache.put(this.getCacheKey(), this.removeCacheHeaders(response.clone()))
+    );
+  }
+  /**
+   * Adds headers to a cached response.
+   *
+   * @param {Response} cached The cached Response.
+   * @returns {Response} A new Response with dynamic CORS headers applied.
+   * @see {@link removeCacheHeaders}
+   */
+  addCacheHeaders(cached) {
+    const headers = new Headers(cached.headers);
+    addCorsHeaders(getOrigin(this.request), this, headers);
+    return new Response(cached.body, {
+      status: cached.status,
+      statusText: cached.statusText,
+      headers
+    });
+  }
+  /**
+   * Removes headers that should not be stored in the cache (currently only CORS headers).
+   *
+   * @param {Response} response The Response to clean before caching.
+   * @returns {Response} A new Response with excluded headers removed.
+   * @see {@link addCacheHeaders}
+   */
+  removeCacheHeaders(response) {
+    const excludeSet = new Set(this.excludeCacheHeaders().map((h) => h.toLowerCase()));
+    const headers = new Headers();
+    for (const [key, value] of response.headers) {
+      if (!excludeSet.has(key)) {
+        headers.set(key, value);
+      }
+    }
+    return new Response(response.body, {
+      status: response.status,
+      statusText: response.statusText,
+      headers
+    });
+  }
+  /**
+   * Returns the list of headers to exclude from the cached response.
+   * By default, excludes only dynamic CORS headers.
+   *
+   * @returns {string[]} Array of header names to exclude.
+   * @see {@link removeCacheHeaders}
+   */
+  excludeCacheHeaders() {
+    return [
+      Cors.ALLOW_ORIGIN,
+      Cors.ALLOW_CREDENTIALS,
+      Cors.EXPOSE_HEADERS,
+      Cors.ALLOW_METHODS,
+      Cors.MAX_AGE
+    ];
+  }
+};
+
 // src/basic-worker.ts
 var BasicWorker = class extends CacheWorker {
   async fetch() {
     if (!this.isAllowed(this.request.method)) {
-      return this.getResponse(MethodNotAllowed, this.request.method);
+      return this.getResponse(MethodNotAllowed);
     }
     try {
       return await this.dispatch();
@@ -568,34 +621,37 @@ var BasicWorker = class extends CacheWorker {
     const handler = {
       GET: () => this.get(),
       PUT: () => this.put(),
+      HEAD: () => this.head(),
       POST: () => this.post(),
       PATCH: () => this.patch(),
       DELETE: () => this.delete(),
-      HEAD: () => this.head(),
       OPTIONS: () => this.options()
     };
-    return (handler[method] ?? (() => this.getResponse(MethodNotAllowed, method)))();
+    return (handler[method] ?? (() => this.getResponse(MethodNotAllowed)))();
+  }
+  isAllowed(method) {
+    return isMethod(method) && this.getAllowMethods().includes(method);
   }
   async get() {
-    return this.getResponse(MethodNotImplemented, "GET" /* GET */);
+    return this.getResponse(MethodNotImplemented);
   }
   async put() {
-    return this.getResponse(MethodNotImplemented, "PUT" /* PUT */);
+    return this.getResponse(MethodNotImplemented);
   }
   async post() {
-    return this.getResponse(MethodNotImplemented, "POST" /* POST */);
+    return this.getResponse(MethodNotImplemented);
   }
   async patch() {
-    return this.getResponse(MethodNotImplemented, "PATCH" /* PATCH */);
+    return this.getResponse(MethodNotImplemented);
   }
   async delete() {
-    return this.getResponse(MethodNotImplemented, "DELETE" /* DELETE */);
+    return this.getResponse(MethodNotImplemented);
   }
   async options() {
     return this.getResponse(Options);
   }
   async head() {
-    const worker = this.createWorker(new Request(this.request, { method: "GET" }));
+    const worker = this.createWorker(new Request(this.request, { method: "GET" /* GET */ }));
     return this.getResponse(Head, await worker.fetch());
   }
   async getResponse(ResponseClass, ...args) {
@@ -603,58 +659,10 @@ var BasicWorker = class extends CacheWorker {
     this.setCachedResponse(response);
     return response;
   }
-  isAllowed(method) {
-    return isMethod(method) && this.getAllowMethods().includes(method);
-  }
-};
-
-// src/routes.ts
-var Route = class {
-  /**
-   * @param pattern - A RegExp or string used to match the request path
-   * @param callback - Function to handle requests matching the pattern
-   */
-  constructor(pattern, callback) {
-    this.callback = callback;
-    this.pattern = new RegExp(pattern);
-  }
-  pattern;
-};
-var Routes = class {
-  map = /* @__PURE__ */ new Map();
-  /**
-   * Adds a route to the collection under the given HTTP method.
-   *
-   * @param method - HTTP method (GET, POST, etc.)
-   * @param route - Route instance to add
-   * @returns The Routes instance (for chaining)
-   */
-  add(method, route) {
-    const existing = this.map.get(method);
-    if (existing) {
-      existing.push(route);
-    } else {
-      this.map.set(method, [route]);
-    }
-    return this;
-  }
-  /**
-   * Finds the first route that matches the given method and URL.
-   *
-   * @param method - HTTP method of the request
-   * @param url - Full URL string of the request
-   * @returns The first matching Route, or undefined if none match
-   */
-  get(method, url) {
-    const routes = this.map.get(method);
-    if (!routes) return void 0;
-    const pathname = new URL(url).pathname;
-    return routes.find(({ pattern }) => pattern.test(pathname));
-  }
 };
 
-// src/routed-worker.ts
-var RoutedWorker = class extends BasicWorker {
+// src/route-worker.ts
+var RouteWorker = class extends BasicWorker {
   routes = new Routes();
   initialize(routes) {
     routes.forEach(([method, pattern, callback]) => {
@@ -708,7 +716,7 @@ export {
   NotImplemented,
   Options,
   Route,
-  RoutedWorker,
+  RouteWorker,
   Routes,
   ServiceUnavailable,
   StatusCodes,