@vue/language-core 3.0.0-alpha.2 → 3.0.0-alpha.6

package/lib/codegen/globalTypes.js

@@ -13,7 +13,7 @@ function getGlobalTypesFileName({ lib, target, checkUnknownProps, checkUnknownEv
     ].map(v => (typeof v === 'boolean' ? Number(v) : v)).join('_') + '.d.ts';
 }
 function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvents, checkUnknownComponents, }) {
-    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${checkUnknownProps ? '' : ' & Record<string, unknown>'}`;
+    const fnPropsType = `(T extends { $props: infer Props } ? Props : {})${checkUnknownProps ? '' : ' & Record<string, unknown>'}`;
     let text = ``;
     if (target < 3.5) {
         text += `
@@ -51,10 +51,31 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N2] } :
 		N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N3] } :
 		${checkUnknownComponents ? '{}' : '{ [K in N0]: unknown }'};
-	type __VLS_FunctionalComponentProps<T, K> =
-		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
-		: T extends (props: infer P, ...args: any) => any ? P :
-		{};
+	type __VLS_FunctionalComponentCtx<T, K> = __VLS_PickNotAny<'__ctx' extends keyof __VLS_PickNotAny<K, {}>
+		? K extends { __ctx?: infer Ctx } ? NonNullable<Ctx> : never : any
+		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
+	>;
+	type __VLS_FunctionalComponentProps<T, K> = '__ctx' extends keyof __VLS_PickNotAny<K, {}>
+		? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
+		: T extends (props: infer P, ...args: any) => any ? P
+		: {};
+	type __VLS_FunctionalComponent<T> = (props: ${fnPropsType}, ctx?: any) => __VLS_Element & {
+		__ctx?: {
+			attrs?: any,
+			slots?: T extends { ${(0, shared_1.getSlotsPropertyName)(target)}: infer Slots } ? Slots : Record<string, any>,
+			emit?: T extends { $emit: infer Emit } ? Emit : {},
+			props?: ${fnPropsType},
+			expose?: (exposed: T) => void,
+		}
+	};
+	type __VLS_NormalizeSlotReturns<S, R = NonNullable<S> extends (...args: any) => infer K ? K : any> = R extends any[] ? {
+		[K in keyof R]: R[K] extends infer V
+			? V extends Element ? V
+			: V extends new (...args: any) => infer R ? ReturnType<__VLS_FunctionalComponent<R>>
+			: V extends (...args: any) => infer R ? R
+			: any
+			: never
+	} : R;
 	type __VLS_IsFunction<T, K> = K extends keyof T
 		? __VLS_IsAny<T[K]> extends false
 		? unknown extends T[K]
@@ -62,13 +83,13 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 		: true
 		: false
 		: false;
-	type __VLS_NormalizeComponentEvent<Props, Events, onEvent extends keyof Props, Event extends keyof Events, CamelizedEvent extends keyof Events> = (
+	type __VLS_NormalizeComponentEvent<Props, Emits, onEvent extends keyof Props, Event extends keyof Emits, CamelizedEvent extends keyof Emits> = (
 		__VLS_IsFunction<Props, onEvent> extends true
 			? Props
-			: __VLS_IsFunction<Events, Event> extends true
-				? { [K in onEvent]?: Events[Event] }
-				: __VLS_IsFunction<Events, CamelizedEvent> extends true
-					? { [K in onEvent]?: Events[CamelizedEvent] }
+			: __VLS_IsFunction<Emits, Event> extends true
+				? { [K in onEvent]?: Emits[Event] }
+				: __VLS_IsFunction<Emits, CamelizedEvent> extends true
+					? { [K in onEvent]?: Emits[CamelizedEvent] }
 					: Props
 	)${checkUnknownEvents ? '' : ' & Record<string, unknown>'};
 	// fix https://github.com/vuejs/language-tools/issues/926
@@ -94,11 +115,16 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 			}
 		>
 	>;
