@neoaren/comet/dist/index.js

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name2 in all)
    __defProp(target, name2, { get: all[name2], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  ALL: () => ALL,
  BASE_URL: () => BASE_URL,
  CONNECT: () => CONNECT,
  Cookies: () => Cookies,
  DELETE: () => DELETE,
  Data: () => Data,
  GET: () => GET,
  HEAD: () => HEAD,
  Method: () => Method,
  OPTIONS: () => OPTIONS,
  PATCH: () => PATCH,
  POST: () => POST,
  PUT: () => PUT,
  Reply: () => Reply,
  Router: () => Router,
  SameSite: () => SameSite,
  Server: () => Server,
  Status: () => Status,
  TRACE: () => TRACE,
  compareCompatibilityDates: () => compareCompatibilityDates,
  compareMethods: () => compareMethods,
  comparePathnames: () => comparePathnames,
  cors: () => cors,
  defaultCookiesOptions: () => defaultCookiesOptions,
  getPathnameParameters: () => getPathnameParameters,
  isValidCompatibilityDate: () => isValidCompatibilityDate,
  isValidPathname: () => isValidPathname,
  logger: () => logger,
  middleware: () => middleware,
  next: () => next,
  preflightHandler: () => preflightHandler,
  recordException: () => recordException,
  schemaValidation: () => schemaValidation,
  server: () => server
});
module.exports = __toCommonJS(src_exports);

// src/logger.ts
var import_api = require("@opentelemetry/api");
var import_api_logs = require("@opentelemetry/api-logs");

// package.json
var name = "@neoaren/comet";
var version = "3.4.1";

// src/logger.ts
var otelLogger = import_api_logs.logs.getLogger(name, version);
function convert(...data) {
  return data.map((entry) => {
    if (typeof entry === "string") return entry;
    if (entry === void 0) return "undefined";
    return JSON.stringify(entry, null, 2);
  }).join(", ");
}
var logger = {
  trace: (...body) => otelLogger.emit({ severityNumber: import_api_logs.SeverityNumber.TRACE, body: convert(body) }),
  debug: (...body) => otelLogger.emit({ severityNumber: import_api_logs.SeverityNumber.DEBUG, body: convert(body) }),
  info: (...body) => otelLogger.emit({ severityNumber: import_api_logs.SeverityNumber.INFO, body: convert(body) }),
  log: (...body) => otelLogger.emit({ severityNumber: import_api_logs.SeverityNumber.INFO, body: convert(body) }),
  warn: (...body) => otelLogger.emit({ severityNumber: import_api_logs.SeverityNumber.WARN, body: convert(body) }),
  error: (...body) => otelLogger.emit({ severityNumber: import_api_logs.SeverityNumber.ERROR, body: convert(body) })
};
function recordException(exception) {
  if (exception instanceof Error || typeof exception === "string") {
    import_api.trace.getActiveSpan()?.recordException(exception);
  } else if (typeof exception === "object" && exception !== null && "toString" in exception) {
    import_api.trace.getActiveSpan()?.recordException(exception.toString());
  }
}

