@vue/server-renderer 3.2.44 → 3.2.46

package/dist/server-renderer.cjs.js

@@ -1,11 +1,22 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var vue = require('vue');
+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);
+
 // leading comma for empty string ""
 const shouldIgnoreProp = shared.makeMap(`,key,ref,innerHTML,textContent,ref_key,ref_for`);
 function ssrRenderAttrs(props, tag) {
@@ -77,44 +88,73 @@ function ssrRenderStyle(raw) {
     return shared.escapeHtml(shared.stringifyStyle(styles));
 }
 
-const compileCache = Object.create(null);
-function ssrCompile(template, instance) {
-    // TODO: This is copied from runtime-core/src/component.ts and should probably be refactored
-    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}\n${codeFrame}` : message);
+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) {
+    // template-compiled slots are always rendered as fragments
+    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)) {
+            // normal slot
+            renderVNodeChildren(push, ret, parentComponent, slotScopeId);
         }
-    };
-    const { code } = compilerSsr.compile(template, finalCompilerOptions);
-    return (compileCache[cacheKey] = Function('require', code)(require));
+        else {
+            // ssr slot.
+            // check if the slot renders all comments, in which case use the fallback
+            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 is '<!---->' or '<!--[-->' or '<!--]-->', return true directly
+    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 context = parentComponent.appContext.provides[Vue.ssrContextKey];
     const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
     const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
     // record current index of the target buffer to handle nested teleports
@@ -135,890 +175,906 @@ function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parent
     parentPush('<!--teleport end-->');
 }
 
-const { createComponentInstance, setCurrentRenderingInstance, setupComponent, renderComponentRoot, normalizeVNode } = vue.ssrUtils;
-// Each component has a buffer array.
-// A buffer array can contain one of the following:
-// - plain string
-// - A resolved buffer (recursive arrays of strings that can be unrolled
-//   synchronously)
-// - An async buffer (a Promise that resolves to a resolved buffer)
-function createBuffer() {
-    let appendable = false;
-    const buffer = [];
-    return {
-        getBuffer() {
-            // Return static buffer and await on items during unroll stage
-            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)) {
-                // promise, or child buffer with async, mark as async.
-                // this allows skipping unnecessary await ticks during unroll stage
-                buffer.hasAsync = true;
-            }
-        }
-    };
+function ssrInterpolate(value) {
+    return shared.escapeHtml(shared.toDisplayString(value));
 }
-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; /* LifecycleHooks.SERVER_PREFETCH */
-    if (hasAsyncSetup || prefetches) {
-        let p = hasAsyncSetup
-            ? res
-            : Promise.resolve();
-        if (prefetches) {
-            p = p
-                .then(() => Promise.all(prefetches.map(prefetch => prefetch.call(instance.proxy))))
-                // Note: error display is already done by the wrapped lifecycle hook function.
-                .catch(() => { });
-        }
-        return p.then(() => renderComponentSubTree(instance, slotScopeId));
+
+let shouldTrack = true;
+const trackStack = [];
+function pauseTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = false;
+}
+function resetTracking() {
+    const last = trackStack.pop();
+    shouldTrack = last === undefined ? true : last;
+}
+
+function toRaw(observed) {
+    const raw = observed && observed["__v_raw" /* ReactiveFlags.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) {
+    // avoid props formatting or warn handler tracking deps that might be mutated
+    // during patch, leading to infinite recursion.
+    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 /* ErrorCodes.APP_WARN_HANDLER */, [
+            msg + args.join(''),
+            instance && instance.proxy,
+            trace
+                .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)
+                .join('\n'),
+            trace
+        ]);
     }
     else {
-        return renderComponentSubTree(instance, slotScopeId);
+        const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+        /* istanbul ignore if */
+        if (trace.length &&
+            // avoid spamming console during tests
+            !false) {
+            warnArgs.push(`\n`, ...formatTrace(trace));
+        }
+        console.warn(...warnArgs);
     }
+    resetTracking();
 }
-function renderComponentSubTree(instance, slotScopeId) {
-    const comp = instance.type;
-    const { getBuffer, push } = createBuffer();
-    if (shared.isFunction(comp)) {
-        let root = renderComponentRoot(instance);
-        // #5817 scope ID attrs not falling through if functional component doesn't
-        // have props
-        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);
+function getComponentTrace() {
+    let currentVNode = stack[stack.length - 1];
+    if (!currentVNode) {
+        return [];
     }
-    else {
-        if ((!instance.render || instance.render === shared.NOOP) &&
-            !instance.ssrRender &&
-            !comp.ssrRender &&
-            shared.isString(comp.template)) {
-            comp.ssrRender = ssrCompile(comp.template, instance);
+    // we can't just use the stack because it will be incomplete during updates
+    // that did not start from the root. Re-construct the parent chain using
+    // instance parent pointers.
+    const normalizedStack = [];
+    while (currentVNode) {
+        const last = normalizedStack[0];
+        if (last && last.vnode === currentVNode) {
+            last.recurseCount++;
         }
-        // perf: enable caching of computed getters during render
-        // since there cannot be state mutations during render.
-        for (const e of instance.scope.effects) {
-            if (e.computed)
-                e.computed._cacheable = true;
-        }
-        const ssrRender = instance.ssrRender || comp.ssrRender;
-        if (ssrRender) {
-            // optimized
-            // resolve fallthrough attrs
-            let attrs = instance.inheritAttrs !== false ? instance.attrs : undefined;
-            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) {
-                    // parent is a non-SSR compiled component and is rendering this
-                    // component as root. inherit its scopeId if present.
-                    cur = parent;
-                }
-                else {
-                    break;
-                }
-            }
-            if (slotScopeId) {
-                if (!hasCloned)
-                    attrs = { ...attrs };
-                attrs[slotScopeId.trim()] = '';
-            }
-            // set current rendering instance for asset resolution
-            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(`<!---->`);
+        else {
+            normalizedStack.push({
+                vnode: currentVNode,
+                recurseCount: 0
+            });
         }
+        const parentInstance = currentVNode.component && currentVNode.component.parent;
+        currentVNode = parentInstance && parentInstance.vnode;
     }
-    return getBuffer();
+    return normalizedStack;
 }
-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(`<!--[-->`); // open
-            renderVNodeChildren(push, children, parentComponent, slotScopeId);
-            push(`<!--]-->`); // close
-            break;
-        default:
-            if (shapeFlag & 1 /* ShapeFlags.ELEMENT */) {
-                renderElementVNode(push, vnode, parentComponent, slotScopeId);
-            }
-            else if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
-                push(renderComponentVNode(vnode, parentComponent, slotScopeId));
-            }
-            else if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) {
-                renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
-            }
-            else if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
-                renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
-            }
-            else {
-                vue.warn('[@vue/server-renderer] Invalid VNode type:', type, `(${typeof type})`);
-            }
-    }
+/* istanbul ignore next */
+function formatTrace(trace) {
+    const logs = [];
+    trace.forEach((entry, i) => {
+        logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry));
+    });
+    return logs;
 }
-function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
-    for (let i = 0; i < children.length; i++) {
-        renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
+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];
+}
+/* istanbul ignore next */
+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 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);
+/* istanbul ignore next */
+function formatProp(key, value, raw) {
+    if (shared.isString(value)) {
+        value = JSON.stringify(value);
+        return raw ? value : [`${key}=${value}`];
     }
-    if (props) {
-        openTag += ssrRenderAttrs(props, tag);
+    else if (typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value == null) {
+        return raw ? value : [`${key}=${value}`];
     }
-    if (scopeId) {
-        openTag += ` ${scopeId}`;
+    else if (isRef(value)) {
+        value = formatProp(key, toRaw(value.value), true);
+        return raw ? value : [`${key}=Ref<`, value, `>`];
     }
-    // inherit parent chain scope id if this is the root node
-    let curParent = parentComponent;
-    let curVnode = vnode;
-    while (curParent && curVnode === curParent.subTree) {
-        curVnode = curParent.vnode;
-        if (curVnode.scopeId) {
-            openTag += ` ${curVnode.scopeId}`;
-        }
-        curParent = curParent.parent;
+    else if (shared.isFunction(value)) {
+        return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
     }
-    if (slotScopeId) {
-        openTag += ` ${slotScopeId}`;
+    else {
+        value = toRaw(value);
+        return raw ? value : [`${key}=`, value];
     }
-    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));
+}
+
+const ErrorTypeStrings = {
+    ["sp" /* LifecycleHooks.SERVER_PREFETCH */]: 'serverPrefetch hook',
+    ["bc" /* LifecycleHooks.BEFORE_CREATE */]: 'beforeCreate hook',
+    ["c" /* LifecycleHooks.CREATED */]: 'created hook',
+    ["bm" /* LifecycleHooks.BEFORE_MOUNT */]: 'beforeMount hook',
+    ["m" /* LifecycleHooks.MOUNTED */]: 'mounted hook',
+    ["bu" /* LifecycleHooks.BEFORE_UPDATE */]: 'beforeUpdate hook',
+    ["u" /* LifecycleHooks.UPDATED */]: 'updated',
+    ["bum" /* LifecycleHooks.BEFORE_UNMOUNT */]: 'beforeUnmount hook',
+    ["um" /* LifecycleHooks.UNMOUNTED */]: 'unmounted hook',
+    ["a" /* LifecycleHooks.ACTIVATED */]: 'activated hook',
+    ["da" /* LifecycleHooks.DEACTIVATED */]: 'deactivated hook',
+    ["ec" /* LifecycleHooks.ERROR_CAPTURED */]: 'errorCaptured hook',
+    ["rtc" /* LifecycleHooks.RENDER_TRACKED */]: 'renderTracked hook',
+    ["rtg" /* LifecycleHooks.RENDER_TRIGGERED */]: 'renderTriggered hook',
+    [0 /* ErrorCodes.SETUP_FUNCTION */]: 'setup function',
+    [1 /* ErrorCodes.RENDER_FUNCTION */]: 'render function',
+    [2 /* ErrorCodes.WATCH_GETTER */]: 'watcher getter',
+    [3 /* ErrorCodes.WATCH_CALLBACK */]: 'watcher callback',
+    [4 /* ErrorCodes.WATCH_CLEANUP */]: 'watcher cleanup function',
+    [5 /* ErrorCodes.NATIVE_EVENT_HANDLER */]: 'native event handler',
+    [6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */]: 'component event handler',
+    [7 /* ErrorCodes.VNODE_HOOK */]: 'vnode hook',
+    [8 /* ErrorCodes.DIRECTIVE_HOOK */]: 'directive hook',
+    [9 /* ErrorCodes.TRANSITION_HOOK */]: 'transition hook',
+    [10 /* ErrorCodes.APP_ERROR_HANDLER */]: 'app errorHandler',
+    [11 /* ErrorCodes.APP_WARN_HANDLER */]: 'app warnHandler',
+    [12 /* ErrorCodes.FUNCTION_REF */]: 'ref function',
+    [13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */]: 'async component loader',
+    [14 /* ErrorCodes.SCHEDULER */]: '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;
+        // the exposed instance is the render proxy to keep it consistent with 2.x
+        const exposedInstance = instance.proxy;
+        // in production the hook receives only the error code
+        const errorInfo = ErrorTypeStrings[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 (!hasChildrenOverride) {
-            if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) {
-                push(shared.escapeHtml(children));
-            }
-            else if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
-                renderVNodeChildren(push, children, parentComponent, slotScopeId);
-            }
+        // app-level handling
+        const appErrorHandler = instance.appContext.config.errorHandler;
+        if (appErrorHandler) {
+            callWithErrorHandling(appErrorHandler, null, 10 /* ErrorCodes.APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);
+            return;
         }
-        push(`</${tag}>`);
     }
+    logError(err, type, contextVNode, throwInDev);
 }
-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);
+function logError(err, type, contextVNode, throwInDev = true) {
+    {
+        const info = ErrorTypeStrings[type];
+        if (contextVNode) {
+            pushWarningContext(contextVNode);
         }
-    }
-    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.`);
+        warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+        if (contextVNode) {
+            popWarningContext();
+        }
+        // crash in dev by default so it's more noticeable
+        if (throwInDev) {
+            throw err;
+        }
+        else {
+            console.error(err);
         }
