@visulima/error-handler 1.0.0

package/dist/handler/http/fetch-handler.js

@@ -0,0 +1,267 @@
+import { htmlErrorHandler } from '../../error-handler/html-error-handler.js';
+import jsonapiErrorHandler from '../../error-handler/jsonapi-error-handler.js';
+import problemErrorHandler from '../../error-handler/problem-error-handler.js';
+import { textErrorHandler } from '../../error-handler/text-error-handler.js';
+import { jsonErrorHandler } from '../../error-handler/json-error-handler.js';
+import { jsonpErrorHandler } from '../../error-handler/jsonp-error-handler.js';
+import { xmlErrorHandler } from '../../error-handler/xml-error-handler.js';
+
+var __defProp$2 = Object.defineProperty;
+var __name$2 = (target, value) => __defProp$2(target, "name", { value, configurable: true });
+class MockServerResponse {
+  static {
+    __name$2(this, "MockServerResponse");
+  }
+  statusCode = 200;
+  statusMessage = "";
+  headers = {};
+  headersSent = false;
+  writable = true;
+  finished = false;
+  writableEnded = false;
+  writableFinished = false;
+  writableHighWaterMark = 16384;
+  writableLength = 0;
+  destroyed = false;
+  writableCorked = 0;
+  readable = false;
+  readableHighWaterMark = 16384;
+  readableLength = 0;
+  errored = null;
+  closed = false;
+  readableAborted = false;
+  readableDidRead = false;
+  readableEncoding = null;
+  readableEnded = false;
+  readableFlowing = null;
+  _events;
+  _eventsCount = 0;
+  _maxListeners;
+  body = "";
+  setHeader(name, value) {
+    this.headers[name.toLowerCase()] = value;
+    return this;
+  }
+  getHeader(name) {
+    return this.headers[name.toLowerCase()];
+  }
+  getHeaders() {
+    return { ...this.headers };
+  }
+  getHeaderNames() {
+    return Object.keys(this.headers);
+  }
+  hasHeader(name) {
+    return name.toLowerCase() in this.headers;
+  }
+  removeHeader(name) {
+    delete this.headers[name.toLowerCase()];
+    return this;
+  }
+  writeHead(statusCode, statusMessage, headers) {
+    this.statusCode = statusCode;
+    if (typeof statusMessage === "string") {
+      this.statusMessage = statusMessage;
+    }
+    if (typeof statusMessage === "object") {
+      headers = statusMessage;
+    }
+    if (headers) {
+      Object.assign(this.headers, headers);
+    }
+    return this;
+  }
+  write(chunk) {
+    this.body += chunk.toString();
+    return true;
+  }
+  end(data, encoding, cb) {
+    if (data) {
+      this.body += data.toString();
+    }
+    this.finished = true;
+    return this;
+  }
+  flushHeaders() {
+    this.headersSent = true;
+  }
+  // Stub methods for interface compliance
+  addListener = /* @__PURE__ */ __name$2(() => this, "addListener");
+  on = /* @__PURE__ */ __name$2(() => this, "on");
+  once = /* @__PURE__ */ __name$2(() => this, "once");
+  removeListener = /* @__PURE__ */ __name$2(() => this, "removeListener");
+  off = /* @__PURE__ */ __name$2(() => this, "off");
+  removeAllListeners = /* @__PURE__ */ __name$2(() => this, "removeAllListeners");
+  setMaxListeners = /* @__PURE__ */ __name$2(() => this, "setMaxListeners");
+  getMaxListeners = /* @__PURE__ */ __name$2(() => 10, "getMaxListeners");
+  listeners = /* @__PURE__ */ __name$2(() => [], "listeners");
+  rawListeners = /* @__PURE__ */ __name$2(() => [], "rawListeners");
+  emit = /* @__PURE__ */ __name$2(() => false, "emit");
+  eventNames = /* @__PURE__ */ __name$2(() => [], "eventNames");
+  listenerCount = /* @__PURE__ */ __name$2(() => 0, "listenerCount");
+  prependListener = /* @__PURE__ */ __name$2(() => this, "prependListener");
+  prependOnceListener = /* @__PURE__ */ __name$2(() => this, "prependOnceListener");
+  // Additional methods
+  cork = /* @__PURE__ */ __name$2(() => {
+  }, "cork");
+  uncork = /* @__PURE__ */ __name$2(() => {
+  }, "uncork");
+  destroy = /* @__PURE__ */ __name$2(() => this, "destroy");
+  read = /* @__PURE__ */ __name$2(() => null, "read");
+  setEncoding = /* @__PURE__ */ __name$2(() => this, "setEncoding");
+  pause = /* @__PURE__ */ __name$2(() => this, "pause");
+  resume = /* @__PURE__ */ __name$2(() => this, "resume");
+  isPaused = /* @__PURE__ */ __name$2(() => false, "isPaused");
+  destroySoon = /* @__PURE__ */ __name$2(() => this, "destroySoon");
+  pipe = /* @__PURE__ */ __name$2(() => ({}), "pipe");
+  unpipe = /* @__PURE__ */ __name$2(() => this, "unpipe");
+  unshift = /* @__PURE__ */ __name$2(() => {
+  }, "unshift");
+  wrap = /* @__PURE__ */ __name$2(() => this, "wrap");
+  setTimeout = /* @__PURE__ */ __name$2(() => this, "setTimeout");
+  assignSocket = /* @__PURE__ */ __name$2(() => {
+  }, "assignSocket");
+  detachSocket = /* @__PURE__ */ __name$2(() => {
+  }, "detachSocket");
+  writeContinue = /* @__PURE__ */ __name$2(() => {
+  }, "writeContinue");
+  writeEarlyHints = /* @__PURE__ */ __name$2(() => {
+  }, "writeEarlyHints");
+  sendDate = true;
+  strictContentLength = false;
+  chunkedEncoding = false;
+  shouldKeepAlive = true;
+  useChunkedEncodingByDefault = true;
+  _hasBody = true;
+  _trailer = "";
+  connection = null;
+  socket = null;
+}
+const fetchHtmlErrorHandler = /* @__PURE__ */ __name$2((options = {}) => {
+  const nodeHandler = htmlErrorHandler(options);
+  return async (error, request) => {
+    const mockReq = {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(Array.from(request.headers.entries()))
+    };
+    const mockRes = new MockServerResponse();
+    await nodeHandler(error, mockReq, mockRes);
+    const contentType = mockRes.getHeader("content-type") || "text/html; charset=utf-8";
+    return new Response(mockRes.body, {
+      status: mockRes.statusCode,
+      headers: {
+        "content-type": contentType,
+        ...mockRes.headers
+      }
+    });
+  };
+}, "fetchHtmlErrorHandler");
+
+var __defProp$1 = Object.defineProperty;
+var __name$1 = (target, value) => __defProp$1(target, "name", { value, configurable: true });
+const negotiateContentType = /* @__PURE__ */ __name$1((acceptHeader) => {
+  if (!acceptHeader) return "text/html";
+  const accept = acceptHeader.toLowerCase();
+  if (accept.includes("text/html")) return "text/html";
+  if (accept.includes("application/vnd.api+json")) return "application/vnd.api+json";
+  if (accept.includes("application/problem+json")) return "application/problem+json";
+  if (accept.includes("application/json")) return "application/json";
+  if (accept.includes("text/plain")) return "text/plain";
+  if (accept.includes("application/javascript") || accept.includes("text/javascript")) return "application/javascript";
+  if (accept.includes("application/xml") || accept.includes("text/xml")) return "application/xml";
+  return "text/html";
+}, "negotiateContentType");
+const adaptErrorHandlerToFetch = /* @__PURE__ */ __name$1((nodeHandler) => {
+  return async (error, request) => {
+    const mockReq = {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers.entries())
+    };
+    const mockRes = {
+      statusCode: 200,
+      headers: {},
+      _body: "",
+      setHeader(name, value) {
+        this.headers[name.toLowerCase()] = value;
+      },
+      getHeader(name) {
+        return this.headers[name.toLowerCase()];
+      },
+      getHeaders() {
+        return { ...this.headers };
+      },
+      writeHead(statusCode) {
+        this.statusCode = statusCode;
+      },
+      write(chunk) {
+        this._body += chunk.toString();
+      },
+      end(data) {
+        if (data) {
+          this._body += data.toString();
+        }
+      },
+      flushHeaders() {
+      }
+    };
+    await nodeHandler(error, mockReq, mockRes);
+    const headers = {};
+    for (const [key, value] of Object.entries(mockRes.headers)) {
+      if (Array.isArray(value)) {
+        headers[key] = value.join(", ");
+      } else {
+        headers[key] = String(value);
+      }
+    }
+    return new Response(mockRes._body, {
+      status: mockRes.statusCode,
+      headers
+    });
+  };
+}, "adaptErrorHandlerToFetch");
+const createFetchNegotiatedErrorHandler = /* @__PURE__ */ __name$1((errorHandlers, showTrace, defaultHtmlHandler) => async (error, request) => {
+  const accept = request.headers.get("accept");
+  const chosenType = negotiateContentType(accept);
+  let fetchErrorHandler = defaultHtmlHandler || adaptErrorHandlerToFetch(problemErrorHandler);
+  if (chosenType === "text/html" && defaultHtmlHandler) {
+    fetchErrorHandler = defaultHtmlHandler;
+  } else if (chosenType === "application/vnd.api+json") {
+    fetchErrorHandler = adaptErrorHandlerToFetch(jsonapiErrorHandler);
+  } else if (chosenType === "application/problem+json") {
+    fetchErrorHandler = adaptErrorHandlerToFetch(problemErrorHandler);
+  } else if (chosenType === "application/json") {
+    fetchErrorHandler = adaptErrorHandlerToFetch(jsonErrorHandler());
+  } else if (chosenType === "text/plain") {
+    fetchErrorHandler = adaptErrorHandlerToFetch(textErrorHandler());
+  } else if (chosenType === "application/javascript") {
+    fetchErrorHandler = adaptErrorHandlerToFetch(jsonpErrorHandler());
+  } else if (chosenType === "application/xml") {
+    fetchErrorHandler = adaptErrorHandlerToFetch(xmlErrorHandler());
+  }
+  for (const { handler, regex } of errorHandlers) {
+    const headerStr = accept ?? "";
+    if (regex.test(headerStr)) {
+      fetchErrorHandler = handler;
+      break;
+    }
+  }
+  error.expose = showTrace;
+  return fetchErrorHandler(error, request);
+}, "createFetchNegotiatedErrorHandler");
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const fetchHandler = /* @__PURE__ */ __name(async (error, options = {}) => {
+  const defaultHtml = fetchHtmlErrorHandler(options);
+  const negotiated = createFetchNegotiatedErrorHandler(options.extraHandlers ?? [], options.showTrace ?? true, defaultHtml);
+  return async (request) => {
+    if (options?.onError) {
+      await options.onError(error, request);
+    }
+    return negotiated(error, request);
+  };
+}, "fetchHandler");
+
+export { fetchHandler as default };