// src/cookies.ts
var defaultCookiesOptions = {
  decode: decodeURIComponent,
  encode: encodeURIComponent,
  limit: 64
};
var SameSite = /* @__PURE__ */ ((SameSite2) => {
  SameSite2["Strict"] = "Strict";
  SameSite2["Lax"] = "Lax";
  SameSite2["None"] = "None";
  return SameSite2;
})(SameSite || {});
var Cookies = class _Cookies {
  data = /* @__PURE__ */ new Map();
  get [Symbol.toStringTag]() {
    return `Cookies(${this.data.size})`;
  }
  // Get a cookie by name
  get(name2) {
    return this.data.get(name2)?.value;
  }
  // Check if a cookie exists
  has(name2) {
    return this.data.has(name2);
  }
  // Set a cookie with a name, a value and optional metadata
  set(name2, value, meta) {
    this.data.set(name2, { name: name2, value, ...meta ? { meta } : {} });
  }
  // Delete a cookie
  delete(name2) {
    this.data.delete(name2);
  }
  // Returns an array that contains the key-value pairs for each cookie
  entries() {
    return [...this.data.entries()].map(([name2, cookie]) => [name2, cookie.value]);
  }
  // Returns an array that contains the keys for each cookie
  keys() {
    return [...this.data.keys()];
  }
  // Returns an array that contains the values for each cookie
  values() {
    return [...this.data.values()].map((cookie) => cookie.value);
  }
  // Parse cookies from headers
  static async parse(headers, options) {
    const allOptions = this.getAllOptions(options);
    const cookies = new _Cookies();
    const pairs = headers.get("Cookie")?.split(";", allOptions.limit) ?? [];
    for (const pair of pairs) {
      let [name2, value] = pair.split("=", 2).map((component) => component.trim());
      if (!name2 || !value) {
        recordException(`[Comet] Failed to parse malformatted cookie "${pair}".`);
        continue;
      }
      if (value.startsWith('"') && value.endsWith('"')) value = value.slice(1, -1);
      try {
        if (allOptions.decode !== null) name2 = await allOptions.decode(name2);
        if (allOptions.decode !== null) value = await allOptions.decode(value);
        cookies.set(name2, value);
      } catch (error) {
        recordException(`[Comet] Failed to decode cookie "${pair}".`);
        recordException(error);
      }
    }
    return cookies;
  }
  // Serialize cookies to headers
  static async serialize(cookies, headers, options) {
    const allOptions = this.getAllOptions(options);
    for (const cookie of cookies.data.values()) {
      const serialized = [];
      try {
        const name2 = allOptions.encode === null ? cookie.name : await allOptions.encode(cookie.name);
        const value = allOptions.encode === null ? cookie.value : await allOptions.encode(cookie.value);
        serialized.push(`${name2}=${value}`);
      } catch (error) {
        recordException(`[Comet] Failed to encode cookie "${cookie.name}".`);
        recordException(error);
        continue;
      }
      if (cookie.meta?.domain) serialized.push(`Domain=${cookie.meta.domain}`);
      if (cookie.meta?.expires) serialized.push(`Expires=${new Date(cookie.meta.expires).toUTCString()}`);
      if (cookie.meta?.httpOnly) serialized.push("HttpOnly");
      if (cookie.meta?.maxAge) serialized.push(`Max-Age=${cookie.meta.maxAge}`);
      if (cookie.meta?.path) serialized.push(`Path=${cookie.meta.path}`);
      if (cookie.meta?.sameSite) serialized.push(`SameSite=${cookie.meta.sameSite}`);
      if (cookie.meta?.secure) serialized.push("Secure");
      headers.append("Set-Cookie", serialized.join("; "));
    }
  }
  // Get all options with fallback to default options
  static getAllOptions(options) {
    return { ...defaultCookiesOptions, ...options };
  }
};

// src/middleware.ts
var NextData = class {
  // @ts-expect-error data could use better typing
  constructor(data = {}) {
    this.data = data;
  }
};
var next = (extension) => new NextData(extension);
function middleware(options, handler) {
  const _options = typeof options === "object" ? options : {};
  const _handler = typeof options === "function" ? options : handler;
  if (!_handler) throw new Error("[Comet] A middleware received no handler argument.");
  return {
    ..._options,
    handler: async (input) => {
      const nextData = await _handler(input);
      if (nextData instanceof NextData) Object.assign(input.event, nextData.data);
    }
  };
}

// src/types.ts
var Method = /* @__PURE__ */ ((Method2) => {
  Method2["ALL"] = "ALL";
  Method2["GET"] = "GET";
  Method2["HEAD"] = "HEAD";
  Method2["POST"] = "POST";
  Method2["PUT"] = "PUT";
  Method2["DELETE"] = "DELETE";
  Method2["CONNECT"] = "CONNECT";
  Method2["OPTIONS"] = "OPTIONS";
  Method2["TRACE"] = "TRACE";
  Method2["PATCH"] = "PATCH";
  return Method2;
})(Method || {});
var ALL = "ALL" /* ALL */;
var GET = "GET" /* GET */;
var HEAD = "HEAD" /* HEAD */;
var POST = "POST" /* POST */;
var PUT = "PUT" /* PUT */;
var DELETE = "DELETE" /* DELETE */;
var CONNECT = "CONNECT" /* CONNECT */;
var OPTIONS = "OPTIONS" /* OPTIONS */;
var TRACE = "TRACE" /* TRACE */;
var PATCH = "PATCH" /* PATCH */;