-        return [];
-    }
-    if (!shared.isString(target)) {
-        vue.warn(`[@vue/server-renderer] Teleport target must be a query selector string.`);
-        return [];
     }
-    ssrRenderTeleport(push, push => {
-        renderVNodeChildren(push, vnode.children, parentComponent, slotScopeId);
-    }, target, disabled || disabled === '', parentComponent);
 }
 
-const { isVNode } = vue.ssrUtils;
-async function unrollBuffer(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;
+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);
+}
+/* istanbul ignore next */
+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) {
+        // try to infer the name based on reverse resolution
+        const inferFromRegistry = (registry) => {
+            for (const key in registry) {
+                if (registry[key] === Component) {
+                    return key;
+                }
             }
-            if (shared.isString(item)) {
-                ret += item;
+        };
+        name =
+            inferFromRegistry(instance.components ||
+                instance.parent.type.components) || inferFromRegistry(instance.appContext.components);
+    }
+    return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+}
+
+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 {
-                ret += await unrollBuffer(item);
+        }
+        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);
             }
         }
-        return ret;
+    }
+}
+
+async function ssrRenderSuspense(push, { default: renderContent }) {
+    if (renderContent) {
+        renderContent();
     }
     else {
-        // sync buffer can be more efficiently unrolled without unnecessary await
-        // ticks
-        return unrollBufferSync(buffer);
+        push(`<!---->`);
     }
 }