package/dist/handler/http/node-handler.d.ts

@@ -0,0 +1,11 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { HtmlErrorHandlerOptions } from '../../error-handler/html-error-handler.js';
+import { E as ErrorHandlers } from '../../packem_shared/types.d-DLy8CCca.js';
+
+declare const httpHandler: (error: Error, options?: HtmlErrorHandlerOptions & {
+    showTrace?: boolean;
+    extraHandlers?: ErrorHandlers;
+    onError?: (error: Error, request: IncomingMessage, response: ServerResponse) => void | Promise<void>;
+}) => Promise<(request: IncomingMessage, response: ServerResponse) => Promise<void>>;
+
+export { httpHandler as default };

package/dist/handler/http/node-handler.js

@@ -0,0 +1,17 @@
+import { htmlErrorHandler } from '../../error-handler/html-error-handler.js';
+import createNegotiatedErrorHandler from '../../packem_shared/createNegotiatedErrorHandler-Cd7yj67Z.js';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const httpHandler = /* @__PURE__ */ __name(async (error, options = {}) => {
+  const defaultHtml = htmlErrorHandler(options);
+  const negotiated = createNegotiatedErrorHandler(options.extraHandlers ?? [], options.showTrace ?? true, defaultHtml);
+  return async (request, response) => {
+    if (options?.onError) {
+      await options.onError(error, request, response);
+    }
+    await negotiated(error, request, response);
+  };
+}, "httpHandler");
+
+export { httpHandler as default };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { default as jsonapiErrorHandler } from './error-handler/jsonapi-error-handler.js';
+export { default as problemErrorHandler } from './error-handler/problem-error-handler.js';
+export { HtmlErrorHandlerOptions, htmlErrorHandler } from './error-handler/html-error-handler.js';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { E as ErrorHandlers, a as ErrorHandler } from './packem_shared/types.d-DLy8CCca.js';
+export { A as ApiFormat } from './packem_shared/types.d-DLy8CCca.js';
+export { TextErrorFormatter, TextErrorHandlerOptions, textErrorHandler } from './error-handler/text-error-handler.js';
+export { JsonErrorBody, JsonErrorFormatter, JsonErrorHandlerOptions, jsonErrorHandler } from './error-handler/json-error-handler.js';
+export { JsonpErrorBody, JsonpErrorFormatter, JsonpErrorHandlerOptions, jsonpErrorHandler } from './error-handler/jsonp-error-handler.js';
+export { ToXmlOptions, XmlErrorBody, XmlErrorFormatter, XmlErrorHandlerOptions, xmlErrorHandler } from './error-handler/xml-error-handler.js';
+
+declare const createNegotiatedErrorHandler: <Request extends IncomingMessage, Response extends ServerResponse>(errorHandlers: ErrorHandlers, showTrace: boolean, defaultHtmlHandler?: ErrorHandler) => (error: Error, request: Request, response: Response) => Promise<void>;
+
+export { ErrorHandler, ErrorHandlers, createNegotiatedErrorHandler };

