@piagent/platform 1.2.17 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/logger/index.js

@@ -0,0 +1,44 @@
+// src/middleware/logger/index.ts
+import { getColorEnabledAsync } from "../../utils/color.js";
+var humanize = (times) => {
+  const [delimiter, separator] = [",", "."];
+  const orderTimes = times.map((v) => v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1" + delimiter));
+  return orderTimes.join(separator);
+};
+var time = (start) => {
+  const delta = Date.now() - start;
+  return humanize([delta < 1e3 ? delta + "ms" : Math.round(delta / 1e3) + "s"]);
+};
+var colorStatus = async (status) => {
+  const colorEnabled = await getColorEnabledAsync();
+  if (colorEnabled) {
+    switch (status / 100 | 0) {
+      case 5:
+        return `\x1B[31m${status}\x1B[0m`;
+      case 4:
+        return `\x1B[33m${status}\x1B[0m`;
+      case 3:
+        return `\x1B[36m${status}\x1B[0m`;
+      case 2:
+        return `\x1B[32m${status}\x1B[0m`;
+    }
+  }
+  return `${status}`;
+};
+async function log(fn, prefix, method, path, status = 0, elapsed) {
+  const out = prefix === "<--" /* Incoming */ ? `${prefix} ${method} ${path}` : `${prefix} ${method} ${path} ${await colorStatus(status)} ${elapsed}`;
+  fn(out);
+}
+var logger = (fn = console.log) => {
+  return async function logger2(c, next) {
+    const { method, url } = c.req;
+    const path = url.slice(url.indexOf("/", 8));
+    await log(fn, "<--" /* Incoming */, method, path);
+    const start = Date.now();
+    await next();
+    await log(fn, "-->" /* Outgoing */, method, path, c.res.status, time(start));
+  };
+};
+export {
+  logger
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/method-not-allowed/index.js

@@ -0,0 +1,68 @@
+// src/middleware/method-not-allowed/index.ts
+import { basePath, matchedRoutes } from "../../helper/route/index.js";
+import { METHOD_NAME_ALL } from "../../router.js";
+import { TrieRouter } from "../../router/trie-router/index.js";
+var methodNotAllowed = (options) => {
+  let methodRouter;
+  return async function methodNotAllowed2(c, next) {
+    const routeIndex = c.req.routeIndex;
+    await next();
+    if (c.res.status !== 404) {
+      return;
+    }
+    if (c.error) {
+      return;
+    }
+    if (!methodRouter) {
+      const methodsByPath = /* @__PURE__ */ new Map();
+      for (const route of options.app.routes) {
+        if (route.method === METHOD_NAME_ALL || route.method === "HEAD") {
+          continue;
+        }
+        const methods2 = methodsByPath.get(route.path) ?? /* @__PURE__ */ new Set();
+        methods2.add(route.method);
+        if (route.method === "GET") {
+          methods2.add("HEAD");
+        }
+        methodsByPath.set(route.path, methods2);
+      }
+      methodRouter = new TrieRouter();
+      for (const [path, methods2] of methodsByPath) {
+        methodRouter.add(METHOD_NAME_ALL, path, [...methods2]);
+      }
+    }
+    let requestPath = c.req.path;
+    const routes = matchedRoutes(c);
+    const currentRoute = routes[routeIndex];
+    const sourceRoute = options.app.routes.find((route) => route.handler === methodNotAllowed2);
+    if (currentRoute && sourceRoute) {
+      const currentBasePathParts = basePath(c, routeIndex).split("/").filter(Boolean);
+      const sourceBasePathLength = sourceRoute.basePath.split("/").filter(Boolean).length;
+      const mountBasePathParts = currentBasePathParts.slice(
+        0,
+        currentBasePathParts.length - sourceBasePathLength
+      );
+      if (mountBasePathParts.length > 0) {
+        const mountBasePath = `/${mountBasePathParts.join("/")}`;
+        requestPath = c.req.path.slice(mountBasePath.length) || "/";
+      }
+    }
+    const allowedMethods = /* @__PURE__ */ new Set();
+    for (const [methods2] of methodRouter.match(METHOD_NAME_ALL, requestPath)[0]) {
+      for (const method of methods2) {
+        allowedMethods.add(method);
+      }
+    }
+    if (allowedMethods.size === 0 || allowedMethods.has(c.req.method)) {
+      return;
+    }
+    c.res.headers.delete("Allow");
+    c.res.headers.delete("Content-Length");
+    const methods = [...allowedMethods];
+    const allow = methods.join(", ");
+    c.res = options.onMethodNotAllowed ? await options.onMethodNotAllowed(c, methods) : c.text("Method Not Allowed", 405, { Allow: allow });
+  };
+};
+export {
+  methodNotAllowed
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/method-override/index.js

@@ -0,0 +1,84 @@
+// src/middleware/method-override/index.ts
+import { parseBody } from "../../utils/body.js";
+var DEFAULT_METHOD_FORM_NAME = "_method";
+var methodOverride = (options) => async function methodOverride2(c, next) {
+  if (c.req.method === "GET") {
+    return await next();
+  }
+  const app = options.app;
+  if (!(options.header || options.query)) {
+    const contentType = c.req.header("content-type");
+    const methodFormName = options.form || DEFAULT_METHOD_FORM_NAME;
+    const clonedRequest = c.req.raw.clone();
+    const newRequest = clonedRequest.clone();
+    if (contentType?.startsWith("multipart/form-data")) {
+      const form = await clonedRequest.formData();
+      const method = form.get(methodFormName);
+      if (method) {
+        const newForm = await newRequest.formData();
+        newForm.delete(methodFormName);
+        const newHeaders = new Headers(clonedRequest.headers);
+        newHeaders.delete("content-type");
+        newHeaders.delete("content-length");
+        const request = new Request(c.req.url, {
+          body: newForm,
+          headers: newHeaders,
+          method
+        });
+        return app.fetch(request, c.env, getExecutionCtx(c));
+      }
+    }
+    if (contentType?.startsWith("application/x-www-form-urlencoded")) {
+      const params = await parseBody(clonedRequest);
+      const method = params[methodFormName];
+      if (method) {
+        delete params[methodFormName];
+        const newParams = new URLSearchParams(params);
+        const request = new Request(newRequest, {
+          body: newParams,
+          method
+        });
+        return app.fetch(request, c.env, getExecutionCtx(c));
+      }
+    }
+  } else if (options.header) {
+    const headerName = options.header;
+    const method = c.req.header(headerName);
+    if (method) {
+      const newHeaders = new Headers(c.req.raw.headers);
+      newHeaders.delete(headerName);
+      const request = new Request(c.req.raw, {
+        headers: newHeaders,
+        method
+      });
+      return app.fetch(request, c.env, getExecutionCtx(c));
+    }
+  } else if (options.query) {
+    const queryName = options.query;
+    const method = c.req.query(queryName);
+    if (method) {
+      const url = new URL(c.req.url);
+      url.searchParams.delete(queryName);
+      const requestInit = {
+        body: c.req.raw.body,
+        headers: c.req.raw.headers,
+        method,
+        duplex: c.req.raw.body ? "half" : void 0
+      };
+      const request = new Request(url.toString(), requestInit);
+      return app.fetch(request, c.env, getExecutionCtx(c));
+    }
+  }
+  await next();
+};
+var getExecutionCtx = (c) => {
+  let executionCtx;
+  try {
+    executionCtx = c.executionCtx;
+  } catch {
+  }
+  return executionCtx;
+};
+export {
+  methodOverride
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/powered-by/index.js

@@ -0,0 +1,10 @@
+// src/middleware/powered-by/index.ts
+var poweredBy = (options) => {
+  return async function poweredBy2(c, next) {
+    await next();
+    c.res.headers.set("X-Powered-By", options?.serverName ?? "Hono");
+  };
+};
+export {
+  poweredBy
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/pretty-json/index.js

@@ -0,0 +1,15 @@
+// src/middleware/pretty-json/index.ts
+var prettyJSON = (options) => {
+  const targetQuery = options?.query ?? "pretty";
+  return async function prettyJSON2(c, next) {
+    const pretty = options?.force || c.req.query(targetQuery) || c.req.query(targetQuery) === "";
+    await next();
+    if (pretty && c.res.headers.get("Content-Type")?.startsWith("application/json")) {
+      const obj = await c.res.json();
+      c.res = new Response(JSON.stringify(obj, null, options?.space ?? 2), c.res);
+    }
+  };
+};
+export {
+  prettyJSON
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/request-id/index.js

@@ -0,0 +1,5 @@
+// src/middleware/request-id/index.ts
+import { requestId } from "./request-id.js";
+export {
+  requestId
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/request-id/request-id.js

@@ -0,0 +1,21 @@
+// src/middleware/request-id/request-id.ts
+var requestId = ({
+  limitLength = 255,
+  headerName = "X-Request-Id",
+  generator = () => crypto.randomUUID()
+} = {}) => {
+  return async function requestId2(c, next) {
+    let reqId = headerName ? c.req.header(headerName) : void 0;
+    if (!reqId || reqId.length > limitLength || /[^\w\-=]/.test(reqId)) {
+      reqId = generator(c);
+    }
+    c.set("requestId", reqId);
+    if (headerName) {
+      c.header(headerName, reqId);
+    }
+    await next();
+  };
+};
+export {
+  requestId
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/secure-headers/index.js

@@ -0,0 +1,6 @@
+// src/middleware/secure-headers/index.ts
+import { NONCE, secureHeaders } from "./secure-headers.js";
+export {
+  NONCE,
+  secureHeaders
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/secure-headers/secure-headers.js

@@ -0,0 +1,172 @@
+// src/middleware/secure-headers/secure-headers.ts
+import { encodeBase64 } from "../../utils/encode.js";
+var HEADERS_MAP = {
+  crossOriginEmbedderPolicy: ["Cross-Origin-Embedder-Policy", "require-corp"],
+  crossOriginResourcePolicy: ["Cross-Origin-Resource-Policy", "same-origin"],
+  crossOriginOpenerPolicy: ["Cross-Origin-Opener-Policy", "same-origin"],
+  originAgentCluster: ["Origin-Agent-Cluster", "?1"],
+  referrerPolicy: ["Referrer-Policy", "no-referrer"],
+  strictTransportSecurity: ["Strict-Transport-Security", "max-age=15552000; includeSubDomains"],
+  xContentTypeOptions: ["X-Content-Type-Options", "nosniff"],
+  xDnsPrefetchControl: ["X-DNS-Prefetch-Control", "off"],
+  xDownloadOptions: ["X-Download-Options", "noopen"],
+  xFrameOptions: ["X-Frame-Options", "SAMEORIGIN"],
+  xPermittedCrossDomainPolicies: ["X-Permitted-Cross-Domain-Policies", "none"],
+  xXssProtection: ["X-XSS-Protection", "0"]
+};
+var DEFAULT_OPTIONS = {
+  crossOriginEmbedderPolicy: false,
+  crossOriginResourcePolicy: true,
+  crossOriginOpenerPolicy: true,
+  originAgentCluster: true,
+  referrerPolicy: true,
+  strictTransportSecurity: true,
+  xContentTypeOptions: true,
+  xDnsPrefetchControl: true,
+  xDownloadOptions: true,
+  xFrameOptions: true,
+  xPermittedCrossDomainPolicies: true,
+  xXssProtection: true,
+  removePoweredBy: true,
+  permissionsPolicy: {}
+};
+var generateNonce = () => {
+  const arrayBuffer = new Uint8Array(16);
+  crypto.getRandomValues(arrayBuffer);
+  return encodeBase64(arrayBuffer.buffer);
+};
+var NONCE = (ctx) => {
+  const key = "secureHeadersNonce";
+  const init = ctx.get(key);
+  const nonce = init || generateNonce();
+  if (init == null) {
+    ctx.set(key, nonce);
+  }
+  return `'nonce-${nonce}'`;
+};
+var secureHeaders = (customOptions) => {
+  const options = { ...DEFAULT_OPTIONS, ...customOptions };
+  const headersToSet = getFilteredHeaders(options);
+  const callbacks = [];
+  if (options.contentSecurityPolicy) {
+    const [callback, value] = getCSPDirectives(
+      options.contentSecurityPolicy,
+      "Content-Security-Policy"
+    );
+    if (callback) {
+      callbacks.push(callback);
+    }
+    headersToSet.push(["Content-Security-Policy", value]);
+  }
+  if (options.contentSecurityPolicyReportOnly) {
+    const [callback, value] = getCSPDirectives(
+      options.contentSecurityPolicyReportOnly,
+      "Content-Security-Policy-Report-Only"
+    );
+    if (callback) {
+      callbacks.push(callback);
+    }
+    headersToSet.push(["Content-Security-Policy-Report-Only", value]);
+  }
+  if (options.permissionsPolicy && Object.keys(options.permissionsPolicy).length > 0) {
+    headersToSet.push([
+      "Permissions-Policy",
+      getPermissionsPolicyDirectives(options.permissionsPolicy)
+    ]);
+  }
+  if (options.reportingEndpoints) {
+    headersToSet.push(["Reporting-Endpoints", getReportingEndpoints(options.reportingEndpoints)]);
+  }
+  if (options.reportTo) {
+    headersToSet.push(["Report-To", getReportToOptions(options.reportTo)]);
+  }
+  return async function secureHeaders2(ctx, next) {
+    const headersToSetForReq = callbacks.length === 0 ? headersToSet : callbacks.reduce((acc, cb) => cb(ctx, acc), headersToSet);
+    await next();
+    setHeaders(ctx, headersToSetForReq);
+    if (options?.removePoweredBy) {
+      ctx.res.headers.delete("X-Powered-By");
+    }
+  };
+};
+function getFilteredHeaders(options) {
+  return Object.entries(HEADERS_MAP).filter(([key]) => options[key]).map(([key, defaultValue]) => {
+    const overrideValue = options[key];
+    return typeof overrideValue === "string" ? [defaultValue[0], overrideValue] : defaultValue;
+  });
+}
+function getCSPDirectives(contentSecurityPolicy, headerName) {
+  const callbacks = [];
+  const resultValues = [];
+  for (const [directive, value] of Object.entries(contentSecurityPolicy)) {
+    const valueArray = Array.isArray(value) ? value : [value];
+    valueArray.forEach((value2, i) => {
+      if (typeof value2 === "function") {
+        const index = i * 2 + 2 + resultValues.length;
+        callbacks.push((ctx, values) => {
+          values[index] = value2(ctx, directive);
+        });
+      }
+    });
+    resultValues.push(
+      directive.replace(
+        /[A-Z]+(?![a-z])|[A-Z]/g,
+        (match, offset) => offset ? "-" + match.toLowerCase() : match.toLowerCase()
+      ),
+      ...valueArray.flatMap((value2) => [" ", value2]),
+      "; "
+    );
+  }
+  resultValues.pop();
+  return callbacks.length === 0 ? [void 0, resultValues.join("")] : [
+    (ctx, headersToSet) => headersToSet.map((values) => {
+      if (values[0] === headerName) {
+        const clone = values[1].slice();
+        callbacks.forEach((cb) => {
+          cb(ctx, clone);
+        });
+        return [values[0], clone.join("")];
+      } else {
+        return values;
+      }
+    }),
+    resultValues
+  ];
+}
+function getPermissionsPolicyDirectives(policy) {
+  return Object.entries(policy).map(([directive, value]) => {
+    const kebabDirective = camelToKebab(directive);
+    if (typeof value === "boolean") {
+      return `${kebabDirective}=${value ? "*" : "none"}`;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return `${kebabDirective}=()`;
+      }
+      if (value.length === 1 && (value[0] === "*" || value[0] === "none")) {
+        return `${kebabDirective}=${value[0]}`;
+      }
+      const allowlist = value.map((item) => ["self", "src"].includes(item) ? item : `"${item}"`);
+      return `${kebabDirective}=(${allowlist.join(" ")})`;
+    }
+    return "";
+  }).filter(Boolean).join(", ");
+}
+function camelToKebab(str) {
+  return str.replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function getReportingEndpoints(reportingEndpoints = []) {
+  return reportingEndpoints.map((endpoint) => `${endpoint.name}="${endpoint.url}"`).join(", ");
+}
+function getReportToOptions(reportTo = []) {
+  return reportTo.map((option) => JSON.stringify(option)).join(", ");
+}
+function setHeaders(ctx, headersToSet) {
+  headersToSet.forEach(([header, value]) => {
+    ctx.res.headers.set(header, value);
+  });
+}
+export {
+  NONCE,
+  secureHeaders
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/serve-static/index.js

@@ -0,0 +1,77 @@
+// src/middleware/serve-static/index.ts
+import { COMPRESSIBLE_CONTENT_TYPE_REGEX } from "../../utils/compress.js";
+import { getMimeType } from "../../utils/mime.js";
+import { tryDecodeURI } from "../../utils/url.js";
+import { defaultJoin } from "./path.js";
+var ENCODINGS = {
+  br: ".br",
+  zstd: ".zst",
+  gzip: ".gz"
+};
+var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
+var DEFAULT_DOCUMENT = "index.html";
+var serveStatic = (options) => {
+  const root = options.root ?? "./";
+  const optionPath = options.path;
+  const join = options.join ?? defaultJoin;
+  return async (c, next) => {
+    if (c.finalized) {
+      return next();
+    }
+    let filename;
+    if (options.path) {
+      filename = options.path;
+    } else {
+      try {
+        filename = tryDecodeURI(c.req.path);
+        if (/(?:^|[\/\\])\.{1,2}(?:$|[\/\\])|[\/\\]{2,}|\\/.test(filename)) {
+          throw new Error();
+        }
+      } catch {
+        await options.onNotFound?.(c.req.path, c);
+        return next();
+      }
+    }
+    let path = join(
+      root,
+      !optionPath && options.rewriteRequestPath ? options.rewriteRequestPath(filename) : filename
+    );
+    if (options.isDir && await options.isDir(path)) {
+      path = join(path, DEFAULT_DOCUMENT);
+    }
+    const getContent = options.getContent;
+    let content = await getContent(path, c);
+    if (content instanceof Response) {
+      return c.newResponse(content.body, content);
+    }
+    if (content != null) {
+      const mimeType = options.mimes && getMimeType(path, options.mimes) || getMimeType(path);
+      c.header("Content-Type", mimeType || "application/octet-stream");
+      if (options.precompressed && (!mimeType || COMPRESSIBLE_CONTENT_TYPE_REGEX.test(mimeType))) {
+        const acceptEncodingSet = new Set(
+          c.req.header("Accept-Encoding")?.split(",").map((encoding) => encoding.trim())
+        );
+        for (const encoding of ENCODINGS_ORDERED_KEYS) {
+          if (!acceptEncodingSet.has(encoding)) {
+            continue;
+          }
+          const compressedContent = await getContent(path + ENCODINGS[encoding], c);
+          if (compressedContent) {
+            content = compressedContent;
+            c.header("Content-Encoding", encoding);
+            c.header("Vary", "Accept-Encoding", { append: true });
+            break;
+          }
+        }
+      }
+      await options.onFound?.(path, c);
+      return c.body(content);
+    }
+    await options.onNotFound?.(path, c);
+    await next();
+    return;
+  };
+};
+export {
+  serveStatic
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/serve-static/path.js

@@ -0,0 +1,18 @@
+// src/middleware/serve-static/path.ts
+var defaultJoin = (...paths) => {
+  let result = paths.filter((p) => p !== "").join("/");
+  result = result.replace(/(?<=\/)\/+/g, "");
+  const segments = result.split("/");
+  const resolved = [];
+  for (const segment of segments) {
+    if (segment === ".." && resolved.length > 0 && resolved.at(-1) !== "..") {
+      resolved.pop();
+    } else if (segment !== ".") {
+      resolved.push(segment);
+    }
+  }
+  return resolved.join("/") || ".";
+};
+export {
+  defaultJoin
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/timeout/index.js

@@ -0,0 +1,25 @@
+// src/middleware/timeout/index.ts
+import { HTTPException } from "../../http-exception.js";
+var defaultTimeoutException = new HTTPException(504, {
+  message: "Gateway Timeout"
+});
+var timeout = (duration, exception = defaultTimeoutException) => {
+  return async function timeout2(context, next) {
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(typeof exception === "function" ? exception(context) : exception);
+      }, duration);
+    });
+    try {
+      await Promise.race([next(), timeoutPromise]);
+    } finally {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    }
+  };
+};
+export {
+  timeout
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/timing/index.js

@@ -0,0 +1,9 @@
+// src/middleware/timing/index.ts
+import { timing, setMetric, startTime, endTime, wrapTime } from "./timing.js";
+export {
+  endTime,
+  setMetric,
+  startTime,
+  timing,
+  wrapTime
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/middleware/timing/timing.js

@@ -0,0 +1,104 @@
+// src/middleware/timing/timing.ts
+import "../../context.js";
+var getTime = () => {
+  try {
+    return performance.now();
+  } catch {
+  }
+  return Date.now();
+};
+var timing = (config) => {
+  const options = {
+    total: true,
+    enabled: true,
+    totalDescription: "Total Response Time",
+    autoEnd: true,
+    crossOrigin: false,
+    ...config
+  };
+  return async function timing2(c, next) {
+    const headers = [];
+    const timers = /* @__PURE__ */ new Map();
+    if (c.get("metric")) {
+      return await next();
+    }
+    c.set("metric", { headers, timers });
+    if (options.total) {
+      startTime(c, "total", options.totalDescription);
+    }
+    await next();
+    if (options.total) {
+      endTime(c, "total");
+    }
+    if (options.autoEnd) {
+      timers.forEach((_, key) => {
+        endTime(c, key);
+      });
+    }
+    const enabled = typeof options.enabled === "function" ? options.enabled(c) : options.enabled;
+    if (enabled) {
+      c.res.headers.append("Server-Timing", headers.join(","));
+      const crossOrigin = typeof options.crossOrigin === "function" ? options.crossOrigin(c) : options.crossOrigin;
+      if (crossOrigin) {
+        c.res.headers.append(
+          "Timing-Allow-Origin",
+          typeof crossOrigin === "string" ? crossOrigin : "*"
+        );
+      }
+    }
+  };
+};
+var setMetric = (c, name, valueDescription, description, precision) => {
+  const metrics = c.get("metric");
+  if (!metrics) {
+    console.warn("Metrics not initialized! Please add the `timing()` middleware to this route!");
+    return;
+  }
+  if (typeof valueDescription === "number") {
+    const dur = valueDescription.toFixed(precision || 1);
+    const metric = description ? `${name};dur=${dur};desc="${description}"` : `${name};dur=${dur}`;
+    metrics.headers.push(metric);
+  } else {
+    const metric = valueDescription ? `${name};desc="${valueDescription}"` : `${name}`;
+    metrics.headers.push(metric);
+  }
+};
+var startTime = (c, name, description) => {
+  const metrics = c.get("metric");
+  if (!metrics) {
+    console.warn("Metrics not initialized! Please add the `timing()` middleware to this route!");
+    return;
+  }
+  metrics.timers.set(name, { description, start: getTime() });
+};
+var endTime = (c, name, precision) => {
+  const metrics = c.get("metric");
+  if (!metrics) {
+    console.warn("Metrics not initialized! Please add the `timing()` middleware to this route!");
+    return;
+  }
+  const timer = metrics.timers.get(name);
+  if (!timer) {
+    console.warn(`Timer "${name}" does not exist!`);
+    return;
+  }
+  const { description, start } = timer;
+  const duration = getTime() - start;
+  setMetric(c, name, duration, description, precision);
+  metrics.timers.delete(name);
+};
+async function wrapTime(c, name, callable, description, precision) {
+  startTime(c, name, description);
+  try {
+    return await callable;
+  } finally {
+    endTime(c, name, precision);
+  }
+}
+export {
+  endTime,
+  setMetric,
+  startTime,
+  timing,
+  wrapTime
+};