@dcloudio/uni-cli-shared 3.0.0-alpha-4070720250804001 → 3.0.0-alpha-4070620250731002

package/lib/vapor/@vue/server-renderer/dist/server-renderer.cjs.js

@@ -1,1144 +0,0 @@
-/**
-* @vue/server-renderer v3.6.0-alpha.2
-* (c) 2018-present Yuxi (Evan) You and Vue contributors
-* @license MIT
-**/
-'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 = /* @__PURE__ */ 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 if (key === "className") {
-      ret += ` class="${String(value)}"`;
-    } else {
-      ret += ssrRenderDynamicAttr(key, value, tag);
-    }
-  }
-  return ret;
-}
-function ssrRenderDynamicAttr(key, value, tag) {
-  if (!shared.isRenderableAttrValue(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 (!shared.isRenderableAttrValue(value)) {
-    return ``;
-  }
-  return ` ${key}="${shared.escapeHtml(value)}"`;
-}
-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(ssrResetCssVars(raw));
-  return shared.escapeHtml(shared.stringifyStyle(styles));
-}
-function ssrResetCssVars(raw) {
-  if (!shared.isArray(raw) && shared.isObject(raw)) {
-    const res = {};
-    for (const key in raw) {
-      if (key.startsWith(":--")) {
-        res[key.slice(1)] = shared.normalizeCssVarValue(raw[key]);
-      } else {
-        res[key] = raw[key];
-      }
-    }
-    return res;
-  }
-  return raw;
-}
-
-function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
-  return renderComponentVNode(
-    Vue.createVNode(comp, props, children),
-    parentComponent,
-    slotScopeId
-  );
-}
-
-const { ensureValidVNode } = Vue.ssrUtils;
-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)) {
-      const validSlotContent = ensureValidVNode(ret);
-      if (validSlotContent) {
-        renderVNodeChildren(
-          push,
-          validSlotContent,
-          parentComponent,
-          slotScopeId
-        );
-      } else if (fallbackRenderFn) {
-        fallbackRenderFn();
-      }
-    } 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 {
-        let start = 0;
-        let end = slotBuffer.length;
-        if (transition && slotBuffer[0] === "<!--[-->" && slotBuffer[end - 1] === "<!--]-->") {
-          start++;
-          end--;
-        }
-        for (let i = start; i < end; i++) {
-          push(slotBuffer[i]);
-        }
-      }
-    }
-  } else if (fallbackRenderFn) {
-    fallbackRenderFn();
-  }
-}
-const commentTestRE = /^<!--[\s\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 start anchor--><!--teleport anchor-->`;
-  } else {
-    const { getBuffer, push } = createBuffer();
-    push(`<!--teleport start anchor-->`);
-    contentRenderFn(push);
-    push(`<!--teleport anchor-->`);
-    teleportContent = getBuffer();
-  }
-  targetBuffer.splice(bufferIndex, 0, teleportContent);
-  parentPush("<!--teleport end-->");
-}
-
-function ssrInterpolate(value) {
-  return shared.escapeHtml(shared.toDisplayString(value));
-}
-
-let activeSub = void 0;
-function setActiveSub(sub) {
-  try {
-    return activeSub;
-  } finally {
-    activeSub = sub;
-  }
-}
-
-function toRaw(observed) {
-  const raw = observed && observed["__v_raw"];
-  return raw ? toRaw(raw) : observed;
-}
-
-function isRef(r) {
-  return r ? r["__v_isRef"] === true : false;
-}
-
-const stack = [];
-function pushWarningContext$1(ctx) {
-  stack.push(ctx);
-}
-function popWarningContext$1() {
-  stack.pop();
-}
-let isWarning = false;
-function warn$1(msg, ...args) {
-  if (isWarning) return;
-  isWarning = true;
-  const prevSub = setActiveSub();
-  const entry = stack.length ? stack[stack.length - 1] : null;
-  const instance = isVNode$2(entry) ? entry.component : entry;
-  const appWarnHandler = instance && instance.appContext.config.warnHandler;
-  const trace = getComponentTrace();
-  if (appWarnHandler) {
-    callWithErrorHandling(
-      appWarnHandler,
-      instance,
-      11,
-      [
-        // eslint-disable-next-line no-restricted-syntax
-        msg + args.map((a) => {
-          var _a, _b;
-          return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
-        }).join(""),
-        instance && instance.proxy || instance,
-        trace.map(
-          ({ ctx }) => `at <${formatComponentName(instance, ctx.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);
-  }
-  setActiveSub(prevSub);
-  isWarning = false;
-}
-function getComponentTrace() {
-  let currentCtx = stack[stack.length - 1];
-  if (!currentCtx) {
-    return [];
-  }
-  const normalizedStack = [];
-  while (currentCtx) {
-    const last = normalizedStack[0];
-    if (last && last.ctx === currentCtx) {
-      last.recurseCount++;
-    } else {
-      normalizedStack.push({
-        ctx: currentCtx,
-        recurseCount: 0
-      });
-    }
-    if (isVNode$2(currentCtx)) {
-      const parent = currentCtx.component && currentCtx.component.parent;
-      currentCtx = parent && parent.vnode || parent;
-    } else {
-      currentCtx = currentCtx.parent;
-    }
-  }
-  return normalizedStack;
-}
-function formatTrace(trace) {
-  const logs = [];
-  trace.forEach((entry, i) => {
-    logs.push(...i === 0 ? [] : [`
-`], ...formatTraceEntry(entry));
-  });
-  return logs;
-}
-function formatTraceEntry({ ctx, recurseCount }) {
-  const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
-  const instance = isVNode$2(ctx) ? ctx.component : ctx;
-  const isRoot = instance ? instance.parent == null : false;
-  const open = ` at <${formatComponentName(instance, ctx.type, isRoot)}`;
-  const close = `>` + postfix;
-  return ctx.props ? [open, ...formatProps(ctx.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 (shared.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 (shared.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",
-  [15]: "component update",
-  [16]: "app unmount cleanup function"
-};
-function callWithErrorHandling(fn, instance, type, args) {
-  try {
-    return args ? fn(...args) : fn();
-  } catch (err) {
-    handleError(err, instance, type);
-  }
-}
-function handleError(err, instance, type, throwInDev = true) {
-  const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || shared.EMPTY_OBJ;
-  if (instance) {
-    let cur = instance.parent;
-    const exposedInstance = instance.proxy || instance;
-    const errorInfo = 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;
-    }
-    if (errorHandler) {
-      const prevSub = setActiveSub();
-      callWithErrorHandling(errorHandler, null, 10, [
-        err,
-        exposedInstance,
-        errorInfo
-      ]);
-      setActiveSub(prevSub);
-      return;
-    }
-  }
-  logError(err, type, instance, throwInDev, throwUnhandledErrorInProduction);
-}
-function logError(err, type, instance, throwInDev = true, throwInProd = false) {
-  {
-    const info = ErrorTypeStrings[type] || type;
-    if (instance) {
-      pushWarningContext$1(instance);
-    }
-    warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
-    if (instance) {
-      popWarningContext$1();
-    }
-    if (err instanceof Error) {
-      console.error(
-        `---BEGIN:EXCEPTION---${err.message}
-${err.stack || ""}---END:EXCEPTION---`
-      );
-    } else {
-      console.error(err);
-    }
-  }
-}
-
-function isVNode$2(value) {
-  return value ? value.__v_isVNode === true : false;
-}
-
-const classifyRE = /(?:^|[-_])(\w)/g;
-const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
-function getComponentName(Component, includeInferred = true) {
-  return shared.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`;
-}
-
-const warn = warn$1 ;
-
-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") {
-    if (!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 (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: Vue.ssrUtils.getComponentPublicInstance(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) => {
-    {
-      const message = `[@vue/server-renderer] Template compilation error: ${err.message}`;
-      const codeFrame = err.loc && shared.generateCodeFrame(
-        template,
-        err.loc.start.offset,
-        err.loc.end.offset
-      );
-      Vue.warn(codeFrame ? `${message}
-${codeFrame}` : message);
-    }
-  };
-  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,
-  pushWarningContext,
-  popWarningContext
-} = 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;
-        return;
-      }
-      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 = vnode.component = createComponentInstance(
-    vnode,
-    parentComponent,
-    null
-  );
-  pushWarningContext(vnode);
-  const res = setupComponent(
-    instance,
-    true
-    /* isSSR */
-  );
-  popWarningContext();
-  const hasAsyncSetup = shared.isPromise(res);
-  let prefetches = instance.sp;
-  if (hasAsyncSetup || prefetches) {
-    const p = Promise.resolve(res).then(() => {
-      if (hasAsyncSetup) prefetches = instance.sp;
-      if (prefetches) {
-        return Promise.all(
-          prefetches.map((prefetch) => prefetch.call(instance.proxy))
-        );
-      }
-    }).catch(shared.NOOP);
-    return p.then(() => renderComponentSubTree(instance, slotScopeId));
-  } else {
-    return renderComponentSubTree(instance, slotScopeId);
-  }
-}
-function renderComponentSubTree(instance, slotScopeId) {
-  pushWarningContext(instance.vnode);
-  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);
-    }
-    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 };
-        const slotScopeIdList = slotScopeId.trim().split(" ");
-        for (let i = 0; i < slotScopeIdList.length; i++) {
-          attrs[slotScopeIdList[i]] = "";
-        }
-      }
-      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(`<!---->`);
-    }
-  }
-  popWarningContext();
-  return getBuffer();
-}
-function renderVNode(push, vnode, parentComponent, slotScopeId) {
-  const { type, shapeFlag, children, dirs, props } = vnode;
-  if (dirs) {
-    vnode.props = applySSRDirectives(vnode, props, dirs);
-  }
-  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 } = vnode;
-  let openTag = `<${tag}`;
-  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;
-function nestedUnrollBuffer(buffer, parentRet, startIndex) {
-  if (!buffer.hasAsync) {
-    return parentRet + unrollBufferSync$1(buffer);
-  }
-  let ret = parentRet;
-  for (let i = startIndex; i < buffer.length; i += 1) {
-    const item = buffer[i];
-    if (shared.isString(item)) {
-      ret += item;
-      continue;
-    }
-    if (shared.isPromise(item)) {
-      return item.then((nestedItem) => {
-        buffer[i] = nestedItem;
-        return nestedUnrollBuffer(buffer, ret, i);
-      });
-    }
-    const result = nestedUnrollBuffer(item, ret, 0);
-    if (shared.isPromise(result)) {
-      return result.then((nestedItem) => {
-        buffer[i] = nestedItem;
-        return nestedUnrollBuffer(buffer, "", i);
-      });
-    }
-    ret = result;
-  }
-  return ret;
-}
-function unrollBuffer$1(buffer) {
-  return nestedUnrollBuffer(buffer, "", 0);
-}
-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("node: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;