@piagent/platform 1.2.17 → 1.3.0-ie.8

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/jsx/intrinsic-element/components.js

@@ -0,0 +1,189 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var components_exports = {};
+__export(components_exports, {
+  button: () => button,
+  form: () => form,
+  input: () => input,
+  link: () => link,
+  meta: () => meta,
+  script: () => script,
+  style: () => style,
+  title: () => title
+});
+module.exports = __toCommonJS(components_exports);
+var import_html = require("../../helper/html");
+var import_base = require("../base");
+var import_children = require("../children");
+var import_constants = require("../constants");
+var import_context = require("../context");
+var import_common = require("./common");
+const metaTagMap = /* @__PURE__ */ new WeakMap();
+const insertIntoHead = (tagName, tag, props, precedence) => ({ buffer, context }) => {
+  if (!buffer) {
+    return;
+  }
+  const map = metaTagMap.get(context) || {};
+  metaTagMap.set(context, map);
+  const tags = map[tagName] ||= [];
+  let duped = false;
+  const deDupeKeys = import_common.deDupeKeyMap[tagName];
+  const deDupeByKey = (0, import_common.shouldDeDupeByKey)(tagName, precedence !== void 0);
+  if (deDupeByKey) {
+    LOOP: for (const [, tagProps] of tags) {
+      if (tagName === "link" && !(tagProps.rel === "stylesheet" && tagProps[import_common.dataPrecedenceAttr] !== void 0)) {
+        continue;
+      }
+      for (const key of deDupeKeys) {
+        if ((tagProps?.[key] ?? null) === props?.[key]) {
+          duped = true;
+          break LOOP;
+        }
+      }
+    }
+  }
+  if (duped) {
+    buffer[0] = buffer[0].replaceAll(tag, "");
+  } else if (deDupeByKey || tagName === "link") {
+    tags.push([tag, props, precedence]);
+  } else {
+    tags.unshift([tag, props, precedence]);
+  }
+  if (buffer[0].indexOf("</head>") !== -1) {
+    let insertTags;
+    if (tagName === "link" || precedence !== void 0) {
+      const precedences = [];
+      insertTags = tags.map(([tag2, , tagPrecedence], index) => {
+        if (tagPrecedence === void 0) {
+          return [tag2, Number.MAX_SAFE_INTEGER, index];
+        }
+        let order = precedences.indexOf(tagPrecedence);
+        if (order === -1) {
+          precedences.push(tagPrecedence);
+          order = precedences.length - 1;
+        }
+        return [tag2, order, index];
+      }).sort((a, b) => a[1] - b[1] || a[2] - b[2]).map(([tag2]) => tag2);
+    } else {
+      insertTags = tags.map(([tag2]) => tag2);
+    }
+    insertTags.forEach((tag2) => {
+      buffer[0] = buffer[0].replaceAll(tag2, "");
+    });
+    buffer[0] = buffer[0].replace(/(?=<\/head>)/, insertTags.join(""));
+  }
+};
+const returnWithoutSpecialBehavior = (tag, children, props) => (0, import_html.raw)(new import_base.JSXNode(tag, props, (0, import_children.toArray)(children ?? [])).toString());
+const documentMetadataTag = (tag, children, props, sort) => {
+  if ("itemProp" in props) {
+    return returnWithoutSpecialBehavior(tag, children, props);
+  }
+  let { precedence, blocking, ...restProps } = props;
+  precedence = sort ? precedence ?? "" : void 0;
+  if (sort) {
+    restProps[import_common.dataPrecedenceAttr] = precedence;
+  }
+  const string = new import_base.JSXNode(tag, restProps, (0, import_children.toArray)(children || [])).toString();
+  if (string instanceof Promise) {
+    return string.then(
+      (resString) => (0, import_html.raw)(string, [
+        ...resString.callbacks || [],
+        insertIntoHead(tag, resString, restProps, precedence)
+      ])
+    );
+  } else {
+    return (0, import_html.raw)(string, [insertIntoHead(tag, string, restProps, precedence)]);
+  }
+};
+const title = ({ children, ...props }) => {
+  const nameSpaceContext = (0, import_base.getNameSpaceContext)();
+  if (nameSpaceContext) {
+    const context = (0, import_context.useContext)(nameSpaceContext);
+    if (context === "svg" || context === "head") {
+      return new import_base.JSXNode(
+        "title",
+        props,
+        (0, import_children.toArray)(children ?? [])
+      );
+    }
+  }
+  return documentMetadataTag("title", children, props, false);
+};
+const script = ({
+  children,
+  ...props
+}) => {
+  const nameSpaceContext = (0, import_base.getNameSpaceContext)();
+  if (["src", "async"].some((k) => !props[k]) || nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "head") {
+    return returnWithoutSpecialBehavior("script", children, props);
+  }
+  return documentMetadataTag("script", children, props, false);
+};
+const style = ({
+  children,
+  ...props
+}) => {
+  if (!["href", "precedence"].every((k) => k in props)) {
+    return returnWithoutSpecialBehavior("style", children, props);
+  }
+  props["data-href"] = props.href;
+  delete props.href;
+  return documentMetadataTag("style", children, props, true);
+};
+const link = ({ children, ...props }) => {
+  if (["onLoad", "onError"].some((k) => k in props) || props.rel === "stylesheet" && (!("precedence" in props) || "disabled" in props)) {
+    return returnWithoutSpecialBehavior("link", children, props);
+  }
+  return documentMetadataTag("link", children, props, (0, import_common.isStylesheetLinkWithPrecedence)(props));
+};
+const meta = ({ children, ...props }) => {
+  const nameSpaceContext = (0, import_base.getNameSpaceContext)();
+  if (nameSpaceContext && (0, import_context.useContext)(nameSpaceContext) === "head") {
+    return returnWithoutSpecialBehavior("meta", children, props);
+  }
+  return documentMetadataTag("meta", children, props, false);
+};
+const newJSXNode = (tag, { children, ...props }) => (
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  new import_base.JSXNode(tag, props, (0, import_children.toArray)(children ?? []))
+);
+const form = (props) => {
+  if (typeof props.action === "function") {
+    props.action = import_constants.PERMALINK in props.action ? props.action[import_constants.PERMALINK] : void 0;
+  }
+  return newJSXNode("form", props);
+};
+const formActionableElement = (tag, props) => {
+  if (typeof props.formAction === "function") {
+    props.formAction = import_constants.PERMALINK in props.formAction ? props.formAction[import_constants.PERMALINK] : void 0;
+  }
+  return newJSXNode(tag, props);
+};
+const input = (props) => formActionableElement("input", props);
+const button = (props) => formActionableElement("button", props);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  button,
+  form,
+  input,
+  link,
+  meta,
+  script,
+  style,
+  title
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/jsx/intrinsic-elements.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var intrinsic_elements_exports = {};
+module.exports = __toCommonJS(intrinsic_elements_exports);

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/jsx/jsx-dev-runtime.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsx_dev_runtime_exports = {};
+__export(jsx_dev_runtime_exports, {
+  Fragment: () => import_base2.Fragment,
+  jsxDEV: () => jsxDEV
+});
+module.exports = __toCommonJS(jsx_dev_runtime_exports);
+var import_base = require("./base");
+var import_base2 = require("./base");
+function jsxDEV(tag, props, key) {
+  let node;
+  if (!props || !("children" in props)) {
+    node = (0, import_base.jsxFn)(tag, props, []);
+  } else {
+    const children = props.children;
+    node = Array.isArray(children) ? (0, import_base.jsxFn)(tag, props, children) : (0, import_base.jsxFn)(tag, props, [children]);
+  }
+  node.key = key;
+  return node;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  jsxDEV
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/jsx/jsx-runtime.js

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsx_runtime_exports = {};
+__export(jsx_runtime_exports, {
+  Fragment: () => import_jsx_dev_runtime.Fragment,
+  jsx: () => import_jsx_dev_runtime.jsxDEV,
+  jsxAttr: () => jsxAttr,
+  jsxEscape: () => jsxEscape,
+  jsxTemplate: () => import_html.html,
+  jsxs: () => import_jsx_dev_runtime2.jsxDEV
+});
+module.exports = __toCommonJS(jsx_runtime_exports);
+var import_jsx_dev_runtime = require("./jsx-dev-runtime");
+var import_jsx_dev_runtime2 = require("./jsx-dev-runtime");
+var import_html = require("../helper/html");
+var import_html2 = require("../utils/html");
+var import_utils = require("./utils");
+const jsxAttr = (key, v) => {
+  if (!(0, import_utils.isValidAttributeName)(key)) {
+    return (0, import_html.raw)("");
+  }
+  const buffer = [`${key}="`];
+  if (key === "style" && typeof v === "object") {
+    let styleStr = "";
+    (0, import_utils.styleObjectForEach)(v, (property, value) => {
+      if (value != null) {
+        styleStr += `${styleStr ? ";" : ""}${property}:${value}`;
+      }
+    });
+    (0, import_html2.escapeToBuffer)(styleStr, buffer);
+    buffer[0] += '"';
+  } else if (typeof v === "string") {
+    (0, import_html2.escapeToBuffer)(v, buffer);
+    buffer[0] += '"';
+  } else if (v === null || v === void 0) {
+    return (0, import_html.raw)("");
+  } else if (typeof v === "number" || v.isEscaped) {
+    buffer[0] += `${v}"`;
+  } else if (v instanceof Promise) {
+    buffer.unshift('"', v);
+  } else {
+    (0, import_html2.escapeToBuffer)(v.toString(), buffer);
+    buffer[0] += '"';
+  }
+  return buffer.length === 1 ? (0, import_html.raw)(buffer[0]) : (0, import_html2.stringBufferToString)(buffer, void 0);
+};
+const jsxEscape = (value) => value;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  jsx,
+  jsxAttr,
+  jsxEscape,
+  jsxTemplate,
+  jsxs
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/jsx/streaming.js

@@ -0,0 +1,179 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streaming_exports = {};
+__export(streaming_exports, {
+  StreamingContext: () => StreamingContext,
+  Suspense: () => Suspense,
+  renderToReadableStream: () => renderToReadableStream
+});
+module.exports = __toCommonJS(streaming_exports);
+var import_html = require("../helper/html");
+var import_html2 = require("../utils/html");
+var import_base = require("./base");
+var import_components = require("./components");
+var import_constants = require("./constants");
+var import_context = require("./context");
+var import_components2 = require("./dom/components");
+var import_render = require("./dom/render");
+const StreamingContext = (0, import_context.createContext)(null);
+let suspenseCounter = 0;
+const Suspense = async ({
+  children,
+  fallback
+}) => {
+  if (!Array.isArray(children)) {
+    children = [children];
+  }
+  const nonce = (0, import_context.useContext)(StreamingContext)?.scriptNonce;
+  let resArray = [];
+  const stackNode = { [import_constants.DOM_STASH]: [0, []] };
+  const popNodeStack = () => {
+    import_render.buildDataStack.pop();
+  };
+  try {
+    stackNode[import_constants.DOM_STASH][0] = 0;
+    import_render.buildDataStack.push([[], stackNode]);
+    resArray = children.map(
+      (c) => c == null || typeof c === "boolean" ? "" : c.toString()
+    );
+  } catch (e) {
+    if (e instanceof Promise) {
+      const resume = (0, import_context.captureRenderContext)();
+      resArray = [
+        e.then(
+          () => resume(() => {
+            stackNode[import_constants.DOM_STASH][0] = 0;
+            import_render.buildDataStack.push([[], stackNode]);
+            return (0, import_components.childrenToString)(children).finally(popNodeStack);
+          })
+        )
+      ];
+    } else {
+      throw e;
+    }
+  } finally {
+    popNodeStack();
+  }
+  if (resArray.some((res) => res instanceof Promise)) {
+    const index = suspenseCounter++;
+    const fallbackStr = await fallback.toString();
+    return (0, import_html.raw)(`<template id="H:${index}"></template>${fallbackStr}<!--/$-->`, [
+      ...fallbackStr.callbacks || [],
+      ({ phase, buffer, context }) => {
+        if (phase === import_html2.HtmlEscapedCallbackPhase.BeforeStream) {
+          return;
+        }
+        return Promise.all(resArray).then(async (htmlArray) => {
+          htmlArray = htmlArray.flat();
+          const content = htmlArray.join("");
+          if (buffer) {
+            buffer[0] = buffer[0].replace(
+              new RegExp(`<template id="H:${index}"></template>.*?<!--/\\$-->`),
+              content
+            );
+          }
+          let html = buffer ? "" : `<template data-hono-target="H:${index}">${content}</template><script${nonce ? ` nonce="${nonce}"` : ""}>
+((d,c,n) => {
+c=d.currentScript.previousSibling
+d=d.getElementById('H:${index}')
+if(!d)return
+do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='/$')
+d.replaceWith(c.content)
+})(document)
+</script>`;
+          const callbacks = htmlArray.map((html2) => html2.callbacks || []).flat();
+          if (!callbacks.length) {
+            return html;
+          }
+          if (phase === import_html2.HtmlEscapedCallbackPhase.Stream) {
+            html = await (0, import_html2.resolveCallback)(html, import_html2.HtmlEscapedCallbackPhase.BeforeStream, true, context);
+          }
+          return (0, import_html.raw)(html, callbacks);
+        });
+      }
+    ]);
+  } else {
+    return (0, import_html.raw)(resArray.join(""));
+  }
+};
+Suspense[import_constants.DOM_RENDERER] = import_components2.Suspense;
+const textEncoder = new TextEncoder();
+const renderToReadableStream = (content, onError = console.trace) => {
+  let cancelled = false;
+  const reader = new ReadableStream({
+    async start(controller) {
+      try {
+        if (content instanceof import_base.JSXNode) {
+          content = content.toString();
+        }
+        const context = typeof content === "object" ? content : {};
+        const resolved = await (0, import_html2.resolveCallback)(
+          content,
+          import_html2.HtmlEscapedCallbackPhase.BeforeStream,
+          true,
+          context
+        );
+        if (!cancelled) {
+          controller.enqueue(textEncoder.encode(resolved));
+        }
+        let resolvedCount = 0;
+        const callbacks = [];
+        const then = (promise) => {
+          callbacks.push(
+            promise.catch((err) => {
+              console.log(err);
+              onError(err);
+              return "";
+            }).then(async (res) => {
+              res = await (0, import_html2.resolveCallback)(
+                res,
+                import_html2.HtmlEscapedCallbackPhase.BeforeStream,
+                true,
+                context
+              );
+              res.callbacks?.map((c) => c({ phase: import_html2.HtmlEscapedCallbackPhase.Stream, context })).filter(Boolean).forEach(then);
+              resolvedCount++;
+              if (!cancelled) {
+                controller.enqueue(textEncoder.encode(res));
+              }
+            })
+          );
+        };
+        resolved.callbacks?.map((c) => c({ phase: import_html2.HtmlEscapedCallbackPhase.Stream, context })).filter(Boolean).forEach(then);
+        while (resolvedCount !== callbacks.length) {
+          await Promise.all(callbacks);
+        }
+      } catch (e) {
+        onError(e);
+      }
+      if (!cancelled) {
+        controller.close();
+      }
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+  return reader;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StreamingContext,
+  Suspense,
+  renderToReadableStream
+});

package/benchmarks/e2-framework-v1/project/vendor/hono/dist/cjs/jsx/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);