package/dist/index.js

@@ -0,0 +1,8 @@
+export { default as jsonapiErrorHandler } from './error-handler/jsonapi-error-handler.js';
+export { default as problemErrorHandler } from './error-handler/problem-error-handler.js';
+export { htmlErrorHandler } from './error-handler/html-error-handler.js';
+export { default as createNegotiatedErrorHandler } from './packem_shared/createNegotiatedErrorHandler-Cd7yj67Z.js';
+export { textErrorHandler } from './error-handler/text-error-handler.js';
+export { jsonErrorHandler } from './error-handler/json-error-handler.js';
+export { jsonpErrorHandler } from './error-handler/jsonp-error-handler.js';
+export { xmlErrorHandler } from './error-handler/xml-error-handler.js';

package/dist/packem_shared/add-status-code-to-response-DdfxTQsK.js

@@ -0,0 +1,17 @@
+import { StatusCodes } from 'http-status-codes';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const addStatusCodeToResponse = /* @__PURE__ */ __name((response, error) => {
+  const err = error;
+  const candidate = Number(err.statusCode ?? err.status);
+  if (Number.isInteger(candidate) && candidate >= 400 && candidate <= 599) {
+    response.statusCode = candidate;
+    return;
+  }
+  if (response.statusCode < 400) {
+    response.statusCode = StatusCodes.INTERNAL_SERVER_ERROR;
+  }
+}, "addStatusCodeToResponse");
+
+export { addStatusCodeToResponse as a };

