@pastweb/vue 2.0.0

package/dist/node_modules/@vue/server-renderer/dist/server-renderer.cjs.cjs

@@ -0,0 +1,830 @@
+"use strict";
+const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
+const require_index = require("../../shared/index.cjs");
+const require_compiler_ssr_cjs$1 = require("../../compiler-ssr/dist/compiler-ssr.cjs.cjs");
+//#region node_modules/@vue/server-renderer/dist/server-renderer.cjs.js
+/**
+* @vue/server-renderer v3.5.39
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+var require_server_renderer_cjs = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var Vue = require("vue");
+	var shared = require_index.default;
+	var compilerSsr = require_compiler_ssr_cjs$1.default;
+	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 (let key in props) {
+			if (shouldIgnoreProp(key) || shared.isOn(key) || tag === "textarea" && key === "value" || key.startsWith(".")) continue;
+			const value = props[key];
+			if (key.startsWith("^")) key = key.slice(1);
+			if (key === "class") ret += ` class="${ssrRenderClass(value)}"`;
+			else if (key === "style") ret += ` style="${ssrRenderStyle(value)}"`;
+			else if (key === "className") {
+				if (value != null) ret += ` class="${shared.escapeHtml(String(value))}"`;
+			} else ret += ssrRenderDynamicAttr(key, value, tag);
+		}
+		return ret;
+	}
+	function ssrRenderDynamicAttr(key, value, tag) {
+		if (!shared.isRenderableAttrValue(value)) return ``;
+		const attrKey = tag && (tag.indexOf("-") > 0 || shared.isSVGTag(tag)) ? key : shared.propsToAttrMap[key] || key.toLowerCase();
+		if (shared.isBooleanAttr(attrKey)) return shared.includeBooleanAttr(value) ? ` ${attrKey}` : ``;
+		else if (shared.isSSRSafeAttrName(attrKey)) return value === "" ? ` ${attrKey}` : ` ${attrKey}="${shared.escapeHtml(value)}"`;
+		else {
+			console.warn(`[@vue/server-renderer] Skipped rendering unsafe attribute name: ${attrKey}`);
+			return ``;
+		}
+	}
+	function ssrRenderAttr(key, value) {
+		if (!shared.isRenderableAttrValue(value)) return ``;
+		return ` ${key}="${shared.escapeHtml(value)}"`;
+	}
+	function ssrRenderClass(raw) {
+		return shared.escapeHtml(shared.normalizeClass(raw));
+	}
+	function ssrRenderStyle(raw) {
+		if (!raw) return "";
+		if (shared.isString(raw)) return shared.escapeHtml(raw);
+		const styles = shared.normalizeStyle(ssrResetCssVars(raw));
+		return shared.escapeHtml(shared.stringifyStyle(styles));
+	}
+	function ssrResetCssVars(raw) {
+		if (!shared.isArray(raw) && shared.isObject(raw)) {
+			const res = {};
+			for (const key in raw) if (key.startsWith(":--")) res[key.slice(1)] = shared.normalizeCssVarValue(raw[key]);
+			else res[key] = raw[key];
+			return res;
+		}
+		return raw;
+	}
+	function ssrRenderComponent(comp, props = null, children = null, parentComponent = null, slotScopeId) {
+		return renderComponentVNode(Vue.createVNode(comp, props, children), parentComponent, slotScopeId);
+	}
+	const { ensureValidVNode } = Vue.ssrUtils;
+	function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId) {
+		push(`<!--[-->`);
+		ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId);
+		push(`<!--]-->`);
+	}
+	function ssrRenderSlotInner(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent, slotScopeId, transition) {
+		const slotFn = slots[slotName];
+		if (slotFn) {
+			const slotBuffer = [];
+			const bufferedPush = (item) => {
+				slotBuffer.push(item);
+			};
+			const ret = slotFn(slotProps, bufferedPush, parentComponent, slotScopeId ? " " + slotScopeId : "");
+			if (shared.isArray(ret)) {
+				const validSlotContent = ensureValidVNode(ret);
+				if (validSlotContent) renderVNodeChildren(push, validSlotContent, parentComponent, slotScopeId);
+				else if (fallbackRenderFn) fallbackRenderFn();
+				else if (transition) push(`<!---->`);
+			} 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--;
+					}
+					if (start < end) for (let i = start; i < end; i++) push(slotBuffer[i]);
+					else if (transition) push(`<!---->`);
+				}
+			}
+		} else if (fallbackRenderFn) fallbackRenderFn();
+		else if (transition) push(`<!---->`);
+	}
+	const commentTestRE = /^<!--[\s\S]*-->$/;
+	const commentRE = /<!--[^]*?-->/gm;
+	function isComment(item) {
+		if (typeof item !== "string" || !commentTestRE.test(item)) return false;
+		if (item.length <= 8) return true;
+		return !item.replace(commentRE, "").trim();
+	}
+	function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+		parentPush("<!--teleport start-->");
+		const context = parentComponent.appContext.provides[Vue.ssrContextKey];
+		const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+		const targetBuffer = teleportBuffers[target] || (teleportBuffers[target] = []);
+		const bufferIndex = targetBuffer.length;
+		let teleportContent;
+		if (disabled) {
+			contentRenderFn(parentPush);
+			teleportContent = `<!--teleport start anchor--><!--teleport anchor-->`;
+		} else {
+			const { getBuffer, push } = createBuffer();
+			push(`<!--teleport start anchor-->`);
+			contentRenderFn(push);
+			push(`<!--teleport anchor-->`);
+			teleportContent = getBuffer();
+		}
+		targetBuffer.splice(bufferIndex, 0, teleportContent);
+		if (shared.isPromise(teleportContent) || shared.isArray(teleportContent) && teleportContent.hasAsync) targetBuffer.hasAsync = true;
+		parentPush("<!--teleport end-->");
+	}
+	function ssrInterpolate(value) {
+		return shared.escapeHtml(shared.toDisplayString(value));
+	}
+	// @__NO_SIDE_EFFECTS__
+	function toRaw(observed) {
+		const raw = observed && observed["__v_raw"];
+		return raw ? /* @__PURE__ */ toRaw(raw) : observed;
+	}
+	// @__NO_SIDE_EFFECTS__
+	function isRef(r) {
+		return r ? r["__v_isRef"] === true : false;
+	}
+	const stack = [];
+	function pushWarningContext$1(vnode) {
+		stack.push(vnode);
+	}
+	function popWarningContext$1() {
+		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, [
+			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 && 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 (/* @__PURE__ */ isRef(value)) {
+			value = formatProp(key, /* @__PURE__ */ toRaw(value.value), true);
+			return raw ? value : [
+				`${key}=Ref<`,
+				value,
+				`>`
+			];
+		} else if (shared.isFunction(value)) return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
+		else {
+			value = /* @__PURE__ */ toRaw(value);
+			return raw ? value : [`${key}=`, value];
+		}
+	}
+	const ErrorTypeStrings = {
+		["sp"]: "serverPrefetch hook",
+		["bc"]: "beforeCreate hook",
+		["c"]: "created hook",
+		["bm"]: "beforeMount hook",
+		["m"]: "mounted hook",
+		["bu"]: "beforeUpdate hook",
+		["u"]: "updated",
+		["bum"]: "beforeUnmount hook",
+		["um"]: "unmounted hook",
+		["a"]: "activated hook",
+		["da"]: "deactivated hook",
+		["ec"]: "errorCaptured hook",
+		["rtc"]: "renderTracked hook",
+		["rtg"]: "renderTriggered hook",
+		[0]: "setup function",
+		[1]: "render function",
+		[2]: "watcher getter",
+		[3]: "watcher callback",
+		[4]: "watcher cleanup function",
+		[5]: "native event handler",
+		[6]: "component event handler",
+		[7]: "vnode hook",
+		[8]: "directive hook",
+		[9]: "transition hook",
+		[10]: "app errorHandler",
+		[11]: "app warnHandler",
+		[12]: "ref function",
+		[13]: "async component loader",
+		[14]: "scheduler flush",
+		[15]: "component update",
+		[16]: "app unmount cleanup function"
+	};
+	function callWithErrorHandling(fn, instance, type, args) {
+		try {
+			return args ? fn(...args) : fn();
+		} catch (err) {
+			handleError(err, instance, type);
+		}
+	}
+	function handleError(err, instance, type, throwInDev = true) {
+		const contextVNode = instance ? instance.vnode : null;
+		const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || shared.EMPTY_OBJ;
+		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;
+			}
+			if (errorHandler) {
+				callWithErrorHandling(errorHandler, null, 10, [
+					err,
+					exposedInstance,
+					errorInfo
+				]);
+				return;
+			}
+		}
+		logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+	}
+	function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
+		{
+			const info = ErrorTypeStrings[type];
+			if (contextVNode) pushWarningContext$1(contextVNode);
+			warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+			if (contextVNode) popWarningContext$1();
+			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) {
+			const inferFromRegistry = (registry) => {
+				for (const key in registry) if (registry[key] === Component) return key;
+			};
+			name = inferFromRegistry(instance.components) || instance.parent && inferFromRegistry(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) || source < 0) {
+				warn(`The v-for range expects a positive 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]) {
+			let i = 0;
+			for (const item of source) renderItem(item, 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);
+			}
+		}
+	}
+	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,
+		ssrGetDynamicModelProps,
+		ssrIncludeBooleanAttr: shared.includeBooleanAttr,
+		ssrInterpolate,
+		ssrLooseContain,
+		ssrLooseEqual,
+		ssrRenderAttr,
+		ssrRenderAttrs,
+		ssrRenderClass,
+		ssrRenderComponent,
+		ssrRenderDynamicAttr,
+		ssrRenderDynamicModel,
+		ssrRenderList,
+		ssrRenderSlot,
+		ssrRenderSlotInner,
+		ssrRenderStyle,
+		ssrRenderSuspense,
+		ssrRenderTeleport,
+		ssrRenderVNode: renderVNode
+	});
+	const compileCache = /* @__PURE__ */ Object.create(null);
+	function ssrCompile(template, instance) {
+		const Component = instance.type;
+		const { isCustomElement, compilerOptions } = instance.appContext.config;
+		const { delimiters, compilerOptions: componentCompilerOptions } = Component;
+		const finalCompilerOptions = shared.extend(shared.extend({
+			isCustomElement,
+			delimiters
+		}, compilerOptions), componentCompilerOptions);
+		finalCompilerOptions.isCustomElement = finalCompilerOptions.isCustomElement || shared.NO;
+		finalCompilerOptions.isNativeTag = finalCompilerOptions.isNativeTag || shared.NO;
+		const cacheKey = JSON.stringify({
+			template,
+			compilerOptions: finalCompilerOptions
+		}, (key, value) => {
+			return shared.isFunction(value) ? value.toString() : value;
+		});
+		const cached = compileCache[cacheKey];
+		if (cached) return cached;
+		finalCompilerOptions.onError = (err) => {
+			{
+				const message = `[@vue/server-renderer] Template compilation error: ${err.message}`;
+				const codeFrame = err.loc && shared.generateCodeFrame(template, err.loc.start.offset, err.loc.end.offset);
+				Vue.warn(codeFrame ? `${message}
+${codeFrame}` : message);
+			}
+		};
+		const { code } = compilerSsr.compile(template, finalCompilerOptions);
+		const requireMap = {
+			vue: Vue__namespace,
+			"vue/server-renderer": helpers
+		};
+		const fakeRequire = (id) => requireMap[id];
+		return compileCache[cacheKey] = Function("require", code)(fakeRequire);
+	}
+	const { createComponentInstance, setCurrentRenderingInstance, setupComponent, renderComponentRoot, normalizeVNode, pushWarningContext, popWarningContext } = Vue.ssrUtils;
+	function createBuffer() {
+		let appendable = false;
+		const buffer = [];
+		return {
+			getBuffer() {
+				return buffer;
+			},
+			push(item) {
+				const isStringItem = shared.isString(item);
+				if (appendable && isStringItem) {
+					buffer[buffer.length - 1] += item;
+					return;
+				}
+				buffer.push(item);
+				appendable = isStringItem;
+				if (shared.isPromise(item) || shared.isArray(item) && item.hasAsync) buffer.hasAsync = true;
+			}
+		};
+	}
+	function renderComponentVNode(vnode, parentComponent = null, slotScopeId) {
+		const instance = vnode.component = createComponentInstance(vnode, parentComponent, null);
+		pushWarningContext(vnode);
+		const res = setupComponent(instance, true);
+		popWarningContext();
+		const hasAsyncSetup = shared.isPromise(res);
+		let prefetches = instance.sp;
+		if (hasAsyncSetup || prefetches) return Promise.resolve(res).then(() => {
+			if (hasAsyncSetup) prefetches = instance.sp;
+			if (prefetches) return Promise.all(prefetches.map((prefetch) => prefetch.call(instance.proxy)));
+		}).catch(shared.NOOP).then(() => renderComponentSubTree(instance, slotScopeId));
+		else return renderComponentSubTree(instance, slotScopeId);
+	}
+	function renderComponentSubTree(instance, slotScopeId) {
+		pushWarningContext(instance.vnode);
+		const comp = instance.type;
+		const { getBuffer, push } = createBuffer();
+		if (shared.isFunction(comp)) {
+			let root = renderComponentRoot(instance);
+			if (!comp.props) {
+				for (const key in instance.attrs) if (key.startsWith(`data-v-`)) (root.props || (root.props = {}))[key] = ``;
+			}
+			renderVNode(push, instance.subTree = root, instance, slotScopeId);
+		} else {
+			if ((!instance.render || instance.render === shared.NOOP) && !instance.ssrRender && !comp.ssrRender && shared.isString(comp.template)) comp.ssrRender = ssrCompile(comp.template, instance);
+			const ssrRender = instance.ssrRender || comp.ssrRender;
+			if (ssrRender) {
+				let attrs = instance.inheritAttrs !== false ? instance.attrs : void 0;
+				let hasCloned = false;
+				let cur = instance;
+				while (true) {
+					const scopeId = cur.vnode.scopeId;
+					if (scopeId) {
+						if (!hasCloned) {
+							attrs = { ...attrs };
+							hasCloned = true;
+						}
+						attrs[scopeId] = "";
+					}
+					const parent = cur.parent;
+					if (parent && parent.subTree && parent.subTree === cur.vnode) cur = parent;
+					else break;
+				}
+				if (slotScopeId) {
+					if (!hasCloned) attrs = { ...attrs };
+					const slotScopeIdList = slotScopeId.trim().split(" ");
+					for (let i = 0; i < slotScopeIdList.length; i++) attrs[slotScopeIdList[i]] = "";
+				}
+				const prev = setCurrentRenderingInstance(instance);
+				try {
+					ssrRender(instance.proxy, push, instance, attrs, instance.props, instance.setupState, instance.data, instance.ctx);
+				} finally {
+					setCurrentRenderingInstance(prev);
+				}
+			} else if (instance.render && instance.render !== shared.NOOP) renderVNode(push, instance.subTree = renderComponentRoot(instance), instance, slotScopeId);
+			else {
+				const componentName = comp.name || comp.__file || `<Anonymous>`;
+				Vue.warn(`Component ${componentName} is missing template or render function.`);
+				push(`<!---->`);
+			}
+		}
+		popWarningContext();
+		return getBuffer();
+	}
+	function renderVNode(push, vnode, parentComponent, slotScopeId) {
+		const { type, shapeFlag, children, dirs, props } = vnode;
+		if (dirs) vnode.props = applySSRDirectives(vnode, props, dirs);
+		switch (type) {
+			case Vue.Text:
+				push(shared.escapeHtml(children));
+				break;
+			case Vue.Comment:
+				push(children ? `<!--${shared.escapeHtmlComment(children)}-->` : `<!---->`);
+				break;
+			case Vue.Static:
+				push(children);
+				break;
+			case Vue.Fragment:
+				if (vnode.slotScopeIds) slotScopeId = (slotScopeId ? slotScopeId + " " : "") + vnode.slotScopeIds.join(" ");
+				push(`<!--[-->`);
+				renderVNodeChildren(push, children, parentComponent, slotScopeId);
+				push(`<!--]-->`);
+				break;
+			default: if (shapeFlag & 1) renderElementVNode(push, vnode, parentComponent, slotScopeId);
+			else if (shapeFlag & 6) push(renderComponentVNode(vnode, parentComponent, slotScopeId));
+			else if (shapeFlag & 64) renderTeleportVNode(push, vnode, parentComponent, slotScopeId);
+			else if (shapeFlag & 128) renderVNode(push, vnode.ssContent, parentComponent, slotScopeId);
+			else Vue.warn("[@vue/server-renderer] Invalid VNode type:", type, `(${typeof type})`);
+		}
+	}
+	function renderVNodeChildren(push, children, parentComponent, slotScopeId) {
+		for (let i = 0; i < children.length; i++) renderVNode(push, normalizeVNode(children[i]), parentComponent, slotScopeId);
+	}
+	function renderElementVNode(push, vnode, parentComponent, slotScopeId) {
+		const tag = vnode.type;
+		let { props, children, shapeFlag, scopeId } = vnode;
+		let openTag = `<${tag}`;
+		if (props) openTag += ssrRenderAttrs(props, tag);
+		const renderedScopeIds = [];
+		const appendScopeId = (id) => {
+			if (id && (!props || !shared.hasOwn(props, id)) && !renderedScopeIds.includes(id)) {
+				openTag += ` ${id}`;
+				renderedScopeIds.push(id);
+			}
+		};
+		if (scopeId) appendScopeId(scopeId);
+		let curParent = parentComponent;
+		let curVnode = vnode;
+		while (curParent && curVnode === curParent.subTree) {
+			curVnode = curParent.vnode;
+			if (curVnode.scopeId) appendScopeId(curVnode.scopeId);
+			curParent = curParent.parent;
+		}
+		if (slotScopeId) {
+			const slotScopeIdList = slotScopeId.trim().split(" ");
+			for (let i = 0; i < slotScopeIdList.length; i++) appendScopeId(slotScopeIdList[i]);
+		}
+		push(openTag + `>`);
+		if (!shared.isVoidTag(tag)) {
+			let hasChildrenOverride = false;
+			if (props) {
+				if (props.innerHTML) {
+					hasChildrenOverride = true;
+					push(props.innerHTML);
+				} else if (props.textContent) {
+					hasChildrenOverride = true;
+					push(shared.escapeHtml(props.textContent));
+				} else if (tag === "textarea" && props.value) {
+					hasChildrenOverride = true;
+					push(shared.escapeHtml(props.value));
+				}
+			}
+			if (!hasChildrenOverride) {
+				if (shapeFlag & 8) push(shared.escapeHtml(children));
+				else if (shapeFlag & 16) renderVNodeChildren(push, children, parentComponent, slotScopeId);
+			}
+			push(`</${tag}>`);
+		}
+	}
+	function applySSRDirectives(vnode, rawProps, dirs) {
+		const toMerge = [];
+		for (let i = 0; i < dirs.length; i++) {
+			const binding = dirs[i];
+			const { dir: { getSSRProps } } = binding;
+			if (getSSRProps) {
+				const props = getSSRProps(binding, vnode);
+				if (props) toMerge.push(props);
+			}
+		}
+		return Vue.mergeProps(rawProps || {}, ...toMerge);
+	}
+	function renderTeleportVNode(push, vnode, parentComponent, slotScopeId) {
+		const target = vnode.props && vnode.props.to;
+		const disabled = vnode.props && vnode.props.disabled;
+		if (!target) {
+			if (!disabled) Vue.warn(`[@vue/server-renderer] Teleport is missing target prop.`);
+			return [];
+		}
+		if (!shared.isString(target)) {
+			Vue.warn(`[@vue/server-renderer] Teleport target must be a query selector string.`);
+			return [];
+		}
+		ssrRenderTeleport(push, (push2) => {
+			renderVNodeChildren(push2, vnode.children, parentComponent, slotScopeId);
+		}, target, disabled || disabled === "", parentComponent);
+	}
+	const { isVNode: isVNode$1 } = Vue.ssrUtils;
+	function nestedUnrollBuffer(buffer, parentRet, startIndex) {
+		if (!buffer.hasAsync) return parentRet + unrollBufferSync$1(buffer);
+		let ret = parentRet;
+		for (let i = startIndex; i < buffer.length; i += 1) {
+			const item = buffer[i];
+			if (shared.isString(item)) {
+				ret += item;
+				continue;
+			}
+			if (shared.isPromise(item)) return item.then((nestedItem) => {
+				buffer[i] = nestedItem;
+				return nestedUnrollBuffer(buffer, ret, i);
+			});
+			const result = nestedUnrollBuffer(item, ret, 0);
+			if (shared.isPromise(result)) return result.then((nestedItem) => {
+				buffer[i] = nestedItem;
+				return nestedUnrollBuffer(buffer, "", i);
+			});
+			ret = result;
+		}
+		return ret;
+	}
+	function unrollBuffer$1(buffer) {
+		return nestedUnrollBuffer(buffer, "", 0);
+	}
+	function unrollBufferSync$1(buffer) {
+		let ret = "";
+		for (let i = 0; i < buffer.length; i++) {
+			let item = buffer[i];
+			if (shared.isString(item)) ret += item;
+			else ret += unrollBufferSync$1(item);
+		}
+		return ret;
+	}
+	async function renderToString(input, context = {}) {
+		if (isVNode$1(input)) return renderToString(Vue.createApp({ render: () => input }), context);
+		const vnode = Vue.createVNode(input._component, input._props);
+		vnode.appContext = input._context;
+		input.provide(Vue.ssrContextKey, context);
+		const result = await unrollBuffer$1(await renderComponentVNode(vnode));
+		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(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;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_server_renderer_cjs();
+	}
+});
+
+//# sourceMappingURL=server-renderer.cjs.cjs.map