-function unrollBufferSync(buffer) {
-    let ret = '';
-    for (let i = 0; i < buffer.length; i++) {
-        let item = buffer[i];
-        if (shared.isString(item)) {
-            ret += item;
-        }
-        else {
-            // since this is a sync buffer, child buffers are never promises
-            ret += unrollBufferSync(item);
-        }
+
+function ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
+    if (typeof dir !== 'function' && dir.getSSRProps) {
+        return (dir.getSSRProps({
+            dir,
+            instance,
+            value,
+            oldValue: undefined,
+            arg,
+            modifiers
+        }, null) || {});
     }
-    return ret;
+    return {};
 }
-async function renderToString(input, context = {}) {
-    if (isVNode(input)) {
-        // raw vnode, wrap with app (for context)
-        return renderToString(vue.createApp({ render: () => input }), context);
+
+const ssrLooseEqual = shared.looseEqual;
+function ssrLooseContain(arr, value) {
+    return shared.looseIndexOf(arr, value) > -1;
+}
+// for <input :type="type" v-model="model" value="value">
+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:
+            // text types
+            return ssrRenderAttr('value', model);
     }
-    // rendering an app
-    const vnode = vue.createVNode(input._component, input._props);
-    vnode.appContext = input._context;
-    // provide the ssr context to the tree
-    input.provide(vue.ssrContextKey, context);
-    const buffer = await renderComponentVNode(vnode);
-    const result = await unrollBuffer(buffer);
-    await resolveTeleports(context);
-    if (context.__watcherHandles) {
-        for (const unwatch of context.__watcherHandles) {
-            unwatch();
-        }
+}
+// for <input v-bind="obj" v-model="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:
+            // text types
+            return { value: model };
     }
-    return result;
 }