package/dist/packem_shared/createNegotiatedErrorHandler-Cd7yj67Z.js

@@ -0,0 +1,52 @@
+import jsonapiErrorHandler from '../error-handler/jsonapi-error-handler.js';
+import problemErrorHandler from '../error-handler/problem-error-handler.js';
+import { textErrorHandler } from '../error-handler/text-error-handler.js';
+import { jsonErrorHandler } from '../error-handler/json-error-handler.js';
+import { jsonpErrorHandler } from '../error-handler/jsonp-error-handler.js';
+import { xmlErrorHandler } from '../error-handler/xml-error-handler.js';
+import { Accepts } from '@tinyhttp/accepts';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const createNegotiatedErrorHandler = /* @__PURE__ */ __name((errorHandlers, showTrace, defaultHtmlHandler) => async (error, request, response) => {
+  const accept = new Accepts(request);
+  const chosenType = accept.type([
+    "text/html",
+    "application/vnd.api+json",
+    "application/problem+json",
+    "application/json",
+    "text/plain",
+    "application/javascript",
+    "text/javascript",
+    "application/xml",
+    "text/xml"
+  ]);
+  let errorHandler = defaultHtmlHandler || problemErrorHandler;
+  if (chosenType === "text/html" && defaultHtmlHandler) {
+    errorHandler = defaultHtmlHandler;
+  } else if (chosenType === "application/vnd.api+json") {
+    errorHandler = jsonapiErrorHandler;
+  } else if (chosenType === "application/problem+json") {
+    errorHandler = problemErrorHandler;
+  } else if (chosenType === "application/json") {
+    errorHandler = jsonErrorHandler();
+  } else if (chosenType === "text/plain") {
+    errorHandler = textErrorHandler();
+  } else if (chosenType === "application/javascript" || chosenType === "text/javascript") {
+    errorHandler = jsonpErrorHandler();
+  } else if (chosenType === "application/xml" || chosenType === "text/xml") {
+    errorHandler = xmlErrorHandler();
+  }
+  for (const { handler, regex } of errorHandlers) {
+    const headerVal = request.headers.accept ?? "";
+    const headerStr = Array.isArray(headerVal) ? headerVal.join(",") : headerVal;
+    if (regex.test(headerStr)) {
+      errorHandler = handler;
+      break;
+    }
+  }
+  error.expose = showTrace;
+  await errorHandler(error, request, response);
+}, "createNegotiatedErrorHandler");
+
+export { createNegotiatedErrorHandler as default };