// src/cors.ts
var defaultCorsOptions = {
  credentials: false,
  exposedHeaders: [],
  headers: [],
  maxAge: 86400,
  methods: [],
  origins: []
};
function getAllOptions(options) {
  const allOptions = { ...defaultCorsOptions, ...options };
  const allowedOrigins = parseListValue(allOptions.origins);
  const allowedHeaders = parseListValue(allOptions.headers);
  const allowedMethods = parseListValue(allOptions.methods);
  const exposedHeaders = parseListValue(allOptions.exposedHeaders);
  const { credentials: allowCredentials, maxAge } = allOptions;
  return { allowedOrigins, allowedHeaders, allowedMethods, exposedHeaders, allowCredentials, maxAge };
}
function parseListValue(value) {
  return Array.isArray(value) ? value : value.split(",").map((s) => s.trim());
}
var cors = (options) => middleware({
  name: "CORS"
}, ({ event }) => {
  const { allowedOrigins, exposedHeaders, allowCredentials } = getAllOptions(options);
  const origin = event.headers.get("origin");
  if (allowedOrigins.includes("*")) {
    event.reply.headers.set("access-control-allow-origin", "*");
  } else if (origin && (allowedOrigins.includes(origin) || allowedOrigins.some((allowed) => allowed.startsWith("https://*.") && origin.endsWith(allowed.slice(9))))) {
    event.reply.headers.set("access-control-allow-origin", origin);
    event.reply.headers.append("vary", "origin");
  }
  if (allowCredentials) event.reply.headers.set("access-control-allow-credentials", "true");
  if (exposedHeaders.length > 0) event.reply.headers.set("access-control-expose-headers", exposedHeaders.join(","));
  return event.next();
});
var preflightHandler = (router, options) => middleware({
  name: "Preflight handler"
}, ({ event }) => {
  if (event.method !== "OPTIONS" /* OPTIONS */) return event.next();
  const { allowedHeaders, allowedMethods, maxAge } = getAllOptions(options);
  const requestMethod = event.headers.get("access-control-request-method") ?? void 0;
  const route = router.find(event.pathname, requestMethod, void 0, true);
  if (!route) return event.reply.notFound();
  if (allowedHeaders.length > 0) event.reply.headers.set("access-control-allow-headers", allowedHeaders.join(","));
  if (allowedMethods.length > 0) event.reply.headers.set("access-control-allow-methods", allowedMethods.join(","));
  event.reply.headers.set("access-control-max-age", maxAge.toString());
  event.reply.headers.set("content-length", "0");
  return event.reply.noContent();
});

// src/data.ts
var import_api2 = require("@opentelemetry/api");
var Data = class _Data {
  constructor(request, method, pathname, hostname, headers, cookies, query, params, body, _raw, server2) {
    this.request = request;
    this.method = method;
    this.pathname = pathname;
    this.hostname = hostname;
    this.headers = headers;
    this.cookies = cookies;
    this.query = query;
    this.params = params;
    this.body = body;
    this._raw = _raw;
    this.server = server2;
  }
  static async fromRequest(request, options, serverName) {
    const url = new URL(request.url);
    const { raw, body } = await this.parseRequestBody(request);
    import_api2.trace.getActiveSpan()?.addEvent("convert request to data", {
      method: request.method,
      pathname: url.pathname,
      hostname: url.hostname,
      protocol: url.protocol,
      params: url.search
    });
    return new _Data(
      request,
      request.method.toUpperCase(),
      url.pathname,
      url.hostname.toLowerCase(),
      request.headers,
      await Cookies.parse(request.headers, options.cookies),
      Object.fromEntries(url.searchParams.entries()),
      {},
      body,
      raw,
      { name: serverName }
    );
  }
  static async parseRequestBody(request) {
    const contentType = request.headers.get("content-type")?.split(";")[0];
    import_api2.trace.getActiveSpan()?.addEvent("parse request body", {
      contentType: request.headers.get("content-type") ?? void 0,
      parsedContentType: contentType
    });
    switch (contentType) {
      case "application/json": {
        const text = await request.text();
        return { raw: text, body: JSON.parse(text) };
      }
      case "multipart/form-data": {
        const formData = await request.formData();
        const body = {};
        for (const [key, value] of formData.entries()) body[key] = value;
        return { body };
      }
      case "application/x-www-form-urlencoded": {
        const text = await request.text();
        const entries = text.split("&").map((x) => x.split("=").map(decodeURIComponent));
        return { body: Object.fromEntries(entries) };
      }
      default:
        return { body: void 0 };
    }
  }
};