-async function resolveTeleports(context) {
-    if (context.__teleportBuffers) {
-        context.teleports = context.teleports || {};
-        for (const key in context.__teleportBuffers) {
-            // note: it's OK to await sequentially here because the Promises were
-            // created eagerly in parallel.
-            context.teleports[key] = await unrollBuffer(await Promise.all([context.__teleportBuffers[key]]));
-        }
+
+// internal runtime helpers
+
+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 = Object.create(null);
+function ssrCompile(template, instance) {
+    // TODO: This is copied from runtime-core/src/component.ts and should probably be refactored
+    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}\n${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 { isVNode: isVNode$1 } = vue.ssrUtils;
-async function unrollBuffer$1(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);
+const { createComponentInstance, setCurrentRenderingInstance, setupComponent, renderComponentRoot, normalizeVNode } = Vue.ssrUtils;
+// Each component has a buffer array.
+// A buffer array can contain one of the following:
+// - plain string
+// - A resolved buffer (recursive arrays of strings that can be unrolled
+//   synchronously)
+// - An async buffer (a Promise that resolves to a resolved buffer)
+function createBuffer() {
+    let appendable = false;
+    const buffer = [];
+    return {
+        getBuffer() {
+            // Return static buffer and await on items during unroll stage
+            return buffer;
+        },
+        push(item) {
+            const isStringItem = shared.isString(item);
+            if (appendable && isStringItem) {
+                buffer[buffer.length - 1] += item;
             }
             else {
-                await unrollBuffer$1(item, stream);
+                buffer.push(item);
+            }
+            appendable = isStringItem;
+            if (shared.isPromise(item) || (shared.isArray(item) && item.hasAsync)) {
+                // promise, or child buffer with async, mark as async.
+                // this allows skipping unnecessary await ticks during unroll stage
+                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; /* LifecycleHooks.SERVER_PREFETCH */
+    if (hasAsyncSetup || prefetches) {
+        let p = hasAsyncSetup
+            ? res
+            : Promise.resolve();
+        if (prefetches) {
+            p = p
+                .then(() => Promise.all(prefetches.map(prefetch => prefetch.call(instance.proxy))))
+                // Note: error display is already done by the wrapped lifecycle hook function.
+                .catch(() => { });
+        }
+        return p.then(() => renderComponentSubTree(instance, slotScopeId));
     }
     else {
-        // sync buffer can be more efficiently unrolled without unnecessary await
-        // ticks
-        unrollBufferSync$1(buffer, stream);
+        return renderComponentSubTree(instance, slotScopeId);
     }
 }
-function unrollBufferSync$1(buffer, stream) {
-    for (let i = 0; i < buffer.length; i++) {
-        let item = buffer[i];
-        if (shared.isString(item)) {
-            stream.push(item);
-        }
-        else {
-            // since this is a sync buffer, child buffers are never promises
-            unrollBufferSync$1(item, stream);
+function renderComponentSubTree(instance, slotScopeId) {
+    const comp = instance.type;
+    const { getBuffer, push } = createBuffer();
+    if (shared.isFunction(comp)) {
+        let root = renderComponentRoot(instance);
+        // #5817 scope ID attrs not falling through if functional component doesn't
+        // have props
+        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);
     }
-}
-function renderToSimpleStream(input, context, stream) {
-    if (isVNode$1(input)) {
-        // raw vnode, wrap with app (for context)
-        return renderToSimpleStream(vue.createApp({ render: () => input }), context, stream);
-    }
-    // rendering an app
-    const vnode = vue.createVNode(input._component, input._props);
-    vnode.appContext = input._context;
-    // provide the ssr context to the tree
-    input.provide(vue.ssrContextKey, context);
-    Promise.resolve(renderComponentVNode(vnode))
-        .then(buffer => unrollBuffer$1(buffer, stream))
-        .then(() => resolveTeleports(context))
-        .then(() => {
-        if (context.__watcherHandles) {
-            for (const unwatch of context.__watcherHandles) {
-                unwatch();
-            }
+    else {
+        if ((!instance.render || instance.render === shared.NOOP) &&
+            !instance.ssrRender &&
+            !comp.ssrRender &&
+            shared.isString(comp.template)) {
+            comp.ssrRender = ssrCompile(comp.template, instance);
         }
-    })
-        .then(() => stream.push(null))
-        .catch(error => {
-        stream.destroy(error);
-    });
-    return stream;
-}
-/**
- * @deprecated
- */
-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);
+        // perf: enable caching of computed getters during render
+        // since there cannot be state mutations during render.
+        for (const e of instance.scope.effects) {
+            if (e.computed)
+                e.computed._cacheable = true;
         }
-    });
-}
-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();
+        const ssrRender = instance.ssrRender || comp.ssrRender;
+        if (ssrRender) {
+            // optimized
+            // resolve fallthrough attrs
+            let attrs = instance.inheritAttrs !== false ? instance.attrs : undefined;
+            let hasCloned = false;
+            let cur = instance;
+            while (true) {
+                const scopeId = cur.vnode.scopeId;
+                if (scopeId) {
+                    if (!hasCloned) {
+                        attrs = { ...attrs };
+                        hasCloned = true;
                     }
-                },
-                destroy(err) {
-                    controller.error(err);
+                    attrs[scopeId] = '';
                 }
-            });
-        },
-        cancel() {
-            cancelled = true;
-        }
-    });
-}
-function pipeToWebWritable(input, context = {}, writable) {
-    const writer = writable.getWriter();
-    const encoder = new TextEncoder();
-    // #4287 CloudFlare workers do not implement `ready` property
-    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) {
-            // TODO better error handling?
-            console.log(err);
-            writer.close();
-        }
-    });
-}
-
-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) {
-    // template-compiled slots are always rendered as fragments
-    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)) {
-            // normal slot
-            renderVNodeChildren(push, ret, parentComponent, slotScopeId);
-        }
-        else {
-            // ssr slot.
-            // check if the slot renders all comments, in which case use the fallback
-            let isEmptySlot = true;
-            if (transition) {
-                isEmptySlot = false;
-            }
-            else {
-                for (let i = 0; i < slotBuffer.length; i++) {
-                    if (!isComment(slotBuffer[i])) {
-                        isEmptySlot = false;
-                        break;
-                    }
+                const parent = cur.parent;
+                if (parent && parent.subTree && parent.subTree === cur.vnode) {
+                    // parent is a non-SSR compiled component and is rendering this
+                    // component as root. inherit its scopeId if present.
+                    cur = parent;
                 }
-            }
-            if (isEmptySlot) {
-                if (fallbackRenderFn) {
-                    fallbackRenderFn();
+                else {
+                    break;
                 }
             }
-            else {
-                for (let i = 0; i < slotBuffer.length; i++) {
-                    push(slotBuffer[i]);
-                }
+            if (slotScopeId) {
+                if (!hasCloned)
+                    attrs = { ...attrs };
+                attrs[slotScopeId.trim()] = '';
+            }
+            // set current rendering instance for asset resolution
+            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 (fallbackRenderFn) {
-        fallbackRenderFn();
-    }
-}
-const commentTestRE = /^<!--.*-->$/s;
-const commentRE = /<!--[^]*?-->/gm;
-function isComment(item) {
-    if (typeof item !== 'string' || !commentTestRE.test(item))
-        return false;
-    // if item is '<!---->' or '<!--[-->' or '<!--]-->', return true directly
-    if (item.length <= 8)
-        return true;
-    return !item.replace(commentRE, '').trim();
-}
-
-function ssrInterpolate(value) {
-    return shared.escapeHtml(shared.toDisplayString(value));
-}
-
-function toRaw(observed) {
-    const raw = observed && observed["__v_raw" /* ReactiveFlags.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) {
-    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 /* ErrorCodes.APP_WARN_HANDLER */, [
-            msg + args.join(''),
-            instance && instance.proxy,
-            trace
-                .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`)
-                .join('\n'),
-            trace
-        ]);
-    }
-    else {
-        const warnArgs = [`[Vue warn]: ${msg}`, ...args];
-        /* istanbul ignore if */
-        if (trace.length &&
-            // avoid spamming console during tests
-            !false) {
-            warnArgs.push(`\n`, ...formatTrace(trace));
-        }
-        console.warn(...warnArgs);
-    }
-}
-function getComponentTrace() {
-    let currentVNode = stack[stack.length - 1];
-    if (!currentVNode) {
-        return [];
-    }
-    // we can't just use the stack because it will be incomplete during updates
-    // that did not start from the root. Re-construct the parent chain using
-    // instance parent pointers.
-    const normalizedStack = [];
-    while (currentVNode) {
-        const last = normalizedStack[0];
-        if (last && last.vnode === currentVNode) {
-            last.recurseCount++;
-        }
+        else if (instance.render && instance.render !== shared.NOOP) {
+            renderVNode(push, (instance.subTree = renderComponentRoot(instance)), instance, slotScopeId);
+        }
         else {
-            normalizedStack.push({
-                vnode: currentVNode,
-                recurseCount: 0
-            });
+            const componentName = comp.name || comp.__file || `<Anonymous>`;
+            Vue.warn(`Component ${componentName} is missing template or render function.`);
+            push(`<!---->`);
         }
-        const parentInstance = currentVNode.component && currentVNode.component.parent;
-        currentVNode = parentInstance && parentInstance.vnode;
     }
-    return normalizedStack;
-}
-/* istanbul ignore next */
-function formatTrace(trace) {
-    const logs = [];
-    trace.forEach((entry, i) => {
-        logs.push(...(i === 0 ? [] : [`\n`]), ...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];
+    return getBuffer();
 }
-/* istanbul ignore next */
-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(` ...`);
+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(`<!--[-->`); // open
+            renderVNodeChildren(push, children, parentComponent, slotScopeId);
+            push(`<!--]-->`); // close
+            break;
+        default:
+            if (shapeFlag & 1 /* ShapeFlags.ELEMENT */) {
+                renderElementVNode(push, vnode, parentComponent, slotScopeId);
+            }
+            else if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
+                push(renderComponentVNode(vnode, parentComponent, slotScopeId));
+            }
+            else if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) {
+                renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
+            }
+            else if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
+                renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
+            }
+            else {
+                Vue.warn('[@vue/server-renderer] Invalid VNode type:', type, `(${typeof type})`);
+            }
     }
-    return res;
 }
-/* istanbul ignore next */
-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}`];
+function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
+    for (let i = 0; i < children.length; i++) {
+        renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
     }
-    else if (isRef(value)) {
-        value = formatProp(key, toRaw(value.value), true);
-        return raw ? value : [`${key}=Ref<`, value, `>`];
+}
+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);
     }
-    else if (shared.isFunction(value)) {
-        return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+    if (props) {
+        openTag += ssrRenderAttrs(props, tag);
     }
-    else {
-        value = toRaw(value);
-        return raw ? value : [`${key}=`, value];
+    if (scopeId) {
+        openTag += ` ${scopeId}`;
     }
-}
-
-const ErrorTypeStrings = {
-    ["sp" /* LifecycleHooks.SERVER_PREFETCH */]: 'serverPrefetch hook',
-    ["bc" /* LifecycleHooks.BEFORE_CREATE */]: 'beforeCreate hook',
-    ["c" /* LifecycleHooks.CREATED */]: 'created hook',
-    ["bm" /* LifecycleHooks.BEFORE_MOUNT */]: 'beforeMount hook',
-    ["m" /* LifecycleHooks.MOUNTED */]: 'mounted hook',
-    ["bu" /* LifecycleHooks.BEFORE_UPDATE */]: 'beforeUpdate hook',
-    ["u" /* LifecycleHooks.UPDATED */]: 'updated',
-    ["bum" /* LifecycleHooks.BEFORE_UNMOUNT */]: 'beforeUnmount hook',
-    ["um" /* LifecycleHooks.UNMOUNTED */]: 'unmounted hook',
-    ["a" /* LifecycleHooks.ACTIVATED */]: 'activated hook',
-    ["da" /* LifecycleHooks.DEACTIVATED */]: 'deactivated hook',
-    ["ec" /* LifecycleHooks.ERROR_CAPTURED */]: 'errorCaptured hook',
-    ["rtc" /* LifecycleHooks.RENDER_TRACKED */]: 'renderTracked hook',
-    ["rtg" /* LifecycleHooks.RENDER_TRIGGERED */]: 'renderTriggered hook',
-    [0 /* ErrorCodes.SETUP_FUNCTION */]: 'setup function',
-    [1 /* ErrorCodes.RENDER_FUNCTION */]: 'render function',
-    [2 /* ErrorCodes.WATCH_GETTER */]: 'watcher getter',
-    [3 /* ErrorCodes.WATCH_CALLBACK */]: 'watcher callback',
-    [4 /* ErrorCodes.WATCH_CLEANUP */]: 'watcher cleanup function',
-    [5 /* ErrorCodes.NATIVE_EVENT_HANDLER */]: 'native event handler',
-    [6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */]: 'component event handler',
-    [7 /* ErrorCodes.VNODE_HOOK */]: 'vnode hook',
-    [8 /* ErrorCodes.DIRECTIVE_HOOK */]: 'directive hook',
-    [9 /* ErrorCodes.TRANSITION_HOOK */]: 'transition hook',
-    [10 /* ErrorCodes.APP_ERROR_HANDLER */]: 'app errorHandler',
-    [11 /* ErrorCodes.APP_WARN_HANDLER */]: 'app warnHandler',
-    [12 /* ErrorCodes.FUNCTION_REF */]: 'ref function',
-    [13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */]: 'async component loader',
-    [14 /* ErrorCodes.SCHEDULER */]: '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();
+    // inherit parent chain scope id if this is the root node
+    let curParent = parentComponent;
+    let curVnode = vnode;
+    while (curParent && curVnode === curParent.subTree) {
+        curVnode = curParent.vnode;
+        if (curVnode.scopeId) {
+            openTag += ` ${curVnode.scopeId}`;
+        }
+        curParent = curParent.parent;
     }
-    catch (err) {
-        handleError(err, instance, type);
+    if (slotScopeId) {
+        openTag += ` ${slotScopeId}`;
     }
-    return res;
-}
-function handleError(err, instance, type, throwInDev = true) {
-    const contextVNode = instance ? instance.vnode : null;
-    if (instance) {
-        let cur = instance.parent;
-        // the exposed instance is the render proxy to keep it consistent with 2.x
-        const exposedInstance = instance.proxy;
-        // in production the hook receives only the error code
-        const errorInfo = ErrorTypeStrings[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;
-                    }
-                }
+    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));
             }
-            cur = cur.parent;
         }
-        // app-level handling
-        const appErrorHandler = instance.appContext.config.errorHandler;
-        if (appErrorHandler) {
-            callWithErrorHandling(appErrorHandler, null, 10 /* ErrorCodes.APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);
-            return;
+        if (!hasChildrenOverride) {
+            if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) {
+                push(shared.escapeHtml(children));
+            }
+            else if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
+                renderVNodeChildren(push, children, parentComponent, slotScopeId);
+            }
         }
+        push(`</${tag}>`);
     }
-    logError(err, type, contextVNode, throwInDev);
 }
-function logError(err, type, contextVNode, throwInDev = true) {
-    {
-        const info = ErrorTypeStrings[type];
-        if (contextVNode) {
-            pushWarningContext(contextVNode);
+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);
         }
-        warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
-        if (contextVNode) {
-            popWarningContext();
+    }
+    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.`);
         }
-        // crash in dev by default so it's more noticeable
-        if (throwInDev) {
-            throw err;
+        return [];
+    }
+    if (!shared.isString(target)) {
+        Vue.warn(`[@vue/server-renderer] Teleport target must be a query selector string.`);
+        return [];
+    }
+    ssrRenderTeleport(push, push => {
+        renderVNodeChildren(push, 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 {
+        // sync buffer can be more efficiently unrolled without unnecessary await
+        // ticks
+        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 {
-            console.error(err);
+            // since this is a sync buffer, child buffers are never promises
+            ret += unrollBufferSync$1(item);
         }
     }
+    return ret;
 }
-
-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);
-}
-/* istanbul ignore next */
-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];
+async function renderToString(input, context = {}) {
+    if (isVNode$1(input)) {
+        // raw vnode, wrap with app (for context)
+        return renderToString(Vue.createApp({ render: () => input }), context);
+    }
+    // rendering an app
+    const vnode = Vue.createVNode(input._component, input._props);
+    vnode.appContext = input._context;
+    // provide the ssr context to the tree
+    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();
         }
     }
-    if (!name && instance && instance.parent) {
-        // try to infer the name based on reverse resolution
-        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 result;
+}
+async function resolveTeleports(context) {
+    if (context.__teleportBuffers) {
+        context.teleports = context.teleports || {};
+        for (const key in context.__teleportBuffers) {
+            // note: it's OK to await sequentially here because the Promises were
+            // created eagerly in parallel.
+            context.teleports[key] = await unrollBuffer$1(await Promise.all([context.__teleportBuffers[key]]));
+        }
     }
-    return name ? classify(name) : isRoot ? `App` : `Anonymous`;
 }
 
-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);
+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 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 {
+        // sync buffer can be more efficiently unrolled without unnecessary await
+        // ticks
+        unrollBufferSync(buffer, stream);
     }
-    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);
-            }
+}
+function unrollBufferSync(buffer, stream) {
+    for (let i = 0; i < buffer.length; i++) {
+        let item = buffer[i];
+        if (shared.isString(item)) {
+            stream.push(item);
         }
         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);
-            }
+            // since this is a sync buffer, child buffers are never promises
+            unrollBufferSync(item, stream);
         }
     }
 }
