@piagent/platform 1.2.17 → 1.3.0-ie.9

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

@@ -0,0 +1,162 @@
+// src/middleware/ip-restriction/index.ts
+import { HTTPException } from "../../http-exception.js";
+import {
+  convertIPv4MappedIPv6ToIPv4,
+  convertIPv4ToBinary,
+  convertIPv6BinaryToString,
+  convertIPv6ToBinary,
+  distinctRemoteAddr,
+  isIPv4MappedIPv6,
+  INVALID_IP_ADDRESS_ERROR_CODE
+} from "../../utils/ipaddr.js";
+var IS_CIDR_NOTATION_REGEX = /\/[^/]*$/;
+var parseCidrPrefix = (rule, prefix, max) => {
+  if (!/^[0-9]{1,3}$/.test(prefix)) {
+    throw new TypeError(`Invalid rule: ${rule}`);
+  }
+  const parsedPrefix = parseInt(prefix);
+  if (parsedPrefix > max) {
+    throw new TypeError(`Invalid rule: ${rule}`);
+  }
+  return parsedPrefix;
+};
+var buildMatcher = (rules) => {
+  const functionRules = [];
+  const staticRules = /* @__PURE__ */ new Set();
+  const staticIPv4Rules = /* @__PURE__ */ new Set();
+  const staticIPv6Rules = /* @__PURE__ */ new Set();
+  const cidrRules = [];
+  const registerStaticRule = (rule) => {
+    const type = distinctRemoteAddr(rule);
+    if (type === void 0) {
+      throw new TypeError(`Invalid rule: ${rule}`);
+    }
+    if (type === "IPv4") {
+      const ipv4binary = convertIPv4ToBinary(rule);
+      staticRules.add(rule);
+      staticRules.add(`::ffff:${rule}`);
+      staticIPv4Rules.add(ipv4binary);
+      staticIPv6Rules.add(0xffffn << 32n | ipv4binary);
+    } else {
+      const ipv6binary = convertIPv6ToBinary(rule);
+      const ipv6Addr = convertIPv6BinaryToString(ipv6binary);
+      staticRules.add(ipv6Addr);
+      staticIPv6Rules.add(ipv6binary);
+      if (isIPv4MappedIPv6(ipv6binary)) {
+        staticRules.add(ipv6Addr.substring(7));
+        staticIPv4Rules.add(convertIPv4MappedIPv6ToIPv4(ipv6binary));
+      }
+    }
+  };
+  for (let rule of rules) {
+    if (rule === "*") {
+      return () => true;
+    } else if (typeof rule === "function") {
+      functionRules.push(rule);
+    } else {
+      if (IS_CIDR_NOTATION_REGEX.test(rule)) {
+        const separatedRule = rule.split("/");
+        const addrStr = separatedRule[0];
+        const type = distinctRemoteAddr(addrStr);
+        if (type === void 0) {
+          throw new TypeError(`Invalid rule: ${rule}`);
+        }
+        let isIPv4 = type === "IPv4";
+        let prefix = parseCidrPrefix(rule, separatedRule[1], isIPv4 ? 32 : 128);
+        if (isIPv4 ? prefix === 32 : prefix === 128) {
+          rule = addrStr;
+        } else {
+          let addr = (isIPv4 ? convertIPv4ToBinary : convertIPv6ToBinary)(addrStr);
+          if (type === "IPv6" && isIPv4MappedIPv6(addr) && prefix >= 96) {
+            isIPv4 = true;
+            addr = convertIPv4MappedIPv6ToIPv4(addr);
+            prefix -= 96;
+          }
+          const mask = (1n << BigInt(prefix)) - 1n << BigInt((isIPv4 ? 32 : 128) - prefix);
+          cidrRules.push([isIPv4, addr & mask, mask]);
+          continue;
+        }
+      }
+      registerStaticRule(rule);
+    }
+  }
+  return (remote) => {
+    if (staticRules.has(remote.addr)) {
+      return true;
+    }
+    const remoteAddr = remote.binaryAddr ||= (remote.isIPv4 ? convertIPv4ToBinary : convertIPv6ToBinary)(remote.addr);
+    const remoteIPv4Addr = remote.isIPv4 || isIPv4MappedIPv6(remoteAddr) ? remote.isIPv4 ? remoteAddr : convertIPv4MappedIPv6ToIPv4(remoteAddr) : void 0;
+    if ((remote.isIPv4 ? staticIPv4Rules : staticIPv6Rules).has(remoteAddr)) {
+      return true;
+    }
+    for (const [isIPv4, addr, mask] of cidrRules) {
+      if (isIPv4) {
+        if (remoteIPv4Addr === void 0) {
+          continue;
+        }
+        if ((remoteIPv4Addr & mask) === addr) {
+          return true;
+        }
+        continue;
+      }
+      if (remote.isIPv4) {
+        continue;
+      }
+      if ((remoteAddr & mask) === addr) {
+        return true;
+      }
+    }
+    for (const rule of functionRules) {
+      if (rule({ addr: remote.addr, type: remote.type })) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+var ipRestriction = (getIP, { denyList = [], allowList = [] }, onError) => {
+  const allowLength = allowList.length;
+  const denyMatcher = buildMatcher(denyList);
+  const allowMatcher = buildMatcher(allowList);
+  const blockError = (c) => new HTTPException(403, {
+    res: c.text("Forbidden", {
+      status: 403
+    })
+  });
+  return async function ipRestriction2(c, next) {
+    const connInfo = getIP(c);
+    const addr = typeof connInfo === "string" ? connInfo : connInfo.remote.address;
+    if (!addr) {
+      throw blockError(c);
+    }
+    const type = typeof connInfo !== "string" && connInfo.remote.addressType || distinctRemoteAddr(addr);
+    const remoteData = { addr, type, isIPv4: type === "IPv4" };
+    try {
+      if (denyMatcher(remoteData)) {
+        if (onError) {
+          return onError({ addr, type }, c);
+        }
+        throw blockError(c);
+      }
+      if (allowMatcher(remoteData)) {
+        return await next();
+      }
+    } catch (e) {
+      if (e instanceof TypeError && e.code === INVALID_IP_ADDRESS_ERROR_CODE) {
+        throw blockError(c);
+      }
+      throw e;
+    }
+    if (allowLength === 0) {
+      return await next();
+    } else {
+      if (onError) {
+        return await onError({ addr, type }, c);
+      }
+      throw blockError(c);
+    }
+  };
+};
+export {
+  ipRestriction
+};

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

@@ -0,0 +1,58 @@
+// src/middleware/jsx-renderer/index.ts
+import { html, raw } from "../../helper/html/index.js";
+import { Fragment, createContext, jsx, useContext } from "../../jsx/index.js";
+import { renderToReadableStream } from "../../jsx/streaming.js";
+var RequestContext = createContext(null);
+var createRenderer = (c, Layout, component, options) => (children, props) => {
+  options = typeof options === "function" ? options(c) : options;
+  const docType = typeof options?.docType === "string" ? options.docType : options?.docType === false ? "" : "<!DOCTYPE html>";
+  const currentLayout = component ? jsx(
+    (props2) => component(props2, c),
+    {
+      Layout,
+      ...props
+    },
+    children
+  ) : children;
+  const body = html`${raw(docType)}${jsx(
+    RequestContext.Provider,
+    { value: c },
+    currentLayout
+  )}`;
+  if (options?.stream) {
+    if (options.stream === true) {
+      c.header("Transfer-Encoding", "chunked");
+      c.header("Content-Type", "text/html; charset=UTF-8");
+      c.header("Content-Encoding", "Identity");
+    } else {
+      for (const [key, value] of Object.entries(options.stream)) {
+        c.header(key, value);
+      }
+    }
+    return c.body(renderToReadableStream(body));
+  } else {
+    return c.html(body);
+  }
+};
+var jsxRenderer = (component, options) => function jsxRenderer2(c, next) {
+  const Layout = c.getLayout() ?? Fragment;
+  if (component) {
+    c.setLayout((props) => {
+      return component({ ...props, Layout }, c);
+    });
+  }
+  c.setRenderer(createRenderer(c, Layout, component, options));
+  return next();
+};
+var useRequestContext = () => {
+  const c = useContext(RequestContext);
+  if (!c) {
+    throw new Error("RequestContext is not provided.");
+  }
+  return c;
+};
+export {
+  RequestContext,
+  jsxRenderer,
+  useRequestContext
+};

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

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

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

@@ -0,0 +1,117 @@
+// src/middleware/jwk/jwk.ts
+import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
+import { HTTPException } from "../../http-exception.js";
+import { Jwt } from "../../utils/jwt/index.js";
+import "../../context.js";
+var jwk = (options, init) => {
+  const verifyOpts = options.verification || {};
+  if (!options || !(options.keys || options.jwks_uri)) {
+    throw new Error('JWK auth middleware requires options for either "keys" or "jwks_uri" or both');
+  }
+  if (!crypto.subtle || !crypto.subtle.importKey) {
+    throw new Error("`crypto.subtle.importKey` is undefined. JWK auth middleware requires it.");
+  }
+  return async function jwk2(ctx, next) {
+    const headerName = options.headerName || "Authorization";
+    const credentials = ctx.req.raw.headers.get(headerName);
+    let token;
+    if (credentials) {
+      const parts = credentials.split(/\s+/);
+      if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
+        const errDescription = "invalid credentials structure";
+        throw new HTTPException(401, {
+          message: errDescription,
+          res: unauthorizedResponse({
+            ctx,
+            error: "invalid_request",
+            errDescription,
+            realm: options.realm
+          })
+        });
+      } else {
+        token = parts[1];
+      }
+    } else if (options.cookie) {
+      if (typeof options.cookie == "string") {
+        token = getCookie(ctx, options.cookie);
+      } else if (options.cookie.secret) {
+        if (options.cookie.prefixOptions) {
+          token = await getSignedCookie(
+            ctx,
+            options.cookie.secret,
+            options.cookie.key,
+            options.cookie.prefixOptions
+          );
+        } else {
+          token = await getSignedCookie(ctx, options.cookie.secret, options.cookie.key);
+        }
+      } else {
+        if (options.cookie.prefixOptions) {
+          token = getCookie(ctx, options.cookie.key, options.cookie.prefixOptions);
+        } else {
+          token = getCookie(ctx, options.cookie.key);
+        }
+      }
+    }
+    if (!token) {
+      if (options.allow_anon) {
+        return next();
+      }
+      const errDescription = "no authorization included in request";
+      throw new HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription,
+          realm: options.realm
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      const keys = typeof options.keys === "function" ? await options.keys(ctx) : options.keys;
+      const jwks_uri = typeof options.jwks_uri === "function" ? await options.jwks_uri(ctx) : options.jwks_uri;
+      payload = await Jwt.verifyWithJwks(
+        token,
+        { keys, jwks_uri, verification: verifyOpts, allowedAlgorithms: options.alg },
+        init
+      );
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      if (cause instanceof Error && cause.constructor === Error) {
+        throw cause;
+      }
+      throw new HTTPException(401, {
+        message: "Unauthorized",
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_token",
+          statusText: "Unauthorized",
+          errDescription: "token verification failure",
+          realm: options.realm
+        }),
+        cause
+      });
+    }
+    ctx.set("jwtPayload", payload);
+    await next();
+  };
+};
+function unauthorizedResponse(opts) {
+  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
+  const errDescription = opts.errDescription.replace(/"/g, '\\"');
+  return new Response("Unauthorized", {
+    status: 401,
+    statusText: opts.statusText,
+    headers: {
+      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
+    }
+  });
+}
+export {
+  jwk
+};

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

@@ -0,0 +1,11 @@
+// src/middleware/jwt/index.ts
+import { jwt, verifyWithJwks, verify, decode, sign } from "./jwt.js";
+import { AlgorithmTypes } from "../../utils/jwt/jwa.js";
+export {
+  AlgorithmTypes,
+  decode,
+  jwt,
+  sign,
+  verify,
+  verifyWithJwks
+};

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

@@ -0,0 +1,119 @@
+// src/middleware/jwt/jwt.ts
+import { getCookie, getSignedCookie } from "../../helper/cookie/index.js";
+import { HTTPException } from "../../http-exception.js";
+import { Jwt } from "../../utils/jwt/index.js";
+import "../../context.js";
+var jwt = (options) => {
+  const verifyOpts = options.verification || {};
+  if (!options || !options.secret) {
+    throw new Error('JWT auth middleware requires options for "secret"');
+  }
+  if (!options.alg) {
+    throw new Error('JWT auth middleware requires options for "alg"');
+  }
+  if (!crypto.subtle || !crypto.subtle.importKey) {
+    throw new Error("`crypto.subtle.importKey` is undefined. JWT auth middleware requires it.");
+  }
+  return async function jwt2(ctx, next) {
+    const headerName = options.headerName || "Authorization";
+    const credentials = ctx.req.raw.headers.get(headerName);
+    let token;
+    if (credentials) {
+      const parts = credentials.split(/\s+/);
+      if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
+        const errDescription = "invalid credentials structure";
+        throw new HTTPException(401, {
+          message: errDescription,
+          res: unauthorizedResponse({
+            ctx,
+            error: "invalid_request",
+            errDescription,
+            realm: options.realm
+          })
+        });
+      } else {
+        token = parts[1];
+      }
+    } else if (options.cookie) {
+      if (typeof options.cookie == "string") {
+        token = getCookie(ctx, options.cookie);
+      } else if (options.cookie.secret) {
+        if (options.cookie.prefixOptions) {
+          token = await getSignedCookie(
+            ctx,
+            options.cookie.secret,
+            options.cookie.key,
+            options.cookie.prefixOptions
+          );
+        } else {
+          token = await getSignedCookie(ctx, options.cookie.secret, options.cookie.key);
+        }
+      } else {
+        if (options.cookie.prefixOptions) {
+          token = getCookie(ctx, options.cookie.key, options.cookie.prefixOptions);
+        } else {
+          token = getCookie(ctx, options.cookie.key);
+        }
+      }
+    }
+    if (!token) {
+      const errDescription = "no authorization included in request";
+      throw new HTTPException(401, {
+        message: errDescription,
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_request",
+          errDescription,
+          realm: options.realm
+        })
+      });
+    }
+    let payload;
+    let cause;
+    try {
+      payload = await Jwt.verify(token, options.secret, {
+        alg: options.alg,
+        ...verifyOpts
+      });
+    } catch (e) {
+      cause = e;
+    }
+    if (!payload) {
+      throw new HTTPException(401, {
+        message: "Unauthorized",
+        res: unauthorizedResponse({
+          ctx,
+          error: "invalid_token",
+          statusText: "Unauthorized",
+          errDescription: "token verification failure",
+          realm: options.realm
+        }),
+        cause
+      });
+    }
+    ctx.set("jwtPayload", payload);
+    await next();
+  };
+};
+function unauthorizedResponse(opts) {
+  const realm = (opts.realm ?? opts.ctx.req.url).replace(/"/g, '\\"');
+  const errDescription = opts.errDescription.replace(/"/g, '\\"');
+  return new Response("Unauthorized", {
+    status: 401,
+    statusText: opts.statusText,
+    headers: {
+      "WWW-Authenticate": `Bearer realm="${realm}",error="${opts.error}",error_description="${errDescription}"`
+    }
+  });
+}
+var verifyWithJwks = Jwt.verifyWithJwks;
+var verify = Jwt.verify;
+var decode = Jwt.decode;
+var sign = Jwt.sign;
+export {
+  decode,
+  jwt,
+  sign,
+  verify,
+  verifyWithJwks
+};

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

@@ -0,0 +1,15 @@
+// src/middleware/language/index.ts
+import {
+  languageDetector,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery
+} from "./language.js";
+export {
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  languageDetector
+};

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

@@ -0,0 +1,172 @@
+// src/middleware/language/language.ts
+import { setCookie, getCookie } from "../../helper/cookie/index.js";
+import { parseAccept } from "../../utils/accept.js";
+var DEFAULT_OPTIONS = {
+  order: ["querystring", "cookie", "header"],
+  lookupQueryString: "lang",
+  lookupCookie: "language",
+  lookupFromHeaderKey: "accept-language",
+  lookupFromPathIndex: 0,
+  caches: ["cookie"],
+  ignoreCase: true,
+  fallbackLanguage: "en",
+  supportedLanguages: ["en"],
+  cookieOptions: {
+    sameSite: "Strict",
+    secure: true,
+    maxAge: 365 * 24 * 60 * 60,
+    httpOnly: true
+  },
+  debug: false
+};
+function parseAcceptLanguage(header) {
+  return parseAccept(header).map(({ type, q }) => ({ lang: type, q }));
+}
+var normalizeLanguage = (lang, options) => {
+  if (!lang) {
+    return void 0;
+  }
+  try {
+    let normalizedLang = lang.trim();
+    if (options.convertDetectedLanguage) {
+      normalizedLang = options.convertDetectedLanguage(normalizedLang);
+    }
+    const compLang = options.ignoreCase ? normalizedLang.toLowerCase() : normalizedLang;
+    const compSupported = options.supportedLanguages.map(
+      (l) => options.ignoreCase ? l.toLowerCase() : l
+    );
+    const exactIndex = compSupported.indexOf(compLang);
+    if (exactIndex !== -1) {
+      return options.supportedLanguages[exactIndex];
+    }
+    let longestMatchIndex = -1;
+    let longestMatchLength = -1;
+    for (let i = 0; i < compSupported.length; i++) {
+      const candidate = compSupported[i];
+      if (candidate.length < compLang.length && candidate.length > longestMatchLength && compLang.startsWith(candidate) && compLang[candidate.length] === "-") {
+        longestMatchIndex = i;
+        longestMatchLength = candidate.length;
+      }
+    }
+    if (longestMatchIndex !== -1) {
+      return options.supportedLanguages[longestMatchIndex];
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var detectFromQuery = (c, options) => {
+  const query = c.req.query(options.lookupQueryString);
+  return normalizeLanguage(query, options);
+};
+var detectFromCookie = (c, options) => {
+  const cookie = getCookie(c, options.lookupCookie);
+  return normalizeLanguage(cookie, options);
+};
+function detectFromHeader(c, options) {
+  try {
+    const acceptLanguage = c.req.header(options.lookupFromHeaderKey);
+    if (!acceptLanguage) {
+      return void 0;
+    }
+    const languages = parseAcceptLanguage(acceptLanguage);
+    for (const { lang } of languages) {
+      const normalizedLang = normalizeLanguage(lang, options);
+      if (normalizedLang) {
+        return normalizedLang;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectFromPath(c, options) {
+  const url = new URL(c.req.url);
+  const pathSegments = url.pathname.split("/").filter(Boolean);
+  const langSegment = pathSegments[options.lookupFromPathIndex];
+  return normalizeLanguage(langSegment, options);
+}
+var detectors = {
+  querystring: detectFromQuery,
+  cookie: detectFromCookie,
+  header: detectFromHeader,
+  path: detectFromPath
+};
+function validateOptions(options) {
+  if (!options.supportedLanguages.includes(options.fallbackLanguage)) {
+    throw new Error("Fallback language must be included in supported languages");
+  }
+  if (options.lookupFromPathIndex < 0) {
+    throw new Error("Path index must be non-negative");
+  }
+  if (!options.order.every((detector) => Object.keys(detectors).includes(detector))) {
+    throw new Error("Invalid detector type in order array");
+  }
+}
+function cacheLanguage(c, language, options) {
+  if (!Array.isArray(options.caches) || !options.caches.includes("cookie")) {
+    return;
+  }
+  try {
+    setCookie(c, options.lookupCookie, language, options.cookieOptions);
+  } catch (error) {
+    if (options.debug) {
+      console.error("Failed to cache language:", error);
+    }
+  }
+}
+var detectLanguage = (c, options) => {
+  let detectedLang;
+  for (const detectorName of options.order) {
+    const detector = detectors[detectorName];
+    try {
+      detectedLang = detector(c, options);
+      if (detectedLang) {
+        if (options.debug) {
+          console.log(`Language detected from ${detectorName}: ${detectedLang}`);
+        }
+        break;
+      }
+    } catch (error) {
+      if (options.debug) {
+        console.error(`Error in ${detectorName} detector:`, error);
+      }
+      continue;
+    }
+  }
+  const finalLang = detectedLang || options.fallbackLanguage;
+  if (detectedLang && options.caches) {
+    cacheLanguage(c, finalLang, options);
+  }
+  return finalLang;
+};
+var languageDetector = (userOptions) => {
+  const options = {
+    ...DEFAULT_OPTIONS,
+    ...userOptions,
+    cookieOptions: {
+      ...DEFAULT_OPTIONS.cookieOptions,
+      ...userOptions.cookieOptions
+    }
+  };
+  validateOptions(options);
+  return async function languageDetector2(ctx, next) {
+    const lang = detectLanguage(ctx, options);
+    ctx.set("language", lang);
+    await next();
+  };
+};
+export {
+  DEFAULT_OPTIONS,
+  detectFromCookie,
+  detectFromHeader,
+  detectFromPath,
+  detectFromQuery,
+  detectors,
+  languageDetector,
+  normalizeLanguage,
+  parseAcceptLanguage,
+  validateOptions
+};