// src/reply.ts
var import_api3 = require("@opentelemetry/api");
var Status = /* @__PURE__ */ ((Status2) => {
  Status2["Continue"] = "continue";
  Status2["SwitchingProtocols"] = "switchingProtocols";
  Status2["Processing"] = "processing";
  Status2["Ok"] = "ok";
  Status2["Created"] = "created";
  Status2["Accepted"] = "accepted";
  Status2["NonAuthoritativeInformation"] = "nonAuthoritativeInformation";
  Status2["NoContent"] = "noContent";
  Status2["ResetContent"] = "resetContent";
  Status2["PartialContent"] = "partialContent";
  Status2["MultiStatus"] = "multiStatus";
  Status2["MultipleChoices"] = "multipleChoices";
  Status2["MovedPermanently"] = "movedPermanently";
  Status2["MovedTemporarily"] = "movedTemporarily";
  Status2["SeeOther"] = "seeOther";
  Status2["NotModified"] = "notModified";
  Status2["UseProxy"] = "useProxy";
  Status2["TemporaryRedirect"] = "temporaryRedirect";
  Status2["PermanentRedirect"] = "permanentRedirect";
  Status2["BadRequest"] = "badRequest";
  Status2["Unauthorized"] = "unauthorized";
  Status2["PaymentRequired"] = "paymentRequired";
  Status2["Forbidden"] = "forbidden";
  Status2["NotFound"] = "notFound";
  Status2["MethodNotAllowed"] = "methodNotAllowed";
  Status2["NotAcceptable"] = "notAcceptable";
  Status2["ProxyAuthenticationRequired"] = "proxyAuthenticationRequired";
  Status2["RequestTimeout"] = "requestTimeout";
  Status2["Conflict"] = "conflict";
  Status2["Gone"] = "gone";
  Status2["LengthRequired"] = "lengthRequired";
  Status2["PreconditionFailed"] = "preconditionFailed";
  Status2["RequestTooLong"] = "requestTooLong";
  Status2["RequestUriTooLong"] = "requestUriTooLong";
  Status2["UnsupportedMediaType"] = "unsupportedMediaType";
  Status2["RequestedRangeNotSatisfiable"] = "requestedRangeNotSatisfiable";
  Status2["ExpectationFailed"] = "expectationFailed";
  Status2["ImATeapot"] = "imATeapot";
  Status2["InsufficientSpaceOnResource"] = "insufficientSpaceOnResource";
  Status2["MethodFailure"] = "methodFailure";
  Status2["MisdirectedRequest"] = "misdirectedRequest";
  Status2["UnprocessableEntity"] = "unprocessableEntity";
  Status2["FailedDependency"] = "failedDependency";
  Status2["PreconditionRequired"] = "preconditionRequired";
  Status2["TooManyRequests"] = "tooManyRequests";
  Status2["RequestHeaderFieldsTooLarge"] = "requestHeaderFieldsTooLarge";
  Status2["UnavailableForLegalReasons"] = "unavailableForLegalReasons";
  Status2["InternalServerError"] = "internalServerError";
  Status2["NotImplemented"] = "notImplemented";
  Status2["BadGateway"] = "badGateway";
  Status2["ServiceUnavailable"] = "serviceUnavailable";
  Status2["GatewayTimeout"] = "gatewayTimeout";
  Status2["HttpVersionNotSupported"] = "httpVersionNotSupported";
  Status2["InsufficientStorage"] = "insufficientStorage";
  Status2["NetworkAuthenticationRequired"] = "networkAuthenticationRequired";
  return Status2;
})(Status || {});
var Reply = class {
  // Reply data for regular replies
  body;
  status = Number.NaN;
  headers = new Headers();
  cookies = new Cookies();
  // Reply data for raw replies
  _raw;
  // The date the reply was sent
  sent;
  // Convert a reply to a standard response
  static async toResponse(reply, options) {
    if (!reply.sent) {
      recordException("[Comet] No reply was sent for this event.");
      return new Response(null, { status: 500 });
    }
    if (reply._raw !== void 0) {
      import_api3.trace.getActiveSpan()?.addEvent("return raw response");
      return reply._raw;
    }
    const status = reply.status;
    const headers = reply.headers;
    await Cookies.serialize(reply.cookies, reply.headers, options.cookies);
    if (reply.body instanceof WebSocket) {
      import_api3.trace.getActiveSpan()?.addEvent("return websocket response");
      return new Response(null, { status, headers, webSocket: reply.body });
    }
    if (reply.body instanceof ReadableStream) {
      import_api3.trace.getActiveSpan()?.addEvent("return streamed response");
      return new Response(reply.body, { status, headers });
    }
    let body = null;
    if (reply.body) {
      headers.set("content-type", "application/json");
      body = options.dev ? JSON.stringify(reply.body, null, 2) : JSON.stringify(reply.body);
    }
    import_api3.trace.getActiveSpan()?.addEvent("convert response");
    return new Response(body, { status, headers });
  }
  // Send a regular reply
  send(status, body) {
    if (this.sent) {
      recordException("[Comet] Cannot send a reply after one has already been sent.");
      return this;
    }
    this.status = status;
    this.body = body;
    this.sent = /* @__PURE__ */ new Date();
    import_api3.trace.getActiveSpan()?.addEvent("send reply", {
      status,
      sent: +this.sent
    });
    return this;
  }
  // Send a raw reply
  raw(response) {
    if (this.sent) {
      recordException("[Comet] Cannot send a reply after one has already been sent.");
      return this;
    }
    this._raw = response;
    this.sent = /* @__PURE__ */ new Date();
    import_api3.trace.getActiveSpan()?.addEvent("raw reply", {
      sent: +this.sent
    });
    return this;
  }
  // Send a custom HTTP response
  custom(status, body) {
    return this.send(status, body);
  }
  // Send an HTTP `100 Continue` informational response
  continue(body) {
    return this.send(100, body);
  }
  // Send an HTTP `101 Switching Protocols` informational response
  switchingProtocols(body) {
    return this.send(101, body);
  }
  // Send an HTTP `102 Processing` informational response
  processing(body) {
    return this.send(102, body);
  }
  // Send an HTTP `200 OK` successful response
  ok(body) {
    return this.send(200, body);
  }
  // Send an HTTP `201 Created` successful response
  created(body) {
    return this.send(201, body);
  }
  // Send an HTTP `202 Accepted` successful response
  accepted(body) {
    return this.send(202, body);
  }
  // Send an HTTP `203 Non-Authoritative Information` successful response
  nonAuthoritativeInformation(body) {
    return this.send(203, body);
  }
  // Send an HTTP `204 No Content` successful response
  noContent(body) {
    return this.send(204, body);
  }
  // Send an HTTP `205 Reset Content` successful response
  resetContent(body) {
    return this.send(205, body);
  }
  // Send an HTTP `206 Partial Content` successful response
  partialContent(body) {
    return this.send(206, body);
  }
  // Send an HTTP `207 Multi-Status` successful response
  multiStatus(body) {
    return this.send(207, body);
  }
  // Send an HTTP `300 Multiple Choices` redirection response
  multipleChoices(body) {
    return this.send(300, body);
  }
  // Send an HTTP `301 Moved Permanently` redirection response
  movedPermanently(body) {
    return this.send(301, body);
  }
  // Send an HTTP `302 Moved Temporarily` redirection response
  movedTemporarily(body) {
    return this.send(302, body);
  }
  // Send an HTTP `303 See Other` redirection response
  seeOther(body) {
    return this.send(303, body);
  }
  // Send an HTTP `304 Not Modified` redirection response
  notModified(body) {
    return this.send(304, body);
  }
  // Send an HTTP `305 Use Proxy` redirection response
  useProxy(body) {
    return this.send(305, body);
  }
  // Send an HTTP `307 Temporary Redirect` redirection response
  temporaryRedirect(body) {
    return this.send(307, body);
  }
  // Send an HTTP `308 Permanent Redirect` redirection response
  permanentRedirect(body) {
    return this.send(308, body);
  }
  // Send an HTTP `400 Bad Request` client error response
  badRequest(body) {
    return this.send(400, body);
  }
  // Send an HTTP `401 Unauthorized` client error response
  unauthorized(body) {
    return this.send(401, body);
  }
  // Send an HTTP `402 Payment Required` client error response
  paymentRequired(body) {
    return this.send(402, body);
  }
  // Send an HTTP `403 Forbidden` client error response
  forbidden(body) {
    return this.send(403, body);
  }
  // Send an HTTP `404 Not Found` client error response
  notFound(body) {
    return this.send(404, body);
  }
  // Send an HTTP `405 Method Not Allowed` client error response
  methodNotAllowed(body) {
    return this.send(405, body);
  }
  // Send an HTTP `406 Not Acceptable` client error response
  notAcceptable(body) {
    return this.send(406, body);
  }
  // Send an HTTP `407 Proxy Authentication Required` client error response
  proxyAuthenticationRequired(body) {
    return this.send(407, body);
  }
  // Send an HTTP `408 Request Timeout` client error response
  requestTimeout(body) {
    return this.send(408, body);
  }
  // Send an HTTP `409 Conflict` client error response
  conflict(body) {
    return this.send(409, body);
  }
  // Send an HTTP `410 Gone` client error response
  gone(body) {
    return this.send(410, body);
  }
  // Send an HTTP `411 Length Required` client error response
  lengthRequired(body) {
    return this.send(411, body);
  }
  // Send an HTTP `412 Precondition Failed` client error response
  preconditionFailed(body) {
    return this.send(412, body);
  }
  // Send an HTTP `413 Request Too Long` client error response
  requestTooLong(body) {
    return this.send(413, body);
  }
  // Send an HTTP `414 Request URI Too Long` client error response
  requestUriTooLong(body) {
    return this.send(414, body);
  }
  // Send an HTTP `415 Unsupported Media Type` client error response
  unsupportedMediaType(body) {
    return this.send(415, body);
  }
  // Send an HTTP `416 Requested Range Not Satisfiable` client error response
  requestedRangeNotSatisfiable(body) {
    return this.send(416, body);
  }
  // Send an HTTP `417 Expectation Failed` client error response
  expectationFailed(body) {
    return this.send(417, body);
  }
  // Send an HTTP `418 I'm a teapot` client error response
  imATeapot(body) {
    return this.send(418, body);
  }
  // Send an HTTP `419 Insufficient Space On Resource` client error response
  insufficientSpaceOnResource(body) {
    return this.send(419, body);
  }
  // Send an HTTP `420 Method Failure` client error response
  methodFailure(body) {
    return this.send(420, body);
  }
  // Send an HTTP `421 Misdirected Request` client error response
  misdirectedRequest(body) {
    return this.send(421, body);
  }
  // Send an HTTP `422 Unprocessable Entity` client error response
  unprocessableEntity(body) {
    return this.send(422, body);
  }
  // Send an HTTP `424 Failed Dependency` client error response
  failedDependency(body) {
    return this.send(424, body);
  }
  // Send an HTTP `428 Precondition Required` client error response
  preconditionRequired(body) {
    return this.send(428, body);
  }
  // Send an HTTP `429 Too Many Requests` client error response
  tooManyRequests(body) {
    return this.send(429, body);
  }
  // Send an HTTP `431 Request Header Fields Too Large` client error response
  requestHeaderFieldsTooLarge(body) {
    return this.send(431, body);
  }
  // Send an HTTP `451 Unavailable For Legal Reasons` client error response
  unavailableForLegalReasons(body) {
    return this.send(451, body);
  }
  // Send an HTTP `500 Internal Server Error` server error response
  internalServerError(body) {
    return this.send(500, body);
  }
  // Send an HTTP `501 Not Implemented` server error response
  notImplemented(body) {
    return this.send(501, body);
  }
  // Send an HTTP `502 Bad Gateway` server error response
  badGateway(body) {
    return this.send(502, body);
  }
  // Send an HTTP `503 Service Unavailable` server error response
  serviceUnavailable(body) {
    return this.send(503, body);
  }
  // Send an HTTP `504 Gateway Timeout` server error response
  gatewayTimeout(body) {
    return this.send(504, body);
  }
  // Send an HTTP `505 Http Version Not Supported` server error response
  httpVersionNotSupported(body) {
    return this.send(505, body);
  }
  // Send an HTTP `507 Insufficient Storage` server error response
  insufficientStorage(body) {
    return this.send(507, body);
  }
  // Send an HTTP `511 Network Authentication Required` server error response
  networkAuthenticationRequired(body) {
    return this.send(511, body);
  }
};

