@piagent/platform 1.2.17 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/buffer.js

@@ -0,0 +1,78 @@
+// src/utils/buffer.ts
+import { sha256 } from "./crypto.js";
+var equal = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  const va = new DataView(a);
+  const vb = new DataView(b);
+  let i = va.byteLength;
+  while (i--) {
+    if (va.getUint8(i) !== vb.getUint8(i)) {
+      return false;
+    }
+  }
+  return true;
+};
+var constantTimeEqualString = (a, b) => {
+  const aLen = a.length;
+  const bLen = b.length;
+  const maxLen = Math.max(aLen, bLen);
+  let out = aLen ^ bLen;
+  for (let i = 0; i < maxLen; i++) {
+    const aChar = i < aLen ? a.charCodeAt(i) : 0;
+    const bChar = i < bLen ? b.charCodeAt(i) : 0;
+    out |= aChar ^ bChar;
+  }
+  return out === 0;
+};
+var timingSafeEqualString = async (a, b, hashFunction) => {
+  if (!hashFunction) {
+    hashFunction = sha256;
+  }
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+  if (sa == null || sb == null || typeof sa !== "string" || typeof sb !== "string") {
+    return false;
+  }
+  const hashEqual = constantTimeEqualString(sa, sb);
+  const originalEqual = constantTimeEqualString(a, b);
+  return hashEqual && originalEqual;
+};
+var timingSafeEqual = async (a, b, hashFunction) => {
+  if (typeof a === "string" && typeof b === "string") {
+    return timingSafeEqualString(a, b, hashFunction);
+  }
+  if (!hashFunction) {
+    hashFunction = sha256;
+  }
+  const [sa, sb] = await Promise.all([hashFunction(a), hashFunction(b)]);
+  if (!sa || !sb || typeof sa !== "string" || typeof sb !== "string") {
+    return false;
+  }
+  return timingSafeEqualString(sa, sb);
+};
+var bufferToString = (buffer) => {
+  if (buffer instanceof ArrayBuffer) {
+    const enc = new TextDecoder("utf-8");
+    return enc.decode(buffer);
+  }
+  return buffer;
+};
+var bufferToFormData = (arrayBuffer, contentType) => {
+  const response = new Response(arrayBuffer, {
+    headers: {
+      // Normalize the media type (case-insensitive) while keeping parameters like the boundary
+      "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase())
+    }
+  });
+  return response.formData();
+};
+export {
+  bufferToFormData,
+  bufferToString,
+  equal,
+  timingSafeEqual
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/color.js

@@ -0,0 +1,25 @@
+// src/utils/color.ts
+function getColorEnabled() {
+  const { process, Deno } = globalThis;
+  const isNoColor = typeof Deno?.noColor === "boolean" ? Deno.noColor : process !== void 0 ? (
+    // eslint-disable-next-line no-unsafe-optional-chaining
+    "NO_COLOR" in process?.env
+  ) : false;
+  return !isNoColor;
+}
+async function getColorEnabledAsync() {
+  const { navigator } = globalThis;
+  const cfWorkers = "cloudflare:workers";
+  const isNoColor = navigator !== void 0 && navigator.userAgent === "Cloudflare-Workers" ? await (async () => {
+    try {
+      return "NO_COLOR" in ((await import(cfWorkers)).env ?? {});
+    } catch {
+      return false;
+    }
+  })() : !getColorEnabled();
+  return !isNoColor;
+}
+export {
+  getColorEnabled,
+  getColorEnabledAsync
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/compress.js

@@ -0,0 +1,5 @@
+// src/utils/compress.ts
+var COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|msgpack|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|vnd\.msgpack|wasm|x-httpd-php|x-javascript|x-msgpack|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml|msgpack))(?:[;\s]|$)/i;
+export {
+  COMPRESSIBLE_CONTENT_TYPE_REGEX
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/concurrent.js

@@ -0,0 +1,39 @@
+// src/utils/concurrent.ts
+var DEFAULT_CONCURRENCY = 1024;
+var createPool = ({
+  concurrency,
+  interval
+} = {}) => {
+  concurrency ||= DEFAULT_CONCURRENCY;
+  if (concurrency === Infinity) {
+    return {
+      run: async (fn) => fn()
+    };
+  }
+  const pool = /* @__PURE__ */ new Set();
+  const run = async (fn, promise, resolve) => {
+    if (pool.size >= concurrency) {
+      promise ||= new Promise((r) => resolve = r);
+      setTimeout(() => run(fn, promise, resolve));
+      return promise;
+    }
+    const marker = {};
+    pool.add(marker);
+    const result = await fn();
+    if (interval) {
+      setTimeout(() => pool.delete(marker), interval);
+    } else {
+      pool.delete(marker);
+    }
+    if (resolve) {
+      resolve(result);
+      return promise;
+    } else {
+      return result;
+    }
+  };
+  return { run };
+};
+export {
+  createPool
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/constants.js

@@ -0,0 +1,5 @@
+// src/utils/constants.ts
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+export {
+  COMPOSED_HANDLER
+};

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

@@ -0,0 +1,174 @@
+// src/utils/cookie.ts
+import { tryDecodeURIComponent } from "./url.js";
+var algorithm = { name: "HMAC", hash: "SHA-256" };
+var getCryptoKey = async (secret) => {
+  const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
+  return await crypto.subtle.importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
+};
+var makeSignature = async (value, secret) => {
+  const key = await getCryptoKey(secret);
+  const signature = await crypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
+  return btoa(String.fromCharCode(...new Uint8Array(signature)));
+};
+var verifySignature = async (base64Signature, value, secret) => {
+  try {
+    const signatureBinStr = atob(base64Signature);
+    const signature = new Uint8Array(signatureBinStr.length);
+    for (let i = 0, len = signatureBinStr.length; i < len; i++) {
+      signature[i] = signatureBinStr.charCodeAt(i);
+    }
+    return await crypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value));
+  } catch {
+    return false;
+  }
+};
+var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+var relaxedCookieNameRegEx = /^[!#-:<>-[\]-~]+$/;
+var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+var trimCookieWhitespace = (value) => {
+  let start = 0;
+  let end = value.length;
+  while (start < end) {
+    const charCode = value.charCodeAt(start);
+    if (charCode !== 32 && charCode !== 9) {
+      break;
+    }
+    start++;
+  }
+  while (end > start) {
+    const charCode = value.charCodeAt(end - 1);
+    if (charCode !== 32 && charCode !== 9) {
+      break;
+    }
+    end--;
+  }
+  return start === 0 && end === value.length ? value : value.slice(start, end);
+};
+var parse = (cookie, name) => {
+  if (name && cookie.indexOf(name) === -1) {
+    return {};
+  }
+  const pairs = cookie.split(";");
+  const parsedCookie = /* @__PURE__ */ Object.create(null);
+  for (const pairStr of pairs) {
+    const valueStartPos = pairStr.indexOf("=");
+    if (valueStartPos === -1) {
+      continue;
+    }
+    const cookieName = trimCookieWhitespace(pairStr.substring(0, valueStartPos));
+    if (name && name !== cookieName || !relaxedCookieNameRegEx.test(cookieName) || cookieName in parsedCookie) {
+      continue;
+    }
+    let cookieValue = trimCookieWhitespace(pairStr.substring(valueStartPos + 1));
+    if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) {
+      cookieValue = cookieValue.slice(1, -1);
+    }
+    if (validCookieValueRegEx.test(cookieValue)) {
+      parsedCookie[cookieName] = tryDecodeURIComponent(cookieValue);
+      if (name) {
+        break;
+      }
+    }
+  }
+  return parsedCookie;
+};
+var parseSigned = async (cookie, secret, name) => {
+  const parsedCookie = /* @__PURE__ */ Object.create(null);
+  const secretKey = await getCryptoKey(secret);
+  for (const [key, value] of Object.entries(parse(cookie, name))) {
+    const signatureStartPos = value.lastIndexOf(".");
+    if (signatureStartPos < 1) {
+      continue;
+    }
+    const signedValue = value.substring(0, signatureStartPos);
+    const signature = value.substring(signatureStartPos + 1);
+    if (signature.length !== 44 || !signature.endsWith("=")) {
+      continue;
+    }
+    const isVerified = await verifySignature(signature, signedValue, secretKey);
+    parsedCookie[key] = isVerified ? signedValue : false;
+  }
+  return parsedCookie;
+};
+var _serialize = (name, value, opt = {}) => {
+  if (!validCookieNameRegEx.test(name)) {
+    throw new Error("Invalid cookie name");
+  }
+  let cookie = `${name}=${value}`;
+  if (name.startsWith("__Secure-") && !opt.secure) {
+    throw new Error("__Secure- Cookie must have Secure attributes");
+  }
+  if (name.startsWith("__Host-")) {
+    if (!opt.secure) {
+      throw new Error("__Host- Cookie must have Secure attributes");
+    }
+    if (opt.path !== "/") {
+      throw new Error('__Host- Cookie must have Path attributes with "/"');
+    }
+    if (opt.domain) {
+      throw new Error("__Host- Cookie must not have Domain attributes");
+    }
+  }
+  for (const key of ["domain", "path", "sameSite", "priority"]) {
+    if (opt[key] && /[;\r\n]/.test(opt[key])) {
+      throw new Error(`${key} must not contain ";", "\\r", or "\\n"`);
+    }
+  }
+  if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
+    if (opt.maxAge > 3456e4) {
+      throw new Error(
+        "Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration."
+      );
+    }
+    cookie += `; Max-Age=${opt.maxAge | 0}`;
+  }
+  if (opt.domain && opt.prefix !== "host") {
+    cookie += `; Domain=${opt.domain}`;
+  }
+  if (opt.path) {
+    cookie += `; Path=${opt.path}`;
+  }
+  if (opt.expires) {
+    if (opt.expires.getTime() - Date.now() > 3456e7) {
+      throw new Error(
+        "Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future."
+      );
+    }
+    cookie += `; Expires=${opt.expires.toUTCString()}`;
+  }
+  if (opt.httpOnly) {
+    cookie += "; HttpOnly";
+  }
+  if (opt.secure) {
+    cookie += "; Secure";
+  }
+  if (opt.sameSite) {
+    cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
+  }
+  if (opt.priority) {
+    cookie += `; Priority=${opt.priority.charAt(0).toUpperCase() + opt.priority.slice(1)}`;
+  }
+  if (opt.partitioned) {
+    if (!opt.secure) {
+      throw new Error("Partitioned Cookie must have Secure attributes");
+    }
+    cookie += "; Partitioned";
+  }
+  return cookie;
+};
+var serialize = (name, value, opt) => {
+  value = encodeURIComponent(value);
+  return _serialize(name, value, opt);
+};
+var serializeSigned = async (name, value, secret, opt = {}) => {
+  const signature = await makeSignature(value, secret);
+  value = `${value}.${signature}`;
+  value = encodeURIComponent(value);
+  return _serialize(name, value, opt);
+};
+export {
+  parse,
+  parseSigned,
+  serialize,
+  serializeSigned
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/crypto.js

@@ -0,0 +1,44 @@
+// src/utils/crypto.ts
+var sha256 = async (data) => {
+  const algorithm = { name: "SHA-256", alias: "sha256" };
+  const hash = await createHash(data, algorithm);
+  return hash;
+};
+var sha1 = async (data) => {
+  const algorithm = { name: "SHA-1", alias: "sha1" };
+  const hash = await createHash(data, algorithm);
+  return hash;
+};
+var md5 = async (data) => {
+  const algorithm = { name: "MD5", alias: "md5" };
+  const hash = await createHash(data, algorithm);
+  return hash;
+};
+var createHash = async (data, algorithm) => {
+  let sourceBuffer;
+  if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) {
+    sourceBuffer = data;
+  } else {
+    if (typeof data === "object") {
+      data = JSON.stringify(data);
+    }
+    sourceBuffer = new TextEncoder().encode(String(data));
+  }
+  if (crypto && crypto.subtle) {
+    const buffer = await crypto.subtle.digest(
+      {
+        name: algorithm.name
+      },
+      sourceBuffer
+    );
+    const hash = Array.prototype.map.call(new Uint8Array(buffer), (x) => ("00" + x.toString(16)).slice(-2)).join("");
+    return hash;
+  }
+  return null;
+};
+export {
+  createHash,
+  md5,
+  sha1,
+  sha256
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/encode.js

@@ -0,0 +1,29 @@
+// src/utils/encode.ts
+var decodeBase64Url = (str) => {
+  return decodeBase64(str.replace(/_|-/g, (m) => ({ _: "/", "-": "+" })[m] ?? m));
+};
+var encodeBase64Url = (buf) => encodeBase64(buf).replace(/\/|\+/g, (m) => ({ "/": "_", "+": "-" })[m] ?? m);
+var encodeBase64 = (buf) => {
+  let binary = "";
+  const bytes = new Uint8Array(buf);
+  for (let i = 0, len = bytes.length; i < len; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+};
+var decodeBase64 = (str) => {
+  const binary = atob(str);
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  const half = binary.length / 2;
+  for (let i = 0, j = binary.length - 1; i <= half; i++, j--) {
+    bytes[i] = binary.charCodeAt(i);
+    bytes[j] = binary.charCodeAt(j);
+  }
+  return bytes;
+};
+export {
+  decodeBase64,
+  decodeBase64Url,
+  encodeBase64,
+  encodeBase64Url
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/filepath.js

@@ -0,0 +1,35 @@
+// src/utils/filepath.ts
+var getFilePath = (options) => {
+  let filename = options.filename;
+  const defaultDocument = options.defaultDocument || "index.html";
+  if (filename.endsWith("/")) {
+    filename = filename.concat(defaultDocument);
+  } else if (!filename.match(/\.[a-zA-Z0-9_-]+$/)) {
+    filename = filename.concat("/" + defaultDocument);
+  }
+  const path = getFilePathWithoutDefaultDocument({
+    root: options.root,
+    filename
+  });
+  return path;
+};
+var getFilePathWithoutDefaultDocument = (options) => {
+  let root = options.root || "";
+  let filename = options.filename;
+  if (/(?:^|[\/\\])\.\.(?:$|[\/\\])/.test(filename)) {
+    return;
+  }
+  filename = filename.replace(/^\.?[\/\\]/, "");
+  filename = filename.replace(/\\/g, "/");
+  root = root.replace(/\/$/, "");
+  let path = root ? root + "/" + filename : filename;
+  path = path.replace(/^\.?\//, "");
+  if (root[0] !== "/" && path[0] === "/") {
+    return;
+  }
+  return path;
+};
+export {
+  getFilePath,
+  getFilePathWithoutDefaultDocument
+};

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/utils/handler.js

@@ -0,0 +1,13 @@
+// src/utils/handler.ts
+import { COMPOSED_HANDLER } from "./constants.js";
+var isMiddleware = (handler) => handler.length > 1;
+var findTargetHandler = (handler) => {
+  return handler[COMPOSED_HANDLER] ? (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    findTargetHandler(handler[COMPOSED_HANDLER])
+  ) : handler;
+};
+export {
+  findTargetHandler,
+  isMiddleware
+};

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

@@ -0,0 +1,123 @@
+// src/utils/html.ts
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var escapeRe = /[&<>'"]/;
+var stringBufferToString = async (buffer, callbacks) => {
+  let str = "";
+  callbacks ||= [];
+  const resolvedBuffer = await Promise.all(buffer);
+  for (let i = resolvedBuffer.length - 1; ; i--) {
+    str += resolvedBuffer[i];
+    i--;
+    if (i < 0) {
+      break;
+    }
+    let r = resolvedBuffer[i];
+    if (typeof r === "object") {
+      callbacks.push(...r.callbacks || []);
+    }
+    const isEscaped = r.isEscaped;
+    r = await (typeof r === "object" ? r.toString() : r);
+    if (typeof r === "object") {
+      callbacks.push(...r.callbacks || []);
+    }
+    if (r.isEscaped ?? isEscaped) {
+      str += r;
+    } else {
+      const buf = [str];
+      escapeToBuffer(r, buf);
+      str = buf[0];
+    }
+  }
+  return raw(str, callbacks);
+};
+var escapeToBuffer = (str, buffer) => {
+  const match = str.search(escapeRe);
+  if (match === -1) {
+    buffer[0] += str;
+    return;
+  }
+  let escape;
+  let index;
+  let lastIndex = 0;
+  for (index = match; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34:
+        escape = "&quot;";
+        break;
+      case 39:
+        escape = "&#39;";
+        break;
+      case 38:
+        escape = "&amp;";
+        break;
+      case 60:
+        escape = "&lt;";
+        break;
+      case 62:
+        escape = "&gt;";
+        break;
+      default:
+        continue;
+    }
+    buffer[0] += str.substring(lastIndex, index) + escape;
+    lastIndex = index + 1;
+  }
+  buffer[0] += str.substring(lastIndex, index);
+};
+var resolveCallbackSync = (str) => {
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return str;
+  }
+  const buffer = [str];
+  const context = {};
+  callbacks.forEach((c) => c({ phase: HtmlEscapedCallbackPhase.Stringify, buffer, context }));
+  return buffer[0];
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
+    (res) => Promise.all(
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+    ).then(() => buffer[0])
+  );
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks);
+  } else {
+    return resStr;
+  }
+};
+export {
+  HtmlEscapedCallbackPhase,
+  escapeToBuffer,
+  raw,
+  resolveCallback,
+  resolveCallbackSync,
+  stringBufferToString
+};