+	type __VLS_ResolveEmits<
+		Comp,
+		Emits,
+		TypeEmits = ${target >= 3.6 ? `Comp extends { __typeEmits?: infer T } ? unknown extends T ? {} : import('${lib}').ShortEmitsToObject<T> : {}` : `{}`},
+		NormalizedEmits = __VLS_NormalizeEmits<Emits> extends infer E ? string extends keyof E ? {} : E : never,
+	> = __VLS_SpreadMerge<NormalizedEmits, TypeEmits>;
+	type __VLS_ResolveDirectives<T> = {
+		[K in Exclude<keyof T, keyof __VLS_GlobalDirectives> & string as \`v\${Capitalize<K>}\`]: T[K];
+	};
 	type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
-	type __VLS_PickFunctionalComponentCtx<T, K> = NonNullable<__VLS_PickNotAny<
-		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: infer Ctx } ? Ctx : never : any
-		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
-	>>;
 	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
 
 	function __VLS_getVForSourceType<T extends number | string | any[] | Iterable<any>>(source: T): [
@@ -123,19 +149,12 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 			: (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
 	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
 	function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
-		T extends new (...args: any) => any
-		? (props: ${fnPropsType}, ctx?: any) => __VLS_Element & {
-			__ctx?: {
-				attrs?: any;
-				slots?: K extends { ${(0, shared_1.getSlotsPropertyName)(target)}: infer Slots } ? Slots : any;
-				emit?: K extends { $emit: infer Emit } ? Emit : any;
-				expose?(exposed: K): void;
-				props?: ${fnPropsType};
-			}
-		}
-		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+		T extends new (...args: any) => any ? __VLS_FunctionalComponent<K>
+		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>${(target === 2.7
+        ? `: T extends import('${lib}').AsyncComponent ? (props: {}, ctx?: any) => any`
+        : ``)}
 		: T extends (...args: any) => any ? T
-		: (_: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${checkUnknownProps ? '' : ' & Record<string, unknown>'} } };
+		: __VLS_FunctionalComponent<{}>;
 	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
 	function __VLS_asFunctionalElement<T>(tag: T, endTag?: T): (attrs: T${checkUnknownComponents ? '' : ' & Record<string, unknown>'}) => void;
 	function __VLS_asFunctionalSlot<S>(slot: S): S extends () => infer R ? (props: {}) => R : NonNullable<S>;

package/lib/codegen/localTypes.d.ts

@@ -1,6 +1,5 @@
-import type * as ts from 'typescript';
-import { VueCompilerOptions } from '../types';
-export declare function getLocalTypesGenerator(compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): {
+import type { VueCompilerOptions } from '../types';
+export declare function getLocalTypesGenerator(vueCompilerOptions: VueCompilerOptions): {
     generate: (names: string[]) => Generator<string, void, unknown>;
     getUsedNames(): Set<string>;
     readonly PrettifyLocal: string;

package/lib/codegen/localTypes.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLocalTypesGenerator = getLocalTypesGenerator;
 const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
-function getLocalTypesGenerator(compilerOptions, vueCompilerOptions) {
+function getLocalTypesGenerator(vueCompilerOptions) {
     const used = new Set();
     const OmitKeepDiscriminatedUnion = defineHelper(`__VLS_OmitKeepDiscriminatedUnion`, () => `
 type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> = T extends any
@@ -13,7 +13,7 @@ type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> = T extends any
     const WithDefaults = defineHelper(`__VLS_WithDefaults`, () => `
 type __VLS_WithDefaults<P, D> = {
 	[K in keyof Pick<P, keyof P>]: K extends keyof D
-		? ${PrettifyLocal.name}<P[K] & { default: D[K]}>
+		? ${PrettifyLocal.name}<P[K] & { default: D[K] }>
 		: P[K]
 };
 `.trimStart());
@@ -41,19 +41,10 @@ type __VLS_PropsChildren<S> = {
 	)]?: S;
 };
 `.trimStart());
-    const TypePropsToOption = defineHelper(`__VLS_TypePropsToOption`, () => compilerOptions.exactOptionalPropertyTypes ?
-        `
+    const TypePropsToOption = defineHelper(`__VLS_TypePropsToOption`, () => `
 type __VLS_TypePropsToOption<T> = {
 	[K in keyof T]-?: {} extends Pick<T, K>
-		? { type: import('${vueCompilerOptions.lib}').PropType<T[K]> }
-		: { type: import('${vueCompilerOptions.lib}').PropType<T[K]>, required: true }
-};
-`.trimStart() :
-        `
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-	[K in keyof T]-?: {} extends Pick<T, K>
-		? { type: import('${vueCompilerOptions.lib}').PropType<__VLS_NonUndefinedable<T[K]>> }
+		? { type: import('${vueCompilerOptions.lib}').PropType<Required<T>[K]> }
 		: { type: import('${vueCompilerOptions.lib}').PropType<T[K]>, required: true }
 };
 `.trimStart());