package/dist/packem_shared/send-json-o-t1rNfw.js

@@ -0,0 +1,8 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const sendJson = /* @__PURE__ */ __name((response, jsonBody, contentType = "application/json; charset=utf-8") => {
+  response.setHeader("content-type", contentType);
+  response.end(JSON.stringify(jsonBody));
+}, "sendJson");
+
+export { sendJson as s };

package/dist/packem_shared/set-error-headers-B6ZeX5k4.js

@@ -0,0 +1,10 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const setErrorHeaders = /* @__PURE__ */ __name((response, error) => {
+  const headers = error.headers ?? {};
+  Object.keys(headers).forEach((header) => {
+    response.setHeader(header, headers[header]);
+  });
+}, "setErrorHeaders");
+
+export { setErrorHeaders as s };

package/dist/packem_shared/types.d-DLy8CCca.d.ts

@@ -0,0 +1,26 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+type ErrorHandler = <Request extends IncomingMessage, Response extends ServerResponse>(
+    error: Error,
+    request: Request,
+    response: Response,
+) => Promise<void> | void;
+
+type FetchErrorHandler = (
+    error: unknown,
+    request: Request,
+) => Promise<Response> | Response;
+
+type ErrorHandlers = {
+    handler: ErrorHandler;
+    regex: RegExp;
+}[];
+
+type FetchErrorHandlers = {
+    handler: FetchErrorHandler;
+    regex: RegExp;
+}[];
+
+type ApiFormat = "jsonapi" | "problem" | "html";
+
+export type { ApiFormat as A, ErrorHandlers as E, FetchErrorHandlers as F, ErrorHandler as a };

package/package.json

