@vue/language-core 3.0.0-alpha.0 → 3.0.0-alpha.4

package/lib/codegen/template/vSlot.d.ts

@@ -2,5 +2,4 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateVSlot(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, slotDir: CompilerDOM.DirectiveNode): Generator<Code>;
-export declare function generateImplicitDefaultSlot(ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code, void, any>;
+export declare function generateVSlot(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, slotDir: CompilerDOM.DirectiveNode | undefined): Generator<Code>;

package/lib/codegen/template/vSlot.js

@@ -1,93 +1,145 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVSlot = generateVSlot;
-exports.generateImplicitDefaultSlot = generateImplicitDefaultSlot;
 const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("../../utils/shared");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
+const elementChildren_1 = require("./elementChildren");
 const objectProperty_1 = require("./objectProperty");
-const templateChild_1 = require("./templateChild");
 function* generateVSlot(options, ctx, node, slotDir) {
     if (!ctx.currentComponent) {
         return;
     }
-    ctx.currentComponent.used = true;
     const slotBlockVars = [];
-    yield `{${utils_1.newLine}`;
-    yield `const { `;
-    if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
-        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+    const slotVar = ctx.getInternalVariable();
+    if (slotDir) {
+        yield `{${utils_1.newLine}`;
     }
-    else {
-        yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+    if (slotDir || node.children.length) {
+        ctx.currentComponent.used = true;
+        yield `const { `;
+        if (slotDir) {
+            if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+            }
+            else {
+                yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+            }
+        }
+        else {
+            // #932: reference for implicit default slot
+            const { start, end } = getElementInnerLoc(options, node);
+            yield* (0, wrapWith_1.wrapWith)(start, end, ctx.codeFeatures.navigation, `default`);
+        }
+        yield `: ${slotVar} } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
     }
-    yield `: __VLS_thisSlot } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
-    if (slotDir.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+    if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         const slotAst = (0, utils_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
         (0, utils_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
-        if (!slotDir.exp.content.includes(':')) {
-            yield `const [`;
-            yield [
-                slotDir.exp.content,
-                'template',
-                slotDir.exp.loc.start.offset,
-                ctx.codeFeatures.all,
-            ];
-            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${utils_1.endOfLine}`;
+        yield* generateSlotParameters(options, ctx, slotAst, slotDir.exp, slotVar);
+    }
+    for (const varName of slotBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node.children);
+    for (const varName of slotBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    if (options.vueCompilerOptions.strictSlotChildren && node.children.length) {
+        const { start, end } = getElementInnerLoc(options, node);
+        yield `(): __VLS_NormalizeSlotReturns<typeof ${slotVar}> => (`;
+        yield* (0, wrapWith_1.wrapWith)(start, end, ctx.codeFeatures.verification, `{} as [`, ...ctx.currentComponent.childTypes.map(name => `${name}, `), `]`);
+        yield `)${utils_1.endOfLine}`;
+    }
+    if (slotDir) {
+        let isStatic = true;
+        if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            isStatic = slotDir.arg.isStatic;
         }
-        else {
-            yield `const `;
+        if (isStatic && !slotDir.arg) {
+            yield `${ctx.currentComponent.ctxVar}.slots!['`;
             yield [
-                slotDir.exp.content,
+                '',
                 'template',
-                slotDir.exp.loc.start.offset,
-                ctx.codeFeatures.all,
+                slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+                    ? '#'.length
+                    : slotDir.loc.source.startsWith('v-slot:')
+                        ? 'v-slot:'.length
+                        : 0),
+                ctx.codeFeatures.completion,
             ];
-            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${utils_1.endOfLine}`;
+            yield `'/* empty slot name completion */]${utils_1.endOfLine}`;
         }
+        yield `}${utils_1.newLine}`;
     }
-    for (const varName of slotBlockVars) {
-        ctx.addLocalVariable(varName);
+}
+function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
+    const { ts } = options;
+    const statement = ast.statements[0];
+    if (!ts.isExpressionStatement(statement) || !ts.isArrowFunction(statement.expression)) {
+        return;
     }
-    yield* ctx.resetDirectiveComments('end of slot children start');
-    let prev;
-    for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
-        prev = childNode;
+    const { expression } = statement;
+    const startOffset = exp.loc.start.offset - 1;
+    const modifies = [];
+    const types = [];
+    for (const { name, type } of expression.parameters) {
+        if (type) {
+            modifies.push([
+                [``],
+                name.end,
+                type.end,
+            ]);
+            types.push(chunk((0, shared_1.getStartEnd)(ts, type, ast).start, type.end));
+        }
+        else {
+            types.push(null);
+        }
     }
-    for (const varName of slotBlockVars) {
-        ctx.removeLocalVariable(varName);
+    yield `const [`;
+    let nextStart = 1;
+    for (const [codes, start, end] of modifies) {
+        yield chunk(nextStart, start);
+        yield* codes;
+        nextStart = end;
     }
-    let isStatic = true;
-    if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        isStatic = slotDir.arg.isStatic;
+    yield chunk(nextStart, expression.equalsGreaterThanToken.pos - 1);
+    yield `] = __VLS_getSlotParameters(${slotVar}`;
+    if (types.some(t => t)) {
+        yield `, `;
+        yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_: `, type, `, `] : `_, `), `) => [] as any`);
     }
-    if (isStatic && !slotDir.arg) {
-        yield `${ctx.currentComponent.ctxVar}.slots!['`;
-        yield [
-            '',
+    yield `)${utils_1.endOfLine}`;
+    function chunk(start, end) {
+        return [
+            ast.text.slice(start, end),
             'template',
-            slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
-                ? '#'.length
-                : slotDir.loc.source.startsWith('v-slot:')
-                    ? 'v-slot:'.length
-                    : 0),
-            ctx.codeFeatures.completion,
+            startOffset + start,
+            ctx.codeFeatures.all,
         ];
-        yield `'/* empty slot name completion */]${utils_1.endOfLine}`;
     }
-    yield* ctx.generateAutoImportCompletion();
-    yield `}${utils_1.newLine}`;
 }
-function* generateImplicitDefaultSlot(ctx, node) {
-    if (!ctx.currentComponent) {
-        return;
-    }
+function getElementInnerLoc(options, node) {
     if (node.children.length) {
-        ctx.currentComponent.used = true;
-        yield `${ctx.currentComponent.ctxVar}.slots!.`;
-        yield* (0, wrapWith_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
-        yield utils_1.endOfLine;
+        let start = node.children[0].loc.start.offset;
+        let end = node.children.at(-1).loc.end.offset;
+        while (options.template.content[start - 1] !== '>') {
+            start--;
+        }
+        while (options.template.content[end] !== '<') {
+            end++;
+        }
+        return {
+            start,
+            end,
+        };
+    }
+    else {
+        return {
+            start: node.loc.start.offset,
+            end: node.loc.end.offset,
+        };
     }
 }
 //# sourceMappingURL=vSlot.js.map

package/lib/codegen/utils/index.d.ts

@@ -1,6 +1,6 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
-import type { Code, SfcBlock, SfcBlockAttr, VueCodeInformation } from '../../types';
+import type { Code, SfcBlock, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
@@ -18,4 +18,3 @@ export declare function collectIdentifiers(ts: typeof import('typescript'), node
 export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;
-export declare function generateSfcBlockAttrValue(src: SfcBlockAttr & object, text: string, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/index.js

@@ -6,7 +6,6 @@ exports.collectIdentifiers = collectIdentifiers;
 exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
-exports.generateSfcBlockAttrValue = generateSfcBlockAttrValue;
 const shared_1 = require("../../utils/shared");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
@@ -65,19 +64,4 @@ function generateSfcBlockSection(block, start, end, features) {
         features,
     ];
 }
-function* generateSfcBlockAttrValue(src, text, features) {
-    const { offset, quotes } = src;
-    if (!quotes) {
-        yield [``, 'main', offset, { verification: true }];
-    }
-    yield [
-        `'${text}'`,
-        'main',
-        quotes ? offset - 1 : offset,
-        features
-    ];
-    if (!quotes) {
-        yield [``, 'main', offset + text.length, { __combineOffset: 2 }];
-    }
-}
 //# sourceMappingURL=index.js.map

package/lib/parsers/scriptSetupRanges.js

@@ -159,7 +159,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     defaultValue,
                     required,
                     isModel: isDefineModel,
-                    comments: getCommentsRange(ts, node, parents, ast),
+                    comments: getClosestMultiLineCommentRange(ts, node, parents, ast),
                     argNode: options,
                 });
             }
@@ -410,18 +410,20 @@ function getStatementRange(ts, parents, node, ast) {
     }
     return statementRange;
 }
-function getCommentsRange(ts, node, parents, ast) {
+function getClosestMultiLineCommentRange(ts, node, parents, ast) {
     for (let i = parents.length - 1; i >= 0; i--) {
         if (ts.isStatement(node)) {
             break;
         }
         node = parents[i];
     }
-    const comments = ts.getLeadingCommentRanges(ast.text, node.pos);
-    if (comments?.length) {
+    const comment = ts.getLeadingCommentRanges(ast.text, node.pos)
+        ?.reverse()
+        .find(range => range.kind === 3);
+    if (comment) {
         return {
-            start: comments[0].pos,
-            end: comments.at(-1).end,
+            start: comment.pos,
+            end: comment.end,
         };
     }
 }

package/lib/plugins/vue-template-inline-css.js

@@ -21,7 +21,7 @@ const plugin = () => {
             if (embeddedFile.id !== 'template_inline_css' || !sfc.template?.ast) {
                 return;
             }
-            embeddedFile.parentCodeId = 'template';
+            embeddedFile.parentCodeId = sfc.template.lang === 'md' ? 'root_tags' : 'template';
             embeddedFile.content.push(...generate(sfc.template.ast));
         },
     };

package/lib/plugins/vue-template-inline-ts.js

@@ -38,13 +38,13 @@ const plugin = ctx => {
         },
         resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
             // access template content to watch change
-            (() => sfc.template?.content)();
+            void sfc.template?.content;
             const parsed = parseds.get(sfc);
             if (parsed) {
                 const codes = parsed.get(embeddedFile.id);
                 if (codes) {
                     embeddedFile.content.push(...codes);
-                    embeddedFile.parentCodeId = 'template';
+                    embeddedFile.parentCodeId = sfc.template?.lang === 'md' ? 'root_tags' : 'template';
                 }
             }
         },

package/lib/plugins/vue-tsx.d.ts

@@ -138,6 +138,17 @@ export declare const tsCodegen: WeakMap<Sfc, {
     };
     getGeneratedTemplate: () => {
         codes: Code[];
+        currentInfo: {
+            ignoreError?: boolean;
+            expectError?: {
+                token: number;
+                node: import("@vue/compiler-dom").CommentNode;
+            };
+            generic?: {
+                content: string;
+                offset: number;
+            };
+        };
         codeFeatures: {
             all: import("../types").VueCodeInformation;
             none: import("../types").VueCodeInformation;
@@ -157,6 +168,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
         };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
+        inVFor: boolean;
         slots: {
             name: string;
             offset?: number;
@@ -170,10 +182,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[];
         dollarVars: Set<string>;
         accessExternalVariables: Map<string, Set<number>>;
-        lastGenericComment: {
-            content: string;
-            offset: number;
-        } | undefined;
         blockConditions: string[];
         scopedClasses: {
             source: string;
@@ -187,25 +195,26 @@ export declare const tsCodegen: WeakMap<Sfc, {
         templateRefs: Map<string, {
             typeExp: string;
             offset: number;
-        }>;
+        }[]>;
         currentComponent: {
             ctxVar: string;
+            childTypes: string[];
             used: boolean;
         } | undefined;
         singleRootElTypes: string[];
         singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
+        addTemplateRef(name: string, typeExp: string, offset: number): void;
         accessExternalVariable(name: string, offset?: number): void;
-        hasLocalVariable: (name: string) => boolean;
-        addLocalVariable: (name: string) => void;
-        removeLocalVariable: (name: string) => void;
-        getInternalVariable: () => string;
-        getHoistVariable: (originalVar: string) => string;
-        generateHoistVariables: () => Generator<string, void, unknown>;
-        generateConditionGuards: () => Generator<string, void, unknown>;
-        ignoreError: () => Generator<Code>;
-        expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
-        resetDirectiveComments: (endStr: string) => Generator<Code>;
-        generateAutoImportCompletion: () => Generator<Code>;
+        hasLocalVariable(name: string): boolean;
+        addLocalVariable(name: string): void;
+        removeLocalVariable(name: string): void;
+        getInternalVariable(): string;
+        getHoistVariable(originalVar: string): string;
+        generateHoistVariables(): Generator<string, void, unknown>;
+        generateConditionGuards(): Generator<string, void, unknown>;
+        generateAutoImportCompletion(): Generator<Code>;
+        enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
+        exit(): Generator<Code>;
     } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;

package/lib/plugins/vue-tsx.js

@@ -12,6 +12,7 @@ const vueCompilerOptions_1 = require("../parsers/vueCompilerOptions");
 const signals_1 = require("../utils/signals");
 const ts_1 = require("../utils/ts");
 exports.tsCodegen = new WeakMap();
+const validLangs = new Set(['js', 'jsx', 'ts', 'tsx']);
 const plugin = ctx => {
     let appendedGlobalTypes = false;
     return {
@@ -22,11 +23,10 @@ const plugin = ctx => {
         ],
         getEmbeddedCodes(fileName, sfc) {
             const codegen = useCodegen(fileName, sfc);
-            const files = [];
-            if (['js', 'ts', 'jsx', 'tsx'].includes(codegen.getLang())) {
-                files.push({ id: 'script_' + codegen.getLang(), lang: codegen.getLang() });
-            }
-            return files;
+            return [{
+                    id: 'script_' + codegen.getLang(),
+                    lang: codegen.getLang(),
+                }];
         },
         resolveEmbeddedCode(fileName, sfc, embeddedFile) {
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
@@ -53,11 +53,23 @@ const plugin = ctx => {
 exports.default = plugin;
 function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
+    const getRawLang = (0, alien_signals_1.computed)(() => {
+        if (sfc.script && sfc.scriptSetup) {
+            if (sfc.scriptSetup.lang !== 'js') {
+                return sfc.scriptSetup.lang;
+            }
+            else {
+                return sfc.script.lang;
+            }
+        }
+        return sfc.scriptSetup?.lang ?? sfc.script?.lang;
+    });
     const getLang = (0, alien_signals_1.computed)(() => {
-        return !sfc.script && !sfc.scriptSetup ? 'ts'
-            : sfc.scriptSetup && sfc.scriptSetup.lang !== 'js' ? sfc.scriptSetup.lang
-                : sfc.script && sfc.script.lang !== 'js' ? sfc.script.lang
-                    : 'js';
+        const rawLang = getRawLang();
+        if (rawLang && validLangs.has(rawLang)) {
+            return rawLang;
+        }
+        return 'ts';
     });
     const getResolvedOptions = (0, alien_signals_1.computed)(() => {
         const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(sfc.comments);
@@ -68,13 +80,13 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
         }
         return ctx.vueCompilerOptions;
     });
-    const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script
+    const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script && validLangs.has(sfc.script.lang)
         ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, !!sfc.scriptSetup, false)
         : undefined);
-    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup
+    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup && validLangs.has(sfc.scriptSetup.lang)
         ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, sfc.scriptSetup.ast, getResolvedOptions())
         : undefined);
-    const getSetupBindingNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+    const getSetupBindingNames = (0, signals_1.computedSet)(() => {
         const newNames = new Set();
         const bindings = getScriptSetupRanges()?.bindings;
         if (sfc.scriptSetup && bindings) {
@@ -83,8 +95,8 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
             }
         }
         return newNames;
-    }));
-    const getSetupImportComponentNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+    });
+    const getSetupImportComponentNames = (0, signals_1.computedSet)(() => {
         const newNames = new Set();
         const bindings = getScriptSetupRanges()?.bindings;
         if (sfc.scriptSetup && bindings) {
@@ -98,21 +110,21 @@ function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
             }
         }
         return newNames;
-    }));
-    const getSetupDestructuredPropNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+    });
+    const getSetupDestructuredPropNames = (0, signals_1.computedSet)(() => {
         const newNames = new Set(getScriptSetupRanges()?.defineProps?.destructured?.keys());
         const rest = getScriptSetupRanges()?.defineProps?.destructuredRest;
         if (rest) {
             newNames.add(rest);
         }
         return newNames;
-    }));
-    const getSetupTemplateRefNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+    });
+    const getSetupTemplateRefNames = (0, signals_1.computedSet)(() => {
         const newNames = new Set(getScriptSetupRanges()?.useTemplateRef
             .map(({ name }) => name)
             .filter(name => name !== undefined));
         return newNames;
-    }));
+    });
     const setupHasDefineSlots = (0, alien_signals_1.computed)(() => !!getScriptSetupRanges()?.defineSlots);
     const getSetupSlotsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineSlots?.name);
     const getSetupPropsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineProps?.name);