// src/utils.ts
var BASE_URL = "https://comet";
function isValidPathname(value) {
  if (typeof value !== "string") return false;
  try {
    new URLPattern(value, BASE_URL);
    return true;
  } catch {
    return false;
  }
}
function isValidCompatibilityDate(value) {
  return typeof value === "string" && !Number.isNaN(new Date(value).valueOf());
}
function comparePathnames(check, against) {
  if (!against || against === "*") return true;
  return new URLPattern(against, BASE_URL).test(check, BASE_URL);
}
function compareMethods(check, against) {
  if (!against || against === "ALL" /* ALL */) return true;
  return check === against;
}
function compareCompatibilityDates(check, against) {
  if (!against) return true;
  if (!check) return false;
  return new Date(check) >= new Date(against);
}
function getPathnameParameters(pathname, template) {
  const result = new URLPattern(template, BASE_URL).exec(pathname, BASE_URL);
  return result?.pathname?.groups ?? {};
}

// src/router.ts
var Router = class {
  // Take router options
  constructor(options) {
    this.options = options;
  }
  // Registry of routes
  routes = [];
  ready = true;
  // Register a new route
  register = (options, handler) => {
    const _register = (inputMethod) => {
      const pathname = `${this.options.prefix ?? ""}${options.pathname ?? "*"}`;
      const method2 = inputMethod ?? "ALL" /* ALL */;
      const compatibilityDate = options.compatibilityDate;
      const name2 = options.name ?? `${method2} ${pathname}${compatibilityDate ? ` (${compatibilityDate})` : ""}`;
      if (!isValidPathname(pathname)) {
        recordException(`[Comet] Failed to set up route '${name2}' due to an invalid pathname.`);
        return;
      }
      if (options.compatibilityDate !== void 0 && !isValidCompatibilityDate(options.compatibilityDate)) {
        recordException(`[Comet] Failed to set up route '${name2}' due to an invalid compatibility date.`);
        return;
      }
      const schemas = { body: options.body, params: options.params, query: options.query };
      this.routes.push({ ...options, pathname, method: method2, name: name2, handler, schemas });
    };
    const { method } = options;
    if (Array.isArray(method)) {
      for (const each of method) _register(each);
    } else {
      _register(method);
    }
    this.ready = false;
  };
  // Find a route on a server by pathname, method and compatibility date
  find = (pathname, method, compatibilityDate, ignoreCompatibilityDate) => {
    for (const route of this.routes) {
      const doPathnamesMatch = comparePathnames(pathname, route.pathname);
      if (!doPathnamesMatch) continue;
      const doMethodsMatch = compareMethods(method, route.method);
      if (!doMethodsMatch) continue;
      if (ignoreCompatibilityDate) return route;
      const doCompatibilityDatesMatch = compareCompatibilityDates(compatibilityDate, route.compatibilityDate);
      if (doCompatibilityDatesMatch) return route;
    }
  };
  // Initialize router by sorting the routes by compatibility date in descending order to ensure the correct functioning of the find algorithm
  init = () => {
    if (this.ready) return;
    this.routes.sort((a, b) => {
      if (a.pathname !== b.pathname || a.method !== b.method) return 0;
      return compareCompatibilityDates(a.compatibilityDate, b.compatibilityDate) ? -1 : 1;
    });
    this.ready = true;
  };
  getRoutes = () => this.routes;
};

