initial vitepress site with basic nav

node_modules/@vue/server-renderer/dist/server-renderer.cjs.prod.js

@@ -0,0 +1,826 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Vue = require('vue');
+var shared = require('@vue/shared');
+var compilerSsr = require('@vue/compiler-ssr');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    for (var k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Vue__namespace = /*#__PURE__*/_interopNamespaceDefault(Vue);
+
+const shouldIgnoreProp = shared.makeMap(
+  `,key,ref,innerHTML,textContent,ref_key,ref_for`
+);
+function ssrRenderAttrs(props, tag) {
+  let ret = "";
+  for (const key in props) {
+    if (shouldIgnoreProp(key) || shared.isOn(key) || tag === "textarea" && key === "value") {
+      continue;
+    }
+    const value = props[key];
+    if (key === "class") {
+      ret += ` class="${ssrRenderClass(value)}"`;
+    } else if (key === "style") {
+      ret += ` style="${ssrRenderStyle(value)}"`;
+    } else {
+      ret += ssrRenderDynamicAttr(key, value, tag);
+    }
+  }
+  return ret;
+}
+function ssrRenderDynamicAttr(key, value, tag) {
+  if (!isRenderableValue(value)) {
+    return ``;
+  }
+  const attrKey = tag && (tag.indexOf("-") > 0 || shared.isSVGTag(tag)) ? key : shared.propsToAttrMap[key] || key.toLowerCase();
+  if (shared.isBooleanAttr(attrKey)) {
+    return shared.includeBooleanAttr(value) ? ` ${attrKey}` : ``;
+  } else if (shared.isSSRSafeAttrName(attrKey)) {
+    return value === "" ? ` ${attrKey}` : ` ${attrKey}="${shared.escapeHtml(value)}"`;
+  } else {
+    console.warn(
+      `[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`
+    );
+    return ``;
+  }
+}
+function ssrRenderAttr(key, value) {
+  if (!isRenderableValue(value)) {
+    return ``;
+  }
+  return ` ${key}="${shared.escapeHtml(value)}"`;
+}
+function isRenderableValue(value) {
+  if (value == null) {
+    return false;
+  }
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean";
+}
+function ssrRenderClass(raw) {
+  return shared.escapeHtml(shared.normalizeClass(raw));
+}
+function ssrRenderStyle(raw) {
+  if (!raw) {
+    return "";
+  }
+  if (shared.isString(raw)) {
+    return shared.escapeHtml(raw);
+  }
+  const styles = shared.normalizeStyle(raw);
+  return shared.escapeHtml(shared.stringifyStyle(styles));
+}
+
+function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
+  return renderComponentVNode(
+    Vue.createVNode(comp, props, children),
+    parentComponent,
+    slotScopeId
+  );
+}
+
+function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
+  push(`<!--[-->`);
+  ssrRenderSlotInner(
+    slots,
+    slotName,
+    slotProps,
+    fallbackRenderFn,
+    push,
+    parentComponent,
+    slotScopeId
+  );
+  push(`<!--]-->`);
+}
+function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
+  const slotFn = slots[slotName];
+  if (slotFn) {
+    const slotBuffer = [];
+    const bufferedPush = (item) => {
+      slotBuffer.push(item);
+    };
+    const ret = slotFn(
+      slotProps,
+      bufferedPush,
+      parentComponent,
+      slotScopeId ? " " + slotScopeId : ""
+    );
+    if (shared.isArray(ret)) {
+      renderVNodeChildren(push, ret, parentComponent, slotScopeId);
+    } else {
+      let isEmptySlot = true;
+      if (transition) {
+        isEmptySlot = false;
+      } else {
+        for (let i = 0; i < slotBuffer.length; i++) {
+          if (!isComment(slotBuffer[i])) {
+            isEmptySlot = false;
+            break;
+          }
+        }
+      }
+      if (isEmptySlot) {
+        if (fallbackRenderFn) {
+          fallbackRenderFn();
+        }
+      } else {
+        for (let i = 0; i < slotBuffer.length; i++) {
+          push(slotBuffer[i]);
+        }
+      }
+    }
+  } else if (fallbackRenderFn) {
+    fallbackRenderFn();
+  }
+}
+const commentTestRE = /^<!--.*-->$/s;
+const commentRE = /<!--[^]*?-->/gm;
+function isComment(item) {
+  if (typeof item !== "string" || !commentTestRE.test(item))
+    return false;
+  if (item.length <= 8)
+    return true;
+  return !item.replace(commentRE, "").trim();
+}
+
+function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+  parentPush("<!--teleport start-->");
+  const context = parentComponent.appContext.provides[Vue.ssrContextKey];
+  const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+  const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
+  const bufferIndex = targetBuffer.length;
+  let teleportContent;
+  if (disabled) {
+    contentRenderFn(parentPush);
+    teleportContent = `<!--teleport anchor-->`;
+  } else {
+    const { getBuffer, push } = createBuffer();
+    contentRenderFn(push);
+    push(`<!--teleport anchor-->`);
+    teleportContent = getBuffer();
+  }
+  targetBuffer.splice(bufferIndex, 0, teleportContent);
+  parentPush("<!--teleport end-->");
+}
+
+function ssrInterpolate(value) {
+  return shared.escapeHtml(shared.toDisplayString(value));
+}
+
+function ssrRenderList(source, renderItem) {
+  if (shared.isArray(source) || shared.isString(source)) {
+    for (let i = 0, l = source.length; i < l; i++) {
+      renderItem(source[i], i);
+    }
+  } else if (typeof source === "number") {
+    for (let i = 0; i < source; i++) {
+      renderItem(i + 1, i);
+    }
+  } else if (shared.isObject(source)) {
+    if (source[Symbol.iterator]) {
+      const arr = Array.from(source);
+      for (let i = 0, l = arr.length; i < l; i++) {
+        renderItem(arr[i], i);
+      }
+    } else {
+      const keys = Object.keys(source);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        renderItem(source[key], key, i);
+      }
+    }
+  }
+}
+
+async function ssrRenderSuspense(push, { default: renderContent }) {
+  if (renderContent) {
+    renderContent();
+  } else {
+    push(`<!---->`);
+  }
+}
+
+function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
+  if (typeof dir !== "function" && dir.getSSRProps) {
+    return dir.getSSRProps(
+      {
+        dir,
+        instance,
+        value,
+        oldValue: void 0,
+        arg,
+        modifiers
+      },
+      null
+    ) || {};
+  }
+  return {};
+}
+
+const ssrLooseEqual = shared.looseEqual;
+function ssrLooseContain(arr, value) {
+  return shared.looseIndexOf(arr, value) > -1;
+}
+function ssrRenderDynamicModel(type, model, value) {
+  switch (type) {
+    case "radio":
+      return shared.looseEqual(model, value) ? " checked" : "";
+    case "checkbox":
+      return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? " checked" : "";
+    default:
+      return ssrRenderAttr("value", model);
+  }
+}
+function ssrGetDynamicModelProps(existingProps = {}, model) {
+  const { type, value } = existingProps;
+  switch (type) {
+    case "radio":
+      return shared.looseEqual(model, value) ? { checked: true } : null;
+    case "checkbox":
+      return (shared.isArray(model) ? ssrLooseContain(model, value) : model) ? { checked: true } : null;
+    default:
+      return { value: model };
+  }
+}
+
+var helpers = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ssrGetDirectiveProps: ssrGetDirectiveProps,
+  ssrGetDynamicModelProps: ssrGetDynamicModelProps,
+  ssrIncludeBooleanAttr: shared.includeBooleanAttr,
+  ssrInterpolate: ssrInterpolate,
+  ssrLooseContain: ssrLooseContain,
+  ssrLooseEqual: ssrLooseEqual,
+  ssrRenderAttr: ssrRenderAttr,
+  ssrRenderAttrs: ssrRenderAttrs,
+  ssrRenderClass: ssrRenderClass,
+  ssrRenderComponent: ssrRenderComponent,
+  ssrRenderDynamicAttr: ssrRenderDynamicAttr,
+  ssrRenderDynamicModel: ssrRenderDynamicModel,
+  ssrRenderList: ssrRenderList,
+  ssrRenderSlot: ssrRenderSlot,
+  ssrRenderSlotInner: ssrRenderSlotInner,
+  ssrRenderStyle: ssrRenderStyle,
+  ssrRenderSuspense: ssrRenderSuspense,
+  ssrRenderTeleport: ssrRenderTeleport,
+  ssrRenderVNode: renderVNode
+});
+
+const compileCache = /* @__PURE__ */ Object.create(null);
+function ssrCompile(template, instance) {
+  const Component = instance.type;
+  const { isCustomElement, compilerOptions } = instance.appContext.config;
+  const { delimiters, compilerOptions: componentCompilerOptions } = Component;
+  const finalCompilerOptions = shared.extend(
+    shared.extend(
+      {
+        isCustomElement,
+        delimiters
+      },
+      compilerOptions
+    ),
+    componentCompilerOptions
+  );
+  finalCompilerOptions.isCustomElement = finalCompilerOptions.isCustomElement || shared.NO;
+  finalCompilerOptions.isNativeTag = finalCompilerOptions.isNativeTag || shared.NO;
+  const cacheKey = JSON.stringify(
+    {
+      template,
+      compilerOptions: finalCompilerOptions
+    },
+    (key, value) => {
+      return shared.isFunction(value) ? value.toString() : value;
+    }
+  );
+  const cached = compileCache[cacheKey];
+  if (cached) {
+    return cached;
+  }
+  finalCompilerOptions.onError = (err) => {
+    {
+      throw err;
+    }
+  };
+  const { code } = compilerSsr.compile(template, finalCompilerOptions);
+  const requireMap = {
+    vue: Vue__namespace,
+    "vue/server-renderer": helpers
+  };
+  const fakeRequire = (id) => requireMap[id];
+  return compileCache[cacheKey] = Function("require", code)(fakeRequire);
+}
+
+const {
+  createComponentInstance,
+  setCurrentRenderingInstance,
+  setupComponent,
+  renderComponentRoot,
+  normalizeVNode
+} = Vue.ssrUtils;
+function createBuffer() {
+  let appendable = false;
+  const buffer = [];
+  return {
+    getBuffer() {
+      return buffer;
+    },
+    push(item) {
+      const isStringItem = shared.isString(item);
+      if (appendable && isStringItem) {
+        buffer[buffer.length - 1] += item;
+      } else {
+        buffer.push(item);
+      }
+      appendable = isStringItem;
+      if (shared.isPromise(item) || shared.isArray(item) && item.hasAsync) {
+        buffer.hasAsync = true;
+      }
+    }
+  };
+}
+function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
+  const instance = createComponentInstance(vnode, parentComponent, null);
+  const res = setupComponent(
+    instance,
+    true
+    /* isSSR */
+  );
+  const hasAsyncSetup = shared.isPromise(res);
+  const prefetches = instance.sp;
+  if (hasAsyncSetup || prefetches) {
+    let p = hasAsyncSetup ? res : Promise.resolve();
+    if (prefetches) {
+      p = p.then(
+        () => Promise.all(prefetches.map((prefetch) => prefetch.call(instance.proxy)))
+      ).catch(() => {
+      });
+    }
+    return p.then(() => renderComponentSubTree(instance, slotScopeId));
+  } else {
+    return renderComponentSubTree(instance, slotScopeId);
+  }
+}
+function renderComponentSubTree(instance, slotScopeId) {
+  const comp = instance.type;
+  const { getBuffer, push } = createBuffer();
+  if (shared.isFunction(comp)) {
+    let root = renderComponentRoot(instance);
+    if (!comp.props) {
+      for (const key in instance.attrs) {
+        if (key.startsWith(`data-v-`)) {
+          (root.props || (root.props = {}))[key] = ``;
+        }
+      }
+    }
+    renderVNode(push, instance.subTree = root, instance, slotScopeId);
+  } else {
+    if ((!instance.render || instance.render === shared.NOOP) && !instance.ssrRender && !comp.ssrRender && shared.isString(comp.template)) {
+      comp.ssrRender = ssrCompile(comp.template, instance);
+    }
+    for (const e of instance.scope.effects) {
+      if (e.computed)
+        e.computed._cacheable = true;
+    }
+    const ssrRender = instance.ssrRender || comp.ssrRender;
+    if (ssrRender) {
+      let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
+      let hasCloned = false;
+      let cur = instance;
+      while (true) {
+        const scopeId = cur.vnode.scopeId;
+        if (scopeId) {
+          if (!hasCloned) {
+            attrs = { ...attrs };
+            hasCloned = true;
+          }
+          attrs[scopeId] = "";
+        }
+        const parent = cur.parent;
+        if (parent && parent.subTree && parent.subTree === cur.vnode) {
+          cur = parent;
+        } else {
+          break;
+        }
+      }
+      if (slotScopeId) {
+        if (!hasCloned)
+          attrs = { ...attrs };
+        attrs[slotScopeId.trim()] = "";
+      }
+      const prev = setCurrentRenderingInstance(instance);
+      try {
+        ssrRender(
+          instance.proxy,
+          push,
+          instance,
+          attrs,
+          // compiler-optimized bindings
+          instance.props,
+          instance.setupState,
+          instance.data,
+          instance.ctx
+        );
+      } finally {
+        setCurrentRenderingInstance(prev);
+      }
+    } else if (instance.render && instance.render !== shared.NOOP) {
+      renderVNode(
+        push,
+        instance.subTree = renderComponentRoot(instance),
+        instance,
+        slotScopeId
+      );
+    } else {
+      const componentName = comp.name || comp.__file || `<Anonymous>`;
+      Vue.warn(`Component ${componentName} is missing template or render function.`);
+      push(`<!---->`);
+    }
+  }
+  return getBuffer();
+}
+function renderVNode(push, vnode, parentComponent, slotScopeId) {
+  const { type, shapeFlag, children } = vnode;
+  switch (type) {
+    case Vue.Text:
+      push(shared.escapeHtml(children));
+      break;
+    case Vue.Comment:
+      push(
+        children ? `<!--${shared.escapeHtmlComment(children)}-->` : `<!---->`
+      );
+      break;
+    case Vue.Static:
+      push(children);
+      break;
+    case Vue.Fragment:
+      if (vnode.slotScopeIds) {
+        slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
+      }
+      push(`<!--[-->`);
+      renderVNodeChildren(
+        push,
+        children,
+        parentComponent,
+        slotScopeId
+      );
+      push(`<!--]-->`);
+      break;
+    default:
+      if (shapeFlag & 1) {
+        renderElementVNode(push, vnode, parentComponent, slotScopeId);
+      } else if (shapeFlag & 6) {
+        push(renderComponentVNode(vnode, parentComponent, slotScopeId));
+      } else if (shapeFlag & 64) {
+        renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
+      } else if (shapeFlag & 128) {
+        renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
+      } else {
+        Vue.warn(
+          "[@vue/server-renderer] Invalid VNode type:",
+          type,
+          `(${typeof type})`
+        );
+      }
+  }
+}
+function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
+  for (let i = 0; i < children.length; i++) {
+    renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
+  }
+}
+function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
+  const tag = vnode.type;
+  let { props, children, shapeFlag, scopeId, dirs } = vnode;
+  let openTag = `<${tag}`;
+  if (dirs) {
+    props = applySSRDirectives(vnode, props, dirs);
+  }
+  if (props) {
+    openTag += ssrRenderAttrs(props, tag);
+  }
+  if (scopeId) {
+    openTag += ` ${scopeId}`;
+  }
+  let curParent = parentComponent;
+  let curVnode = vnode;
+  while (curParent && curVnode === curParent.subTree) {
+    curVnode = curParent.vnode;
+    if (curVnode.scopeId) {
+      openTag += ` ${curVnode.scopeId}`;
+    }
+    curParent = curParent.parent;
+  }
+  if (slotScopeId) {
+    openTag += ` ${slotScopeId}`;
+  }
+  push(openTag + `>`);
+  if (!shared.isVoidTag(tag)) {
+    let hasChildrenOverride = false;
+    if (props) {
+      if (props.innerHTML) {
+        hasChildrenOverride = true;
+        push(props.innerHTML);
+      } else if (props.textContent) {
+        hasChildrenOverride = true;
+        push(shared.escapeHtml(props.textContent));
+      } else if (tag === "textarea" && props.value) {
+        hasChildrenOverride = true;
+        push(shared.escapeHtml(props.value));
+      }
+    }
+    if (!hasChildrenOverride) {
+      if (shapeFlag & 8) {
+        push(shared.escapeHtml(children));
+      } else if (shapeFlag & 16) {
+        renderVNodeChildren(
+          push,
+          children,
+          parentComponent,
+          slotScopeId
+        );
+      }
+    }
+    push(`</${tag}>`);
+  }
+}
+function applySSRDirectives(vnode, rawProps, dirs) {
+  const toMerge = [];
+  for (let i = 0; i < dirs.length; i++) {
+    const binding = dirs[i];
+    const {
+      dir: { getSSRProps }
+    } = binding;
+    if (getSSRProps) {
+      const props = getSSRProps(binding, vnode);
+      if (props)
+        toMerge.push(props);
+    }
+  }
+  return Vue.mergeProps(rawProps || {}, ...toMerge);
+}
+function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
+  const target = vnode.props && vnode.props.to;
+  const disabled = vnode.props && vnode.props.disabled;
+  if (!target) {
+    if (!disabled) {
+      Vue.warn(`[@vue/server-renderer] Teleport is missing target prop.`);
+    }
+    return [];
+  }
+  if (!shared.isString(target)) {
+    Vue.warn(
+      `[@vue/server-renderer] Teleport target must be a query selector string.`
+    );
+    return [];
+  }
+  ssrRenderTeleport(
+    push,
+    (push2) => {
+      renderVNodeChildren(
+        push2,
+        vnode.children,
+        parentComponent,
+        slotScopeId
+      );
+    },
+    target,
+    disabled || disabled === "",
+    parentComponent
+  );
+}
+
+const { isVNode: isVNode$1 } = Vue.ssrUtils;
+async function unrollBuffer$1(buffer) {
+  if (buffer.hasAsync) {
+    let ret = "";
+    for (let i = 0; i < buffer.length; i++) {
+      let item = buffer[i];
+      if (shared.isPromise(item)) {
+        item = await item;
+      }
+      if (shared.isString(item)) {
+        ret += item;
+      } else {
+        ret += await unrollBuffer$1(item);
+      }
+    }
+    return ret;
+  } else {
+    return unrollBufferSync$1(buffer);
+  }
+}
+function unrollBufferSync$1(buffer) {
+  let ret = "";
+  for (let i = 0; i < buffer.length; i++) {
+    let item = buffer[i];
+    if (shared.isString(item)) {
+      ret += item;
+    } else {
+      ret += unrollBufferSync$1(item);
+    }
+  }
+  return ret;
+}
+async function renderToString(input, context = {}) {
+  if (isVNode$1(input)) {
+    return renderToString(Vue.createApp({ render: () => input }), context);
+  }
+  const vnode = Vue.createVNode(input._component, input._props);
+  vnode.appContext = input._context;
+  input.provide(Vue.ssrContextKey, context);
+  const buffer = await renderComponentVNode(vnode);
+  const result = await unrollBuffer$1(buffer);
+  await resolveTeleports(context);
+  if (context.__watcherHandles) {
+    for (const unwatch of context.__watcherHandles) {
+      unwatch();
+    }
+  }
+  return result;
+}
+async function resolveTeleports(context) {
+  if (context.__teleportBuffers) {
+    context.teleports = context.teleports || {};
+    for (const key in context.__teleportBuffers) {
+      context.teleports[key] = await unrollBuffer$1(
+        await Promise.all([context.__teleportBuffers[key]])
+      );
+    }
+  }
+}
+
+const { isVNode } = Vue.ssrUtils;
+async function unrollBuffer(buffer, stream) {
+  if (buffer.hasAsync) {
+    for (let i = 0; i < buffer.length; i++) {
+      let item = buffer[i];
+      if (shared.isPromise(item)) {
+        item = await item;
+      }
+      if (shared.isString(item)) {
+        stream.push(item);
+      } else {
+        await unrollBuffer(item, stream);
+      }
+    }
+  } else {
+    unrollBufferSync(buffer, stream);
+  }
+}
+function unrollBufferSync(buffer, stream) {
+  for (let i = 0; i < buffer.length; i++) {
+    let item = buffer[i];
+    if (shared.isString(item)) {
+      stream.push(item);
+    } else {
+      unrollBufferSync(item, stream);
+    }
+  }
+}
+function renderToSimpleStream(input, context, stream) {
+  if (isVNode(input)) {
+    return renderToSimpleStream(
+      Vue.createApp({ render: () => input }),
+      context,
+      stream
+    );
+  }
+  const vnode = Vue.createVNode(input._component, input._props);
+  vnode.appContext = input._context;
+  input.provide(Vue.ssrContextKey, context);
+  Promise.resolve(renderComponentVNode(vnode)).then((buffer) => unrollBuffer(buffer, stream)).then(() => resolveTeleports(context)).then(() => {
+    if (context.__watcherHandles) {
+      for (const unwatch of context.__watcherHandles) {
+        unwatch();
+      }
+    }
+  }).then(() => stream.push(null)).catch((error) => {
+    stream.destroy(error);
+  });
+  return stream;
+}
+function renderToStream(input, context = {}) {
+  console.warn(
+    `[@vue/server-renderer] renderToStream is deprecated - use renderToNodeStream instead.`
+  );
+  return renderToNodeStream(input, context);
+}
+function renderToNodeStream(input, context = {}) {
+  const stream = new (require("stream")).Readable({ read() {
+  } }) ;
+  if (!stream) {
+    throw new Error(
+      `ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.`
+    );
+  }
+  return renderToSimpleStream(input, context, stream);
+}
+function pipeToNodeWritable(input, context = {}, writable) {
+  renderToSimpleStream(input, context, {
+    push(content) {
+      if (content != null) {
+        writable.write(content);
+      } else {
+        writable.end();
+      }
+    },
+    destroy(err) {
+      writable.destroy(err);
+    }
+  });
+}
+function renderToWebStream(input, context = {}) {
+  if (typeof ReadableStream !== "function") {
+    throw new Error(
+      `ReadableStream constructor is not available in the global scope. If the target environment does support web streams, consider using pipeToWebWritable() with an existing WritableStream instance instead.`
+    );
+  }
+  const encoder = new TextEncoder();
+  let cancelled = false;
+  return new ReadableStream({
+    start(controller) {
+      renderToSimpleStream(input, context, {
+        push(content) {
+          if (cancelled)
+            return;
+          if (content != null) {
+            controller.enqueue(encoder.encode(content));
+          } else {
+            controller.close();
+          }
+        },
+        destroy(err) {
+          controller.error(err);
+        }
+      });
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+}
+function pipeToWebWritable(input, context = {}, writable) {
+  const writer = writable.getWriter();
+  const encoder = new TextEncoder();
+  let hasReady = false;
+  try {
+    hasReady = shared.isPromise(writer.ready);
+  } catch (e) {
+  }
+  renderToSimpleStream(input, context, {
+    async push(content) {
+      if (hasReady) {
+        await writer.ready;
+      }
+      if (content != null) {
+        return writer.write(encoder.encode(content));
+      } else {
+        return writer.close();
+      }
+    },
+    destroy(err) {
+      console.log(err);
+      writer.close();
+    }
+  });
+}
+
+Vue.initDirectivesForSSR();
+
+exports.ssrIncludeBooleanAttr = shared.includeBooleanAttr;
+exports.pipeToNodeWritable = pipeToNodeWritable;
+exports.pipeToWebWritable = pipeToWebWritable;
+exports.renderToNodeStream = renderToNodeStream;
+exports.renderToSimpleStream = renderToSimpleStream;
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+exports.renderToWebStream = renderToWebStream;
+exports.ssrGetDirectiveProps = ssrGetDirectiveProps;
+exports.ssrGetDynamicModelProps = ssrGetDynamicModelProps;
+exports.ssrInterpolate = ssrInterpolate;
+exports.ssrLooseContain = ssrLooseContain;
+exports.ssrLooseEqual = ssrLooseEqual;
+exports.ssrRenderAttr = ssrRenderAttr;
+exports.ssrRenderAttrs = ssrRenderAttrs;
+exports.ssrRenderClass = ssrRenderClass;
+exports.ssrRenderComponent = ssrRenderComponent;
+exports.ssrRenderDynamicAttr = ssrRenderDynamicAttr;
+exports.ssrRenderDynamicModel = ssrRenderDynamicModel;
+exports.ssrRenderList = ssrRenderList;
+exports.ssrRenderSlot = ssrRenderSlot;
+exports.ssrRenderSlotInner = ssrRenderSlotInner;
+exports.ssrRenderStyle = ssrRenderStyle;
+exports.ssrRenderSuspense = ssrRenderSuspense;
+exports.ssrRenderTeleport = ssrRenderTeleport;
+exports.ssrRenderVNode = renderVNode;

node_modules/@vue/server-renderer/dist/server-renderer.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+import { VNode, ComponentInternalInstance, App, Slots, Component } from 'vue';
+import { Readable, Writable } from 'stream';
+import { ComponentPublicInstance, Directive } from '@vue/runtime-core';
+export { includeBooleanAttr as ssrIncludeBooleanAttr } from '@vue/shared';
+
+type SSRBuffer = SSRBufferItem[] & {
+    hasAsync?: boolean;
+};
+type SSRBufferItem = string | SSRBuffer | Promise<SSRBuffer>;
+type PushFn = (item: SSRBufferItem) => void;
+type Props = Record<string, unknown>;
+export type SSRContext = {
+    [key: string]: any;
+    teleports?: Record<string, string>;
+    /* removed internal: __teleportBuffers */
+    /* removed internal: __watcherHandles */
+};
+export declare function renderVNode(push: PushFn, vnode: VNode, parentComponent: ComponentInternalInstance, slotScopeId?: string): void;
+
+export declare function renderToString(input: App | VNode, context?: SSRContext): Promise<string>;
+
+export interface SimpleReadable {
+    push(chunk: string | null): void;
+    destroy(err: any): void;
+}
+export declare function renderToSimpleStream<T extends SimpleReadable>(input: App | VNode, context: SSRContext, stream: T): T;
+/**
+ * @deprecated
+ */
+export declare function renderToStream(input: App | VNode, context?: SSRContext): Readable;
+export declare function renderToNodeStream(input: App | VNode, context?: SSRContext): Readable;
+export declare function pipeToNodeWritable(input: App | VNode, context: SSRContext | undefined, writable: Writable): void;
+export declare function renderToWebStream(input: App | VNode, context?: SSRContext): ReadableStream;
+export declare function pipeToWebWritable(input: App | VNode, context: SSRContext | undefined, writable: WritableStream): void;
+
+type SSRSlots = Record<string, SSRSlot>;
+type SSRSlot = (props: Props, push: PushFn, parentComponent: ComponentInternalInstance | null, scopeId: string | null) => void;
+export declare function ssrRenderSlot(slots: Slots | SSRSlots, slotName: string, slotProps: Props, fallbackRenderFn: (() => void) | null, push: PushFn, parentComponent: ComponentInternalInstance, slotScopeId?: string): void;
+export declare function ssrRenderSlotInner(slots: Slots | SSRSlots, slotName: string, slotProps: Props, fallbackRenderFn: (() => void) | null, push: PushFn, parentComponent: ComponentInternalInstance, slotScopeId?: string, transition?: boolean): void;
+
+export declare function ssrRenderComponent(comp: Component, props?: Props | null, children?: Slots | SSRSlots | null, parentComponent?: ComponentInternalInstance | null, slotScopeId?: string): SSRBuffer | Promise<SSRBuffer>;
+
+export declare function ssrRenderTeleport(parentPush: PushFn, contentRenderFn: (push: PushFn) => void, target: string, disabled: boolean, parentComponent: ComponentInternalInstance): void;
+
+export declare function ssrRenderAttrs(props: Record<string, unknown>, tag?: string): string;
+export declare function ssrRenderDynamicAttr(key: string, value: unknown, tag?: string): string;
+export declare function ssrRenderAttr(key: string, value: unknown): string;
+export declare function ssrRenderClass(raw: unknown): string;
+export declare function ssrRenderStyle(raw: unknown): string;
+
+export declare function ssrInterpolate(value: unknown): string;
+
+export declare function ssrRenderList(source: unknown, renderItem: (value: unknown, key: string | number, index?: number) => void): void;
+
+export declare function ssrRenderSuspense(push: PushFn, { default: renderContent }: Record<string, (() => void) | undefined>): Promise<void>;
+
+export declare function ssrGetDirectiveProps(instance: ComponentPublicInstance, dir: Directive, value?: any, arg?: string, modifiers?: Record<string, boolean>): Record<string, any>;
+
+export declare const ssrLooseEqual: (a: unknown, b: unknown) => boolean;
+export declare function ssrLooseContain(arr: unknown[], value: unknown): boolean;
+export declare function ssrRenderDynamicModel(type: unknown, model: unknown, value: unknown): string;
+export declare function ssrGetDynamicModelProps(existingProps: any, model: unknown): {
+    checked: boolean;
+    value?: undefined;
+} | {
+    value: unknown;
+    checked?: undefined;
+} | null;
+
+export { renderVNode as ssrRenderVNode };

node_modules/@vue/server-renderer/dist/server-renderer.esm-bundler.js

@@ -0,0 +1,981 @@
+import { createVNode, ssrContextKey, warn as warn$1, Fragment, Static, Comment, Text, mergeProps, ssrUtils, createApp, initDirectivesForSSR } from 'vue';
+import { makeMap, isOn, isSVGTag, propsToAttrMap, isBooleanAttr, includeBooleanAttr, isSSRSafeAttrName, escapeHtml, normalizeClass, isString, normalizeStyle, stringifyStyle, isArray, toDisplayString, isFunction, getGlobalThis, isObject, looseEqual, looseIndexOf, isPromise, NOOP, escapeHtmlComment, isVoidTag } from '@vue/shared';
+export { includeBooleanAttr as ssrIncludeBooleanAttr } from '@vue/shared';
+
+const shouldIgnoreProp = makeMap(
+  `,key,ref,innerHTML,textContent,ref_key,ref_for`
+);
+function ssrRenderAttrs(props, tag) {
+  let ret = "";
+  for (const key in props) {
+    if (shouldIgnoreProp(key) || isOn(key) || tag === "textarea" && key === "value") {
+      continue;
+    }
+    const value = props[key];
+    if (key === "class") {
+      ret += ` class="${ssrRenderClass(value)}"`;
+    } else if (key === "style") {
+      ret += ` style="${ssrRenderStyle(value)}"`;
+    } else {
+      ret += ssrRenderDynamicAttr(key, value, tag);
+    }
+  }
+  return ret;
+}
+function ssrRenderDynamicAttr(key, value, tag) {
+  if (!isRenderableValue(value)) {
+    return ``;
+  }
+  const attrKey = tag && (tag.indexOf("-") > 0 || isSVGTag(tag)) ? key : propsToAttrMap[key] || key.toLowerCase();
+  if (isBooleanAttr(attrKey)) {
+    return includeBooleanAttr(value) ? ` ${attrKey}` : ``;
+  } else if (isSSRSafeAttrName(attrKey)) {
+    return value === "" ? ` ${attrKey}` : ` ${attrKey}="${escapeHtml(value)}"`;
+  } else {
+    console.warn(
+      `[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`
+    );
+    return ``;
+  }
+}
+function ssrRenderAttr(key, value) {
+  if (!isRenderableValue(value)) {
+    return ``;
+  }
+  return ` ${key}="${escapeHtml(value)}"`;
+}
+function isRenderableValue(value) {
+  if (value == null) {
+    return false;
+  }
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean";
+}
+function ssrRenderClass(raw) {
+  return escapeHtml(normalizeClass(raw));
+}
+function ssrRenderStyle(raw) {
+  if (!raw) {
+    return "";
+  }
+  if (isString(raw)) {
+    return escapeHtml(raw);
+  }
+  const styles = normalizeStyle(raw);
+  return escapeHtml(stringifyStyle(styles));
+}
+
+function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
+  return renderComponentVNode(
+    createVNode(comp, props, children),
+    parentComponent,
+    slotScopeId
+  );
+}
+
+function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
+  push(`<!--[-->`);
+  ssrRenderSlotInner(
+    slots,
+    slotName,
+    slotProps,
+    fallbackRenderFn,
+    push,
+    parentComponent,
+    slotScopeId
+  );
+  push(`<!--]-->`);
+}
+function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
+  const slotFn = slots[slotName];
+  if (slotFn) {
+    const slotBuffer = [];
+    const bufferedPush = (item) => {
+      slotBuffer.push(item);
+    };
+    const ret = slotFn(
+      slotProps,
+      bufferedPush,
+      parentComponent,
+      slotScopeId ? " " + slotScopeId : ""
+    );
+    if (isArray(ret)) {
+      renderVNodeChildren(push, ret, parentComponent, slotScopeId);
+    } else {
+      let isEmptySlot = true;
+      if (transition) {
+        isEmptySlot = false;
+      } else {
+        for (let i = 0; i < slotBuffer.length; i++) {
+          if (!isComment(slotBuffer[i])) {
+            isEmptySlot = false;
+            break;
+          }
+        }
+      }
+      if (isEmptySlot) {
+        if (fallbackRenderFn) {
+          fallbackRenderFn();
+        }
+      } else {
+        for (let i = 0; i < slotBuffer.length; i++) {
+          push(slotBuffer[i]);
+        }
+      }
+    }
+  } else if (fallbackRenderFn) {
+    fallbackRenderFn();
+  }
+}
+const commentTestRE = /^<!--.*-->$/s;
+const commentRE = /<!--[^]*?-->/gm;
+function isComment(item) {
+  if (typeof item !== "string" || !commentTestRE.test(item))
+    return false;
+  if (item.length <= 8)
+    return true;
+  return !item.replace(commentRE, "").trim();
+}
+
+function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+  parentPush("<!--teleport start-->");
+  const context = parentComponent.appContext.provides[ssrContextKey];
+  const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+  const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
+  const bufferIndex = targetBuffer.length;
+  let teleportContent;
+  if (disabled) {
+    contentRenderFn(parentPush);
+    teleportContent = `<!--teleport anchor-->`;
+  } else {
+    const { getBuffer, push } = createBuffer();
+    contentRenderFn(push);
+    push(`<!--teleport anchor-->`);
+    teleportContent = getBuffer();
+  }
+  targetBuffer.splice(bufferIndex, 0, teleportContent);
+  parentPush("<!--teleport end-->");
+}
+
+function ssrInterpolate(value) {
+  return escapeHtml(toDisplayString(value));
+}
+
+Symbol(!!(process.env.NODE_ENV !== "production") ? "iterate" : "");
+Symbol(!!(process.env.NODE_ENV !== "production") ? "Map key iterate" : "");
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === void 0 ? true : last;
+}
+
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? toRaw(raw) : observed;
+}
+
+function isRef(r) {
+  return !!(r && r.__v_isRef === true);
+}
+
+const stack = [];
+function pushWarningContext(vnode) {
+  stack.push(vnode);
+}
+function popWarningContext() {
+  stack.pop();
+}
+function warn(msg, ...args) {
+  if (!!!(process.env.NODE_ENV !== "production"))
+    return;
+  pauseTracking();
+  const instance = stack.length ? stack[stack.length - 1].component : null;
+  const appWarnHandler = instance && instance.appContext.config.warnHandler;
+  const trace = getComponentTrace();
+  if (appWarnHandler) {
+    callWithErrorHandling(
+      appWarnHandler,
+      instance,
+      11,
+      [
+        msg + args.join(""),
+        instance && instance.proxy,
+        trace.map(
+          ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
+        ).join("\n"),
+        trace
+      ]
+    );
+  } else {
+    const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+    if (trace.length && // avoid spamming console during tests
+    true) {
+      warnArgs.push(`
+`, ...formatTrace(trace));
+    }
+    console.warn(...warnArgs);
+  }
+  resetTracking();
+}
+function getComponentTrace() {
+  let currentVNode = stack[stack.length - 1];
+  if (!currentVNode) {
+    return [];
+  }
+  const normalizedStack = [];
+  while (currentVNode) {
+    const last = normalizedStack[0];
+    if (last && last.vnode === currentVNode) {
+      last.recurseCount++;
+    } else {
+      normalizedStack.push({
+        vnode: currentVNode,
+        recurseCount: 0
+      });
+    }
+    const parentInstance = currentVNode.component && currentVNode.component.parent;
+    currentVNode = parentInstance && parentInstance.vnode;
+  }
+  return normalizedStack;
+}
+function formatTrace(trace) {
+  const logs = [];
+  trace.forEach((entry, i) => {
+    logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+  });
+  return logs;
+}
+function formatTraceEntry({ vnode, recurseCount }) {
+  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+  const isRoot = vnode.component ? vnode.component.parent == null : false;
+  const open = ` at <${formatComponentName(
+    vnode.component,
+    vnode.type,
+    isRoot
+  )}`;
+  const close = `>` + postfix;
+  return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+}
+function formatProps(props) {
+  const res = [];
+  const keys = Object.keys(props);
+  keys.slice(0, 3).forEach((key) => {
+    res.push(...formatProp(key, props[key]));
+  });
+  if (keys.length > 3) {
+    res.push(` ...`);
+  }
+  return res;
+}
+function formatProp(key, value, raw) {
+  if (isString(value)) {
+    value = JSON.stringify(value);
+    return raw ? value : [`${key}=${value}`];
+  } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+    return raw ? value : [`${key}=${value}`];
+  } else if (isRef(value)) {
+    value = formatProp(key, toRaw(value.value), true);
+    return raw ? value : [`${key}=Ref<`, value, `>`];
+  } else if (isFunction(value)) {
+    return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+  } else {
+    value = toRaw(value);
+    return raw ? value : [`${key}=`, value];
+  }
+}
+
+const ErrorTypeStrings = {
+  ["sp"]: "serverPrefetch hook",
+  ["bc"]: "beforeCreate hook",
+  ["c"]: "created hook",
+  ["bm"]: "beforeMount hook",
+  ["m"]: "mounted hook",
+  ["bu"]: "beforeUpdate hook",
+  ["u"]: "updated",
+  ["bum"]: "beforeUnmount hook",
+  ["um"]: "unmounted hook",
+  ["a"]: "activated hook",
+  ["da"]: "deactivated hook",
+  ["ec"]: "errorCaptured hook",
+  ["rtc"]: "renderTracked hook",
+  ["rtg"]: "renderTriggered hook",
+  [0]: "setup function",
+  [1]: "render function",
+  [2]: "watcher getter",
+  [3]: "watcher callback",
+  [4]: "watcher cleanup function",
+  [5]: "native event handler",
+  [6]: "component event handler",
+  [7]: "vnode hook",
+  [8]: "directive hook",
+  [9]: "transition hook",
+  [10]: "app errorHandler",
+  [11]: "app warnHandler",
+  [12]: "ref function",
+  [13]: "async component loader",
+  [14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core"
+};
+function callWithErrorHandling(fn, instance, type, args) {
+  let res;
+  try {
+    res = args ? fn(...args) : fn();
+  } catch (err) {
+    handleError(err, instance, type);
+  }
+  return res;
+}
+function handleError(err, instance, type, throwInDev = true) {
+  const contextVNode = instance ? instance.vnode : null;
+  if (instance) {
+    let cur = instance.parent;
+    const exposedInstance = instance.proxy;
+    const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings[type] : type;
+    while (cur) {
+      const errorCapturedHooks = cur.ec;
+      if (errorCapturedHooks) {
+        for (let i = 0; i < errorCapturedHooks.length; i++) {
+          if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+            return;
+          }
+        }
+      }
+      cur = cur.parent;
+    }
+    const appErrorHandler = instance.appContext.config.errorHandler;
+    if (appErrorHandler) {
+      callWithErrorHandling(
+        appErrorHandler,
+        null,
+        10,
+        [err, exposedInstance, errorInfo]
+      );
+      return;
+    }
+  }
+  logError(err, type, contextVNode, throwInDev);
+}
+function logError(err, type, contextVNode, throwInDev = true) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    const info = ErrorTypeStrings[type];
+    if (contextVNode) {
+      pushWarningContext(contextVNode);
+    }
+    warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+    if (contextVNode) {
+      popWarningContext();
+    }
+    if (throwInDev) {
+      throw err;
+    } else {
+      console.error(err);
+    }
+  } else {
+    console.error(err);
+  }
+}
+
+let globalCurrentInstanceSetters;
+let settersKey = "__VUE_INSTANCE_SETTERS__";
+{
+  if (!(globalCurrentInstanceSetters = getGlobalThis()[settersKey])) {
+    globalCurrentInstanceSetters = getGlobalThis()[settersKey] = [];
+  }
+  globalCurrentInstanceSetters.push((i) => i);
+}
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+function getComponentName(Component, includeInferred = true) {
+  return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+}
+function formatComponentName(instance, Component, isRoot = false) {
+  let name = getComponentName(Component);
+  if (!name && Component.__file) {
+    const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+    if (match) {
+      name = match[1];
+    }
+  }
+  if (!name && instance && instance.parent) {
+    const inferFromRegistry = (registry) => {
+      for (const key in registry) {
+        if (registry[key] === Component) {
+          return key;
+        }
+      }
+    };
+    name = inferFromRegistry(
+      instance.components || instance.parent.type.components
+    ) || inferFromRegistry(instance.appContext.components);
+  }
+  return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+
+function ssrRenderList(source, renderItem) {
+  if (isArray(source) || isString(source)) {
+    for (let i = 0, l = source.length; i < l; i++) {
+      renderItem(source[i], i);
+    }
+  } else if (typeof source === "number") {
+    if (!!(process.env.NODE_ENV !== "production") && !Number.isInteger(source)) {
+      warn(`The v-for range expect an integer value but got ${source}.`);
+      return;
+    }
+    for (let i = 0; i < source; i++) {
+      renderItem(i + 1, i);
+    }
+  } else if (isObject(source)) {
+    if (source[Symbol.iterator]) {
+      const arr = Array.from(source);
+      for (let i = 0, l = arr.length; i < l; i++) {
+        renderItem(arr[i], i);
+      }
+    } else {
+      const keys = Object.keys(source);
+      for (let i = 0, l = keys.length; i < l; i++) {
+        const key = keys[i];
+        renderItem(source[key], key, i);
+      }
+    }
+  }
+}
+
+async function ssrRenderSuspense(push, { default: renderContent }) {
+  if (renderContent) {
+    renderContent();
+  } else {
+    push(`<!---->`);
+  }
+}
+
+function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
+  if (typeof dir !== "function" && dir.getSSRProps) {
+    return dir.getSSRProps(
+      {
+        dir,
+        instance,
+        value,
+        oldValue: void 0,
+        arg,
+        modifiers
+      },
+      null
+    ) || {};
+  }
+  return {};
+}
+
+const ssrLooseEqual = looseEqual;
+function ssrLooseContain(arr, value) {
+  return looseIndexOf(arr, value) > -1;
+}
+function ssrRenderDynamicModel(type, model, value) {
+  switch (type) {
+    case "radio":
+      return looseEqual(model, value) ? " checked" : "";
+    case "checkbox":
+      return (isArray(model) ? ssrLooseContain(model, value) : model) ? " checked" : "";
+    default:
+      return ssrRenderAttr("value", model);
+  }
+}
+function ssrGetDynamicModelProps(existingProps = {}, model) {
+  const { type, value } = existingProps;
+  switch (type) {
+    case "radio":
+      return looseEqual(model, value) ? { checked: true } : null;
+    case "checkbox":
+      return (isArray(model) ? ssrLooseContain(model, value) : model) ? { checked: true } : null;
+    default:
+      return { value: model };
+  }
+}
+
+function ssrCompile(template, instance) {
+  {
+    throw new Error(
+      `On-the-fly template compilation is not supported in the ESM build of @vue/server-renderer. All templates must be pre-compiled into render functions.`
+    );
+  }
+}
+
+const {
+  createComponentInstance,
+  setCurrentRenderingInstance,
+  setupComponent,
+  renderComponentRoot,
+  normalizeVNode
+} = ssrUtils;
+function createBuffer() {
+  let appendable = false;
+  const buffer = [];
+  return {
+    getBuffer() {
+      return buffer;
+    },
+    push(item) {
+      const isStringItem = isString(item);
+      if (appendable && isStringItem) {
+        buffer[buffer.length - 1] += item;
+      } else {
+        buffer.push(item);
+      }
+      appendable = isStringItem;
+      if (isPromise(item) || isArray(item) && item.hasAsync) {
+        buffer.hasAsync = true;
+      }
+    }
+  };
+}
+function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
+  const instance = createComponentInstance(vnode, parentComponent, null);
+  const res = setupComponent(
+    instance,
+    true
+    /* isSSR */
+  );
+  const hasAsyncSetup = isPromise(res);
+  const prefetches = instance.sp;
+  if (hasAsyncSetup || prefetches) {
+    let p = hasAsyncSetup ? res : Promise.resolve();
+    if (prefetches) {
+      p = p.then(
+        () => Promise.all(prefetches.map((prefetch) => prefetch.call(instance.proxy)))
+      ).catch(() => {
+      });
+    }
+    return p.then(() => renderComponentSubTree(instance, slotScopeId));
+  } else {
+    return renderComponentSubTree(instance, slotScopeId);
+  }
+}
+function renderComponentSubTree(instance, slotScopeId) {
+  const comp = instance.type;
+  const { getBuffer, push } = createBuffer();
+  if (isFunction(comp)) {
+    let root = renderComponentRoot(instance);
+    if (!comp.props) {
+      for (const key in instance.attrs) {
+        if (key.startsWith(`data-v-`)) {
+          (root.props || (root.props = {}))[key] = ``;
+        }
+      }
+    }
+    renderVNode(push, instance.subTree = root, instance, slotScopeId);
+  } else {
+    if ((!instance.render || instance.render === NOOP) && !instance.ssrRender && !comp.ssrRender && isString(comp.template)) {
+      comp.ssrRender = ssrCompile(comp.template);
+    }
+    for (const e of instance.scope.effects) {
+      if (e.computed)
+        e.computed._cacheable = true;
+    }
+    const ssrRender = instance.ssrRender || comp.ssrRender;
+    if (ssrRender) {
+      let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
+      let hasCloned = false;
+      let cur = instance;
+      while (true) {
+        const scopeId = cur.vnode.scopeId;
+        if (scopeId) {
+          if (!hasCloned) {
+            attrs = { ...attrs };
+            hasCloned = true;
+          }
+          attrs[scopeId] = "";
+        }
+        const parent = cur.parent;
+        if (parent && parent.subTree && parent.subTree === cur.vnode) {
+          cur = parent;
+        } else {
+          break;
+        }
+      }
+      if (slotScopeId) {
+        if (!hasCloned)
+          attrs = { ...attrs };
+        attrs[slotScopeId.trim()] = "";
+      }
+      const prev = setCurrentRenderingInstance(instance);
+      try {
+        ssrRender(
+          instance.proxy,
+          push,
+          instance,
+          attrs,
+          // compiler-optimized bindings
+          instance.props,
+          instance.setupState,
+          instance.data,
+          instance.ctx
+        );
+      } finally {
+        setCurrentRenderingInstance(prev);
+      }
+    } else if (instance.render && instance.render !== NOOP) {
+      renderVNode(
+        push,
+        instance.subTree = renderComponentRoot(instance),
+        instance,
+        slotScopeId
+      );
+    } else {
+      const componentName = comp.name || comp.__file || `<Anonymous>`;
+      warn$1(`Component ${componentName} is missing template or render function.`);
+      push(`<!---->`);
+    }
+  }
+  return getBuffer();
+}
+function renderVNode(push, vnode, parentComponent, slotScopeId) {
+  const { type, shapeFlag, children } = vnode;
+  switch (type) {
+    case Text:
+      push(escapeHtml(children));
+      break;
+    case Comment:
+      push(
+        children ? `<!--${escapeHtmlComment(children)}-->` : `<!---->`
+      );
+      break;
+    case Static:
+      push(children);
+      break;
+    case Fragment:
+      if (vnode.slotScopeIds) {
+        slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
+      }
+      push(`<!--[-->`);
+      renderVNodeChildren(
+        push,
+        children,
+        parentComponent,
+        slotScopeId
+      );
+      push(`<!--]-->`);
+      break;
+    default:
+      if (shapeFlag & 1) {
+        renderElementVNode(push, vnode, parentComponent, slotScopeId);
+      } else if (shapeFlag & 6) {
+        push(renderComponentVNode(vnode, parentComponent, slotScopeId));
+      } else if (shapeFlag & 64) {
+        renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
+      } else if (shapeFlag & 128) {
+        renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
+      } else {
+        warn$1(
+          "[@vue/server-renderer] Invalid VNode type:",
+          type,
+          `(${typeof type})`
+        );
+      }
+  }
+}
+function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
+  for (let i = 0; i < children.length; i++) {
+    renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
+  }
+}
+function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
+  const tag = vnode.type;
+  let { props, children, shapeFlag, scopeId, dirs } = vnode;
+  let openTag = `<${tag}`;
+  if (dirs) {
+    props = applySSRDirectives(vnode, props, dirs);
+  }
+  if (props) {
+    openTag += ssrRenderAttrs(props, tag);
+  }
+  if (scopeId) {
+    openTag += ` ${scopeId}`;
+  }
+  let curParent = parentComponent;
+  let curVnode = vnode;
+  while (curParent && curVnode === curParent.subTree) {
+    curVnode = curParent.vnode;
+    if (curVnode.scopeId) {
+      openTag += ` ${curVnode.scopeId}`;
+    }
+    curParent = curParent.parent;
+  }
+  if (slotScopeId) {
+    openTag += ` ${slotScopeId}`;
+  }
+  push(openTag + `>`);
+  if (!isVoidTag(tag)) {
+    let hasChildrenOverride = false;
+    if (props) {
+      if (props.innerHTML) {
+        hasChildrenOverride = true;
+        push(props.innerHTML);
+      } else if (props.textContent) {
+        hasChildrenOverride = true;
+        push(escapeHtml(props.textContent));
+      } else if (tag === "textarea" && props.value) {
+        hasChildrenOverride = true;
+        push(escapeHtml(props.value));
+      }
+    }
+    if (!hasChildrenOverride) {
+      if (shapeFlag & 8) {
+        push(escapeHtml(children));
+      } else if (shapeFlag & 16) {
+        renderVNodeChildren(
+          push,
+          children,
+          parentComponent,
+          slotScopeId
+        );
+      }
+    }
+    push(`</${tag}>`);
+  }
+}
+function applySSRDirectives(vnode, rawProps, dirs) {
+  const toMerge = [];
+  for (let i = 0; i < dirs.length; i++) {
+    const binding = dirs[i];
+    const {
+      dir: { getSSRProps }
+    } = binding;
+    if (getSSRProps) {
+      const props = getSSRProps(binding, vnode);
+      if (props)
+        toMerge.push(props);
+    }
+  }
+  return mergeProps(rawProps || {}, ...toMerge);
+}
+function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
+  const target = vnode.props && vnode.props.to;
+  const disabled = vnode.props && vnode.props.disabled;
+  if (!target) {
+    if (!disabled) {
+      warn$1(`[@vue/server-renderer] Teleport is missing target prop.`);
+    }
+    return [];
+  }
+  if (!isString(target)) {
+    warn$1(
+      `[@vue/server-renderer] Teleport target must be a query selector string.`
+    );
+    return [];
+  }
+  ssrRenderTeleport(
+    push,
+    (push2) => {
+      renderVNodeChildren(
+        push2,
+        vnode.children,
+        parentComponent,
+        slotScopeId
+      );
+    },
+    target,
+    disabled || disabled === "",
+    parentComponent
+  );
+}
+
+const { isVNode: isVNode$1 } = ssrUtils;
+async function unrollBuffer$1(buffer) {
+  if (buffer.hasAsync) {
+    let ret = "";
+    for (let i = 0; i < buffer.length; i++) {
+      let item = buffer[i];
+      if (isPromise(item)) {
+        item = await item;
+      }
+      if (isString(item)) {
+        ret += item;
+      } else {
+        ret += await unrollBuffer$1(item);
+      }
+    }
+    return ret;
+  } else {
+    return unrollBufferSync$1(buffer);
+  }
+}
+function unrollBufferSync$1(buffer) {
+  let ret = "";
+  for (let i = 0; i < buffer.length; i++) {
+    let item = buffer[i];
+    if (isString(item)) {
+      ret += item;
+    } else {
+      ret += unrollBufferSync$1(item);
+    }
+  }
+  return ret;
+}
+async function renderToString(input, context = {}) {
+  if (isVNode$1(input)) {
+    return renderToString(createApp({ render: () => input }), context);
+  }
+  const vnode = createVNode(input._component, input._props);
+  vnode.appContext = input._context;
+  input.provide(ssrContextKey, context);
+  const buffer = await renderComponentVNode(vnode);
+  const result = await unrollBuffer$1(buffer);
+  await resolveTeleports(context);
+  if (context.__watcherHandles) {
+    for (const unwatch of context.__watcherHandles) {
+      unwatch();
+    }
+  }
+  return result;
+}
+async function resolveTeleports(context) {
+  if (context.__teleportBuffers) {
+    context.teleports = context.teleports || {};
+    for (const key in context.__teleportBuffers) {
+      context.teleports[key] = await unrollBuffer$1(
+        await Promise.all([context.__teleportBuffers[key]])
+      );
+    }
+  }
+}
+
+const { isVNode } = ssrUtils;
+async function unrollBuffer(buffer, stream) {
+  if (buffer.hasAsync) {
+    for (let i = 0; i < buffer.length; i++) {
+      let item = buffer[i];
+      if (isPromise(item)) {
+        item = await item;
+      }
+      if (isString(item)) {
+        stream.push(item);
+      } else {
+        await unrollBuffer(item, stream);
+      }
+    }
+  } else {
+    unrollBufferSync(buffer, stream);
+  }
+}
+function unrollBufferSync(buffer, stream) {
+  for (let i = 0; i < buffer.length; i++) {
+    let item = buffer[i];
+    if (isString(item)) {
+      stream.push(item);
+    } else {
+      unrollBufferSync(item, stream);
+    }
+  }
+}
+function renderToSimpleStream(input, context, stream) {
+  if (isVNode(input)) {
+    return renderToSimpleStream(
+      createApp({ render: () => input }),
+      context,
+      stream
+    );
+  }
+  const vnode = createVNode(input._component, input._props);
+  vnode.appContext = input._context;
+  input.provide(ssrContextKey, context);
+  Promise.resolve(renderComponentVNode(vnode)).then((buffer) => unrollBuffer(buffer, stream)).then(() => resolveTeleports(context)).then(() => {
+    if (context.__watcherHandles) {
+      for (const unwatch of context.__watcherHandles) {
+        unwatch();
+      }
+    }
+  }).then(() => stream.push(null)).catch((error) => {
+    stream.destroy(error);
+  });
+  return stream;
+}
+function renderToStream(input, context = {}) {
+  console.warn(
+    `[@vue/server-renderer] renderToStream is deprecated - use renderToNodeStream instead.`
+  );
+  return renderToNodeStream(input, context);
+}
+function renderToNodeStream(input, context = {}) {
+  {
+    throw new Error(
+      `ESM build of renderToStream() does not support renderToNodeStream(). Use pipeToNodeWritable() with an existing Node.js Writable stream instance instead.`
+    );
+  }
+}
+function pipeToNodeWritable(input, context = {}, writable) {
+  renderToSimpleStream(input, context, {
+    push(content) {
+      if (content != null) {
+        writable.write(content);
+      } else {
+        writable.end();
+      }
+    },
+    destroy(err) {
+      writable.destroy(err);
+    }
+  });
+}
+function renderToWebStream(input, context = {}) {
+  if (typeof ReadableStream !== "function") {
+    throw new Error(
+      `ReadableStream constructor is not available in the global scope. If the target environment does support web streams, consider using pipeToWebWritable() with an existing WritableStream instance instead.`
+    );
+  }
+  const encoder = new TextEncoder();
+  let cancelled = false;
+  return new ReadableStream({
+    start(controller) {
+      renderToSimpleStream(input, context, {
+        push(content) {
+          if (cancelled)
+            return;
+          if (content != null) {
+            controller.enqueue(encoder.encode(content));
+          } else {
+            controller.close();
+          }
+        },
+        destroy(err) {
+          controller.error(err);
+        }
+      });
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+}
+function pipeToWebWritable(input, context = {}, writable) {
+  const writer = writable.getWriter();
+  const encoder = new TextEncoder();
+  let hasReady = false;
+  try {
+    hasReady = isPromise(writer.ready);
+  } catch (e) {
+  }
+  renderToSimpleStream(input, context, {
+    async push(content) {
+      if (hasReady) {
+        await writer.ready;
+      }
+      if (content != null) {
+        return writer.write(encoder.encode(content));
+      } else {
+        return writer.close();
+      }
+    },
+    destroy(err) {
+      console.log(err);
+      writer.close();
+    }
+  });
+}
+
+initDirectivesForSSR();
+
+export { pipeToNodeWritable, pipeToWebWritable, renderToNodeStream, renderToSimpleStream, renderToStream, renderToString, renderToWebStream, ssrGetDirectiveProps, ssrGetDynamicModelProps, ssrInterpolate, ssrLooseContain, ssrLooseEqual, ssrRenderAttr, ssrRenderAttrs, ssrRenderClass, ssrRenderComponent, ssrRenderDynamicAttr, ssrRenderDynamicModel, ssrRenderList, ssrRenderSlot, ssrRenderSlotInner, ssrRenderStyle, ssrRenderSuspense, ssrRenderTeleport, renderVNode as ssrRenderVNode };