@piagent/platform 1.2.16 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/helper/cookie/index.js

@@ -0,0 +1,102 @@
+// src/helper/cookie/index.ts
+import { parse, parseSigned, serialize, serializeSigned } from "../../utils/cookie.js";
+var getCookie = (c, key, prefix) => {
+  const cookie = c.req.raw.headers.get("Cookie");
+  if (typeof key === "string") {
+    if (!cookie) {
+      return void 0;
+    }
+    let finalKey = key;
+    if (prefix === "secure") {
+      finalKey = "__Secure-" + key;
+    } else if (prefix === "host") {
+      finalKey = "__Host-" + key;
+    }
+    const obj2 = parse(cookie, finalKey);
+    return obj2[finalKey];
+  }
+  if (!cookie) {
+    return {};
+  }
+  const obj = parse(cookie);
+  return obj;
+};
+var getSignedCookie = async (c, secret, key, prefix) => {
+  const cookie = c.req.raw.headers.get("Cookie");
+  if (typeof key === "string") {
+    if (!cookie) {
+      return void 0;
+    }
+    let finalKey = key;
+    if (prefix === "secure") {
+      finalKey = "__Secure-" + key;
+    } else if (prefix === "host") {
+      finalKey = "__Host-" + key;
+    }
+    const obj2 = await parseSigned(cookie, secret, finalKey);
+    return obj2[finalKey];
+  }
+  if (!cookie) {
+    return {};
+  }
+  const obj = await parseSigned(cookie, secret);
+  return obj;
+};
+var generateCookie = (name, value, opt) => {
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = serialize("__Secure-" + name, value, { path: "/", ...opt, secure: true });
+  } else if (opt?.prefix === "host") {
+    cookie = serialize("__Host-" + name, value, {
+      ...opt,
+      path: "/",
+      secure: true,
+      domain: void 0
+    });
+  } else {
+    cookie = serialize(name, value, { path: "/", ...opt });
+  }
+  return cookie;
+};
+var setCookie = (c, name, value, opt) => {
+  const cookie = generateCookie(name, value, opt);
+  c.header("Set-Cookie", cookie, { append: true });
+};
+var generateSignedCookie = async (name, value, secret, opt) => {
+  let cookie;
+  if (opt?.prefix === "secure") {
+    cookie = await serializeSigned("__Secure-" + name, value, secret, {
+      path: "/",
+      ...opt,
+      secure: true
+    });
+  } else if (opt?.prefix === "host") {
+    cookie = await serializeSigned("__Host-" + name, value, secret, {
+      ...opt,
+      path: "/",
+      secure: true,
+      domain: void 0
+    });
+  } else {
+    cookie = await serializeSigned(name, value, secret, { path: "/", ...opt });
+  }
+  return cookie;
+};
+var setSignedCookie = async (c, name, value, secret, opt) => {
+  const cookie = await generateSignedCookie(name, value, secret, opt);
+  c.header("set-cookie", cookie, { append: true });
+};
+var deleteCookie = (c, name, opt) => {
+  const deletedCookie = getCookie(c, name, opt?.prefix);
+  setCookie(c, name, "", { ...opt, maxAge: 0 });
+  return deletedCookie;
+};
+export {
+  deleteCookie,
+  generateCookie,
+  generateSignedCookie,
+  getCookie,
+  getSignedCookie,
+  setCookie,
+  setSignedCookie
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/helper/css/common.js

@@ -0,0 +1,236 @@
+// src/helper/css/common.ts
+var PSEUDO_GLOBAL_SELECTOR = ":-hono-global";
+var isPseudoGlobalSelectorRe = new RegExp(`^${PSEUDO_GLOBAL_SELECTOR}{(.*)}$`);
+var DEFAULT_STYLE_ID = "hono-css";
+var SELECTOR = /* @__PURE__ */ Symbol();
+var CLASS_NAME = /* @__PURE__ */ Symbol();
+var STYLE_STRING = /* @__PURE__ */ Symbol();
+var SELECTORS = /* @__PURE__ */ Symbol();
+var EXTERNAL_CLASS_NAMES = /* @__PURE__ */ Symbol();
+var CSS_ESCAPED = /* @__PURE__ */ Symbol();
+var IS_CSS_ESCAPED = /* @__PURE__ */ Symbol();
+var rawCssString = (value) => {
+  return {
+    [CSS_ESCAPED]: value
+  };
+};
+var toHash = (str) => {
+  let i = 0, out = 11;
+  while (i < str.length) {
+    out = 101 * out + str.charCodeAt(i++) >>> 0;
+  }
+  return "css-" + out;
+};
+var normalizeLabel = (label) => {
+  return label.trim().replace(/\s+/g, "-");
+};
+var isValidClassName = (name) => /^-?[_a-zA-Z][_a-zA-Z0-9-]*$/.test(name);
+var hasUnsafeSelectorChar = (name) => /[<{}]/.test(name);
+var RESERVED_KEYFRAME_NAMES = /* @__PURE__ */ new Set([
+  "default",
+  "inherit",
+  "initial",
+  "none",
+  "revert",
+  "revert-layer",
+  "unset"
+]);
+var isValidKeyframeName = (name) => isValidClassName(name) && !RESERVED_KEYFRAME_NAMES.has(name.toLowerCase());
+var defaultOnInvalidSlug = (slug) => {
+  console.warn(`Invalid slug: ${slug}`);
+};
+var cssStringReStr = [
+  '"(?:(?:\\\\[\\s\\S]|[^"\\\\])*)"',
+  // double quoted string
+  "'(?:(?:\\\\[\\s\\S]|[^'\\\\])*)'"
+  // single quoted string
+].join("|");
+var minifyCssRe = new RegExp(
+  [
+    "(" + cssStringReStr + ")",
+    // $1: quoted string
+    "(?:" + [
+      "^\\s+",
+      // head whitespace
+      "\\/\\*.*?\\*\\/\\s*",
+      // multi-line comment
+      "\\/\\/.*\\n\\s*",
+      // single-line comment
+      "\\s+$"
+      // tail whitespace
+    ].join("|") + ")",
+    "\\s*;\\s*(}|$)\\s*",
+    // $2: trailing semicolon
+    "\\s*([{};:,])\\s*",
+    // $3: whitespace around { } : , ;
+    "(\\s)\\s+"
+    // $4: 2+ spaces
+  ].join("|"),
+  "g"
+);
+var minify = (css) => {
+  return css.replace(minifyCssRe, (_, $1, $2, $3, $4) => $1 || $2 || $3 || $4 || "");
+};
+var buildStyleString = (strings, values) => {
+  const selectors = [];
+  const externalClassNames = [];
+  const label = strings[0].match(/^\s*\/\*(.*?)\*\//)?.[1] || "";
+  let styleString = "";
+  for (let i = 0, len = strings.length; i < len; i++) {
+    styleString += strings[i];
+    let vArray = values[i];
+    if (typeof vArray === "boolean" || vArray === null || vArray === void 0) {
+      continue;
+    }
+    if (!Array.isArray(vArray)) {
+      vArray = [vArray];
+    }
+    for (let j = 0, len2 = vArray.length; j < len2; j++) {
+      let value = vArray[j];
+      if (typeof value === "boolean" || value === null || value === void 0) {
+        continue;
+      }
+      if (typeof value === "string") {
+        if (/([\\"'\/])/.test(value)) {
+          styleString += value.replace(/([\\"']|(?<=<)\/)/g, "\\$1");
+        } else {
+          styleString += value;
+        }
+      } else if (typeof value === "number") {
+        styleString += value;
+      } else if (value[CSS_ESCAPED]) {
+        styleString += value[CSS_ESCAPED];
+      } else if (value[CLASS_NAME].startsWith("@keyframes ")) {
+        selectors.push(value);
+        styleString += ` ${value[CLASS_NAME].substring(11)} `;
+      } else {
+        if (strings[i + 1]?.match(/^\s*{/)) {
+          selectors.push(value);
+          value = `.${value[CLASS_NAME]}`;
+        } else {
+          selectors.push(...value[SELECTORS]);
+          externalClassNames.push(...value[EXTERNAL_CLASS_NAMES]);
+          value = value[STYLE_STRING];
+          const valueLen = value.length;
+          if (valueLen > 0) {
+            const lastChar = value[valueLen - 1];
+            if (lastChar !== ";" && lastChar !== "}") {
+              value += ";";
+            }
+          }
+        }
+        styleString += `${value || ""}`;
+      }
+    }
+  }
+  return [label, minify(styleString), selectors, externalClassNames];
+};
+var cssCommon = (strings, values, classNameSlug, onInvalidSlug) => {
+  let [label, thisStyleString, selectors, externalClassNames] = buildStyleString(strings, values);
+  const isPseudoGlobal = isPseudoGlobalSelectorRe.exec(thisStyleString);
+  if (isPseudoGlobal) {
+    thisStyleString = isPseudoGlobal[1];
+  }
+  const hash = toHash(label + thisStyleString);
+  let customSlug;
+  if (classNameSlug) {
+    const slug = classNameSlug(hash, normalizeLabel(label), thisStyleString);
+    if (slug) {
+      if (isValidClassName(slug)) {
+        customSlug = slug;
+      } else {
+        ;
+        (onInvalidSlug || defaultOnInvalidSlug)(slug);
+      }
+    }
+  }
+  const selector = (isPseudoGlobal ? PSEUDO_GLOBAL_SELECTOR : "") + (customSlug || hash);
+  const className = (isPseudoGlobal ? selectors.map((s) => s[CLASS_NAME]) : [selector, ...externalClassNames]).join(" ");
+  return {
+    [SELECTOR]: selector,
+    [CLASS_NAME]: className,
+    [STYLE_STRING]: thisStyleString,
+    [SELECTORS]: selectors,
+    [EXTERNAL_CLASS_NAMES]: externalClassNames
+  };
+};
+var cxCommon = (args) => {
+  for (let i = 0, len = args.length; i < len; i++) {
+    const arg = args[i];
+    if (typeof arg === "string") {
+      args[i] = {
+        [SELECTOR]: "",
+        [CLASS_NAME]: "",
+        [STYLE_STRING]: "",
+        [SELECTORS]: [],
+        // drop names that are unsafe to emit as a selector
+        [EXTERNAL_CLASS_NAMES]: hasUnsafeSelectorChar(arg) ? [] : [arg]
+      };
+    }
+  }
+  return args;
+};
+var keyframesCommon = (strings, values, classNameSlug, onInvalidSlug) => {
+  const [label, styleString] = buildStyleString(strings, values);
+  const hash = toHash(label + styleString);
+  let customSlug;
+  if (classNameSlug) {
+    const slug = classNameSlug(hash, normalizeLabel(label), styleString);
+    if (slug) {
+      if (isValidKeyframeName(slug)) {
+        customSlug = slug;
+      } else {
+        ;
+        (onInvalidSlug || defaultOnInvalidSlug)(slug);
+      }
+    }
+  }
+  return {
+    [SELECTOR]: "",
+    [CLASS_NAME]: `@keyframes ${customSlug || hash}`,
+    [STYLE_STRING]: styleString,
+    [SELECTORS]: [],
+    [EXTERNAL_CLASS_NAMES]: []
+  };
+};
+var viewTransitionNameIndex = 0;
+var viewTransitionCommon = ((strings, values, classNameSlug, onInvalidSlug) => {
+  if (!strings) {
+    strings = [`/* h-v-t ${viewTransitionNameIndex++} */`];
+  }
+  const content = Array.isArray(strings) ? cssCommon(strings, values, classNameSlug, onInvalidSlug) : strings;
+  const transitionName = content[CLASS_NAME];
+  const res = cssCommon(
+    ["view-transition-name:", ""],
+    // eslint-disable-line @typescript-eslint/no-explicit-any
+    [transitionName],
+    classNameSlug,
+    onInvalidSlug
+  );
+  content[CLASS_NAME] = PSEUDO_GLOBAL_SELECTOR + content[CLASS_NAME];
+  content[STYLE_STRING] = content[STYLE_STRING].replace(
+    /(?<=::view-transition(?:[a-z-]*)\()(?=\))/g,
+    transitionName
+  );
+  res[CLASS_NAME] = res[SELECTOR] = transitionName;
+  res[SELECTORS] = [...content[SELECTORS], content];
+  return res;
+});
+export {
+  CLASS_NAME,
+  DEFAULT_STYLE_ID,
+  EXTERNAL_CLASS_NAMES,
+  IS_CSS_ESCAPED,
+  PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR,
+  SELECTORS,
+  STYLE_STRING,
+  buildStyleString,
+  cssCommon,
+  cxCommon,
+  isPseudoGlobalSelectorRe,
+  keyframesCommon,
+  minify,
+  rawCssString,
+  viewTransitionCommon
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/helper/css/index.js

@@ -0,0 +1,140 @@
+// src/helper/css/index.ts
+import { raw } from "../../helper/html/index.js";
+import { DOM_RENDERER } from "../../jsx/constants.js";
+import { createCssJsxDomObjects } from "../../jsx/dom/css.js";
+import { escapeToBuffer } from "../../utils/html.js";
+import {
+  CLASS_NAME,
+  DEFAULT_STYLE_ID,
+  PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR,
+  SELECTORS,
+  STYLE_STRING,
+  cssCommon,
+  cxCommon,
+  keyframesCommon,
+  viewTransitionCommon
+} from "./common.js";
+import { rawCssString } from "./common.js";
+var createCssContext = ({
+  id,
+  classNameSlug,
+  onInvalidSlug
+}) => {
+  const [cssJsxDomObject, StyleRenderToDom] = createCssJsxDomObjects({ id });
+  const contextMap = /* @__PURE__ */ new WeakMap();
+  const nonceMap = /* @__PURE__ */ new WeakMap();
+  const replaceStyleRe = new RegExp(`(<style id="${id}"(?: nonce="[^"]*")?>.*?)(</style>)`);
+  const newCssClassNameObject = (cssClassName) => {
+    const appendStyle = ({ buffer, context }) => {
+      const [toAdd, added] = contextMap.get(context);
+      const names = Object.keys(toAdd);
+      if (!names.length) {
+        return;
+      }
+      let stylesStr = "";
+      names.forEach((className2) => {
+        added[className2] = true;
+        stylesStr += className2.startsWith(PSEUDO_GLOBAL_SELECTOR) ? toAdd[className2] : `${className2[0] === "@" ? "" : "."}${className2}{${toAdd[className2]}}`;
+      });
+      contextMap.set(context, [{}, added]);
+      if (buffer && replaceStyleRe.test(buffer[0])) {
+        buffer[0] = buffer[0].replace(replaceStyleRe, (_, pre, post) => `${pre}${stylesStr}${post}`);
+        return;
+      }
+      const nonce = nonceMap.get(context);
+      const appendStyleScript = `<script${nonce ? ` nonce="${nonce}"` : ""}>document.querySelector('#${id}').textContent+=${JSON.stringify(stylesStr)}</script>`;
+      if (buffer) {
+        buffer[0] = `${appendStyleScript}${buffer[0]}`;
+        return;
+      }
+      return Promise.resolve(appendStyleScript);
+    };
+    const addClassNameToContext = ({ context }) => {
+      if (!contextMap.has(context)) {
+        contextMap.set(context, [{}, {}]);
+      }
+      const [toAdd, added] = contextMap.get(context);
+      let allAdded = true;
+      if (!added[cssClassName[SELECTOR]]) {
+        allAdded = false;
+        toAdd[cssClassName[SELECTOR]] = cssClassName[STYLE_STRING];
+      }
+      cssClassName[SELECTORS].forEach(
+        ({ [CLASS_NAME]: className2, [STYLE_STRING]: styleString }) => {
+          if (!added[className2]) {
+            allAdded = false;
+            toAdd[className2] = styleString;
+          }
+        }
+      );
+      if (allAdded) {
+        return;
+      }
+      return Promise.resolve(raw("", [appendStyle]));
+    };
+    const rawClassName = cssClassName[CLASS_NAME];
+    let escapedClassName = rawClassName;
+    if (/[&<>'"]/.test(rawClassName)) {
+      const escapedBuffer = [""];
+      escapeToBuffer(rawClassName, escapedBuffer);
+      escapedClassName = escapedBuffer[0];
+    }
+    const className = new String(escapedClassName);
+    Object.assign(className, cssClassName);
+    className.isEscaped = true;
+    className.callbacks = [addClassNameToContext];
+    const promise = Promise.resolve(className);
+    Object.assign(promise, cssClassName);
+    promise.toString = cssJsxDomObject.toString;
+    return promise;
+  };
+  const css2 = (strings, ...values) => {
+    return newCssClassNameObject(cssCommon(strings, values, classNameSlug, onInvalidSlug));
+  };
+  const cx2 = (...args) => {
+    args = cxCommon(args);
+    return css2(Array(args.length).fill(""), ...args);
+  };
+  const keyframes2 = (strings, ...values) => keyframesCommon(strings, values, classNameSlug, onInvalidSlug);
+  const viewTransition2 = ((strings, ...values) => {
+    return newCssClassNameObject(
+      viewTransitionCommon(strings, values, classNameSlug, onInvalidSlug)
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+    );
+  });
+  const Style2 = ({ children, nonce } = {}) => raw(
+    `<style id="${id}"${nonce ? ` nonce="${nonce}"` : ""}>${children ? children[STYLE_STRING] : ""}</style>`,
+    [
+      ({ context }) => {
+        nonceMap.set(context, nonce);
+        return void 0;
+      }
+    ]
+  );
+  Style2[DOM_RENDERER] = StyleRenderToDom;
+  return {
+    css: css2,
+    cx: cx2,
+    keyframes: keyframes2,
+    viewTransition: viewTransition2,
+    Style: Style2
+  };
+};
+var defaultContext = createCssContext({
+  id: DEFAULT_STYLE_ID
+});
+var css = defaultContext.css;
+var cx = defaultContext.cx;
+var keyframes = defaultContext.keyframes;
+var viewTransition = defaultContext.viewTransition;
+var Style = defaultContext.Style;
+export {
+  Style,
+  createCssContext,
+  css,
+  cx,
+  keyframes,
+  rawCssString,
+  viewTransition
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/helper/dev/index.js

@@ -0,0 +1,55 @@
+// src/helper/dev/index.ts
+import { getColorEnabled } from "../../utils/color.js";
+import { findTargetHandler, isMiddleware } from "../../utils/handler.js";
+var handlerName = (handler) => {
+  return handler.name || (isMiddleware(handler) ? "[middleware]" : "[handler]");
+};
+var inspectRoutes = (hono) => {
+  return hono.routes.map(({ path, method, handler }) => {
+    const targetHandler = findTargetHandler(handler);
+    return {
+      path,
+      method,
+      name: handlerName(targetHandler),
+      isMiddleware: isMiddleware(targetHandler)
+    };
+  });
+};
+var showRoutes = (hono, opts) => {
+  const colorEnabled = opts?.colorize ?? getColorEnabled();
+  const routeData = {};
+  let maxMethodLength = 0;
+  let maxPathLength = 0;
+  inspectRoutes(hono).filter(({ isMiddleware: isMiddleware2 }) => opts?.verbose || !isMiddleware2).map((route) => {
+    const key = `${route.method}-${route.path}`;
+    (routeData[key] ||= []).push(route);
+    if (routeData[key].length > 1) {
+      return;
+    }
+    maxMethodLength = Math.max(maxMethodLength, route.method.length);
+    maxPathLength = Math.max(maxPathLength, route.path.length);
+    return { method: route.method, path: route.path, routes: routeData[key] };
+  }).forEach((data) => {
+    if (!data) {
+      return;
+    }
+    const { method, path, routes } = data;
+    const methodStr = colorEnabled ? `\x1B[32m${method}\x1B[0m` : method;
+    console.log(`${methodStr} ${" ".repeat(maxMethodLength - method.length)} ${path}`);
+    if (!opts?.verbose) {
+      return;
+    }
+    routes.forEach(({ name }) => {
+      console.log(`${" ".repeat(maxMethodLength + 3)} ${name}`);
+    });
+  });
+};
+var getRouterName = (app) => {
+  app.router.match("GET", "/");
+  return app.router.name;
+};
+export {
+  getRouterName,
+  inspectRoutes,
+  showRoutes
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/helper/factory/index.js

@@ -0,0 +1,30 @@
+// src/helper/factory/index.ts
+import { Hono } from "../../hono.js";
+var Factory = class {
+  initApp;
+  #defaultAppOptions;
+  constructor(init) {
+    this.initApp = init?.initApp;
+    this.#defaultAppOptions = init?.defaultAppOptions;
+  }
+  createApp = (options) => {
+    const app = new Hono(
+      options && this.#defaultAppOptions ? { ...this.#defaultAppOptions, ...options } : options ?? this.#defaultAppOptions
+    );
+    if (this.initApp) {
+      this.initApp(app);
+    }
+    return app;
+  };
+  createMiddleware = (middleware) => middleware;
+  createHandlers = (...handlers) => {
+    return handlers.filter((handler) => handler !== void 0);
+  };
+};
+var createFactory = (init) => new Factory(init);
+var createMiddleware = (middleware) => middleware;
+export {
+  Factory,
+  createFactory,
+  createMiddleware
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/helper/html/index.js

@@ -0,0 +1,41 @@
+// src/helper/html/index.ts
+import { escapeToBuffer, raw, resolveCallbackSync, stringBufferToString } from "../../utils/html.js";
+var html = (strings, ...values) => {
+  const buffer = [""];
+  for (let i = 0, len = strings.length - 1; i < len; i++) {
+    buffer[0] += strings[i];
+    const children = Array.isArray(values[i]) ? values[i].flat(Infinity) : [values[i]];
+    for (let i2 = 0, len2 = children.length; i2 < len2; i2++) {
+      const child = children[i2];
+      if (typeof child === "string") {
+        escapeToBuffer(child, buffer);
+      } else if (typeof child === "number") {
+        ;
+        buffer[0] += child;
+      } else if (typeof child === "boolean" || child === null || child === void 0) {
+        continue;
+      } else if (typeof child === "object" && child.isEscaped) {
+        if (child.callbacks) {
+          buffer.unshift("", child);
+        } else {
+          const tmp = child.toString();
+          if (tmp instanceof Promise) {
+            buffer.unshift("", tmp);
+          } else {
+            buffer[0] += tmp;
+          }
+        }
+      } else if (child instanceof Promise) {
+        buffer.unshift("", child);
+      } else {
+        escapeToBuffer(child.toString(), buffer);
+      }
+    }
+  }
+  buffer[0] += strings.at(-1);
+  return buffer.length === 1 ? "callbacks" in buffer ? raw(resolveCallbackSync(raw(buffer[0], buffer.callbacks))) : raw(buffer[0]) : stringBufferToString(buffer, buffer.callbacks);
+};
+export {
+  html,
+  raw
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/helper/proxy/index.js

@@ -0,0 +1,93 @@
+// src/helper/proxy/index.ts
+import { HTTPException } from "../../http-exception.js";
+var hopByHopHeaders = [
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+var ALLOWED_TOKEN_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/;
+var buildRequestInitFromRequest = (request, strictConnectionProcessing) => {
+  if (!request) {
+    return {};
+  }
+  const headers = new Headers(request.headers);
+  if (strictConnectionProcessing) {
+    const connectionValue = headers.get("connection");
+    if (connectionValue) {
+      const headerNames = connectionValue.split(",").map((h) => h.trim());
+      const invalidHeaders = headerNames.filter((h) => !ALLOWED_TOKEN_PATTERN.test(h));
+      if (invalidHeaders.length > 0) {
+        throw new HTTPException(400, {
+          message: `Invalid Connection header value: ${invalidHeaders.join(", ")}`
+        });
+      }
+      headerNames.forEach((headerName) => {
+        headers.delete(headerName);
+      });
+    }
+  }
+  hopByHopHeaders.forEach((header) => {
+    headers.delete(header);
+  });
+  return {
+    method: request.method,
+    body: request.body,
+    duplex: request.body ? "half" : void 0,
+    headers,
+    signal: request.signal
+  };
+};
+var preprocessRequestInit = (requestInit) => {
+  if (!requestInit.headers || Array.isArray(requestInit.headers) || requestInit.headers instanceof Headers) {
+    return requestInit;
+  }
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(requestInit.headers)) {
+    if (value == null) {
+      headers.delete(key);
+    } else {
+      headers.set(key, value);
+    }
+  }
+  requestInit.headers = headers;
+  return requestInit;
+};
+var proxy = async (input, proxyInit) => {
+  const {
+    raw,
+    customFetch,
+    strictConnectionProcessing = false,
+    ...requestInit
+  } = proxyInit instanceof Request ? { raw: proxyInit } : proxyInit ?? {};
+  const req = new Request(input, {
+    ...buildRequestInitFromRequest(raw, strictConnectionProcessing),
+    ...preprocessRequestInit(requestInit)
+  });
+  req.headers.delete("accept-encoding");
+  const res = await (customFetch || fetch)(req);
+  const resHeaders = new Headers(res.headers);
+  const connectionValue = resHeaders.get("connection");
+  if (connectionValue) {
+    connectionValue.split(",").map((h) => h.trim()).filter((h) => ALLOWED_TOKEN_PATTERN.test(h)).forEach((h) => resHeaders.delete(h));
+  }
+  hopByHopHeaders.forEach((header) => {
+    resHeaders.delete(header);
+  });
+  if (resHeaders.has("content-encoding")) {
+    resHeaders.delete("content-encoding");
+    resHeaders.delete("content-length");
+  }
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers: resHeaders
+  });
+};
+export {
+  proxy
+};