@pleaseai/agent 0.1.16 → 0.1.18

package/.output/server/node_modules/@vue/compiler-ssr/dist/compiler-ssr.cjs.js

@@ -0,0 +1,1413 @@
+/**
+* @vue/compiler-ssr v3.5.30
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var compilerDom = require('@vue/compiler-dom');
+var shared = require('@vue/shared');
+
+const SSR_INTERPOLATE = /* @__PURE__ */ Symbol(`ssrInterpolate`);
+const SSR_RENDER_VNODE = /* @__PURE__ */ Symbol(`ssrRenderVNode`);
+const SSR_RENDER_COMPONENT = /* @__PURE__ */ Symbol(`ssrRenderComponent`);
+const SSR_RENDER_SLOT = /* @__PURE__ */ Symbol(`ssrRenderSlot`);
+const SSR_RENDER_SLOT_INNER = /* @__PURE__ */ Symbol(`ssrRenderSlotInner`);
+const SSR_RENDER_CLASS = /* @__PURE__ */ Symbol(`ssrRenderClass`);
+const SSR_RENDER_STYLE = /* @__PURE__ */ Symbol(`ssrRenderStyle`);
+const SSR_RENDER_ATTRS = /* @__PURE__ */ Symbol(`ssrRenderAttrs`);
+const SSR_RENDER_ATTR = /* @__PURE__ */ Symbol(`ssrRenderAttr`);
+const SSR_RENDER_DYNAMIC_ATTR = /* @__PURE__ */ Symbol(`ssrRenderDynamicAttr`);
+const SSR_RENDER_LIST = /* @__PURE__ */ Symbol(`ssrRenderList`);
+const SSR_INCLUDE_BOOLEAN_ATTR = /* @__PURE__ */ Symbol(
+  `ssrIncludeBooleanAttr`
+);
+const SSR_LOOSE_EQUAL = /* @__PURE__ */ Symbol(`ssrLooseEqual`);
+const SSR_LOOSE_CONTAIN = /* @__PURE__ */ Symbol(`ssrLooseContain`);
+const SSR_RENDER_DYNAMIC_MODEL = /* @__PURE__ */ Symbol(
+  `ssrRenderDynamicModel`
+);
+const SSR_GET_DYNAMIC_MODEL_PROPS = /* @__PURE__ */ Symbol(
+  `ssrGetDynamicModelProps`
+);
+const SSR_RENDER_TELEPORT = /* @__PURE__ */ Symbol(`ssrRenderTeleport`);
+const SSR_RENDER_SUSPENSE = /* @__PURE__ */ Symbol(`ssrRenderSuspense`);
+const SSR_GET_DIRECTIVE_PROPS = /* @__PURE__ */ Symbol(`ssrGetDirectiveProps`);
+const ssrHelpers = {
+  [SSR_INTERPOLATE]: `ssrInterpolate`,
+  [SSR_RENDER_VNODE]: `ssrRenderVNode`,
+  [SSR_RENDER_COMPONENT]: `ssrRenderComponent`,
+  [SSR_RENDER_SLOT]: `ssrRenderSlot`,
+  [SSR_RENDER_SLOT_INNER]: `ssrRenderSlotInner`,
+  [SSR_RENDER_CLASS]: `ssrRenderClass`,
+  [SSR_RENDER_STYLE]: `ssrRenderStyle`,
+  [SSR_RENDER_ATTRS]: `ssrRenderAttrs`,
+  [SSR_RENDER_ATTR]: `ssrRenderAttr`,
+  [SSR_RENDER_DYNAMIC_ATTR]: `ssrRenderDynamicAttr`,
+  [SSR_RENDER_LIST]: `ssrRenderList`,
+  [SSR_INCLUDE_BOOLEAN_ATTR]: `ssrIncludeBooleanAttr`,
+  [SSR_LOOSE_EQUAL]: `ssrLooseEqual`,
+  [SSR_LOOSE_CONTAIN]: `ssrLooseContain`,
+  [SSR_RENDER_DYNAMIC_MODEL]: `ssrRenderDynamicModel`,
+  [SSR_GET_DYNAMIC_MODEL_PROPS]: `ssrGetDynamicModelProps`,
+  [SSR_RENDER_TELEPORT]: `ssrRenderTeleport`,
+  [SSR_RENDER_SUSPENSE]: `ssrRenderSuspense`,
+  [SSR_GET_DIRECTIVE_PROPS]: `ssrGetDirectiveProps`
+};
+compilerDom.registerRuntimeHelpers(ssrHelpers);
+
+const ssrTransformIf = compilerDom.createStructuralDirectiveTransform(
+  /^(?:if|else|else-if)$/,
+  compilerDom.processIf
+);
+function ssrProcessIf(node, context, disableNestedFragments = false, disableComment = false) {
+  const [rootBranch] = node.branches;
+  const ifStatement = compilerDom.createIfStatement(
+    rootBranch.condition,
+    processIfBranch(rootBranch, context, disableNestedFragments)
+  );
+  context.pushStatement(ifStatement);
+  let currentIf = ifStatement;
+  for (let i = 1; i < node.branches.length; i++) {
+    const branch = node.branches[i];
+    const branchBlockStatement = processIfBranch(
+      branch,
+      context,
+      disableNestedFragments
+    );
+    if (branch.condition) {
+      currentIf = currentIf.alternate = compilerDom.createIfStatement(
+        branch.condition,
+        branchBlockStatement
+      );
+    } else {
+      currentIf.alternate = branchBlockStatement;
+    }
+  }
+  if (!currentIf.alternate && !disableComment) {
+    currentIf.alternate = compilerDom.createBlockStatement([
+      compilerDom.createCallExpression(`_push`, ["`<!---->`"])
+    ]);
+  }
+}
+function processIfBranch(branch, context, disableNestedFragments = false) {
+  const { children } = branch;
+  const needFragmentWrapper = !disableNestedFragments && (children.length !== 1 || children[0].type !== 1) && // optimize away nested fragments when the only child is a ForNode
+  !(children.length === 1 && children[0].type === 11);
+  return processChildrenAsStatement(branch, context, needFragmentWrapper);
+}
+
+const ssrTransformFor = compilerDom.createStructuralDirectiveTransform("for", compilerDom.processFor);
+function ssrProcessFor(node, context, disableNestedFragments = false) {
+  const needFragmentWrapper = !disableNestedFragments && (node.children.length !== 1 || node.children[0].type !== 1);
+  const renderLoop = compilerDom.createFunctionExpression(
+    compilerDom.createForLoopParams(node.parseResult)
+  );
+  renderLoop.body = processChildrenAsStatement(
+    node,
+    context,
+    needFragmentWrapper
+  );
+  if (!disableNestedFragments) {
+    context.pushStringPart(`<!--[-->`);
+  }
+  context.pushStatement(
+    compilerDom.createCallExpression(context.helper(SSR_RENDER_LIST), [
+      node.source,
+      renderLoop
+    ])
+  );
+  if (!disableNestedFragments) {
+    context.pushStringPart(`<!--]-->`);
+  }
+}
+
+const ssrTransformSlotOutlet = (node, context) => {
+  if (compilerDom.isSlotOutlet(node)) {
+    const { slotName, slotProps } = compilerDom.processSlotOutlet(node, context);
+    const args = [
+      `_ctx.$slots`,
+      slotName,
+      slotProps || `{}`,
+      // fallback content placeholder. will be replaced in the process phase
+      `null`,
+      `_push`,
+      `_parent`
+    ];
+    if (context.scopeId && context.slotted !== false) {
+      args.push(`"${context.scopeId}-s"`);
+    }
+    let method = SSR_RENDER_SLOT;
+    let parent = context.parent;
+    if (parent) {
+      const children = parent.children;
+      if (parent.type === 10) {
+        parent = context.grandParent;
+      }
+      let componentType;
+      if (parent.type === 1 && parent.tagType === 1 && ((componentType = compilerDom.resolveComponentType(parent, context, true)) === compilerDom.TRANSITION || componentType === compilerDom.TRANSITION_GROUP) && children.filter((c) => c.type === 1).length === 1) {
+        method = SSR_RENDER_SLOT_INNER;
+        if (!(context.scopeId && context.slotted !== false)) {
+          args.push("null");
+        }
+        args.push("true");
+      }
+    }
+    node.ssrCodegenNode = compilerDom.createCallExpression(context.helper(method), args);
+  }
+};
+function ssrProcessSlotOutlet(node, context) {
+  const renderCall = node.ssrCodegenNode;
+  if (node.children.length) {
+    const fallbackRenderFn = compilerDom.createFunctionExpression([]);
+    fallbackRenderFn.body = processChildrenAsStatement(node, context);
+    renderCall.arguments[3] = fallbackRenderFn;
+  }
+  if (context.withSlotScopeId) {
+    const slotScopeId = renderCall.arguments[6];
+    renderCall.arguments[6] = slotScopeId ? `${slotScopeId} + _scopeId` : `_scopeId`;
+  }
+  context.pushStatement(node.ssrCodegenNode);
+}
+
+function createSSRCompilerError(code, loc) {
+  return compilerDom.createCompilerError(code, loc, SSRErrorMessages);
+}
+const SSRErrorMessages = {
+  [65]: `Unsafe attribute name for SSR.`,
+  [66]: `Missing the 'to' prop on teleport element.`,
+  [67]: `Invalid AST node during SSR transform.`
+};
+
+function ssrProcessTeleport(node, context) {
+  const targetProp = compilerDom.findProp(node, "to");
+  if (!targetProp) {
+    context.onError(
+      createSSRCompilerError(66, node.loc)
+    );
+    return;
+  }
+  let target;
+  if (targetProp.type === 6) {
+    target = targetProp.value && compilerDom.createSimpleExpression(targetProp.value.content, true);
+  } else {
+    target = targetProp.exp;
+  }
+  if (!target) {
+    context.onError(
+      createSSRCompilerError(
+        66,
+        targetProp.loc
+      )
+    );
+    return;
+  }
+  const disabledProp = compilerDom.findProp(
+    node,
+    "disabled",
+    false,
+    true
+    /* allow empty */
+  );
+  const disabled = disabledProp ? disabledProp.type === 6 ? `true` : disabledProp.exp || `false` : `false`;
+  const contentRenderFn = compilerDom.createFunctionExpression(
+    [`_push`],
+    void 0,
+    // Body is added later
+    true,
+    // newline
+    false,
+    // isSlot
+    node.loc
+  );
+  contentRenderFn.body = processChildrenAsStatement(node, context);
+  context.pushStatement(
+    compilerDom.createCallExpression(context.helper(SSR_RENDER_TELEPORT), [
+      `_push`,
+      contentRenderFn,
+      target,
+      disabled,
+      `_parent`
+    ])
+  );
+}
+
+const wipMap$3 = /* @__PURE__ */ new WeakMap();
+function ssrTransformSuspense(node, context) {
+  return () => {
+    if (node.children.length) {
+      const wipEntry = {
+        slotsExp: null,
+        // to be immediately set
+        wipSlots: []
+      };
+      wipMap$3.set(node, wipEntry);
+      wipEntry.slotsExp = compilerDom.buildSlots(
+        node,
+        context,
+        (_props, _vForExp, children, loc) => {
+          const fn = compilerDom.createFunctionExpression(
+            [],
+            void 0,
+            // no return, assign body later
+            true,
+            // newline
+            false,
+            // suspense slots are not treated as normal slots
+            loc
+          );
+          wipEntry.wipSlots.push({
+            fn,
+            children
+          });
+          return fn;
+        }
+      ).slots;
+    }
+  };
+}
+function ssrProcessSuspense(node, context) {
+  const wipEntry = wipMap$3.get(node);
+  if (!wipEntry) {
+    return;
+  }
+  const { slotsExp, wipSlots } = wipEntry;
+  for (let i = 0; i < wipSlots.length; i++) {
+    const slot = wipSlots[i];
+    slot.fn.body = processChildrenAsStatement(slot, context);
+  }
+  context.pushStatement(
+    compilerDom.createCallExpression(context.helper(SSR_RENDER_SUSPENSE), [
+      `_push`,
+      slotsExp
+    ])
+  );
+}
+
+const rawChildrenMap = /* @__PURE__ */ new WeakMap();
+const ssrTransformElement = (node, context) => {
+  if (node.type !== 1 || node.tagType !== 0) {
+    return;
+  }
+  return function ssrPostTransformElement() {
+    const openTag = [`<${node.tag}`];
+    const needTagForRuntime = node.tag === "textarea" || node.tag.indexOf("-") > 0;
+    const hasDynamicVBind = compilerDom.hasDynamicKeyVBind(node);
+    const hasCustomDir = node.props.some(
+      (p) => p.type === 7 && !shared.isBuiltInDirective(p.name)
+    );
+    const vShowPropIndex = node.props.findIndex(
+      (i) => i.type === 7 && i.name === "show"
+    );
+    if (vShowPropIndex !== -1) {
+      const vShowProp = node.props[vShowPropIndex];
+      node.props.splice(vShowPropIndex, 1);
+      node.props.push(vShowProp);
+    }
+    const needMergeProps = hasDynamicVBind || hasCustomDir;
+    if (needMergeProps) {
+      const { props, directives } = compilerDom.buildProps(
+        node,
+        context,
+        node.props,
+        false,
+        false,
+        true
+      );
+      if (props || directives.length) {
+        const mergedProps = buildSSRProps(props, directives, context);
+        const propsExp = compilerDom.createCallExpression(
+          context.helper(SSR_RENDER_ATTRS),
+          [mergedProps]
+        );
+        if (node.tag === "textarea") {
+          const existingText = node.children[0];
+          if (!hasContentOverrideDirective(node) && (!existingText || existingText.type !== 5)) {
+            const tempId = `_temp${context.temps++}`;
+            propsExp.arguments = [
+              compilerDom.createAssignmentExpression(
+                compilerDom.createSimpleExpression(tempId, false),
+                mergedProps
+              )
+            ];
+            rawChildrenMap.set(
+              node,
+              compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [
+                compilerDom.createConditionalExpression(
+                  compilerDom.createSimpleExpression(`"value" in ${tempId}`, false),
+                  compilerDom.createSimpleExpression(`${tempId}.value`, false),
+                  compilerDom.createSimpleExpression(
+                    existingText ? existingText.content : ``,
+                    true
+                  ),
+                  false
+                )
+              ])
+            );
+          }
+        } else if (node.tag === "input") {
+          const vModel = findVModel(node);
+          if (vModel) {
+            const tempId = `_temp${context.temps++}`;
+            const tempExp = compilerDom.createSimpleExpression(tempId, false);
+            propsExp.arguments = [
+              compilerDom.createSequenceExpression([
+                compilerDom.createAssignmentExpression(tempExp, mergedProps),
+                compilerDom.createCallExpression(context.helper(compilerDom.MERGE_PROPS), [
+                  tempExp,
+                  compilerDom.createCallExpression(
+                    context.helper(SSR_GET_DYNAMIC_MODEL_PROPS),
+                    [
+                      tempExp,
+                      // existing props
+                      vModel.exp
+                      // model
+                    ]
+                  )
+                ])
+              ])
+            ];
+          }
+        } else if (directives.length && !node.children.length) {
+          if (!hasContentOverrideDirective(node)) {
+            const tempId = `_temp${context.temps++}`;
+            propsExp.arguments = [
+              compilerDom.createAssignmentExpression(
+                compilerDom.createSimpleExpression(tempId, false),
+                mergedProps
+              )
+            ];
+            rawChildrenMap.set(
+              node,
+              compilerDom.createConditionalExpression(
+                compilerDom.createSimpleExpression(`"textContent" in ${tempId}`, false),
+                compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [
+                  compilerDom.createSimpleExpression(`${tempId}.textContent`, false)
+                ]),
+                compilerDom.createSimpleExpression(`${tempId}.innerHTML ?? ''`, false),
+                false
+              )
+            );
+          }
+        }
+        if (needTagForRuntime) {
+          propsExp.arguments.push(`"${node.tag}"`);
+        }
+        openTag.push(propsExp);
+      }
+    }
+    let dynamicClassBinding = void 0;
+    let staticClassBinding = void 0;
+    let dynamicStyleBinding = void 0;
+    for (let i = 0; i < node.props.length; i++) {
+      const prop = node.props[i];
+      if (node.tag === "input" && isTrueFalseValue(prop)) {
+        continue;
+      }
+      if (prop.type === 7) {
+        if (prop.name === "html" && prop.exp) {
+          rawChildrenMap.set(
+            node,
+            compilerDom.createCompoundExpression([`(`, prop.exp, `) ?? ''`])
+          );
+        } else if (prop.name === "text" && prop.exp) {
+          node.children = [compilerDom.createInterpolation(prop.exp, prop.loc)];
+        } else if (prop.name === "slot") {
+          context.onError(
+            compilerDom.createCompilerError(40, prop.loc)
+          );
+        } else if (isTextareaWithValue(node, prop) && prop.exp) {
+          if (!needMergeProps) {
+            node.children = [compilerDom.createInterpolation(prop.exp, prop.loc)];
+          }
+        } else if (!needMergeProps && prop.name !== "on") {
+          const directiveTransform = context.directiveTransforms[prop.name];
+          if (directiveTransform) {
+            const { props, ssrTagParts } = directiveTransform(
+              prop,
+              node,
+              context
+            );
+            if (ssrTagParts) {
+              openTag.push(...ssrTagParts);
+            }
+            for (let j = 0; j < props.length; j++) {
+              const { key, value } = props[j];
+              if (compilerDom.isStaticExp(key)) {
+                let attrName = key.content;
+                if (attrName === "key" || attrName === "ref") {
+                  continue;
+                }
+                if (attrName === "class") {
+                  openTag.push(
+                    ` class="`,
+                    dynamicClassBinding = compilerDom.createCallExpression(
+                      context.helper(SSR_RENDER_CLASS),
+                      [value]
+                    ),
+                    `"`
+                  );
+                } else if (attrName === "style") {
+                  if (dynamicStyleBinding) {
+                    mergeCall(dynamicStyleBinding, value);
+                  } else {
+                    openTag.push(
+                      ` style="`,
+                      dynamicStyleBinding = compilerDom.createCallExpression(
+                        context.helper(SSR_RENDER_STYLE),
+                        [value]
+                      ),
+                      `"`
+                    );
+                  }
+                } else {
+                  attrName = node.tag.indexOf("-") > 0 ? attrName : shared.propsToAttrMap[attrName] || attrName.toLowerCase();
+                  if (shared.isBooleanAttr(attrName)) {
+                    openTag.push(
+                      compilerDom.createConditionalExpression(
+                        compilerDom.createCallExpression(
+                          context.helper(SSR_INCLUDE_BOOLEAN_ATTR),
+                          [value]
+                        ),
+                        compilerDom.createSimpleExpression(" " + attrName, true),
+                        compilerDom.createSimpleExpression("", true),
+                        false
+                      )
+                    );
+                  } else if (shared.isSSRSafeAttrName(attrName)) {
+                    openTag.push(
+                      compilerDom.createCallExpression(context.helper(SSR_RENDER_ATTR), [
+                        key,
+                        value
+                      ])
+                    );
+                  } else {
+                    context.onError(
+                      createSSRCompilerError(
+                        65,
+                        key.loc
+                      )
+                    );
+                  }
+                }
+              } else {
+                const args = [key, value];
+                if (needTagForRuntime) {
+                  args.push(`"${node.tag}"`);
+                }
+                openTag.push(
+                  compilerDom.createCallExpression(
+                    context.helper(SSR_RENDER_DYNAMIC_ATTR),
+                    args
+                  )
+                );
+              }
+            }
+          }
+        }
+      } else {
+        const name = prop.name;
+        if (node.tag === "textarea" && name === "value" && prop.value) {
+          rawChildrenMap.set(node, shared.escapeHtml(prop.value.content));
+        } else if (!needMergeProps) {
+          if (name === "key" || name === "ref") {
+            continue;
+          }
+          if (name === "class" && prop.value) {
+            staticClassBinding = JSON.stringify(prop.value.content);
+          }
+          openTag.push(
+            ` ${prop.name}` + (prop.value ? `="${shared.escapeHtml(prop.value.content)}"` : ``)
+          );
+        }
+      }
+    }
+    if (dynamicClassBinding && staticClassBinding) {
+      mergeCall(dynamicClassBinding, staticClassBinding);
+      removeStaticBinding(openTag, "class");
+    }
+    if (context.scopeId) {
+      openTag.push(` ${context.scopeId}`);
+    }
+    node.ssrCodegenNode = compilerDom.createTemplateLiteral(openTag);
+  };
+};
+function buildSSRProps(props, directives, context) {
+  let mergePropsArgs = [];
+  if (props) {
+    if (props.type === 14) {
+      mergePropsArgs = props.arguments;
+    } else {
+      mergePropsArgs.push(props);
+    }
+  }
+  if (directives.length) {
+    for (const dir of directives) {
+      mergePropsArgs.push(
+        compilerDom.createCallExpression(context.helper(SSR_GET_DIRECTIVE_PROPS), [
+          `_ctx`,
+          ...compilerDom.buildDirectiveArgs(dir, context).elements
+        ])
+      );
+    }
+  }
+  return mergePropsArgs.length > 1 ? compilerDom.createCallExpression(context.helper(compilerDom.MERGE_PROPS), mergePropsArgs) : mergePropsArgs[0];
+}
+function isTrueFalseValue(prop) {
+  if (prop.type === 7) {
+    return prop.name === "bind" && prop.arg && compilerDom.isStaticExp(prop.arg) && (prop.arg.content === "true-value" || prop.arg.content === "false-value");
+  } else {
+    return prop.name === "true-value" || prop.name === "false-value";
+  }
+}
+function isTextareaWithValue(node, prop) {
+  return !!(node.tag === "textarea" && prop.name === "bind" && compilerDom.isStaticArgOf(prop.arg, "value"));
+}
+function mergeCall(call, arg) {
+  const existing = call.arguments[0];
+  if (existing.type === 17) {
+    existing.elements.push(arg);
+  } else {
+    call.arguments[0] = compilerDom.createArrayExpression([existing, arg]);
+  }
+}
+function removeStaticBinding(tag, binding) {
+  const regExp = new RegExp(`^ ${binding}=".+"$`);
+  const i = tag.findIndex((e) => typeof e === "string" && regExp.test(e));
+  if (i > -1) {
+    tag.splice(i, 1);
+  }
+}
+function findVModel(node) {
+  return node.props.find(
+    (p) => p.type === 7 && p.name === "model" && p.exp
+  );
+}
+function hasContentOverrideDirective(node) {
+  return !!compilerDom.findDir(node, "text") || !!compilerDom.findDir(node, "html");
+}
+function ssrProcessElement(node, context) {
+  const isVoidTag = context.options.isVoidTag || shared.NO;
+  const elementsToAdd = node.ssrCodegenNode.elements;
+  for (let j = 0; j < elementsToAdd.length; j++) {
+    context.pushStringPart(elementsToAdd[j]);
+  }
+  if (context.withSlotScopeId) {
+    context.pushStringPart(compilerDom.createSimpleExpression(`_scopeId`, false));
+  }
+  context.pushStringPart(`>`);
+  const rawChildren = rawChildrenMap.get(node);
+  if (rawChildren) {
+    context.pushStringPart(rawChildren);
+  } else if (node.children.length) {
+    processChildren(node, context);
+  }
+  if (!isVoidTag(node.tag)) {
+    context.pushStringPart(`</${node.tag}>`);
+  }
+}
+
+const wipMap$2 = /* @__PURE__ */ new WeakMap();
+function ssrTransformTransitionGroup(node, context) {
+  return () => {
+    const tag = compilerDom.findProp(node, "tag");
+    if (tag) {
+      const otherProps = node.props.filter((p) => p !== tag);
+      const { props, directives } = compilerDom.buildProps(
+        node,
+        context,
+        otherProps,
+        true,
+        false,
+        true
+      );
+      let propsExp = null;
+      if (props || directives.length) {
+        propsExp = compilerDom.createCallExpression(context.helper(SSR_RENDER_ATTRS), [
+          buildSSRProps(props, directives, context)
+        ]);
+      }
+      wipMap$2.set(node, {
+        tag,
+        propsExp,
+        scopeId: context.scopeId || null
+      });
+    }
+  };
+}
+function ssrProcessTransitionGroup(node, context) {
+  const entry = wipMap$2.get(node);
+  if (entry) {
+    const { tag, propsExp, scopeId } = entry;
+    if (tag.type === 7) {
+      context.pushStringPart(`<`);
+      context.pushStringPart(tag.exp);
+      if (propsExp) {
+        context.pushStringPart(propsExp);
+      }
+      if (scopeId) {
+        context.pushStringPart(` ${scopeId}`);
+      }
+      context.pushStringPart(`>`);
+      processChildren(
+        node,
+        context,
+        false,
+        /**
+         * TransitionGroup has the special runtime behavior of flattening and
+         * concatenating all children into a single fragment (in order for them to
+         * be patched using the same key map) so we need to account for that here
+         * by disabling nested fragment wrappers from being generated.
+         */
+        true,
+        /**
+         * TransitionGroup filters out comment children at runtime and thus
+         * doesn't expect comments to be present during hydration. We need to
+         * account for that by disabling the empty comment that is otherwise
+         * rendered for a falsy v-if that has no v-else specified. (#6715)
+         */
+        true
+      );
+      context.pushStringPart(`</`);
+      context.pushStringPart(tag.exp);
+      context.pushStringPart(`>`);
+    } else {
+      context.pushStringPart(`<${tag.value.content}`);
+      if (propsExp) {
+        context.pushStringPart(propsExp);
+      }
+      if (scopeId) {
+        context.pushStringPart(` ${scopeId}`);
+      }
+      context.pushStringPart(`>`);
+      processChildren(node, context, false, true, true);
+      context.pushStringPart(`</${tag.value.content}>`);
+    }
+  } else {
+    processChildren(node, context, true, true, true);
+  }
+}
+
+const wipMap$1 = /* @__PURE__ */ new WeakMap();
+function ssrTransformTransition(node, context) {
+  return () => {
+    const appear = compilerDom.findProp(node, "appear", false, true);
+    wipMap$1.set(node, !!appear);
+  };
+}
+function ssrProcessTransition(node, context) {
+  node.children = node.children.filter((c) => c.type !== 3);
+  const appear = wipMap$1.get(node);
+  if (appear) {
+    context.pushStringPart(`<template>`);
+    processChildren(node, context, false, true);
+    context.pushStringPart(`</template>`);
+  } else {
+    processChildren(node, context, false, true);
+  }
+}
+
+const wipMap = /* @__PURE__ */ new WeakMap();
+const WIP_SLOT = /* @__PURE__ */ Symbol();
+const componentTypeMap = /* @__PURE__ */ new WeakMap();
+const ssrTransformComponent = (node, context) => {
+  if (node.type !== 1 || node.tagType !== 1) {
+    return;
+  }
+  const component = compilerDom.resolveComponentType(
+    node,
+    context,
+    true
+    /* ssr */
+  );
+  const isDynamicComponent = shared.isObject(component) && component.callee === compilerDom.RESOLVE_DYNAMIC_COMPONENT;
+  componentTypeMap.set(node, component);
+  if (shared.isSymbol(component)) {
+    if (component === compilerDom.SUSPENSE) {
+      return ssrTransformSuspense(node, context);
+    } else if (component === compilerDom.TRANSITION_GROUP) {
+      return ssrTransformTransitionGroup(node, context);
+    } else if (component === compilerDom.TRANSITION) {
+      return ssrTransformTransition(node);
+    }
+    return;
+  }
+  const vnodeBranches = [];
+  const clonedNode = clone(node);
+  return function ssrPostTransformComponent() {
+    if (clonedNode.children.length) {
+      compilerDom.buildSlots(clonedNode, context, (props, vFor, children) => {
+        vnodeBranches.push(
+          createVNodeSlotBranch(props, vFor, children, context)
+        );
+        return compilerDom.createFunctionExpression(void 0);
+      });
+    }
+    let propsExp = `null`;
+    if (node.props.length) {
+      const { props, directives } = compilerDom.buildProps(
+        node,
+        context,
+        void 0,
+        true,
+        isDynamicComponent
+      );
+      if (props || directives.length) {
+        propsExp = buildSSRProps(props, directives, context);
+      }
+    }
+    const wipEntries = [];
+    wipMap.set(node, wipEntries);
+    const buildSSRSlotFn = (props, _vForExp, children, loc) => {
+      const param0 = props && compilerDom.stringifyExpression(props) || `_`;
+      const fn = compilerDom.createFunctionExpression(
+        [param0, `_push`, `_parent`, `_scopeId`],
+        void 0,
+        // no return, assign body later
+        true,
+        // newline
+        true,
+        // isSlot
+        loc
+      );
+      wipEntries.push({
+        type: WIP_SLOT,
+        fn,
+        children,
+        // also collect the corresponding vnode branch built earlier
+        vnodeBranch: vnodeBranches[wipEntries.length]
+      });
+      return fn;
+    };
+    const slots = node.children.length ? compilerDom.buildSlots(node, context, buildSSRSlotFn).slots : `null`;
+    if (typeof component !== "string") {
+      node.ssrCodegenNode = compilerDom.createCallExpression(
+        context.helper(SSR_RENDER_VNODE),
+        [
+          `_push`,
+          compilerDom.createCallExpression(context.helper(compilerDom.CREATE_VNODE), [
+            component,
+            propsExp,
+            slots
+          ]),
+          `_parent`
+        ]
+      );
+    } else {
+      node.ssrCodegenNode = compilerDom.createCallExpression(
+        context.helper(SSR_RENDER_COMPONENT),
+        [component, propsExp, slots, `_parent`]
+      );
+    }
+  };
+};
+function ssrProcessComponent(node, context, parent) {
+  const component = componentTypeMap.get(node);
+  if (!node.ssrCodegenNode) {
+    if (component === compilerDom.TELEPORT) {
+      return ssrProcessTeleport(node, context);
+    } else if (component === compilerDom.SUSPENSE) {
+      return ssrProcessSuspense(node, context);
+    } else if (component === compilerDom.TRANSITION_GROUP) {
+      return ssrProcessTransitionGroup(node, context);
+    } else {
+      if (parent.type === WIP_SLOT) {
+        context.pushStringPart(``);
+      }
+      if (component === compilerDom.TRANSITION) {
+        return ssrProcessTransition(node, context);
+      }
+      processChildren(node, context);
+    }
+  } else {
+    const wipEntries = wipMap.get(node) || [];
+    for (let i = 0; i < wipEntries.length; i++) {
+      const { fn, vnodeBranch } = wipEntries[i];
+      fn.body = compilerDom.createIfStatement(
+        compilerDom.createSimpleExpression(`_push`, false),
+        processChildrenAsStatement(
+          wipEntries[i],
+          context,
+          false,
+          true
+        ),
+        vnodeBranch
+      );
+    }
+    if (context.withSlotScopeId) {
+      node.ssrCodegenNode.arguments.push(`_scopeId`);
+    }
+    if (typeof component === "string") {
+      context.pushStatement(
+        compilerDom.createCallExpression(`_push`, [node.ssrCodegenNode])
+      );
+    } else {
+      context.pushStatement(node.ssrCodegenNode);
+    }
+  }
+}
+const rawOptionsMap = /* @__PURE__ */ new WeakMap();
+const [baseNodeTransforms, baseDirectiveTransforms] = compilerDom.getBaseTransformPreset(true);
+const vnodeNodeTransforms = [...baseNodeTransforms, ...compilerDom.DOMNodeTransforms];
+const vnodeDirectiveTransforms = {
+  ...baseDirectiveTransforms,
+  ...compilerDom.DOMDirectiveTransforms
+};
+function createVNodeSlotBranch(slotProps, vFor, children, parentContext) {
+  const rawOptions = rawOptionsMap.get(parentContext.root);
+  const subOptions = {
+    ...rawOptions,
+    // overwrite with vnode-based transforms
+    nodeTransforms: [
+      ...vnodeNodeTransforms,
+      ...rawOptions.nodeTransforms || []
+    ],
+    directiveTransforms: {
+      ...vnodeDirectiveTransforms,
+      ...rawOptions.directiveTransforms || {}
+    }
+  };
+  const wrapperProps = [];
+  if (slotProps) {
+    wrapperProps.push({
+      type: 7,
+      name: "slot",
+      exp: slotProps,
+      arg: void 0,
+      modifiers: [],
+      loc: compilerDom.locStub
+    });
+  }
+  if (vFor) {
+    wrapperProps.push(shared.extend({}, vFor));
+  }
+  const wrapperNode = {
+    type: 1,
+    ns: 0,
+    tag: "template",
+    tagType: 3,
+    props: wrapperProps,
+    children,
+    loc: compilerDom.locStub,
+    codegenNode: void 0
+  };
+  subTransform(wrapperNode, subOptions, parentContext);
+  return compilerDom.createReturnStatement(children);
+}
+function subTransform(node, options, parentContext) {
+  const childRoot = compilerDom.createRoot([node]);
+  const childContext = compilerDom.createTransformContext(childRoot, options);
+  childContext.ssr = false;
+  childContext.scopes = { ...parentContext.scopes };
+  childContext.identifiers = { ...parentContext.identifiers };
+  childContext.imports = parentContext.imports;
+  compilerDom.traverseNode(childRoot, childContext);
+  ["helpers", "components", "directives"].forEach((key) => {
+    childContext[key].forEach((value, helperKey) => {
+      if (key === "helpers") {
+        const parentCount = parentContext.helpers.get(helperKey);
+        if (parentCount === void 0) {
+          parentContext.helpers.set(helperKey, value);
+        } else {
+          parentContext.helpers.set(helperKey, value + parentCount);
+        }
+      } else {
+        parentContext[key].add(value);
+      }
+    });
+  });
+}
+function clone(v) {
+  if (shared.isArray(v)) {
+    return v.map(clone);
+  } else if (shared.isPlainObject(v)) {
+    const res = {};
+    for (const key in v) {
+      res[key] = clone(v[key]);
+    }
+    return res;
+  } else {
+    return v;
+  }
+}
+
+function ssrCodegenTransform(ast, options) {
+  const context = createSSRTransformContext(ast, options);
+  if (options.ssrCssVars) {
+    const cssContext = compilerDom.createTransformContext(compilerDom.createRoot([]), options);
+    const varsExp = compilerDom.processExpression(
+      compilerDom.createSimpleExpression(options.ssrCssVars, false),
+      cssContext
+    );
+    context.body.push(
+      compilerDom.createCompoundExpression([`const _cssVars = { style: `, varsExp, `}`])
+    );
+    Array.from(cssContext.helpers.keys()).forEach((helper) => {
+      ast.helpers.add(helper);
+    });
+  }
+  const isFragment = ast.children.length > 1 && ast.children.some((c) => !compilerDom.isText(c));
+  processChildren(ast, context, isFragment);
+  ast.codegenNode = compilerDom.createBlockStatement(context.body);
+  ast.ssrHelpers = Array.from(
+    /* @__PURE__ */ new Set([
+      ...Array.from(ast.helpers).filter((h) => h in ssrHelpers),
+      ...context.helpers
+    ])
+  );
+  ast.helpers = new Set(Array.from(ast.helpers).filter((h) => !(h in ssrHelpers)));
+}
+function createSSRTransformContext(root, options, helpers = /* @__PURE__ */ new Set(), withSlotScopeId = false) {
+  const body = [];
+  let currentString = null;
+  return {
+    root,
+    options,
+    body,
+    helpers,
+    withSlotScopeId,
+    onError: options.onError || ((e) => {
+      throw e;
+    }),
+    helper(name) {
+      helpers.add(name);
+      return name;
+    },
+    pushStringPart(part) {
+      if (!currentString) {
+        const currentCall = compilerDom.createCallExpression(`_push`);
+        body.push(currentCall);
+        currentString = compilerDom.createTemplateLiteral([]);
+        currentCall.arguments.push(currentString);
+      }
+      const bufferedElements = currentString.elements;
+      const lastItem = bufferedElements[bufferedElements.length - 1];
+      if (shared.isString(part) && shared.isString(lastItem)) {
+        bufferedElements[bufferedElements.length - 1] += part;
+      } else {
+        bufferedElements.push(part);
+      }
+    },
+    pushStatement(statement) {
+      currentString = null;
+      body.push(statement);
+    }
+  };
+}
+function createChildContext(parent, withSlotScopeId = parent.withSlotScopeId) {
+  return createSSRTransformContext(
+    parent.root,
+    parent.options,
+    parent.helpers,
+    withSlotScopeId
+  );
+}
+function processChildren(parent, context, asFragment = false, disableNestedFragments = false, disableComment = false) {
+  if (asFragment) {
+    context.pushStringPart(`<!--[-->`);
+  }
+  const { children } = parent;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    switch (child.type) {
+      case 1:
+        switch (child.tagType) {
+          case 0:
+            ssrProcessElement(child, context);
+            break;
+          case 1:
+            ssrProcessComponent(child, context, parent);
+            break;
+          case 2:
+            ssrProcessSlotOutlet(child, context);
+            break;
+          case 3:
+            break;
+          default:
+            context.onError(
+              createSSRCompilerError(
+                67,
+                child.loc
+              )
+            );
+            const exhaustiveCheck2 = child;
+            return exhaustiveCheck2;
+        }
+        break;
+      case 2:
+        context.pushStringPart(shared.escapeHtml(child.content));
+        break;
+      case 3:
+        if (!disableComment) {
+          context.pushStringPart(`<!--${child.content}-->`);
+        }
+        break;
+      case 5:
+        context.pushStringPart(
+          compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [
+            child.content
+          ])
+        );
+        break;
+      case 9:
+        ssrProcessIf(child, context, disableNestedFragments, disableComment);
+        break;
+      case 11:
+        ssrProcessFor(child, context, disableNestedFragments);
+        break;
+      case 10:
+        break;
+      case 12:
+      case 8:
+        break;
+      default:
+        context.onError(
+          createSSRCompilerError(
+            67,
+            child.loc
+          )
+        );
+        const exhaustiveCheck = child;
+        return exhaustiveCheck;
+    }
+  }
+  if (asFragment) {
+    context.pushStringPart(`<!--]-->`);
+  }
+}
+function processChildrenAsStatement(parent, parentContext, asFragment = false, withSlotScopeId = parentContext.withSlotScopeId) {
+  const childContext = createChildContext(parentContext, withSlotScopeId);
+  processChildren(parent, childContext, asFragment);
+  return compilerDom.createBlockStatement(childContext.body);
+}
+
+const ssrTransformModel = (dir, node, context) => {
+  const model = dir.exp;
+  function checkDuplicatedValue() {
+    const value = compilerDom.findProp(node, "value");
+    if (value) {
+      context.onError(
+        compilerDom.createDOMCompilerError(
+          61,
+          value.loc
+        )
+      );
+    }
+  }
+  const processSelectChildren = (children) => {
+    children.forEach((child) => {
+      if (child.type === 1) {
+        processOption(child);
+      } else if (child.type === 11) {
+        processSelectChildren(child.children);
+      } else if (child.type === 9) {
+        child.branches.forEach((b) => processSelectChildren(b.children));
+      }
+    });
+  };
+  function processOption(plainNode) {
+    if (plainNode.tag === "option") {
+      if (plainNode.props.findIndex((p) => p.name === "selected") === -1) {
+        const value = findValueBinding(plainNode);
+        plainNode.ssrCodegenNode.elements.push(
+          compilerDom.createConditionalExpression(
+            compilerDom.createCallExpression(context.helper(SSR_INCLUDE_BOOLEAN_ATTR), [
+              compilerDom.createConditionalExpression(
+                compilerDom.createCallExpression(`Array.isArray`, [model]),
+                compilerDom.createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [
+                  model,
+                  value
+                ]),
+                compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
+                  model,
+                  value
+                ])
+              )
+            ]),
+            compilerDom.createSimpleExpression(" selected", true),
+            compilerDom.createSimpleExpression("", true),
+            false
+          )
+        );
+      }
+    } else if (plainNode.tag === "optgroup") {
+      processSelectChildren(plainNode.children);
+    }
+  }
+  if (node.tagType === 0) {
+    const res = { props: [] };
+    if (node.tag === "input") {
+      const defaultProps = [
+        // default value binding for text type inputs
+        compilerDom.createObjectProperty(`value`, model)
+      ];
+      const type = compilerDom.findProp(node, "type");
+      if (type) {
+        const value = findValueBinding(node);
+        if (type.type === 7) {
+          res.ssrTagParts = [
+            compilerDom.createCallExpression(context.helper(SSR_RENDER_DYNAMIC_MODEL), [
+              type.exp,
+              model,
+              value
+            ])
+          ];
+        } else if (type.value) {
+          switch (type.value.content) {
+            case "radio":
+              res.props = [
+                compilerDom.createObjectProperty(
+                  `checked`,
+                  compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
+                    model,
+                    value
+                  ])
+                )
+              ];
+              break;
+            case "checkbox":
+              const trueValueBinding = compilerDom.findProp(node, "true-value");
+              if (trueValueBinding) {
+                const trueValue = trueValueBinding.type === 6 ? JSON.stringify(trueValueBinding.value.content) : trueValueBinding.exp;
+                res.props = [
+                  compilerDom.createObjectProperty(
+                    `checked`,
+                    compilerDom.createCallExpression(context.helper(SSR_LOOSE_EQUAL), [
+                      model,
+                      trueValue
+                    ])
+                  )
+                ];
+              } else {
+                res.props = [
+                  compilerDom.createObjectProperty(
+                    `checked`,
+                    compilerDom.createConditionalExpression(
+                      compilerDom.createCallExpression(`Array.isArray`, [model]),
+                      compilerDom.createCallExpression(context.helper(SSR_LOOSE_CONTAIN), [
+                        model,
+                        value
+                      ]),
+                      model
+                    )
+                  )
+                ];
+              }
+              break;
+            case "file":
+              context.onError(
+                compilerDom.createDOMCompilerError(
+                  60,
+                  dir.loc
+                )
+              );
+              break;
+            default:
+              checkDuplicatedValue();
+              res.props = defaultProps;
+              break;
+          }
+        }
+      } else if (compilerDom.hasDynamicKeyVBind(node)) ; else {
+        checkDuplicatedValue();
+        res.props = defaultProps;
+      }
+    } else if (node.tag === "textarea") {
+      checkDuplicatedValue();
+      node.children = [compilerDom.createInterpolation(model, model.loc)];
+    } else if (node.tag === "select") {
+      processSelectChildren(node.children);
+    } else {
+      context.onError(
+        compilerDom.createDOMCompilerError(
+          58,
+          dir.loc
+        )
+      );
+    }
+    return res;
+  } else {
+    return compilerDom.transformModel(dir, node, context);
+  }
+};
+function findValueBinding(node) {
+  const valueBinding = compilerDom.findProp(node, "value");
+  return valueBinding ? valueBinding.type === 7 ? valueBinding.exp : compilerDom.createSimpleExpression(valueBinding.value.content, true) : compilerDom.createSimpleExpression(`null`, false);
+}
+
+const ssrTransformShow = (dir, node, context) => {
+  if (!dir.exp) {
+    context.onError(
+      compilerDom.createDOMCompilerError(62)
+    );
+  }
+  return {
+    props: [
+      compilerDom.createObjectProperty(
+        `style`,
+        compilerDom.createConditionalExpression(
+          dir.exp,
+          compilerDom.createSimpleExpression(`null`, false),
+          compilerDom.createObjectExpression([
+            compilerDom.createObjectProperty(
+              `display`,
+              compilerDom.createSimpleExpression(`none`, true)
+            )
+          ]),
+          false
+        )
+      )
+    ]
+  };
+};
+
+const filterChild = (node) => node.children.filter((n) => !compilerDom.isCommentOrWhitespace(n));
+const hasSingleChild = (node) => filterChild(node).length === 1;
+const ssrInjectFallthroughAttrs = (node, context) => {
+  if (node.type === 0) {
+    context.identifiers._attrs = 1;
+  }
+  if (node.type === 1 && node.tagType === 1 && (node.tag === "transition" || node.tag === "Transition" || node.tag === "KeepAlive" || node.tag === "keep-alive")) {
+    const rootChildren = filterChild(context.root);
+    if (rootChildren.length === 1 && rootChildren[0] === node) {
+      if (hasSingleChild(node)) {
+        injectFallthroughAttrs(node.children[0]);
+      }
+      return;
+    }
+  }
+  const parent = context.parent;
+  if (!parent || parent.type !== 0) {
+    return;
+  }
+  if (node.type === 10 && hasSingleChild(node)) {
+    let hasEncounteredIf = false;
+    for (const c of filterChild(parent)) {
+      if (c.type === 9 || c.type === 1 && compilerDom.findDir(c, "if")) {
+        if (hasEncounteredIf) return;
+        hasEncounteredIf = true;
+      } else if (
+        // node before v-if
+        !hasEncounteredIf || // non else nodes
+        !(c.type === 1 && compilerDom.findDir(c, /else/, true))
+      ) {
+        return;
+      }
+    }
+    injectFallthroughAttrs(node.children[0]);
+  } else if (hasSingleChild(parent)) {
+    injectFallthroughAttrs(node);
+  }
+};
+function injectFallthroughAttrs(node) {
+  if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !compilerDom.findDir(node, "for")) {
+    node.props.push({
+      type: 7,
+      name: "bind",
+      arg: void 0,
+      exp: compilerDom.createSimpleExpression(`_attrs`, false),
+      modifiers: [],
+      loc: compilerDom.locStub
+    });
+  }
+}
+
+const ssrInjectCssVars = (node, context) => {
+  if (!context.ssrCssVars) {
+    return;
+  }
+  if (node.type === 0) {
+    context.identifiers._cssVars = 1;
+  }
+  const parent = context.parent;
+  if (!parent || parent.type !== 0) {
+    return;
+  }
+  if (node.type === 10) {
+    for (const child of node.children) {
+      injectCssVars(child);
+    }
+  } else {
+    injectCssVars(node);
+  }
+};
+function injectCssVars(node) {
+  if (node.type === 1 && (node.tagType === 0 || node.tagType === 1) && !compilerDom.findDir(node, "for")) {
+    if (node.tag === "suspense" || node.tag === "Suspense") {
+      for (const child of node.children) {
+        if (child.type === 1 && child.tagType === 3) {
+          child.children.forEach(injectCssVars);
+        } else {
+          injectCssVars(child);
+        }
+      }
+    } else {
+      node.props.push({
+        type: 7,
+        name: "bind",
+        arg: void 0,
+        exp: compilerDom.createSimpleExpression(`_cssVars`, false),
+        modifiers: [],
+        loc: compilerDom.locStub
+      });
+    }
+  }
+}
+
+function compile(source, options = {}) {
+  options = {
+    ...options,
+    ...compilerDom.parserOptions,
+    ssr: true,
+    inSSR: true,
+    scopeId: options.mode === "function" ? null : options.scopeId,
+    // always prefix since compiler-ssr doesn't have size concern
+    prefixIdentifiers: true,
+    // disable optimizations that are unnecessary for ssr
+    cacheHandlers: false,
+    hoistStatic: false
+  };
+  const ast = typeof source === "string" ? compilerDom.baseParse(source, options) : source;
+  rawOptionsMap.set(ast, options);
+  compilerDom.transform(ast, {
+    ...options,
+    hoistStatic: false,
+    nodeTransforms: [
+      compilerDom.transformVBindShorthand,
+      ssrTransformIf,
+      ssrTransformFor,
+      compilerDom.trackVForSlotScopes,
+      compilerDom.transformExpression,
+      ssrTransformSlotOutlet,
+      ssrInjectFallthroughAttrs,
+      ssrInjectCssVars,
+      ssrTransformElement,
+      ssrTransformComponent,
+      compilerDom.trackSlotScopes,
+      compilerDom.transformStyle,
+      ...options.nodeTransforms || []
+      // user transforms
+    ],
+    directiveTransforms: {
+      // reusing core v-bind
+      bind: compilerDom.transformBind,
+      on: compilerDom.transformOn,
+      // model and show have dedicated SSR handling
+      model: ssrTransformModel,
+      show: ssrTransformShow,
+      // the following are ignored during SSR
+      // on: noopDirectiveTransform,
+      cloak: compilerDom.noopDirectiveTransform,
+      once: compilerDom.noopDirectiveTransform,
+      memo: compilerDom.noopDirectiveTransform,
+      ...options.directiveTransforms || {}
+      // user transforms
+    }
+  });
+  ssrCodegenTransform(ast, options);
+  return compilerDom.generate(ast, options);
+}
+
+exports.compile = compile;