@@ -0,0 +1,151 @@
+{
+  "name": "@visulima/error-handler",
+  "version": "1.0.0",
+  "description": "Error handlers for use in development and production environments.",
+  "keywords": [
+    "visulima",
+    "error",
+    "exception",
+    "error-handlers",
+    "diagnostics",
+    "debugging",
+    "stacktrace",
+    "code-frame",
+    "codeframe",
+    "source-code-preview",
+    "content-negotiation",
+    "problem-json",
+    "rfc7807",
+    "jsonapi",
+    "json-api",
+    "jsonp",
+    "xml",
+    "html-error",
+    "cli",
+    "node",
+    "express",
+    "connect",
+    "middleware",
+    "http-errors",
+    "devtools",
+    "error-reporting",
+    "whoops",
+    "youch",
+    "anolilab",
+    "error-handler"
+  ],
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/prisis"
+    },
+    {
+      "type": "consulting",
+      "url": "https://anolilab.com/support"
+    }
+  ],
+  "homepage": "https://visulima.com/packages/error-handler",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./handler/cli": {
+      "types": "./dist/handler/cli-handler.d.ts",
+      "default": "./dist/handler/cli-handler.js"
+    },
+    "./handler/http/node": {
+      "types": "./dist/handler/http/node-handler.d.ts",
+      "default": "./dist/handler/http/node-handler.js"
+    },
+    "./handler/http/hono": {
+      "types": "./dist/handler/http/fetch-handler.d.ts",
+      "default": "./dist/handler/http/fetch-handler.js"
+    },
+    "./handler/http/bun": {
+      "types": "./dist/handler/http/fetch-handler.d.ts",
+      "default": "./dist/handler/http/fetch-handler.js"
+    },
+    "./handler/http/cloudflare": {
+      "types": "./dist/handler/http/fetch-handler.d.ts",
+      "default": "./dist/handler/http/fetch-handler.js"
+    },
+    "./handler/http/deno": {
+      "types": "./dist/handler/http/fetch-handler.d.ts",
+      "default": "./dist/handler/http/fetch-handler.js"
+    },
+    "./handler/http/edge": {
+      "types": "./dist/handler/http/fetch-handler.d.ts",
+      "default": "./dist/handler/http/fetch-handler.js"
+    },
+    "./handler/fetch": {
+      "types": "./dist/handler/http/fetch-handler.d.ts",
+      "default": "./dist/handler/http/fetch-handler.js"
+    },
+    "./error-handler/html": {
+      "types": "./dist/error-handler/html-error-handler.d.ts",
+      "default": "./dist/error-handler/html-error-handler.js"
+    },
+    "./error-handler/problem": {
+      "types": "./dist/error-handler/problem-error-handler.d.ts",
+      "default": "./dist/error-handler/problem-error-handler.js"
+    },
+    "./error-handler/jsonapi": {
+      "types": "./dist/error-handler/jsonapi-error-handler.d.ts",
+      "default": "./dist/error-handler/jsonapi-error-handler.js"
+    },
+    "./error-handler/text": {
+      "types": "./dist/error-handler/text-error-handler.d.ts",
+      "default": "./dist/error-handler/text-error-handler.js"
+    },
+    "./error-handler/json": {
+      "types": "./dist/error-handler/json-error-handler.d.ts",
+      "default": "./dist/error-handler/json-error-handler.js"
+    },
+    "./error-handler/jsonp": {
+      "types": "./dist/error-handler/jsonp-error-handler.d.ts",
+      "default": "./dist/error-handler/jsonp-error-handler.js"
+    },
+    "./error-handler/xml": {
+      "types": "./dist/error-handler/xml-error-handler.d.ts",
+      "default": "./dist/error-handler/xml-error-handler.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/visulima/visulima.git",
+    "directory": "packages/error-handler"
+  },
+  "bugs": {
+    "url": "https://github.com/visulima/visulima/issues"
+  },
+  "engines": {
+    "node": ">=20.19 <=24.*"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@tinyhttp/accepts": "^2.2.3",
+    "@visulima/boxen": "2.0.2",
+    "@visulima/error": "4.5.0",
+    "http-errors": "^2.0.0",
+    "http-status-codes": "^2.3.0",
+    "jstoxml": "^7.0.1",
+    "ts-japi": "^1.12.0"
+  }
+}