/** * @vue/server-renderer v3.4.38 * (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 { 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(raw); return shared.escapeHtml(shared.stringifyStyle(styles)); } function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) { return renderComponentVNode( Vue.createVNode(comp, props, children), parentComponent, slotScopeId ); } 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 = /^$/; 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(""); 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 = ``; } else { const { getBuffer, push } = createBuffer(); push(``); contentRenderFn(push); push(``); teleportContent = getBuffer(); } targetBuffer.splice(bufferIndex, 0, teleportContent); parentPush(""); } function ssrInterpolate(value) { return shared.escapeHtml(shared.toDisplayString(value)); } function toRaw(observed) { const raw = observed && observed["__v_raw"]; return raw ? toRaw(raw) : observed; } function isRef(r) { return !!(r && r.__v_isRef === true); } const stack = []; function pushWarningContext(vnode) { stack.push(vnode); } function popWarningContext() { stack.pop(); } let isWarning = false; function warn$1(msg, ...args) { if (isWarning) return; isWarning = true; 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, [ // 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, trace.map( ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>` ).join("\n"), trace ] ); } else { const warnArgs = [`[Vue warn]: ${msg}`, ...args]; if (trace.length && // avoid spamming console during tests true) { warnArgs.push(` `, ...formatTrace(trace)); } console.warn(...warnArgs); } isWarning = false; } function getComponentTrace() { let currentVNode = stack[stack.length - 1]; if (!currentVNode) { return []; } const normalizedStack = []; while (currentVNode) { const last = normalizedStack[0]; if (last && last.vnode === currentVNode) { last.recurseCount++; } else { normalizedStack.push({ vnode: currentVNode, recurseCount: 0 }); } const parentInstance = currentVNode.component && currentVNode.component.parent; currentVNode = parentInstance && parentInstance.vnode; } return normalizedStack; } function formatTrace(trace) { const logs = []; trace.forEach((entry, i) => { logs.push(...i === 0 ? [] : [` `], ...formatTraceEntry(entry)); }); return logs; } function formatTraceEntry({ vnode, recurseCount }) { const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; const isRoot = vnode.component ? vnode.component.parent == null : false; const open = ` at <${formatComponentName( vnode.component, vnode.type, isRoot )}`; const close = `>` + postfix; return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close]; } function formatProps(props) { const res = []; const keys = Object.keys(props); keys.slice(0, 3).forEach((key) => { res.push(...formatProp(key, props[key])); }); if (keys.length > 3) { res.push(` ...`); } return res; } function formatProp(key, value, raw) { if (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" }; 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 contextVNode = instance ? instance.vnode : null; if (instance) { let cur = instance.parent; const exposedInstance = instance.proxy; 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; } const appErrorHandler = instance.appContext.config.errorHandler; if (appErrorHandler) { callWithErrorHandling( appErrorHandler, null, 10, [err, exposedInstance, errorInfo] ); return; } } logError(err, type, contextVNode, throwInDev); } function logError(err, type, contextVNode, throwInDev = true) { { const info = ErrorTypeStrings[type]; if (contextVNode) { pushWarningContext(contextVNode); } warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`); if (contextVNode) { popWarningContext(); } if (throwInDev) { throw err; } else { console.error(err); } } } { const g = shared.getGlobalThis(); const registerGlobalSetter = (key, setter) => { let setters; if (!(setters = g[key])) setters = g[key] = []; setters.push(setter); return (v) => { if (setters.length > 1) setters.forEach((set) => set(v)); else setters[0](v); }; }; registerGlobalSetter( `__VUE_INSTANCE_SETTERS__`, (v) => v ); registerGlobalSetter( `__VUE_SSR_SETTERS__`, (v) => v ); } 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 } = 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 = createComponentInstance(vnode, parentComponent, null); const res = setupComponent( instance, true /* isSSR */ ); const hasAsyncSetup = shared.isPromise(res); const prefetches = instance.sp; if (hasAsyncSetup || prefetches) { let p = hasAsyncSetup ? res : Promise.resolve(); if (prefetches) { p = p.then( () => Promise.all( prefetches.map((prefetch) => prefetch.call(instance.proxy)) ) ).catch(shared.NOOP); } return p.then(() => renderComponentSubTree(instance, slotScopeId)); } else { return renderComponentSubTree(instance, slotScopeId); } } function renderComponentSubTree(instance, slotScopeId) { const comp = instance.type; const { getBuffer, push } = createBuffer(); if (shared.isFunction(comp)) { let root = renderComponentRoot(instance); if (!comp.props) { for (const key in instance.attrs) { if (key.startsWith(`data-v-`)) { (root.props || (root.props = {}))[key] = ``; } } } renderVNode(push, instance.subTree = root, instance, slotScopeId); } else { if ((!instance.render || instance.render === shared.NOOP) && !instance.ssrRender && !comp.ssrRender && shared.isString(comp.template)) { comp.ssrRender = ssrCompile(comp.template, instance); } for (const e of instance.scope.effects) { if (e.computed) { e.computed._dirty = true; e.computed._cacheable = true; } } const ssrRender = instance.ssrRender || comp.ssrRender; if (ssrRender) { let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0; let hasCloned = false; let cur = instance; while (true) { const scopeId = cur.vnode.scopeId; if (scopeId) { if (!hasCloned) { attrs = { ...attrs }; hasCloned = true; } attrs[scopeId] = ""; } const parent = cur.parent; if (parent && parent.subTree && parent.subTree === cur.vnode) { cur = parent; } else { break; } } if (slotScopeId) { if (!hasCloned) attrs = { ...attrs }; 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 || ``; Vue.warn(`Component ${componentName} is missing template or render function.`); push(``); } } return getBuffer(); } function renderVNode(push, vnode, parentComponent, slotScopeId) { const { type, shapeFlag, children } = vnode; switch (type) { case Vue.Text: push(shared.escapeHtml(children)); break; case Vue.Comment: push( children ? `` : `` ); break; case Vue.Static: push(children); break; case Vue.Fragment: if (vnode.slotScopeIds) { slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" "); } push(``); renderVNodeChildren( push, children, parentComponent, slotScopeId ); push(``); break; default: if (shapeFlag & 1) { renderElementVNode(push, vnode, parentComponent, slotScopeId); } else if (shapeFlag & 6) { push(renderComponentVNode(vnode, parentComponent, slotScopeId)); } else if (shapeFlag & 64) { renderTeleportVNode(push, vnode, parentComponent, slotScopeId); } else if (shapeFlag & 128) { renderVNode(push, vnode.ssContent, parentComponent, slotScopeId); } else { Vue.warn( "[@vue/server-renderer] Invalid VNode type:", type, `(${typeof type})` ); } } } function renderVNodeChildren(push, children, parentComponent, slotScopeId) { for (let i = 0; i < children.length; i++) { renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId); } } function renderElementVNode(push, vnode, parentComponent, slotScopeId) { const tag = vnode.type; let { props, children, shapeFlag, scopeId, dirs } = vnode; let openTag = `<${tag}`; if (dirs) { props = applySSRDirectives(vnode, props, dirs); } if (props) { openTag += ssrRenderAttrs(props, tag); } if (scopeId) { openTag += ` ${scopeId}`; } let curParent = parentComponent; let curVnode = vnode; while (curParent && curVnode === curParent.subTree) { curVnode = curParent.vnode; if (curVnode.scopeId) { openTag += ` ${curVnode.scopeId}`; } curParent = curParent.parent; } if (slotScopeId) { openTag += ` ${slotScopeId}`; } push(openTag + `>`); if (!shared.isVoidTag(tag)) { let hasChildrenOverride = false; if (props) { if (props.innerHTML) { hasChildrenOverride = true; push(props.innerHTML); } else if (props.textContent) { hasChildrenOverride = true; push(shared.escapeHtml(props.textContent)); } else if (tag === "textarea" && props.value) { hasChildrenOverride = true; push(shared.escapeHtml(props.value)); } } if (!hasChildrenOverride) { if (shapeFlag & 8) { push(shared.escapeHtml(children)); } else if (shapeFlag & 16) { renderVNodeChildren( push, children, parentComponent, slotScopeId ); } } push(``); } } 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;