docs：更新文档

node_modules/@vue/server-renderer/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-present, Yuxi (Evan) You
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@vue/server-renderer/README.md

@@ -0,0 +1,16 @@
+# @vue/server-renderer
+
+``` js
+const { createSSRApp } = require('vue')
+const { renderToString } = require('@vue/server-renderer')
+
+const app = createSSRApp({
+  data: () => ({ msg: 'hello' }),
+  template: `<div>{{ msg }}</div>`
+})
+
+;(async () => {
+  const html = await renderToString(app)
+  console.log(html)
+})()
+```

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

@@ -0,0 +1,835 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var shared = require('@vue/shared');
+var compilerSsr = require('@vue/compiler-ssr');
+var stream = require('stream');
+
+// leading comma for empty string ""
+const shouldIgnoreProp = shared.makeMap(`,key,ref,innerHTML,textContent`);
+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;
+}
+// render an attr with dynamic (unknown) key.
+function ssrRenderDynamicAttr(key, value, tag) {
+    if (!isRenderableValue(value)) {
+        return ``;
+    }
+    const attrKey = tag && tag.indexOf('-') > 0
+        ? key // preserve raw name on custom elements
+        : shared.propsToAttrMap[key] || key.toLowerCase();
+    if (shared.isBooleanAttr(attrKey)) {
+        return value === false ? `` : ` ${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 ``;
+    }
+}
+// Render a v-bind attr with static key. The key is pre-processed at compile
+// time and we only need to check and escape value.
+function ssrRenderAttr(key, value) {
+    if (!isRenderableValue(value)) {
+        return ``;
+    }
+    return ` ${key}="${shared.escapeHtml(value)}"`;
+}
+function isRenderableValue(value) {
+    if (value == null) {
+        return false;
+    }
+    const type = typeof value;
+    return type === 'string' || type === 'number' || type === 'boolean';
+}
+function ssrRenderClass(raw) {
+    return shared.escapeHtml(shared.normalizeClass(raw));
+}
+function ssrRenderStyle(raw) {
+    if (!raw) {
+        return '';
+    }
+    if (shared.isString(raw)) {
+        return shared.escapeHtml(raw);
+    }
+    const styles = shared.normalizeStyle(raw);
+    return shared.escapeHtml(shared.stringifyStyle(styles));
+}
+
+const compileCache = Object.create(null);
+function ssrCompile(template, instance) {
+    const cached = compileCache[template];
+    if (cached) {
+        return cached;
+    }
+    const { code } = compilerSsr.compile(template, {
+        isCustomElement: instance.appContext.config.isCustomElement || shared.NO,
+        isNativeTag: instance.appContext.config.isNativeTag || shared.NO,
+        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);
+            }
+        }
+    });
+    return (compileCache[template] = Function('require', code)(require));
+}
+
+function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+    parentPush('<!--teleport start-->');
+    let teleportContent;
+    if (disabled) {
+        contentRenderFn(parentPush);
+        teleportContent = `<!---->`;
+    }
+    else {
+        const { getBuffer, push } = createBuffer();
+        contentRenderFn(push);
+        push(`<!---->`); // teleport end anchor
+        teleportContent = getBuffer();
+    }
+    const context = parentComponent.appContext.provides[vue.ssrContextKey];
+    const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+    if (teleportBuffers[target]) {
+        teleportBuffers[target].push(teleportContent);
+    }
+    else {
+        teleportBuffers[target] = [teleportContent];
+    }
+    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 renderComponentVNode(vnode, parentComponent = null) {
+    const instance = createComponentInstance(vnode, parentComponent, null);
+    const res = setupComponent(instance, true /* isSSR */);
+    const hasAsyncSetup = shared.isPromise(res);
+    const prefetch = vnode.type.serverPrefetch;
+    if (hasAsyncSetup || prefetch) {
+        let p = hasAsyncSetup
+            ? res.catch(err => {
+                vue.warn(`[@vue/server-renderer]: Uncaught error in async setup:\n`, err);
+            })
+            : Promise.resolve();
+        if (prefetch) {
+            p = p.then(() => prefetch.call(instance.proxy)).catch(err => {
+                vue.warn(`[@vue/server-renderer]: Uncaught error in serverPrefetch:\n`, err);
+            });
+        }
+        return p.then(() => renderComponentSubTree(instance));
+    }
+    else {
+        return renderComponentSubTree(instance);
+    }
+}
+function renderComponentSubTree(instance) {
+    const comp = instance.type;
+    const { getBuffer, push } = createBuffer();
+    if (shared.isFunction(comp)) {
+        renderVNode(push, (instance.subTree = renderComponentRoot(instance)), instance);
+    }
+    else {
+        if (!instance.render && !comp.ssrRender && shared.isString(comp.template)) {
+            comp.ssrRender = ssrCompile(comp.template, instance);
+        }
+        if (comp.ssrRender) {
+            // optimized
+            // resolve fallthrough attrs
+            let attrs = instance.type.inheritAttrs !== false ? instance.attrs : undefined;
+            // inherited scopeId
+            const scopeId = instance.vnode.scopeId;
+            const treeOwnerId = instance.parent && instance.parent.type.__scopeId;
+            const slotScopeId = treeOwnerId && treeOwnerId !== scopeId ? treeOwnerId + '-s' : null;
+            if (scopeId || slotScopeId) {
+                attrs = { ...attrs };
+                if (scopeId)
+                    attrs[scopeId] = '';
+                if (slotScopeId)
+                    attrs[slotScopeId] = '';
+            }
+            // set current rendering instance for asset resolution
+            setCurrentRenderingInstance(instance);
+            comp.ssrRender(instance.proxy, push, instance, attrs, 
+            // compiler-optimized bindings
+            instance.props, instance.setupState, instance.data, instance.ctx);
+            setCurrentRenderingInstance(null);
+        }
+        else if (instance.render) {
+            renderVNode(push, (instance.subTree = renderComponentRoot(instance)), instance);
+        }
+        else {
+            vue.warn(`Component ${comp.name ? `${comp.name} ` : ``} is missing template or render function.`);
+            push(`<!---->`);
+        }
+    }
+    return getBuffer();
+}
+function renderVNode(push, vnode, parentComponent) {
+    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:
+            push(`<!--[-->`); // open
+            renderVNodeChildren(push, children, parentComponent);
+            push(`<!--]-->`); // close
+            break;
+        default:
+            if (shapeFlag & 1 /* ELEMENT */) {
+                renderElementVNode(push, vnode, parentComponent);
+            }
+            else if (shapeFlag & 6 /* COMPONENT */) {
+                push(renderComponentVNode(vnode, parentComponent));
+            }
+            else if (shapeFlag & 64 /* TELEPORT */) {
+                renderTeleportVNode(push, vnode, parentComponent);
+            }
+            else if (shapeFlag & 128 /* SUSPENSE */) {
+                renderVNode(push, vnode.ssContent, parentComponent);
+            }
+            else {
+                vue.warn('[@vue/server-renderer] Invalid VNode type:', type, `(${typeof type})`);
+            }
+    }
+}
+function renderVNodeChildren(push, children, parentComponent) {
+    for (let i = 0; i < children.length; i++) {
+        renderVNode(push, normalizeVNode(children[i]), parentComponent);
+    }
+}
+function renderElementVNode(push, vnode, parentComponent) {
+    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);
+    }
+    openTag += resolveScopeId(scopeId, vnode, parentComponent);
+    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 /* TEXT_CHILDREN */) {
+                push(shared.escapeHtml(children));
+            }
+            else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
+                renderVNodeChildren(push, children, parentComponent);
+            }
+        }
+        push(`</${tag}>`);
+    }
+}
+function resolveScopeId(scopeId, vnode, parentComponent) {
+    let res = ``;
+    if (scopeId) {
+        res = ` ${scopeId}`;
+    }
+    if (parentComponent) {
+        const treeOwnerId = parentComponent.type.__scopeId;
+        // vnode's own scopeId and the current rendering component's scopeId is
+        // different - this is a slot content node.
+        if (treeOwnerId && treeOwnerId !== scopeId) {
+            res += ` ${treeOwnerId}-s`;
+        }
+        if (vnode === parentComponent.subTree) {
+            res += resolveScopeId(parentComponent.vnode.scopeId, parentComponent.vnode, parentComponent.parent);
+        }
+    }
+    return res;
+}
+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) {
+    const target = vnode.props && vnode.props.to;
+    const disabled = vnode.props && vnode.props.disabled;
+    if (!target) {
+        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, push => {
+        renderVNodeChildren(push, vnode.children, parentComponent);
+    }, 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;
+            }
+            if (shared.isString(item)) {
+                ret += item;
+            }
+            else {
+                ret += await unrollBuffer(item);
+            }
+        }
+        return ret;
+    }
+    else {
+        // sync buffer can be more efficiently unrolled without unnecessary await
+        // ticks
+        return unrollBufferSync(buffer);
+    }
+}
+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);
+        }
+    }
+    return ret;
+}
+async function renderToString(input, context = {}) {
+    if (isVNode(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);
+    await resolveTeleports(context);
+    return unrollBuffer(buffer);
+}
+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])));
+        }
+    }
+}
+
+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);
+            }
+            else {
+                await unrollBuffer$1(item, stream);
+            }
+        }
+    }
+    else {
+        // sync buffer can be more efficiently unrolled without unnecessary await
+        // ticks
+        unrollBufferSync$1(buffer, stream);
+    }
+}
+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 renderToStream(input, context = {}) {
+    if (isVNode$1(input)) {
+        // raw vnode, wrap with app (for context)
+        return renderToStream(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 stream$1 = new stream.Readable();
+    Promise.resolve(renderComponentVNode(vnode))
+        .then(buffer => unrollBuffer$1(buffer, stream$1))
+        .then(() => {
+        stream$1.push(null);
+    })
+        .catch(error => {
+        stream$1.destroy(error);
+    });
+    return stream$1;
+}
+
+function ssrRenderComponent(comp, props = null, children = null, parentComponent = null) {
+    return renderComponentVNode(vue.createVNode(comp, props, children), parentComponent);
+}
+
+function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent) {
+    // template-compiled slots are always rendered as fragments
+    push(`<!--[-->`);
+    const slotFn = slots[slotName];
+    if (slotFn) {
+        const scopeId = parentComponent && parentComponent.type.__scopeId;
+        const ret = slotFn(slotProps, push, parentComponent, scopeId ? ` ${scopeId}-s` : ``);
+        if (Array.isArray(ret)) {
+            // normal slot
+            renderVNodeChildren(push, ret, parentComponent);
+        }
+    }
+    else if (fallbackRenderFn) {
+        fallbackRenderFn();
+    }
+    push(`<!--]-->`);
+}
+
+function ssrInterpolate(value) {
+    return shared.escapeHtml(shared.toDisplayString(value));
+}
+
+function toRaw(observed) {
+    return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed);
+}
+
+function isRef(r) {
+    return Boolean(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 /* 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 {
+            normalizedStack.push({
+                vnode: currentVNode,
+                recurseCount: 0
+            });
+        }
+        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];
+}
+/* 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;
+}
+/* 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}`];
+    }
+    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 = {
+    ["bc" /* BEFORE_CREATE */]: 'beforeCreate hook',
+    ["c" /* CREATED */]: 'created hook',
+    ["bm" /* BEFORE_MOUNT */]: 'beforeMount hook',
+    ["m" /* MOUNTED */]: 'mounted hook',
+    ["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook',
+    ["u" /* UPDATED */]: 'updated',
+    ["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',
+    ["um" /* UNMOUNTED */]: 'unmounted hook',
+    ["a" /* ACTIVATED */]: 'activated hook',
+    ["da" /* DEACTIVATED */]: 'deactivated hook',
+    ["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook',
+    ["rtc" /* RENDER_TRACKED */]: 'renderTracked hook',
+    ["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook',
+    [0 /* SETUP_FUNCTION */]: 'setup function',
+    [1 /* RENDER_FUNCTION */]: 'render function',
+    [2 /* WATCH_GETTER */]: 'watcher getter',
+    [3 /* WATCH_CALLBACK */]: 'watcher callback',
+    [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',
+    [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',
+    [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',
+    [7 /* VNODE_HOOK */]: 'vnode hook',
+    [8 /* DIRECTIVE_HOOK */]: 'directive hook',
+    [9 /* TRANSITION_HOOK */]: 'transition hook',
+    [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',
+    [11 /* APP_WARN_HANDLER */]: 'app warnHandler',
+    [12 /* FUNCTION_REF */]: 'ref function',
+    [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',
+    [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +
+        'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'
+};
+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;
+        }
+        // app-level handling
+        const appErrorHandler = instance.appContext.config.errorHandler;
+        if (appErrorHandler) {
+            callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [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(`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);
+        }
+    }
+}
+
+const classifyRE = /(?:^|[-_])(\w)/g;
+const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');
+/* istanbul ignore next */
+function formatComponentName(instance, Component, isRoot = false) {
+    let name = shared.isFunction(Component)
+        ? Component.displayName || Component.name
+        : Component.name;
+    if (!name && Component.__file) {
+        const match = Component.__file.match(/([^/\\]+)\.vue$/);
+        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;
+                }
+            }
+        };
+        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 {
+            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 ssrResolveCssVars(source, scopeId) {
+    const style = {};
+    const prefix = scopeId ? `${scopeId.replace(/^data-v-/, '')}-` : ``;
+    for (const key in source) {
+        style[`--${prefix}${key}`] = source[key];
+    }
+    return { style };
+}
+
+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 (Array.isArray(model)
+                ? ssrLooseContain(model, value)
+                : model)
+                ? ' checked'
+                : '';
+        default:
+            // text types
+            return ssrRenderAttr('value', model);
+    }
+}
+// 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 (Array.isArray(model)
+                ? ssrLooseContain(model, value)
+                : model)
+                ? { checked: true }
+                : null;
+        default:
+            // text types
+            return { value: model };
+    }
+}
+
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+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.ssrRenderStyle = ssrRenderStyle;
+exports.ssrRenderSuspense = ssrRenderSuspense;
+exports.ssrRenderTeleport = ssrRenderTeleport;
+exports.ssrRenderVNode = renderVNode;
+exports.ssrResolveCssVars = ssrResolveCssVars;

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

@@ -0,0 +1,592 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var shared = require('@vue/shared');
+var compilerSsr = require('@vue/compiler-ssr');
+var stream = require('stream');
+
+// leading comma for empty string ""
+const shouldIgnoreProp = shared.makeMap(`,key,ref,innerHTML,textContent`);
+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;
+}
+// render an attr with dynamic (unknown) key.
+function ssrRenderDynamicAttr(key, value, tag) {
+    if (!isRenderableValue(value)) {
+        return ``;
+    }
+    const attrKey = tag && tag.indexOf('-') > 0
+        ? key // preserve raw name on custom elements
+        : shared.propsToAttrMap[key] || key.toLowerCase();
+    if (shared.isBooleanAttr(attrKey)) {
+        return value === false ? `` : ` ${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 ``;
+    }
+}
+// Render a v-bind attr with static key. The key is pre-processed at compile
+// time and we only need to check and escape value.
+function ssrRenderAttr(key, value) {
+    if (!isRenderableValue(value)) {
+        return ``;
+    }
+    return ` ${key}="${shared.escapeHtml(value)}"`;
+}
+function isRenderableValue(value) {
+    if (value == null) {
+        return false;
+    }
+    const type = typeof value;
+    return type === 'string' || type === 'number' || type === 'boolean';
+}
+function ssrRenderClass(raw) {
+    return shared.escapeHtml(shared.normalizeClass(raw));
+}
+function ssrRenderStyle(raw) {
+    if (!raw) {
+        return '';
+    }
+    if (shared.isString(raw)) {
+        return shared.escapeHtml(raw);
+    }
+    const styles = shared.normalizeStyle(raw);
+    return shared.escapeHtml(shared.stringifyStyle(styles));
+}
+
+const compileCache = Object.create(null);
+function ssrCompile(template, instance) {
+    const cached = compileCache[template];
+    if (cached) {
+        return cached;
+    }
+    const { code } = compilerSsr.compile(template, {
+        isCustomElement: instance.appContext.config.isCustomElement || shared.NO,
+        isNativeTag: instance.appContext.config.isNativeTag || shared.NO,
+        onError(err) {
+            {
+                throw err;
+            }
+        }
+    });
+    return (compileCache[template] = Function('require', code)(require));
+}
+
+function ssrRenderTeleport(parentPush, contentRenderFn, target, disabled, parentComponent) {
+    parentPush('<!--teleport start-->');
+    let teleportContent;
+    if (disabled) {
+        contentRenderFn(parentPush);
+        teleportContent = `<!---->`;
+    }
+    else {
+        const { getBuffer, push } = createBuffer();
+        contentRenderFn(push);
+        push(`<!---->`); // teleport end anchor
+        teleportContent = getBuffer();
+    }
+    const context = parentComponent.appContext.provides[vue.ssrContextKey];
+    const teleportBuffers = context.__teleportBuffers || (context.__teleportBuffers = {});
+    if (teleportBuffers[target]) {
+        teleportBuffers[target].push(teleportContent);
+    }
+    else {
+        teleportBuffers[target] = [teleportContent];
+    }
+    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 renderComponentVNode(vnode, parentComponent = null) {
+    const instance = createComponentInstance(vnode, parentComponent, null);
+    const res = setupComponent(instance, true /* isSSR */);
+    const hasAsyncSetup = shared.isPromise(res);
+    const prefetch = vnode.type.serverPrefetch;
+    if (hasAsyncSetup || prefetch) {
+        let p = hasAsyncSetup
+            ? res.catch(err => {
+                vue.warn(`[@vue/server-renderer]: Uncaught error in async setup:\n`, err);
+            })
+            : Promise.resolve();
+        if (prefetch) {
+            p = p.then(() => prefetch.call(instance.proxy)).catch(err => {
+                vue.warn(`[@vue/server-renderer]: Uncaught error in serverPrefetch:\n`, err);
+            });
+        }
+        return p.then(() => renderComponentSubTree(instance));
+    }
+    else {
+        return renderComponentSubTree(instance);
+    }
+}
+function renderComponentSubTree(instance) {
+    const comp = instance.type;
+    const { getBuffer, push } = createBuffer();
+    if (shared.isFunction(comp)) {
+        renderVNode(push, (instance.subTree = renderComponentRoot(instance)), instance);
+    }
+    else {
+        if (!instance.render && !comp.ssrRender && shared.isString(comp.template)) {
+            comp.ssrRender = ssrCompile(comp.template, instance);
+        }
+        if (comp.ssrRender) {
+            // optimized
+            // resolve fallthrough attrs
+            let attrs = instance.type.inheritAttrs !== false ? instance.attrs : undefined;
+            // inherited scopeId
+            const scopeId = instance.vnode.scopeId;
+            const treeOwnerId = instance.parent && instance.parent.type.__scopeId;
+            const slotScopeId = treeOwnerId && treeOwnerId !== scopeId ? treeOwnerId + '-s' : null;
+            if (scopeId || slotScopeId) {
+                attrs = { ...attrs };
+                if (scopeId)
+                    attrs[scopeId] = '';
+                if (slotScopeId)
+                    attrs[slotScopeId] = '';
+            }
+            // set current rendering instance for asset resolution
+            setCurrentRenderingInstance(instance);
+            comp.ssrRender(instance.proxy, push, instance, attrs, 
+            // compiler-optimized bindings
+            instance.props, instance.setupState, instance.data, instance.ctx);
+            setCurrentRenderingInstance(null);
+        }
+        else if (instance.render) {
+            renderVNode(push, (instance.subTree = renderComponentRoot(instance)), instance);
+        }
+        else {
+            vue.warn(`Component ${comp.name ? `${comp.name} ` : ``} is missing template or render function.`);
+            push(`<!---->`);
+        }
+    }
+    return getBuffer();
+}
+function renderVNode(push, vnode, parentComponent) {
+    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:
+            push(`<!--[-->`); // open
+            renderVNodeChildren(push, children, parentComponent);
+            push(`<!--]-->`); // close
+            break;
+        default:
+            if (shapeFlag & 1 /* ELEMENT */) {
+                renderElementVNode(push, vnode, parentComponent);
+            }
+            else if (shapeFlag & 6 /* COMPONENT */) {
+                push(renderComponentVNode(vnode, parentComponent));
+            }
+            else if (shapeFlag & 64 /* TELEPORT */) {
+                renderTeleportVNode(push, vnode, parentComponent);
+            }
+            else if (shapeFlag & 128 /* SUSPENSE */) {
+                renderVNode(push, vnode.ssContent, parentComponent);
+            }
+            else {
+                vue.warn('[@vue/server-renderer] Invalid VNode type:', type, `(${typeof type})`);
+            }
+    }
+}
+function renderVNodeChildren(push, children, parentComponent) {
+    for (let i = 0; i < children.length; i++) {
+        renderVNode(push, normalizeVNode(children[i]), parentComponent);
+    }
+}
+function renderElementVNode(push, vnode, parentComponent) {
+    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);
+    }
+    openTag += resolveScopeId(scopeId, vnode, parentComponent);
+    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 /* TEXT_CHILDREN */) {
+                push(shared.escapeHtml(children));
+            }
+            else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
+                renderVNodeChildren(push, children, parentComponent);
+            }
+        }
+        push(`</${tag}>`);
+    }
+}
+function resolveScopeId(scopeId, vnode, parentComponent) {
+    let res = ``;
+    if (scopeId) {
+        res = ` ${scopeId}`;
+    }
+    if (parentComponent) {
+        const treeOwnerId = parentComponent.type.__scopeId;
+        // vnode's own scopeId and the current rendering component's scopeId is
+        // different - this is a slot content node.
+        if (treeOwnerId && treeOwnerId !== scopeId) {
+            res += ` ${treeOwnerId}-s`;
+        }
+        if (vnode === parentComponent.subTree) {
+            res += resolveScopeId(parentComponent.vnode.scopeId, parentComponent.vnode, parentComponent.parent);
+        }
+    }
+    return res;
+}
+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) {
+    const target = vnode.props && vnode.props.to;
+    const disabled = vnode.props && vnode.props.disabled;
+    if (!target) {
+        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, push => {
+        renderVNodeChildren(push, vnode.children, parentComponent);
+    }, 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;
+            }
+            if (shared.isString(item)) {
+                ret += item;
+            }
+            else {
+                ret += await unrollBuffer(item);
+            }
+        }
+        return ret;
+    }
+    else {
+        // sync buffer can be more efficiently unrolled without unnecessary await
+        // ticks
+        return unrollBufferSync(buffer);
+    }
+}
+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);
+        }
+    }
+    return ret;
+}
+async function renderToString(input, context = {}) {
+    if (isVNode(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);
+    await resolveTeleports(context);
+    return unrollBuffer(buffer);
+}
+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])));
+        }
+    }
+}
+
+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);
+            }
+            else {
+                await unrollBuffer$1(item, stream);
+            }
+        }
+    }
+    else {
+        // sync buffer can be more efficiently unrolled without unnecessary await
+        // ticks
+        unrollBufferSync$1(buffer, stream);
+    }
+}
+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 renderToStream(input, context = {}) {
+    if (isVNode$1(input)) {
+        // raw vnode, wrap with app (for context)
+        return renderToStream(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 stream$1 = new stream.Readable();
+    Promise.resolve(renderComponentVNode(vnode))
+        .then(buffer => unrollBuffer$1(buffer, stream$1))
+        .then(() => {
+        stream$1.push(null);
+    })
+        .catch(error => {
+        stream$1.destroy(error);
+    });
+    return stream$1;
+}
+
+function ssrRenderComponent(comp, props = null, children = null, parentComponent = null) {
+    return renderComponentVNode(vue.createVNode(comp, props, children), parentComponent);
+}
+
+function ssrRenderSlot(slots, slotName, slotProps, fallbackRenderFn, push, parentComponent) {
+    // template-compiled slots are always rendered as fragments
+    push(`<!--[-->`);
+    const slotFn = slots[slotName];
+    if (slotFn) {
+        const scopeId = parentComponent && parentComponent.type.__scopeId;
+        const ret = slotFn(slotProps, push, parentComponent, scopeId ? ` ${scopeId}-s` : ``);
+        if (Array.isArray(ret)) {
+            // normal slot
+            renderVNodeChildren(push, ret, parentComponent);
+        }
+    }
+    else if (fallbackRenderFn) {
+        fallbackRenderFn();
+    }
+    push(`<!--]-->`);
+}
+
+function ssrInterpolate(value) {
+    return shared.escapeHtml(shared.toDisplayString(value));
+}
+
+function ssrRenderList(source, renderItem) {
+    if (shared.isArray(source) || shared.isString(source)) {
+        for (let i = 0, l = source.length; i < l; i++) {
+            renderItem(source[i], i);
+        }
+    }
+    else if (typeof source === 'number') {
+        for (let i = 0; i < source; i++) {
+            renderItem(i + 1, i);
+        }
+    }
+    else if (shared.isObject(source)) {
+        if (source[Symbol.iterator]) {
+            const arr = Array.from(source);
+            for (let i = 0, l = arr.length; i < l; i++) {
+                renderItem(arr[i], i);
+            }
+        }
+        else {
+            const keys = Object.keys(source);
+            for (let i = 0, l = keys.length; i < l; i++) {
+                const key = keys[i];
+                renderItem(source[key], key, i);
+            }
+        }
+    }
+}
+
+async function ssrRenderSuspense(push, { default: renderContent }) {
+    if (renderContent) {
+        renderContent();
+    }
+    else {
+        push(`<!---->`);
+    }
+}
+
+function ssrResolveCssVars(source, scopeId) {
+    const style = {};
+    const prefix = scopeId ? `${scopeId.replace(/^data-v-/, '')}-` : ``;
+    for (const key in source) {
+        style[`--${prefix}${key}`] = source[key];
+    }
+    return { style };
+}
+
+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 (Array.isArray(model)
+                ? ssrLooseContain(model, value)
+                : model)
+                ? ' checked'
+                : '';
+        default:
+            // text types
+            return ssrRenderAttr('value', model);
+    }
+}
+// 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 (Array.isArray(model)
+                ? ssrLooseContain(model, value)
+                : model)
+                ? { checked: true }
+                : null;
+        default:
+            // text types
+            return { value: model };
+    }
+}
+
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+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.ssrRenderStyle = ssrRenderStyle;
+exports.ssrRenderSuspense = ssrRenderSuspense;
+exports.ssrRenderTeleport = ssrRenderTeleport;
+exports.ssrRenderVNode = renderVNode;
+exports.ssrResolveCssVars = ssrResolveCssVars;

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

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { App } from 'vue';
+import { Component } from 'vue';
+import { ComponentInternalInstance } from 'vue';
+import { Readable } from 'stream';
+import { Slots } from 'vue';
+import { VNode } from 'vue';
+
+declare type Props = Record<string, unknown>;
+
+declare type PushFn = (item: SSRBufferItem) => void;
+
+export declare function renderToStream(input: App | VNode, context?: SSRContext): Readable;
+
+export declare function renderToString(input: App | VNode, context?: SSRContext): Promise<string>;
+
+declare type SSRBuffer = SSRBufferItem[] & {
+    hasAsync?: boolean;
+};
+
+declare type SSRBufferItem = string | SSRBuffer | Promise<SSRBuffer>;
+
+export declare type SSRContext = {
+    [key: string]: any;
+    teleports?: Record<string, string>;
+    __teleportBuffers?: Record<string, SSRBuffer>;
+};
+
+export declare function ssrGetDynamicModelProps(existingProps: any, model: unknown): {
+    checked: boolean;
+    value?: undefined;
+} | {
+    value: unknown;
+    checked?: undefined;
+} | null;
+
+export declare function ssrInterpolate(value: unknown): string;
+
+export declare function ssrLooseContain(arr: unknown[], value: unknown): boolean;
+
+export declare const ssrLooseEqual: (a: unknown, b: unknown) => boolean;
+
+export declare function ssrRenderAttr(key: string, value: unknown): string;
+
+export declare function ssrRenderAttrs(props: Record<string, unknown>, tag?: string): string;
+
+export declare function ssrRenderClass(raw: unknown): string;
+
+export declare function ssrRenderComponent(comp: Component, props?: Props | null, children?: Slots | SSRSlots | null, parentComponent?: ComponentInternalInstance | null): SSRBuffer | Promise<SSRBuffer>;
+
+export declare function ssrRenderDynamicAttr(key: string, value: unknown, tag?: string): string;
+
+export declare function ssrRenderDynamicModel(type: unknown, model: unknown, value: unknown): string;
+
+export declare function ssrRenderList(source: unknown, renderItem: (value: unknown, key: string | number, index?: number) => void): void;
+
+export declare function ssrRenderSlot(slots: Slots | SSRSlots, slotName: string, slotProps: Props, fallbackRenderFn: (() => void) | null, push: PushFn, parentComponent: ComponentInternalInstance): void;
+
+export declare function ssrRenderStyle(raw: unknown): string;
+
+export declare function ssrRenderSuspense(push: PushFn, { default: renderContent }: Record<string, (() => void) | undefined>): Promise<void>;
+
+export declare function ssrRenderTeleport(parentPush: PushFn, contentRenderFn: (push: PushFn) => void, target: string, disabled: boolean, parentComponent: ComponentInternalInstance): void;
+
+export declare function ssrRenderVNode(push: PushFn, vnode: VNode, parentComponent: ComponentInternalInstance): void;
+
+export declare function ssrResolveCssVars(source: Record<string, string>, scopeId?: string): {
+    style: Record<string, string>;
+};
+
+declare type SSRSlot = (props: Props, push: PushFn, parentComponent: ComponentInternalInstance | null, scopeId: string | null) => void;
+
+declare type SSRSlots = Record<string, SSRSlot>;
+
+export { }

