@vue/compiler-ssr 3.2.37 → 3.2.38

package/dist/compiler-ssr.cjs.js

@@ -79,9 +79,9 @@ function ssrProcessIf(node, context, disableNestedFragments = false) {
 function processIfBranch(branch, context, disableNestedFragments = false) {
     const { children } = branch;
     const needFragmentWrapper = !disableNestedFragments &&
-        (children.length !== 1 || children[0].type !== 1 /* ELEMENT */) &&
+        (children.length !== 1 || children[0].type !== 1 /* NodeTypes.ELEMENT */) &&
         // optimize away nested fragments when the only child is a ForNode
-        !(children.length === 1 && children[0].type === 11 /* FOR */);
+        !(children.length === 1 && children[0].type === 11 /* NodeTypes.FOR */);
     return processChildrenAsStatement(branch, context, needFragmentWrapper);
 }
 
@@ -91,7 +91,7 @@ const ssrTransformFor = compilerDom.createStructuralDirectiveTransform('for', co
 // codegen nodes.
 function ssrProcessFor(node, context, disableNestedFragments = false) {
     const needFragmentWrapper = !disableNestedFragments &&
-        (node.children.length !== 1 || node.children[0].type !== 1 /* ELEMENT */);
+        (node.children.length !== 1 || node.children[0].type !== 1 /* NodeTypes.ELEMENT */);
     const renderLoop = compilerDom.createFunctionExpression(compilerDom.createForLoopParams(node.parseResult));
     renderLoop.body = processChildrenAsStatement(node, context, needFragmentWrapper);
     // v-for always renders a fragment unless explicitly disabled
@@ -130,10 +130,10 @@ const ssrTransformSlotOutlet = (node, context) => {
         // we need to avoid rendering the slot as a fragment.
         const parent = context.parent;
         if (parent &&
-            parent.type === 1 /* ELEMENT */ &&
-            parent.tagType === 1 /* COMPONENT */ &&
+            parent.type === 1 /* NodeTypes.ELEMENT */ &&
+            parent.tagType === 1 /* ElementTypes.COMPONENT */ &&
             compilerDom.resolveComponentType(parent, context, true) === compilerDom.TRANSITION &&
-            parent.children.filter(c => c.type === 1 /* ELEMENT */).length === 1) {
+            parent.children.filter(c => c.type === 1 /* NodeTypes.ELEMENT */).length === 1) {
             method = SSR_RENDER_SLOT_INNER;
             if (!(context.scopeId && context.slotted !== false)) {
                 args.push('null');
@@ -166,20 +166,20 @@ function createSSRCompilerError(code, loc) {
     return compilerDom.createCompilerError(code, loc, SSRErrorMessages);
 }
 const SSRErrorMessages = {
-    [61 /* X_SSR_UNSAFE_ATTR_NAME */]: `Unsafe attribute name for SSR.`,
-    [62 /* X_SSR_NO_TELEPORT_TARGET */]: `Missing the 'to' prop on teleport element.`,
-    [63 /* X_SSR_INVALID_AST_NODE */]: `Invalid AST node during SSR transform.`
+    [61 /* SSRErrorCodes.X_SSR_UNSAFE_ATTR_NAME */]: `Unsafe attribute name for SSR.`,
+    [62 /* SSRErrorCodes.X_SSR_NO_TELEPORT_TARGET */]: `Missing the 'to' prop on teleport element.`,
+    [63 /* SSRErrorCodes.X_SSR_INVALID_AST_NODE */]: `Invalid AST node during SSR transform.`
 };
 
 // Note: this is a 2nd-pass codegen transform.
 function ssrProcessTeleport(node, context) {
     const targetProp = compilerDom.findProp(node, 'to');
     if (!targetProp) {
-        context.onError(createSSRCompilerError(62 /* X_SSR_NO_TELEPORT_TARGET */, node.loc));
+        context.onError(createSSRCompilerError(62 /* SSRErrorCodes.X_SSR_NO_TELEPORT_TARGET */, node.loc));
         return;
     }
     let target;
-    if (targetProp.type === 6 /* ATTRIBUTE */) {
+    if (targetProp.type === 6 /* NodeTypes.ATTRIBUTE */) {
         target =
             targetProp.value && compilerDom.createSimpleExpression(targetProp.value.content, true);
     }
@@ -187,12 +187,12 @@ function ssrProcessTeleport(node, context) {
         target = targetProp.exp;
     }
     if (!target) {
-        context.onError(createSSRCompilerError(62 /* X_SSR_NO_TELEPORT_TARGET */, targetProp.loc));
+        context.onError(createSSRCompilerError(62 /* SSRErrorCodes.X_SSR_NO_TELEPORT_TARGET */, targetProp.loc));
         return;
     }
     const disabledProp = compilerDom.findProp(node, 'disabled', false, true /* allow empty */);
     const disabled = disabledProp
-        ? disabledProp.type === 6 /* ATTRIBUTE */
+        ? disabledProp.type === 6 /* NodeTypes.ATTRIBUTE */
             ? `true`
             : disabledProp.exp || `false`
         : `false`;
@@ -257,8 +257,8 @@ function ssrProcessSuspense(node, context) {
 // store the raw children so that they can be added in the 2nd pass.
 const rawChildrenMap = new WeakMap();
 const ssrTransformElement = (node, context) => {
-    if (node.type !== 1 /* ELEMENT */ ||
-        node.tagType !== 0 /* ELEMENT */) {
+    if (node.type !== 1 /* NodeTypes.ELEMENT */ ||
+        node.tagType !== 0 /* ElementTypes.ELEMENT */) {
         return;
     }
     return function ssrPostTransformElement() {
@@ -271,7 +271,7 @@ const ssrTransformElement = (node, context) => {
         // overwrite other static attrs and can affect final rendering result,
         // so when they are present we need to bail out to full `renderAttrs`
         const hasDynamicVBind = compilerDom.hasDynamicKeyVBind(node);
-        const hasCustomDir = node.props.some(p => p.type === 7 /* DIRECTIVE */ && !shared.isBuiltInDirective(p.name));
+        const hasCustomDir = node.props.some(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && !shared.isBuiltInDirective(p.name));
         const needMergeProps = hasDynamicVBind || hasCustomDir;
         if (needMergeProps) {
             const { props, directives } = compilerDom.buildProps(node, context, node.props, false /* isComponent */, false /* isDynamicComponent */, true /* ssr */);
@@ -282,7 +282,7 @@ const ssrTransformElement = (node, context) => {
                     const existingText = node.children[0];
                     // If interpolation, this is dynamic <textarea> content, potentially
                     // injected by v-model and takes higher priority than v-bind value
-                    if (!existingText || existingText.type !== 5 /* INTERPOLATION */) {
+                    if (!existingText || existingText.type !== 5 /* NodeTypes.INTERPOLATION */) {
                         // <textarea> with dynamic v-bind. We don't know if the final props
                         // will contain .value, so we will have to do something special:
                         // assign the merged props to a temp variable, and check whether
@@ -338,7 +338,7 @@ const ssrTransformElement = (node, context) => {
                 continue;
             }
             // special cases with children override
-            if (prop.type === 7 /* DIRECTIVE */) {
+            if (prop.type === 7 /* NodeTypes.DIRECTIVE */) {
                 if (prop.name === 'html' && prop.exp) {
                     rawChildrenMap.set(node, prop.exp);
                 }
@@ -346,7 +346,7 @@ const ssrTransformElement = (node, context) => {
                     node.children = [compilerDom.createInterpolation(prop.exp, prop.loc)];
                 }
                 else if (prop.name === 'slot') {
-                    context.onError(compilerDom.createCompilerError(40 /* X_V_SLOT_MISPLACED */, prop.loc));
+                    context.onError(compilerDom.createCompilerError(40 /* ErrorCodes.X_V_SLOT_MISPLACED */, prop.loc));
                 }
                 else if (isTextareaWithValue(node, prop) && prop.exp) {
                     if (!needMergeProps) {
@@ -396,7 +396,7 @@ const ssrTransformElement = (node, context) => {
                                         ]));
                                     }
                                     else {
-                                        context.onError(createSSRCompilerError(61 /* X_SSR_UNSAFE_ATTR_NAME */, key.loc));
+                                        context.onError(createSSRCompilerError(61 /* SSRErrorCodes.X_SSR_UNSAFE_ATTR_NAME */, key.loc));
                                     }
                                 }
                             }
@@ -446,7 +446,7 @@ const ssrTransformElement = (node, context) => {
 function buildSSRProps(props, directives, context) {
     let mergePropsArgs = [];
     if (props) {
-        if (props.type === 14 /* JS_CALL_EXPRESSION */) {
+        if (props.type === 14 /* NodeTypes.JS_CALL_EXPRESSION */) {
             // already a mergeProps call
             mergePropsArgs = props.arguments;
         }
@@ -467,7 +467,7 @@ function buildSSRProps(props, directives, context) {
         : mergePropsArgs[0];
 }
 function isTrueFalseValue(prop) {
-    if (prop.type === 7 /* DIRECTIVE */) {
+    if (prop.type === 7 /* NodeTypes.DIRECTIVE */) {
         return (prop.name === 'bind' &&
             prop.arg &&
             compilerDom.isStaticExp(prop.arg) &&
@@ -484,7 +484,7 @@ function isTextareaWithValue(node, prop) {
 }
 function mergeCall(call, arg) {
     const existing = call.arguments[0];
-    if (existing.type === 17 /* JS_ARRAY_EXPRESSION */) {
+    if (existing.type === 17 /* NodeTypes.JS_ARRAY_EXPRESSION */) {
         existing.elements.push(arg);
     }
     else {
@@ -499,7 +499,7 @@ function removeStaticBinding(tag, binding) {
     }
 }
 function findVModel(node) {
-    return node.props.find(p => p.type === 7 /* DIRECTIVE */ && p.name === 'model' && p.exp);
+    return node.props.find(p => p.type === 7 /* NodeTypes.DIRECTIVE */ && p.name === 'model' && p.exp);
 }
 function ssrProcessElement(node, context) {
     const isVoidTag = context.options.isVoidTag || shared.NO;
@@ -552,7 +552,7 @@ function ssrProcessTransitionGroup(node, context) {
     const entry = wipMap$1.get(node);
     if (entry) {
         const { tag, propsExp } = entry;
-        if (tag.type === 7 /* DIRECTIVE */) {
+        if (tag.type === 7 /* NodeTypes.DIRECTIVE */) {
             // dynamic :tag
             context.pushStringPart(`<`);
             context.pushStringPart(tag.exp);
@@ -603,8 +603,8 @@ const componentTypeMap = new WeakMap();
 // In phase 2. we convert the WIP slots from phase 1 into ssr-specific codegen
 // nodes.
 const ssrTransformComponent = (node, context) => {
-    if (node.type !== 1 /* ELEMENT */ ||
-        node.tagType !== 1 /* COMPONENT */) {
+    if (node.type !== 1 /* NodeTypes.ELEMENT */ ||
+        node.tagType !== 1 /* ElementTypes.COMPONENT */) {
         return;
     }
     const component = compilerDom.resolveComponentType(node, context, true /* ssr */);
@@ -708,7 +708,7 @@ function ssrProcessComponent(node, context, parent) {
             }
             // #5351: filter out comment children inside transition
             if (component === compilerDom.TRANSITION) {
-                node.children = node.children.filter(c => c.type !== 3 /* COMMENT */);
+                node.children = node.children.filter(c => c.type !== 3 /* NodeTypes.COMMENT */);
             }
             processChildren(node, context);
         }
@@ -763,16 +763,16 @@ function createVNodeSlotBranch(props, children, parentContext) {
     };
     // wrap the children with a wrapper template for proper children treatment.
     const wrapperNode = {
-        type: 1 /* ELEMENT */,
-        ns: 0 /* HTML */,
+        type: 1 /* NodeTypes.ELEMENT */,
+        ns: 0 /* Namespaces.HTML */,
         tag: 'template',
-        tagType: 3 /* TEMPLATE */,
+        tagType: 3 /* ElementTypes.TEMPLATE */,
         isSelfClosing: false,
         // important: provide v-slot="props" on the wrapper for proper
         // scope analysis
         props: [
             {
-                type: 7 /* DIRECTIVE */,
+                type: 7 /* NodeTypes.DIRECTIVE */,
                 name: 'slot',
                 exp: props,
                 arg: undefined,
@@ -847,8 +847,10 @@ function ssrCodegenTransform(ast, options) {
     // we do this instead of inlining the expression to ensure the vars are
     // only resolved once per render
     if (options.ssrCssVars) {
-        const varsExp = compilerDom.processExpression(compilerDom.createSimpleExpression(options.ssrCssVars, false), compilerDom.createTransformContext(compilerDom.createRoot([]), options));
+        const cssContext = compilerDom.createTransformContext(compilerDom.createRoot([]), options);
+        const varsExp = compilerDom.processExpression(compilerDom.createSimpleExpression(options.ssrCssVars, false), cssContext);
         context.body.push(compilerDom.createCompoundExpression([`const _cssVars = { style: `, varsExp, `}`]));
+        Array.from(cssContext.helpers.keys()).forEach(helper => ast.helpers.push(helper));
     }
     const isFragment = ast.children.length > 1 && ast.children.some(c => !compilerDom.isText(c));
     processChildren(ast, context, isFragment);
@@ -910,54 +912,54 @@ function processChildren(parent, context, asFragment = false, disableNestedFragm
     for (let i = 0; i < children.length; i++) {
         const child = children[i];
         switch (child.type) {
-            case 1 /* ELEMENT */:
+            case 1 /* NodeTypes.ELEMENT */:
                 switch (child.tagType) {
-                    case 0 /* ELEMENT */:
+                    case 0 /* ElementTypes.ELEMENT */:
                         ssrProcessElement(child, context);
                         break;
-                    case 1 /* COMPONENT */:
+                    case 1 /* ElementTypes.COMPONENT */:
                         ssrProcessComponent(child, context, parent);
                         break;
-                    case 2 /* SLOT */:
+                    case 2 /* ElementTypes.SLOT */:
                         ssrProcessSlotOutlet(child, context);
                         break;
-                    case 3 /* TEMPLATE */:
+                    case 3 /* ElementTypes.TEMPLATE */:
                         // TODO
                         break;
                     default:
-                        context.onError(createSSRCompilerError(63 /* X_SSR_INVALID_AST_NODE */, child.loc));
+                        context.onError(createSSRCompilerError(63 /* SSRErrorCodes.X_SSR_INVALID_AST_NODE */, child.loc));
                         // make sure we exhaust all possible types
                         const exhaustiveCheck = child;
                         return exhaustiveCheck;
                 }
                 break;
-            case 2 /* TEXT */:
+            case 2 /* NodeTypes.TEXT */:
                 context.pushStringPart(shared.escapeHtml(child.content));
                 break;
-            case 3 /* COMMENT */:
+            case 3 /* NodeTypes.COMMENT */:
                 // no need to escape comment here because the AST can only
                 // contain valid comments.
                 context.pushStringPart(`<!--${child.content}-->`);
                 break;
-            case 5 /* INTERPOLATION */:
+            case 5 /* NodeTypes.INTERPOLATION */:
                 context.pushStringPart(compilerDom.createCallExpression(context.helper(SSR_INTERPOLATE), [child.content]));
                 break;
-            case 9 /* IF */:
+            case 9 /* NodeTypes.IF */:
                 ssrProcessIf(child, context, disableNestedFragments);
                 break;
-            case 11 /* FOR */:
+            case 11 /* NodeTypes.FOR */:
                 ssrProcessFor(child, context, disableNestedFragments);
                 break;
-            case 10 /* IF_BRANCH */:
+            case 10 /* NodeTypes.IF_BRANCH */:
                 // no-op - handled by ssrProcessIf
                 break;
-            case 12 /* TEXT_CALL */:
-            case 8 /* COMPOUND_EXPRESSION */:
+            case 12 /* NodeTypes.TEXT_CALL */:
+            case 8 /* NodeTypes.COMPOUND_EXPRESSION */:
                 // no-op - these two types can never appear as template child node since
                 // `transformText` is not used during SSR compile.
                 break;
             default:
-                context.onError(createSSRCompilerError(63 /* X_SSR_INVALID_AST_NODE */, child.loc));
+                context.onError(createSSRCompilerError(63 /* SSRErrorCodes.X_SSR_INVALID_AST_NODE */, child.loc));
                 // make sure we exhaust all possible types
                 const exhaustiveCheck = child;
                 return exhaustiveCheck;
@@ -978,10 +980,10 @@ const ssrTransformModel = (dir, node, context) => {
     function checkDuplicatedValue() {
         const value = compilerDom.findProp(node, 'value');
         if (value) {
-            context.onError(compilerDom.createDOMCompilerError(57 /* X_V_MODEL_UNNECESSARY_VALUE */, value.loc));
+            context.onError(compilerDom.createDOMCompilerError(57 /* DOMErrorCodes.X_V_MODEL_UNNECESSARY_VALUE */, value.loc));
         }
     }
-    if (node.tagType === 0 /* ELEMENT */) {
+    if (node.tagType === 0 /* ElementTypes.ELEMENT */) {
         const res = { props: [] };
         const defaultProps = [
             // default value binding for text type inputs
@@ -991,7 +993,7 @@ const ssrTransformModel = (dir, node, context) => {
             const type = compilerDom.findProp(node, 'type');
             if (type) {
                 const value = findValueBinding(node);
-                if (type.type === 7 /* DIRECTIVE */) {
+                if (type.type === 7 /* NodeTypes.DIRECTIVE */) {
                     // dynamic type
                     res.ssrTagParts = [
                         compilerDom.createCallExpression(context.helper(SSR_RENDER_DYNAMIC_MODEL), [
@@ -1015,7 +1017,7 @@ const ssrTransformModel = (dir, node, context) => {
                         case 'checkbox':
                             const trueValueBinding = compilerDom.findProp(node, 'true-value');
                             if (trueValueBinding) {
-                                const trueValue = trueValueBinding.type === 6 /* ATTRIBUTE */
+                                const trueValue = trueValueBinding.type === 6 /* NodeTypes.ATTRIBUTE */
                                     ? JSON.stringify(trueValueBinding.value.content)
                                     : trueValueBinding.exp;
                                 res.props = [
@@ -1035,7 +1037,7 @@ const ssrTransformModel = (dir, node, context) => {
                             }
                             break;
                         case 'file':
-                            context.onError(compilerDom.createDOMCompilerError(56 /* X_V_MODEL_ON_FILE_INPUT_ELEMENT */, dir.loc));
+                            context.onError(compilerDom.createDOMCompilerError(56 /* DOMErrorCodes.X_V_MODEL_ON_FILE_INPUT_ELEMENT */, dir.loc));
                             break;
                         default:
                             checkDuplicatedValue();
@@ -1057,7 +1059,7 @@ const ssrTransformModel = (dir, node, context) => {
         }
         else if (node.tag === 'select') ;
         else {
-            context.onError(compilerDom.createDOMCompilerError(54 /* X_V_MODEL_ON_INVALID_ELEMENT */, dir.loc));
+            context.onError(compilerDom.createDOMCompilerError(54 /* DOMErrorCodes.X_V_MODEL_ON_INVALID_ELEMENT */, dir.loc));
         }
         return res;
     }
@@ -1069,7 +1071,7 @@ const ssrTransformModel = (dir, node, context) => {
 function findValueBinding(node) {
     const valueBinding = compilerDom.findProp(node, 'value');
     return valueBinding
-        ? valueBinding.type === 7 /* DIRECTIVE */
+        ? valueBinding.type === 7 /* NodeTypes.DIRECTIVE */
             ? valueBinding.exp
             : compilerDom.createSimpleExpression(valueBinding.value.content, true)
         : compilerDom.createSimpleExpression(`null`, false);
@@ -1077,7 +1079,7 @@ function findValueBinding(node) {
 
 const ssrTransformShow = (dir, node, context) => {
     if (!dir.exp) {
-        context.onError(compilerDom.createDOMCompilerError(58 /* X_V_SHOW_NO_EXPRESSION */));
+        context.onError(compilerDom.createDOMCompilerError(58 /* DOMErrorCodes.X_V_SHOW_NO_EXPRESSION */));
     }
     return {
         props: [
@@ -1088,17 +1090,17 @@ const ssrTransformShow = (dir, node, context) => {
     };
 };
 
-const filterChild = (node) => node.children.filter(n => n.type !== 3 /* COMMENT */);
+const filterChild = (node) => node.children.filter(n => n.type !== 3 /* NodeTypes.COMMENT */);
 const hasSingleChild = (node) => filterChild(node).length === 1;
 const ssrInjectFallthroughAttrs = (node, context) => {
     // _attrs is provided as a function argument.
     // mark it as a known identifier so that it doesn't get prefixed by
     // transformExpression.
-    if (node.type === 0 /* ROOT */) {
+    if (node.type === 0 /* NodeTypes.ROOT */) {
         context.identifiers._attrs = 1;
     }
-    if (node.type === 1 /* ELEMENT */ &&
-        node.tagType === 1 /* COMPONENT */ &&
+    if (node.type === 1 /* NodeTypes.ELEMENT */ &&
+        node.tagType === 1 /* ElementTypes.COMPONENT */ &&
         (compilerDom.isBuiltInType(node.tag, 'Transition') ||
             compilerDom.isBuiltInType(node.tag, 'KeepAlive'))) {
         const rootChildren = filterChild(context.root);
@@ -1110,15 +1112,15 @@ const ssrInjectFallthroughAttrs = (node, context) => {
         }
     }
     const parent = context.parent;
-    if (!parent || parent.type !== 0 /* ROOT */) {
+    if (!parent || parent.type !== 0 /* NodeTypes.ROOT */) {
         return;
     }
-    if (node.type === 10 /* IF_BRANCH */ && hasSingleChild(node)) {
+    if (node.type === 10 /* NodeTypes.IF_BRANCH */ && hasSingleChild(node)) {
         // detect cases where the parent v-if is not the only root level node
         let hasEncounteredIf = false;
         for (const c of filterChild(parent)) {
-            if (c.type === 9 /* IF */ ||
-                (c.type === 1 /* ELEMENT */ && compilerDom.findDir(c, 'if'))) {
+            if (c.type === 9 /* NodeTypes.IF */ ||
+                (c.type === 1 /* NodeTypes.ELEMENT */ && compilerDom.findDir(c, 'if'))) {
                 // multiple root v-if
                 if (hasEncounteredIf)
                     return;
@@ -1128,7 +1130,7 @@ const ssrInjectFallthroughAttrs = (node, context) => {
             // node before v-if
             !hasEncounteredIf ||
                 // non else nodes
-                !(c.type === 1 /* ELEMENT */ && compilerDom.findDir(c, /else/, true))) {
+                !(c.type === 1 /* NodeTypes.ELEMENT */ && compilerDom.findDir(c, /else/, true))) {
                 return;
             }
         }
@@ -1139,12 +1141,12 @@ const ssrInjectFallthroughAttrs = (node, context) => {
     }
 };
 function injectFallthroughAttrs(node) {
-    if (node.type === 1 /* ELEMENT */ &&
-        (node.tagType === 0 /* ELEMENT */ ||
-            node.tagType === 1 /* COMPONENT */) &&
+    if (node.type === 1 /* NodeTypes.ELEMENT */ &&
+        (node.tagType === 0 /* ElementTypes.ELEMENT */ ||
+            node.tagType === 1 /* ElementTypes.COMPONENT */) &&
         !compilerDom.findDir(node, 'for')) {
         node.props.push({
-            type: 7 /* DIRECTIVE */,
+            type: 7 /* NodeTypes.DIRECTIVE */,
             name: 'bind',
             arg: undefined,
             exp: compilerDom.createSimpleExpression(`_attrs`, false),
@@ -1161,14 +1163,14 @@ const ssrInjectCssVars = (node, context) => {
     // _cssVars is initialized once per render function
     // the code is injected in ssrCodegenTransform when creating the
     // ssr transform context
-    if (node.type === 0 /* ROOT */) {
+    if (node.type === 0 /* NodeTypes.ROOT */) {
         context.identifiers._cssVars = 1;
     }
     const parent = context.parent;
-    if (!parent || parent.type !== 0 /* ROOT */) {
+    if (!parent || parent.type !== 0 /* NodeTypes.ROOT */) {
         return;
     }
-    if (node.type === 10 /* IF_BRANCH */) {
+    if (node.type === 10 /* NodeTypes.IF_BRANCH */) {
         for (const child of node.children) {
             injectCssVars(child);
         }
@@ -1178,14 +1180,14 @@ const ssrInjectCssVars = (node, context) => {
     }
 };
 function injectCssVars(node) {
-    if (node.type === 1 /* ELEMENT */ &&
-        (node.tagType === 0 /* ELEMENT */ ||
-            node.tagType === 1 /* COMPONENT */) &&
+    if (node.type === 1 /* NodeTypes.ELEMENT */ &&
+        (node.tagType === 0 /* ElementTypes.ELEMENT */ ||
+            node.tagType === 1 /* ElementTypes.COMPONENT */) &&
         !compilerDom.findDir(node, 'for')) {
         if (compilerDom.isBuiltInType(node.tag, 'Suspense')) {
             for (const child of node.children) {
-                if (child.type === 1 /* ELEMENT */ &&
-                    child.tagType === 3 /* TEMPLATE */) {
+                if (child.type === 1 /* NodeTypes.ELEMENT */ &&
+                    child.tagType === 3 /* ElementTypes.TEMPLATE */) {
                     // suspense slot
                     child.children.forEach(injectCssVars);
                 }
@@ -1196,7 +1198,7 @@ function injectCssVars(node) {
         }
         else {
             node.props.push({
-                type: 7 /* DIRECTIVE */,
+                type: 7 /* NodeTypes.DIRECTIVE */,
                 name: 'bind',
                 arg: undefined,
                 exp: compilerDom.createSimpleExpression(`_cssVars`, false),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-ssr",
-  "version": "3.2.37",
+  "version": "3.2.38",
   "description": "@vue/compiler-ssr",
   "main": "dist/compiler-ssr.cjs.js",
   "types": "dist/compiler-ssr.d.ts",
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-ssr#readme",
   "dependencies": {
-    "@vue/shared": "3.2.37",
-    "@vue/compiler-dom": "3.2.37"
+    "@vue/shared": "3.2.38",
+    "@vue/compiler-dom": "3.2.38"
   }
 }