// src/schemaValidation.ts
var import_api4 = require("@opentelemetry/api");
var schemaValidation = (route) => middleware({
  name: "Schema validation"
}, async ({ event }) => {
  const { body: bodySchema, params: paramsSchema, query: querySchema } = route.schemas;
  const paramsResult = paramsSchema?.safeParse(event.params);
  import_api4.trace.getActiveSpan()?.addEvent("params schema parse", {
    success: paramsResult?.success,
    errors: paramsResult?.success ? void 0 : paramsResult?.error.issues.map((issue) => issue.message)
  });
  const queryResult = querySchema?.safeParse(event.query);
  import_api4.trace.getActiveSpan()?.addEvent("query schema parse", {
    success: queryResult?.success,
    errors: paramsResult?.success ? void 0 : paramsResult?.error.issues.map((issue) => issue.message)
  });
  const bodyResult = bodySchema?.safeParse(event.body);
  import_api4.trace.getActiveSpan()?.addEvent("body schema parse", {
    success: bodyResult?.success,
    errors: paramsResult?.success ? void 0 : paramsResult?.error.issues.map((issue) => issue.message)
  });
  const errors = {};
  if (paramsResult?.success === false) errors.params = paramsResult.error.issues;
  if (queryResult?.success === false) errors.query = queryResult.error.issues;
  if (bodyResult?.success === false) errors.body = bodyResult.error.issues;
  if (errors.body || errors.params || errors.query) {
    return event.reply.badRequest({ success: false, errors });
  }
  if (paramsResult?.success) event.params = paramsResult.data;
  if (queryResult?.success) event.query = queryResult.data;
  if (bodyResult?.success) event.body = bodyResult.data;
  return event.next();
});