package/lib/codegen/script/context.d.ts

@@ -1,4 +1,4 @@
-import { InlayHintInfo } from '../inlayHints';
+import type { InlayHintInfo } from '../inlayHints';
 import type { ScriptCodegenOptions } from './index';
 export interface HelperType {
     name: string;

package/lib/codegen/script/context.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createScriptCodegenContext = createScriptCodegenContext;
 const localTypes_1 = require("../localTypes");
 function createScriptCodegenContext(options) {
-    const localTypes = (0, localTypes_1.getLocalTypesGenerator)(options.compilerOptions, options.vueCompilerOptions);
+    const localTypes = (0, localTypes_1.getLocalTypesGenerator)(options.vueCompilerOptions);
     const inlayHints = [];
     return {
         generatedTemplate: false,

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

@@ -3,7 +3,7 @@ import type { ScriptRanges } from '../../parsers/scriptRanges';
 import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
 import type { Code, Sfc, VueCompilerOptions } from '../../types';
 import type { TemplateCodegenContext } from '../template/context';
-import { ScriptCodegenContext } from './context';
+import { type ScriptCodegenContext } from './context';
 export interface ScriptCodegenOptions {
     ts: typeof ts;
     compilerOptions: ts.CompilerOptions;

package/lib/codegen/script/src.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSrc = generateSrc;
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
+const wrapWith_1 = require("../utils/wrapWith");
 function* generateSrc(src) {
     if (src === true) {
         return;
@@ -21,10 +22,10 @@ function* generateSrc(src) {
         text = text + '.js';
     }
     yield `export * from `;
-    yield* (0, utils_1.generateSfcBlockAttrValue)(src, text, {
+    yield* (0, wrapWith_1.wrapWith)(src.offset, src.offset + src.text.length, 'main', {
         ...codeFeatures_1.codeFeatures.all,
-        ...text === src.text ? codeFeatures_1.codeFeatures.navigation : codeFeatures_1.codeFeatures.navigationWithoutRename,
-    });
+        ...text !== src.text ? codeFeatures_1.codeFeatures.navigationWithoutRename : {},
+    }, `'`, [text.slice(0, src.text.length), 'main', src.offset, utils_1.combineLastMapping], text.slice(src.text.length), `'`);
     yield utils_1.endOfLine;
     yield `export { default } from '${text}'${utils_1.endOfLine}`;
 }

package/lib/codegen/script/template.js

@@ -51,7 +51,7 @@ function* generateTemplateElements() {
     yield `let __VLS_elements!: __VLS_IntrinsicElements${utils_1.endOfLine}`;
 }
 function* generateTemplateComponents(options) {
-    const types = [];
+    const types = [`typeof __VLS_ctx`];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
         const { componentsOption } = options.scriptRanges.exportDefault;
         yield `const __VLS_componentsOption = `;
@@ -64,7 +64,6 @@ function* generateTemplateComponents(options) {
         yield utils_1.endOfLine;
         types.push(`typeof __VLS_componentsOption`);
     }
-    types.push(`typeof __VLS_ctx`);
     yield `type __VLS_LocalComponents =`;
     for (const type of types) {
         yield ` & `;
@@ -74,7 +73,7 @@ function* generateTemplateComponents(options) {
     yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
 }
 function* generateTemplateDirectives(options) {
-    const types = [];
+    const types = [`typeof __VLS_ctx`];
     if (options.sfc.script && options.scriptRanges?.exportDefault?.directivesOption) {
         const { directivesOption } = options.scriptRanges.exportDefault;
         yield `const __VLS_directivesOption = `;
@@ -85,9 +84,8 @@ function* generateTemplateDirectives(options) {
             codeFeatures_1.codeFeatures.navigation,
         ];
         yield utils_1.endOfLine;
-        types.push(`typeof __VLS_directivesOption`);
+        types.push(`__VLS_ResolveDirectives<typeof __VLS_directivesOption>`);
     }
-    types.push(`typeof __VLS_ctx`);
     yield `type __VLS_LocalDirectives =`;
     for (const type of types) {
         yield ` & `;

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

@@ -1,6 +1,6 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code, VueCodeInformation } from '../../types';
-import { InlayHintInfo } from '../inlayHints';
+import type { InlayHintInfo } from '../inlayHints';
 import type { TemplateCodegenOptions } from './index';
 export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
 /**
@@ -161,6 +161,7 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     }[]>;
     currentComponent: {
         ctxVar: string;
+        childTypes: string[];
         used: boolean;
     } | undefined;
     singleRootElTypes: string[];

package/lib/codegen/template/element.js

@@ -35,9 +35,11 @@ function* generateComponent(options, ctx, node) {
     const componentVNodeVar = ctx.getInternalVariable();
     const componentCtxVar = ctx.getInternalVariable();
     const isComponentTag = node.tag.toLowerCase() === 'component';
+    ctx.currentComponent?.childTypes.push(`typeof ${componentVNodeVar}`);
     ctx.currentComponent = {
         ctxVar: componentCtxVar,
-        used: false
+        childTypes: [],
+        used: false,
     };
     let props = node.props;
     let dynamicTagInfo;
@@ -159,7 +161,7 @@ function* generateComponent(options, ctx, node) {
     yield* (0, wrapWith_1.wrapWith)(tagOffsets[0], tagOffsets[0] + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, true, failedPropExps), `}`);
     yield `, ...__VLS_functionalComponentArgsRest(${componentFunctionalVar}))${utils_1.endOfLine}`;
     yield* generateFailedPropExps(options, ctx, failedPropExps);
-    yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, componentFunctionalVar, componentVNodeVar, componentCtxVar);
+    yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, componentOriginalVar, componentFunctionalVar, componentVNodeVar, componentCtxVar);
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
     const [refName, offset] = yield* generateElementReference(options, ctx, node);
     const tag = (0, shared_2.hyphenateTag)(node.tag);
@@ -188,7 +190,7 @@ function* generateComponent(options, ctx, node) {
     const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
     yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir);
     if (ctx.currentComponent.used) {
-        yield `var ${componentCtxVar}!: __VLS_PickFunctionalComponentCtx<typeof ${componentOriginalVar}, typeof ${componentVNodeVar}>${utils_1.endOfLine}`;
+        yield `var ${componentCtxVar}!: __VLS_FunctionalComponentCtx<typeof ${componentOriginalVar}, typeof ${componentVNodeVar}>${utils_1.endOfLine}`;
     }
 }
 function* generateElement(options, ctx, node) {
@@ -197,6 +199,7 @@ function* generateElement(options, ctx, node) {
         ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag)
         : undefined;
     const failedPropExps = [];
+    ctx.currentComponent?.childTypes.push(`__VLS_NativeElements['${node.tag}']`);
     yield `__VLS_asFunctionalElement(__VLS_elements`;
     yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
     if (endTagOffset !== undefined) {
@@ -223,7 +226,10 @@ function* generateElement(options, ctx, node) {
         ctx.inheritedAttrVars.add(`__VLS_elements.${node.tag}`);
     }
     (0, styleScopedClasses_1.collectStyleScopedClassReferences)(options, ctx, node);
+    const { currentComponent } = ctx;
+    ctx.currentComponent = undefined;
     yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node.children);
+    ctx.currentComponent = currentComponent;
 }
 function* generateFailedPropExps(options, ctx, failedPropExps) {
     for (const failedExp of failedPropExps) {

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

@@ -1,4 +1,4 @@
-import * as CompilerDOM from '@vue/compiler-dom';
+import type * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';

package/lib/codegen/template/elementDirectives.js

@@ -26,9 +26,7 @@ function* generateElementDirectives(options, ctx, node) {
             || prop.name === 'slot'
             || prop.name === 'on'
             || prop.name === 'model'
-            || prop.name === 'bind'
-            || prop.name === 'scope'
-            || prop.name === 'data') {
+            || prop.name === 'bind') {
             continue;
         }
         ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
@@ -81,6 +79,6 @@ function* generateValue(options, ctx, prop) {
     }
     yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, `value`);
     yield `: `;
-    yield* (0, elementProps_1.generatePropExp)(options, ctx, prop, exp, ctx.codeFeatures.all);
+    yield* (0, elementProps_1.generatePropExp)(options, ctx, prop, exp);
 }
 //# sourceMappingURL=elementDirectives.js.map

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

@@ -1,10 +1,10 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
-import type { Code } from '../../types';
+import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentFunctionalVar: string, componentVNodeVar: string, componentCtxVar: string): Generator<Code>;
-export declare function generateEventArg(ctx: TemplateCodegenContext, name: string, start: number, directive?: string): Generator<Code>;
+export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentOriginalVar: string, componentFunctionalVar: string, componentVNodeVar: string, componentCtxVar: string): Generator<Code>;
+export declare function generateEventArg(ctx: TemplateCodegenContext, name: string, start: number, directive?: string, features?: VueCodeInformation): Generator<Code>;
 export declare function generateEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
 export declare function generateModelEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
 export declare function isCompoundExpression(ts: typeof import('typescript'), ast: ts.SourceFile): boolean;

package/lib/codegen/template/elementEvents.js

@@ -11,9 +11,8 @@ const utils_1 = require("../utils");
 const camelized_1 = require("../utils/camelized");
 const wrapWith_1 = require("../utils/wrapWith");
 const interpolation_1 = require("./interpolation");
-function* generateElementEvents(options, ctx, node, componentFunctionalVar, componentVNodeVar, componentCtxVar) {
-    let emitVar;
-    let eventsVar;
+function* generateElementEvents(options, ctx, node, componentOriginalVar, componentFunctionalVar, componentVNodeVar, componentCtxVar) {
+    let emitsVar;
     let propsVar;
     for (const prop of node.props) {
         if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
@@ -23,12 +22,10 @@ function* generateElementEvents(options, ctx, node, componentFunctionalVar, comp
                     && prop.name === 'model'
                     && (!prop.arg || prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic))) {
             ctx.currentComponent.used = true;
-            if (!emitVar) {
-                emitVar = ctx.getInternalVariable();
-                eventsVar = ctx.getInternalVariable();
+            if (!emitsVar) {
+                emitsVar = ctx.getInternalVariable();
                 propsVar = ctx.getInternalVariable();
-                yield `let ${emitVar}!: typeof ${componentCtxVar}.emit${utils_1.endOfLine}`;
-                yield `let ${eventsVar}!: __VLS_NormalizeEmits<typeof ${emitVar}>${utils_1.endOfLine}`;
+                yield `let ${emitsVar}!: __VLS_ResolveEmits<typeof ${componentOriginalVar}, typeof ${componentCtxVar}.emit>${utils_1.endOfLine}`;
                 yield `let ${propsVar}!: __VLS_FunctionalComponentProps<typeof ${componentFunctionalVar}, typeof ${componentVNodeVar}>${utils_1.endOfLine}`;
             }
             let source = prop.arg?.loc.source ?? 'model-value';
@@ -45,32 +42,43 @@ function* generateElementEvents(options, ctx, node, componentFunctionalVar, comp
                 propPrefix = 'onVnode-';
                 emitPrefix = 'vnode-';
             }
-            yield `(): __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${eventsVar}, '${(0, shared_1.camelize)(propPrefix + source)}', '${emitPrefix + source}', '${(0, shared_1.camelize)(emitPrefix + source)}'> => ({${utils_1.newLine}`;
+            const propName = (0, shared_1.camelize)(propPrefix + source);
+            const emitName = emitPrefix + source;
+            const camelizedEmitName = (0, shared_1.camelize)(emitName);
+            yield `(): __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${emitsVar}, '${propName}', '${emitName}', '${camelizedEmitName}'> => (${utils_1.newLine}`;
+            if (prop.name === 'on') {
+                yield `{ `;
+                yield* generateEventArg(ctx, source, start, emitPrefix.slice(0, -1), ctx.codeFeatures.navigation);
+                yield `: {} as any } as typeof ${emitsVar},${utils_1.newLine}`;
+            }
+            yield `{ `;
             if (prop.name === 'on') {
                 yield* generateEventArg(ctx, source, start, propPrefix.slice(0, -1));
                 yield `: `;
                 yield* generateEventExpression(options, ctx, prop);
             }
             else {
-                yield `'${(0, shared_1.camelize)(propPrefix + source)}': `;
+                yield `'${propName}': `;
                 yield* generateModelEventExpression(options, ctx, prop);
             }
             yield `})${utils_1.endOfLine}`;
         }
     }
 }
-function* generateEventArg(ctx, name, start, directive = 'on') {
-    const features = {
-        ...ctx.codeFeatures.withoutHighlightAndCompletion,
-        ...ctx.codeFeatures.navigationWithoutRename,
-    };
+function* generateEventArg(ctx, name, start, directive = 'on', features = {
+    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+    ...ctx.codeFeatures.navigationWithoutRename,
+}) {
+    if (directive.length) {
+        name = (0, shared_1.capitalize)(name);
+    }
     if (utils_1.identifierRegex.test((0, shared_1.camelize)(name))) {
         yield ['', 'template', start, features];
         yield directive;
-        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), 'template', start, utils_1.combineLastMapping);
+        yield* (0, camelized_1.generateCamelized)(name, 'template', start, utils_1.combineLastMapping);
     }
     else {
-        yield* (0, wrapWith_1.wrapWith)(start, start + name.length, features, `'`, directive, ...(0, camelized_1.generateCamelized)((0, shared_1.capitalize)(name), 'template', start, utils_1.combineLastMapping), `'`);
+        yield* (0, wrapWith_1.wrapWith)(start, start + name.length, features, `'`, directive, ...(0, camelized_1.generateCamelized)(name, 'template', start, utils_1.combineLastMapping), `'`);
     }
 }
 function* generateEventExpression(options, ctx, prop) {

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

@@ -1,5 +1,5 @@
 import * as CompilerDOM from '@vue/compiler-dom';
-import type { Code, VueCodeInformation } from '../../types';
+import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
 export interface FailedPropExpression {
@@ -8,4 +8,4 @@ export interface FailedPropExpression {
     suffix: string;
 }
 export declare function generateElementProps(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, props: CompilerDOM.ElementNode['props'], strictPropsCheck: boolean, enableCodeFeatures: boolean, failedPropExps?: FailedPropExpression[]): Generator<Code>;
-export declare function generatePropExp(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode, exp: CompilerDOM.SimpleExpressionNode | undefined, features: VueCodeInformation, enableCodeFeatures?: boolean): Generator<Code>;
+export declare function generatePropExp(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode, exp: CompilerDOM.SimpleExpressionNode | undefined, enableCodeFeatures?: boolean): Generator<Code>;

package/lib/codegen/template/elementProps.js

@@ -83,7 +83,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             }
             const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(prop.arg
                     ? (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, codeInfo, prop.loc.name_2 ??= {}, shouldCamelize)
-                    : (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.withoutHighlightAndCompletion, propName)), `: `, ...(0, wrapWith_1.wrapWith)(prop.arg?.loc.start.offset ?? prop.loc.start.offset, prop.arg?.loc.end.offset ?? prop.loc.end.offset, ctx.codeFeatures.verification, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, enableCodeFeatures)))];
+                    : (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.withoutHighlightAndCompletion, propName)), `: `, ...(0, wrapWith_1.wrapWith)(prop.arg?.loc.start.offset ?? prop.loc.start.offset, prop.arg?.loc.end.offset ?? prop.loc.end.offset, ctx.codeFeatures.verification, ...generatePropExp(options, ctx, prop, prop.exp, enableCodeFeatures)))];
             if (enableCodeFeatures) {
                 yield* codes;
             }
@@ -148,7 +148,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
                 }
             }
             else {
-                const codes = [...(0, wrapWith_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, `...`, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, enableCodeFeatures))];
+                const codes = [...(0, wrapWith_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, `...`, ...generatePropExp(options, ctx, prop, prop.exp, enableCodeFeatures))];
                 if (enableCodeFeatures) {
                     yield* codes;
                 }
@@ -160,14 +160,11 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
         }
     }
 }
-function* generatePropExp(options, ctx, prop, exp, features, enableCodeFeatures = true) {
+function* generatePropExp(options, ctx, prop, exp, enableCodeFeatures = true) {
     const isShorthand = prop.arg?.loc.start.offset === prop.exp?.loc.start.offset;
-    if (isShorthand && features.completion) {
-        features = {
-            ...features,
-            completion: undefined,
-        };
-    }
+    const features = isShorthand
+        ? ctx.codeFeatures.withoutHighlightAndCompletion
+        : ctx.codeFeatures.all;
     if (exp && exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) { // style='z-index: 2' will compile to {'z-index':'2'}
         if (!isShorthand) { // vue 3.4+
             yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, exp.loc.source, exp.loc.start.offset, exp.loc, `(`, `)`);

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

@@ -1,7 +1,7 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, Sfc, VueCompilerOptions } from '../../types';
-import { TemplateCodegenContext } from './context';
+import { type TemplateCodegenContext } from './context';
 export interface TemplateCodegenOptions {
     ts: typeof ts;
     compilerOptions: ts.CompilerOptions;

package/lib/codegen/template/slotOutlet.js

@@ -39,7 +39,7 @@ function* generateSlotOutlet(options, ctx, node) {
                 && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                 codes = [
                     `[`,
-                    ...(0, elementProps_1.generatePropExp)(options, ctx, nameProp, nameProp.exp, ctx.codeFeatures.all),
+                    ...(0, elementProps_1.generatePropExp)(options, ctx, nameProp, nameProp.exp),
                     `]`
                 ];
             }

package/lib/codegen/template/vSlot.js

@@ -28,7 +28,9 @@ function* generateVSlot(options, ctx, node, slotDir) {
             }
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)(node.children[0].loc.start.offset, node.children.at(-1).loc.end.offset, ctx.codeFeatures.navigation, `default`);
+            // #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}`;
     }
@@ -44,6 +46,12 @@ function* generateVSlot(options, ctx, node, slotDir) {
     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) {
@@ -112,4 +120,26 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
         ];
     }
 }
+function getElementInnerLoc(options, node) {
+    if (node.children.length) {
+        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 < node.loc.end.offset) {
+            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 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/languagePlugin.d.ts

@@ -1,4 +1,4 @@
-import { LanguagePlugin } from '@volar/language-core';
+import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions } from './types';
 import { VueVirtualCode } from './virtualFile/vueFile';

package/lib/plugins/vue-style-css.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-style-css.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const css = require("css-tree");
+const plugin = () => {
+    return {
+        version: 2.1,
+        compileSFCStyle(lang, style) {
+            if (lang === 'css' || lang === 'scss' || lang === 'sass' || lang === 'less') {
+                return css.parse(style, {
+                    filename: 'test.' + lang,
+                    positions: true,
+                });
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-style-css.js.map

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

@@ -37,14 +37,17 @@ const plugin = ctx => {
             return result;
         },
         resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (!embeddedFile.id.startsWith('template_inline_ts_')) {
+                return;
+            }
             // 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

@@ -198,6 +198,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[]>;
         currentComponent: {
             ctxVar: string;
+            childTypes: string[];
             used: boolean;
         } | undefined;
         singleRootElTypes: string[];

package/lib/plugins.d.ts

@@ -1,3 +1,3 @@
-import { VueLanguagePlugin } from './types';
+import { type VueLanguagePlugin } from './types';
 export * from './plugins/shared';
 export declare function createPlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): import("./types").VueLanguagePluginReturn[];

package/lib/types.d.ts

@@ -23,6 +23,7 @@ export interface VueCompilerOptions {
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
+    strictSlotChildren: boolean;
     strictVModel: boolean;
     checkUnknownProps: boolean;
     checkUnknownEvents: boolean;

package/lib/utils/signals.d.ts

@@ -1,2 +1,3 @@
 export declare function computedArray<I, O>(arr: () => I[], getGetter: (item: () => I, index: number) => () => O): readonly Readonly<O>[];
 export declare function computedSet<T>(source: () => Set<T>): () => Set<T>;
+export declare function computedItems<T>(source: () => T[], compareFn: (oldItem: T, newItem: T) => boolean): () => T[];

package/lib/utils/signals.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computedArray = computedArray;
 exports.computedSet = computedSet;
+exports.computedItems = computedItems;
 const alien_signals_1 = require("alien-signals");
 function computedArray(arr, getGetter) {
     const length = (0, alien_signals_1.computed)(() => arr().length);
@@ -51,4 +52,14 @@ function computedSet(source) {
         return newValue;
     });
 }
+function computedItems(source, compareFn) {
+    return (0, alien_signals_1.computed)(oldArr => {
+        oldArr ??= [];
+        const newArr = source();
+        if (oldArr.length === newArr.length && oldArr.every((item, index) => compareFn(item, newArr[index]))) {
+            return oldArr;
+        }
+        return newArr;
+    });
+}
 //# sourceMappingURL=signals.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/lib/virtualFile/computedSfc.js

@@ -88,8 +88,8 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
         const base = computedSfcBlock('style_' + i, 'css', getBlock);
         const getModule = computedAttrValue('__module', base, getBlock);
         const getScoped = (0, alien_signals_1.computed)(() => !!getBlock().scoped);
-        const getCssVars = (0, alien_signals_1.computed)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)]);
-        const getClassNames = (0, alien_signals_1.computed)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)]);
+        const getCssVars = (0, signals_1.computedItems)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
+        const getClassNames = (0, signals_1.computedItems)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)], (oldItem, newItem) => oldItem.text === newItem.text && oldItem.offset === newItem.offset);
         return () => mergeObject(base, {
             get module() { return getModule(); },
             get scoped() { return getScoped(); },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.0-alpha.2",
+	"version": "3.0.0-alpha.6",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,7 +13,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.4.11",
+		"@volar/language-core": "~2.4.13",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/compiler-vue2": "^2.7.16",
 		"@vue/shared": "^3.5.0",
@@ -26,7 +26,7 @@
 		"@types/minimatch": "^5.1.2",
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1",
-		"@volar/typescript": "~2.4.11",
+		"@volar/typescript": "~2.4.13",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
 	"peerDependencies": {
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "79247b7c24b7202ec676723440fdb36c38e6d450"
+	"gitHead": "a7b5649ab4957cd2228f4bbc9205b2008bff58a2"
 }

package/lib/codegen/script/styleModulesType.d.ts

@@ -1,4 +0,0 @@
-import type { Code } from '../../types';
-import type { ScriptCodegenContext } from './context';
-import type { ScriptCodegenOptions } from './index';
-export declare function generateStyleModulesType(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;

package/lib/codegen/script/styleModulesType.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStyleModulesType = generateStyleModulesType;
-const codeFeatures_1 = require("../codeFeatures");
-const utils_1 = require("../utils");
-const template_1 = require("./template");
-function* generateStyleModulesType(options, ctx) {
-    const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
-    if (!styles.length && !options.scriptSetupRanges?.useCssModule.length) {
-        return;
-    }
-    yield `type __VLS_StyleModules = {${utils_1.newLine}`;
-    for (const [style, i] of styles) {
-        const { name, offset } = style.module;
-        if (offset) {
-            yield [
-                name,
-                'main',
-                offset + 1,
-                codeFeatures_1.codeFeatures.all
-            ];
-        }
-        else {
-            yield name;
-        }
-        yield `: Record<string, string> & ${ctx.localTypes.PrettifyLocal}<{}`;
-        for (const className of style.classNames) {
-            yield* (0, template_1.generateCssClassProperty)(i, className.text, className.offset, 'string', false);
-        }
-        yield `>${utils_1.endOfLine}`;
-    }
-    yield `}${utils_1.endOfLine}`;
-}
-//# sourceMappingURL=styleModulesType.js.map

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

@@ -1,3 +0,0 @@
-import type { Code, VueCodeInformation } from '../../types';
-export declare function getObjectProperty(code: string): string;
-export declare function generateObjectProperty(code: string, source: string, offset: number, features: VueCodeInformation, hasQuotes?: boolean, shouldCamelize?: boolean): Generator<Code>;

package/lib/codegen/utils/objectProperty.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getObjectProperty = getObjectProperty;
-exports.generateObjectProperty = generateObjectProperty;
-const shared_1 = require("@vue/shared");
-const utils_1 = require("../utils");
-const camelized_1 = require("../utils/camelized");
-const stringLiteralKey_1 = require("../utils/stringLiteralKey");
-function getObjectProperty(code) {
-    if (utils_1.identifierRegex.test(code)) {
-        return code;
-    }
-    else {
-        return `'${code}'`;
-    }
-}
-function* generateObjectProperty(code, source, offset, features, hasQuotes = false, shouldCamelize = false) {
-    const start = offset;
-    const end = offset + code.length;
-    if (hasQuotes) {
-        code = code.slice(1, -1);
-        offset++;
-    }
-    if (shouldCamelize) {
-        if (utils_1.identifierRegex.test((0, shared_1.camelize)(code))) {
-            yield* (0, camelized_1.generateCamelized)(code, source, offset, features);
-        }
-        else {
-            yield* (0, utils_1.wrapWith)(start, end, source, features, `'`, ...(0, camelized_1.generateCamelized)(code, source, offset, features), `'`);
-        }
-    }
-    else {
-        if (utils_1.identifierRegex.test(code)) {
-            yield [code, source, offset, features];
-        }
-        else {
-            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, source, offset, features);
-        }
-    }
-}
-//# sourceMappingURL=objectProperty.js.map

package/lib/utils/forEachElementNode.d.ts

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

package/lib/utils/forEachElementNode.js

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