-
-async function ssrRenderSuspense(push, { default: renderContent }) {
-    if (renderContent) {
-        renderContent();
-    }
-    else {
-        push(`<!---->`);
+function renderToSimpleStream(input, context, stream) {
+    if (isVNode(input)) {
+        // raw vnode, wrap with app (for context)
+        return renderToSimpleStream(Vue.createApp({ render: () => input }), context, stream);
     }
+    // rendering an app
+    const vnode = Vue.createVNode(input._component, input._props);
+    vnode.appContext = input._context;
+    // provide the ssr context to the tree
+    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 ssrGetDirectiveProps(instance, dir, value, arg, modifiers = {}) {
-    if (typeof dir !== 'function' && dir.getSSRProps) {
-        return (dir.getSSRProps({
-            dir,
-            instance,
-            value,
-            oldValue: undefined,
-            arg,
-            modifiers
-        }, null) || {});
+/**
+ * @deprecated
+ */
+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 {};
+    return renderToSimpleStream(input, context, stream);
 }
-
-const ssrLooseEqual = shared.looseEqual;
-function ssrLooseContain(arr, value) {
-    return shared.looseIndexOf(arr, value) > -1;
+function pipeToNodeWritable(input, context = {}, writable) {
+    renderToSimpleStream(input, context, {
+        push(content) {
+            if (content != null) {
+                writable.write(content);
+            }
+            else {
+                writable.end();
+            }
+        },
+        destroy(err) {
+            writable.destroy(err);
+        }
+    });
 }
-// for <input :type="type" v-model="model" value="value">
-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:
-            // text types
-            return ssrRenderAttr('value', model);
+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;
+        }
+    });
 }
-// for <input v-bind="obj" v-model="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:
-            // text types
-            return { value: model };
+function pipeToWebWritable(input, context = {}, writable) {
+    const writer = writable.getWriter();
+    const encoder = new TextEncoder();
+    // #4287 CloudFlare workers do not implement `ready` property
+    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) {
+            // TODO better error handling?
+            console.log(err);
+            writer.close();
+        }
+    });
 }
 
-vue.initDirectivesForSSR();
+Vue.initDirectivesForSSR();
 
 exports.ssrIncludeBooleanAttr = shared.includeBooleanAttr;
 exports.pipeToNodeWritable = pipeToNodeWritable;