// src/server.ts
var import_api5 = require("@opentelemetry/api");
var Server = class {
  constructor(options = {}) {
    this.options = options;
    this.router = new Router(options);
    this.route = this.router.register;
  }
  router;
  route;
  handler = async (request, env, ctxOrState) => {
    return import_api5.trace.getTracer(name, version).startActiveSpan("Comet Handler", {
      kind: import_api5.SpanKind.SERVER,
      attributes: {
        name: this.options.name
      }
    }, async (span) => {
      try {
        this.router.init();
        const data = await Data.fromRequest(request, this.options, this.options.name);
        const reply = new Reply();
        const isDurableObject = "id" in ctxOrState;
        const event = {
          ...data,
          reply,
          next,
          isDurableObject,
          ...isDurableObject ? { state: ctxOrState } : { ctx: ctxOrState }
        };
        const input = { event, env, logger };
        span.setAttribute("comet.server.durable_object", isDurableObject);
        if (this.options.before) {
          for (const mw of this.options.before) {
            await import_api5.trace.getTracer(name, version).startActiveSpan(
              `Comet Middleware${mw.name ? ` ${mw.name}` : ""}`,
              {
                attributes: {
                  "comet.mw.name": mw.name,
                  "comet.mw.type": "global-before"
                }
              },
              async (span2) => {
                await mw.handler(input);
                span2.end();
              }
            );
            if (event.reply.sent) break;
          }
        }
        if (!event.reply.sent) {
          await import_api5.trace.getTracer(name, version).startActiveSpan(
            "Comet CORS Middleware",
            {
              attributes: {
                "comet.mw.name": "CORS",
                "comet.mw.type": "global-before",
                "comet.mw.cors.origin": event.headers.get("origin") ?? void 0,
                "comet.mw.cors.method": event.method
              }
            },
            async (span2) => {
              await cors(this.options.cors).handler(input);
              span2.end();
            }
          );
        }
        if (!event.reply.sent) {
          await import_api5.trace.getTracer(name, version).startActiveSpan(
            "Comet Routing",
            {
              attributes: {
                "comet.routing.compatibility_date": event.headers.get("x-compatibility-date") ?? void 0,
                "comet.routing.pathname": event.pathname,
                "comet.routing.method": event.method
              }
            },
            async (span2) => {
              const compatibilityDate = event.headers.get("x-compatibility-date") ?? void 0;
              if (compatibilityDate && new Date(compatibilityDate) > /* @__PURE__ */ new Date() && !this.options.dev) {
                event.reply.badRequest({ message: "Invalid compatibility date" });
              } else {
                const route = this.router.find(event.pathname, event.method, compatibilityDate);
                if (!route) {
                  if (event.method === "OPTIONS" /* OPTIONS */) {
                    await preflightHandler(this.router, this.options.cors).handler(input);
                  } else {
                    event.reply.notFound();
                  }
                } else {
                  event.params = getPathnameParameters(event.pathname, route.pathname);
                  if (!event.reply.sent) schemaValidation(route).handler(input);
                  if (route.before) {
                    for (const mw of route.before) {
                      await import_api5.trace.getTracer(name, version).startActiveSpan(
                        `Comet Middleware${mw.name ? ` ${mw.name}` : ""}`,
                        {
                          attributes: {
                            "comet.mw.name": mw.name,
                            "comet.mw.type": "local-before"
                          }
                        },
                        async (span3) => {
                          await mw.handler(input);
                          span3.end();
                        }
                      );
                      if (event.reply.sent) break;
                    }
                  }
                  if (!event.reply.sent) {
                    await import_api5.trace.getTracer(name, version).startActiveSpan(
                      "Comet Main Handler",
                      {
                        attributes: {
                          "comet.route.name": route.name,
                          "comet.route.pathname": route.pathname,
                          "comet.route.compatibility_date": route.compatibilityDate,
                          "comet.route.has_body_schema": !!route.schemas.body,
                          "comet.route.has_query_schema": !!route.schemas.query,
                          "comet.route.has_params_schema": !!route.schemas.params,
                          "comet.route.method": route.method
                        }
                      },
                      async (span3) => {
                        await route.handler(input);
                        span3.end();
                      }
                    );
                  }
                  if (route.after) {
                    if (isDurableObject) {
                      for (const mw of route.after) {
                        await import_api5.trace.getTracer(name, version).startActiveSpan(
                          `Comet Middleware${mw.name ? ` ${mw.name}` : ""}`,
                          {
                            attributes: {
                              "comet.mw.name": mw.name,
                              "comet.mw.type": "local-after"
                            }
                          },
                          async (span3) => {
                            await mw.handler(input);
                            span3.end();
                          }
                        );
                      }
                    } else {
                      ctxOrState.waitUntil(Promise.allSettled(route.after.map(async (mw) => {
                        const span3 = import_api5.trace.getTracer(name, version).startSpan(`Comet Middleware${mw.name ? ` ${mw.name}` : ""}`, {
                          attributes: {
                            "comet.mw.name": mw.name,
                            "comet.mw.type": "local-after"
                          }
                        });
                        await mw.handler(input);
                        span3.end();
                      })));
                    }
                  }
                }
              }
              span2.end();
            }
          );
        }
        if (this.options.after) {
          if (isDurableObject) {
            for (const mw of this.options.after) {
              await import_api5.trace.getTracer(name, version).startActiveSpan(
                `Comet Middleware${mw.name ? ` ${mw.name}` : ""}`,
                {
                  attributes: {
                    "comet.mw.name": mw.name,
                    "comet.mw.type": "global-after"
                  }
                },
                async (span2) => {
                  await mw.handler(input);
                  span2.end();
                }
              );
            }
          } else {
            ctxOrState.waitUntil(Promise.allSettled(this.options.after.map(async (mw) => {
              const span2 = import_api5.trace.getTracer(name, version).startSpan(`Comet Middleware${mw.name ? ` ${mw.name}` : ""}`, {
                attributes: {
                  "comet.mw.name": mw.name,
                  "comet.mw.type": "global-after"
                }
              });
              await mw.handler(input);
              span2.end();
            })));
          }
        }
        span.end();
        return await Reply.toResponse(event.reply, this.options);
      } catch (error) {
        recordException("[Comet] Failed to handle request.");
        recordException(error);
        span.end();
        return new Response(null, { status: 500 });
      }
    });
  };
  static getRouter(server2) {
    return server2.router;
  }
};
function server(options) {
  return new Server(options);
}