node_modules/@vue/server-renderer/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./dist/server-renderer.cjs.prod.js')
+} else {
+  module.exports = require('./dist/server-renderer.cjs.js')
+}

node_modules/@vue/server-renderer/package.json

@@ -0,0 +1,69 @@
+{
+  "_args": [
+    [
+      "@vue/server-renderer@3.0.2",
+      "J:\\Github\\CURD-TS"
+    ]
+  ],
+  "_development": true,
+  "_from": "@vue/server-renderer@3.0.2",
+  "_id": "@vue/server-renderer@3.0.2",
+  "_inBundle": false,
+  "_integrity": "sha1-jeRNMW459OIWa1dOelNSSdwLxUY=",
+  "_location": "/@vue/server-renderer",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "@vue/server-renderer@3.0.2",
+    "name": "@vue/server-renderer",
+    "escapedName": "@vue%2fserver-renderer",
+    "scope": "@vue",
+    "rawSpec": "3.0.2",
+    "saveSpec": null,
+    "fetchSpec": "3.0.2"
+  },
+  "_requiredBy": [
+    "/vitepress"
+  ],
+  "_resolved": "http://192.168.250.101:4873/@vue%2fserver-renderer/-/server-renderer-3.0.2.tgz",
+  "_spec": "3.0.2",
+  "_where": "J:\\Github\\CURD-TS",
+  "author": {
+    "name": "Evan You"
+  },
+  "bugs": {
+    "url": "https://github.com/vuejs/vue-next/issues"
+  },
+  "buildOptions": {
+    "formats": [
+      "cjs"
+    ]
+  },
+  "dependencies": {
+    "@vue/compiler-ssr": "3.0.2",
+    "@vue/shared": "3.0.2"
+  },
+  "description": "@vue/server-renderer",
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "homepage": "https://github.com/vuejs/vue-next/tree/master/packages/server-renderer#readme",
+  "keywords": [
+    "vue"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "@vue/server-renderer",
+  "peerDependencies": {
+    "vue": "3.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/vue-next.git",
+    "directory": "packages/server-renderer"
+  },
+  "types": "dist/server-renderer.d.ts",
+  "version": "3.0.2"
+}