package/lib/types.d.ts

@@ -8,7 +8,7 @@ export type { SFCParseResult } from '@vue/compiler-sfc';
 export { VueEmbeddedCode };
 export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
     strictTemplates?: boolean;
-    target?: 'auto' | 2 | 2.7 | 3 | 3.3 | 3.5 | 99 | number;
+    target?: 'auto' | 2 | 2.7 | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
@@ -23,6 +23,7 @@ export interface VueCompilerOptions {
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
+    strictSlotChildren: boolean;
     strictVModel: boolean;
     checkUnknownProps: boolean;
     checkUnknownEvents: boolean;

package/lib/utils/forEachElementNode.d.ts

@@ -0,0 +1 @@
+export { };

package/lib/utils/forEachElementNode.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=forEachElementNode.js.map

package/lib/utils/ts.js

@@ -217,6 +217,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         vitePressExtensions: [],
         petiteVueExtensions: [],
         jsxSlots: false,
+        strictSlotChildren: strictTemplates,
         strictVModel: strictTemplates,
         checkUnknownProps: strictTemplates,
         checkUnknownEvents: strictTemplates,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.0-alpha.0",
+	"version": "3.0.0-alpha.4",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "4b49cbe09097e482def4603b90f6c3b93bb2e913"
+	"gitHead": "1769cd6b94ec9e0cc2681b8dbba904f35856ba1c"
 }