@vue/language-core 3.2.9 → 3.3.0

package/lib/codegen/utils/merge.js

@@ -3,22 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateIntersectMerge = generateIntersectMerge;
 exports.generateSpreadMerge = generateSpreadMerge;
 const index_1 = require("./index");
-function* generateIntersectMerge(generates) {
-    yield* generates[0];
-    for (let i = 1; i < generates.length; i++) {
+function* generateIntersectMerge(...codes) {
+    yield codes[0];
+    for (let i = 1; i < codes.length; i++) {
         yield ` & `;
-        yield* generates[i];
+        yield codes[i];
     }
 }
-function* generateSpreadMerge(generates) {
-    if (generates.length === 1) {
-        yield* generates[0];
+function* generateSpreadMerge(...codes) {
+    if (codes.length <= 1) {
+        yield* codes;
     }
     else {
         yield `{${index_1.newLine}`;
-        for (const generate of generates) {
+        for (const code of codes) {
             yield `...`;
-            yield* generate;
+            yield code;
             yield `,${index_1.newLine}`;
         }
         yield `}`;

package/lib/compilerOptions.js

@@ -211,6 +211,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         inferTemplateDollarSlots: false,
         skipTemplateCodegen: false,
         fallthroughAttributes: false,
+        checkRequiredFallthroughAttributes: false,
         resolveStyleImports: false,
         resolveStyleClassNames: 'scoped',
         fallthroughComponentNames: [

package/lib/plugins/vue-root-tags.js

@@ -11,27 +11,27 @@ const plugin = () => {
                     lang: 'vue-root-tags',
                 }];
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             if (embeddedFile.id === 'root_tags') {
-                embeddedFile.content.push([sfc.content, undefined, 0, shared_1.allCodeFeatures]);
+                embeddedFile.content.push([ir.content, undefined, 0, shared_1.allCodeFeatures]);
                 for (const block of [
-                    sfc.template,
-                    sfc.script,
-                    sfc.scriptSetup,
-                    ...sfc.styles,
-                    ...sfc.customBlocks,
+                    ir.template,
+                    ir.script,
+                    ir.scriptSetup,
+                    ...ir.styles,
+                    ...ir.customBlocks,
                 ]) {
                     if (!block) {
                         continue;
                     }
                     const offset = block.content.lastIndexOf('\n', block.content.lastIndexOf('\n') - 1) + 1;
                     // fix folding range end position failed to mapping
-                    (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, sfc.content.slice(block.startTagEnd, block.startTagEnd + offset), [
+                    (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, ir.content.slice(block.startTagEnd, block.startTagEnd + offset), [
                         '',
                         undefined,
                         block.startTagEnd + offset,
                         { structure: true },
-                    ], sfc.content.slice(block.startTagEnd + offset, block.endTagStart));
+                    ], ir.content.slice(block.startTagEnd + offset, block.endTagStart));
                 }
             }
             else {

package/lib/plugins/vue-sfc-customblocks.js

@@ -4,16 +4,16 @@ const shared_1 = require("./shared");
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            return sfc.customBlocks.map((customBlock, i) => ({
+        getEmbeddedCodes(_fileName, ir) {
+            return ir.customBlocks.map((customBlock, i) => ({
                 id: 'custom_block_' + i,
                 lang: customBlock.lang,
             }));
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             if (embeddedFile.id.startsWith('custom_block_')) {
                 const index = parseInt(embeddedFile.id.slice('custom_block_'.length));
-                const customBlock = sfc.customBlocks[index];
+                const customBlock = ir.customBlocks[index];
                 embeddedFile.content.push([
                     customBlock.content,
                     customBlock.name,

package/lib/plugins/vue-sfc-scripts.js

@@ -3,21 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
+        getEmbeddedCodes(_fileName, ir) {
             const names = [];
-            if (sfc.script) {
-                names.push({ id: 'script_raw', lang: sfc.script.lang });
+            if (ir.script) {
+                names.push({ id: 'script_raw', lang: ir.script.lang });
             }
-            if (sfc.scriptSetup) {
-                names.push({ id: 'scriptsetup_raw', lang: sfc.scriptSetup.lang });
+            if (ir.scriptSetup) {
+                names.push({ id: 'scriptsetup_raw', lang: ir.scriptSetup.lang });
             }
             return names;
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             const script = embeddedFile.id === 'script_raw'
-                ? sfc.script
+                ? ir.script
                 : embeddedFile.id === 'scriptsetup_raw'
-                    ? sfc.scriptSetup
+                    ? ir.scriptSetup
                     : undefined;
             if (script) {
                 embeddedFile.content.push([

package/lib/plugins/vue-sfc-styles.js

@@ -4,10 +4,10 @@ const shared_1 = require("./shared");
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
+        getEmbeddedCodes(_fileName, ir) {
             const result = [];
-            for (let i = 0; i < sfc.styles.length; i++) {
-                const style = sfc.styles[i];
+            for (let i = 0; i < ir.styles.length; i++) {
+                const style = ir.styles[i];
                 if (style) {
                     result.push({
                         id: 'style_' + i,
@@ -23,10 +23,10 @@ const plugin = () => {
             }
             return result;
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             if (embeddedFile.id.startsWith('style_')) {
                 const index = parseInt(embeddedFile.id.split('_')[1]);
-                const style = sfc.styles[index];
+                const style = ir.styles[index];
                 if (embeddedFile.id.endsWith('_inline_ts')) {
                     embeddedFile.parentCodeId = 'style_' + index;
                     for (const binding of style.bindings) {

package/lib/plugins/vue-sfc-template.js

@@ -4,20 +4,20 @@ const shared_1 = require("./shared");
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            if (sfc.template?.lang === 'html') {
+        getEmbeddedCodes(_fileName, ir) {
+            if (ir.template?.lang === 'html') {
                 return [{
                         id: 'template',
-                        lang: sfc.template.lang,
+                        lang: ir.template.lang,
                     }];
             }
             return [];
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
-            if (embeddedFile.id === 'template' && sfc.template?.lang === 'html') {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
+            if (embeddedFile.id === 'template' && ir.template?.lang === 'html') {
                 embeddedFile.content.push([
-                    sfc.template.content,
-                    sfc.template.name,
+                    ir.template.content,
+                    ir.template.name,
                     0,
                     shared_1.allCodeFeatures,
                 ]);

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

@@ -45,18 +45,18 @@ const codeFeatures = {
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            if (!sfc.template?.ast) {
+        getEmbeddedCodes(_fileName, ir) {
+            if (!ir.template?.ast) {
                 return [];
             }
             return [{ id: 'template_inline_css', lang: 'css' }];
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
-            if (embeddedFile.id !== 'template_inline_css' || !sfc.template?.ast) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
+            if (embeddedFile.id !== 'template_inline_css' || !ir.template?.ast) {
                 return;
             }
-            embeddedFile.parentCodeId = sfc.template.lang === 'md' ? 'root_tags' : 'template';
-            embeddedFile.content.push(...generate(sfc.template.ast));
+            embeddedFile.parentCodeId = ir.template.lang === 'md' ? 'root_tags' : 'template';
+            embeddedFile.content.push(...generate(ir.template.ast));
         },
     };
 };

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

@@ -57,42 +57,42 @@ const plugin = ({ modules: { typescript: ts } }) => {
     const parseds = new WeakMap();
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            if (!sfc.template?.ast) {
+        getEmbeddedCodes(_fileName, ir) {
+            if (!ir.template?.ast) {
                 return [];
             }
-            const parsed = parse(sfc);
-            parseds.set(sfc, parsed);
+            const parsed = parse(ir);
+            parseds.set(ir, parsed);
             const result = [];
             for (const [id] of parsed) {
                 result.push({ id, lang: 'ts' });
             }
             return result;
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             if (!embeddedFile.id.startsWith('template_inline_ts_')) {
                 return;
             }
             // access template content to watch change
-            void sfc.template?.content;
-            const parsed = parseds.get(sfc);
+            void ir.template?.content;
+            const parsed = parseds.get(ir);
             if (parsed) {
                 const codes = parsed.get(embeddedFile.id);
                 if (codes) {
                     embeddedFile.content.push(...codes);
-                    embeddedFile.parentCodeId = sfc.template?.lang === 'md' ? 'root_tags' : 'template';
+                    embeddedFile.parentCodeId = ir.template?.lang === 'md' ? 'root_tags' : 'template';
                 }
             }
         },
     };
-    function parse(sfc) {
+    function parse(ir) {
         const result = new Map();
-        if (!sfc.template?.ast) {
+        if (!ir.template?.ast) {
             return result;
         }
-        const template = sfc.template;
+        const template = ir.template;
         let i = 0;
-        sfc.template.ast.children.forEach(visit);
+        ir.template.ast.children.forEach(visit);
         return result;
         function visit(node) {
             if (node.type === CompilerDOM.NodeTypes.COMMENT) {

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

@@ -1,5 +1,5 @@
-import type { Sfc, VueLanguagePlugin } from '../types';
-export declare const tsCodegen: WeakMap<Sfc, {
+import type { IR, VueLanguagePlugin } from '../types';
+export declare const tsCodegen: WeakMap<IR, {
     getScriptRanges: () => {
         exportDefault: (import("../types").TextRange<import("typescript").Node> & {
             expression: import("../types").TextRange<import("typescript").Expression>;

package/lib/plugins/vue-tsx.js

@@ -50,29 +50,29 @@ const validLangs = new Set(['js', 'jsx', 'ts', 'tsx']);
 const plugin = ({ modules: { typescript: ts }, vueCompilerOptions, }) => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            const lang = computeLang(sfc);
+        getEmbeddedCodes(_fileName, ir) {
+            const lang = computeLang(ir);
             return [{ lang, id: 'script_' + lang }];
         },
-        resolveEmbeddedCode(fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(fileName, ir, embeddedFile) {
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
-                let codegen = exports.tsCodegen.get(sfc);
+                let codegen = exports.tsCodegen.get(ir);
                 if (!codegen) {
-                    exports.tsCodegen.set(sfc, codegen = useCodegen(ts, vueCompilerOptions, fileName, sfc));
+                    exports.tsCodegen.set(ir, codegen = useCodegen(ts, vueCompilerOptions, fileName, ir));
                 }
                 const generatedScript = codegen.getGeneratedScript();
                 embeddedFile.content = [...generatedScript.codes];
             }
         },
     };
-    function computeLang(sfc) {
-        let lang = sfc.scriptSetup?.lang ?? sfc.script?.lang;
-        if (sfc.script && sfc.scriptSetup) {
-            if (sfc.scriptSetup.lang !== 'js') {
-                lang = sfc.scriptSetup.lang;
+    function computeLang(ir) {
+        let lang = ir.scriptSetup?.lang ?? ir.script?.lang;
+        if (ir.script && ir.scriptSetup) {
+            if (ir.scriptSetup.lang !== 'js') {
+                lang = ir.scriptSetup.lang;
             }
             else {
-                lang = sfc.script.lang;
+                lang = ir.script.lang;
             }
         }
         if (lang && validLangs.has(lang)) {
@@ -82,9 +82,9 @@ const plugin = ({ modules: { typescript: ts }, vueCompilerOptions, }) => {
     }
 };
 exports.default = plugin;
-function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
+function useCodegen(ts, vueCompilerOptions, fileName, ir) {
     const getResolvedOptions = (0, alien_signals_1.computed)(() => {
-        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(sfc.comments);
+        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(ir.comments);
         if (options) {
             const resolver = new compilerOptions_1.CompilerOptionsResolver(ts, () => undefined /* does not support resolving target="auto" */);
             resolver.addConfig(options, path.dirname(fileName));
@@ -92,23 +92,23 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         }
         return vueCompilerOptions;
     });
-    const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script && validLangs.has(sfc.script.lang)
-        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, getResolvedOptions())
+    const getScriptRanges = (0, alien_signals_1.computed)(() => ir.script && validLangs.has(ir.script.lang)
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, ir.script.ast, getResolvedOptions())
         : undefined);
-    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup && validLangs.has(sfc.scriptSetup.lang)
-        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, sfc.scriptSetup.ast, getResolvedOptions())
+    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => ir.scriptSetup && validLangs.has(ir.scriptSetup.lang)
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, ir.scriptSetup.ast, getResolvedOptions())
         : undefined);
     const getImportedComponents = (0, signals_1.computedSet)(() => {
         const names = new Set();
         const scriptSetupRanges = getScriptSetupRanges();
-        if (sfc.scriptSetup && scriptSetupRanges) {
+        if (ir.scriptSetup && scriptSetupRanges) {
             for (const range of scriptSetupRanges.components) {
-                names.add(sfc.scriptSetup.content.slice(range.start, range.end));
+                names.add(ir.scriptSetup.content.slice(range.start, range.end));
             }
             const scriptRange = getScriptRanges();
-            if (sfc.script && scriptRange) {
+            if (ir.script && scriptRange) {
                 for (const range of scriptRange.components) {
-                    names.add(sfc.script.content.slice(range.start, range.end));
+                    names.add(ir.script.content.slice(range.start, range.end));
                 }
             }
         }
@@ -142,12 +142,12 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
     const getComponentName = (0, alien_signals_1.computed)(() => {
         let name;
         const componentOptions = getScriptRanges()?.exportDefault?.options;
-        if (sfc.script && componentOptions?.name) {
-            name = sfc.script.content.slice(componentOptions.name.start + 1, componentOptions.name.end - 1);
+        if (ir.script && componentOptions?.name) {
+            name = ir.script.content.slice(componentOptions.name.start + 1, componentOptions.name.end - 1);
         }
         else {
             const { defineOptions } = getScriptSetupRanges() ?? {};
-            if (sfc.scriptSetup && defineOptions?.name) {
+            if (ir.scriptSetup && defineOptions?.name) {
                 name = defineOptions.name;
             }
             else {
@@ -158,13 +158,13 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         return (0, shared_1.capitalize)((0, shared_1.camelize)(name));
     });
     const getGeneratedTemplate = (0, alien_signals_1.computed)(() => {
-        if (getResolvedOptions().skipTemplateCodegen || !sfc.template) {
+        if (getResolvedOptions().skipTemplateCodegen || !ir.template) {
             return;
         }
         return (0, template_1.generateTemplate)({
             typescript: ts,
             vueCompilerOptions: getResolvedOptions(),
-            template: sfc.template,
+            template: ir.template,
             componentName: getComponentName(),
             setupConsts: getSetupConsts(),
             setupRefs: getSetupRefs(),
@@ -175,13 +175,13 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         });
     });
     const getGeneratedStyle = (0, alien_signals_1.computed)(() => {
-        if (!sfc.styles.length) {
+        if (!ir.styles.length) {
             return;
         }
         return (0, style_1.generateStyle)({
             typescript: ts,
             vueCompilerOptions: getResolvedOptions(),
-            styles: sfc.styles,
+            styles: ir.styles,
             setupConsts: getSetupConsts(),
             setupRefs: getSetupRefs(),
         });
@@ -189,17 +189,17 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
     const getSetupExposed = (0, signals_1.computedSet)(() => {
         const allVars = new Set();
         const scriptSetupRanges = getScriptSetupRanges();
-        if (!sfc.scriptSetup || !scriptSetupRanges) {
+        if (!ir.scriptSetup || !scriptSetupRanges) {
             return allVars;
         }
         for (const range of scriptSetupRanges.bindings) {
-            const name = sfc.scriptSetup.content.slice(range.start, range.end);
+            const name = ir.scriptSetup.content.slice(range.start, range.end);
             allVars.add(name);
         }
         const scriptRanges = getScriptRanges();
-        if (sfc.script && scriptRanges) {
+        if (ir.script && scriptRanges) {
             for (const range of scriptRanges.bindings) {
-                const name = sfc.script.content.slice(range.start, range.end);
+                const name = ir.script.content.slice(range.start, range.end);
                 allVars.add(name);
             }
         }
@@ -209,15 +209,15 @@ function useCodegen(ts, vueCompilerOptions, fileName, sfc) {
         return new Set([
             ...getGeneratedTemplate()?.componentAccessMap.keys() ?? [],
             ...getGeneratedStyle()?.componentAccessMap.keys() ?? [],
-            ...sfc.template?.ast?.components.flatMap(name => [(0, shared_1.camelize)(name), (0, shared_1.capitalize)((0, shared_1.camelize)(name))]) ?? [],
+            ...ir.template?.ast?.components.flatMap(name => [(0, shared_1.camelize)(name), (0, shared_1.capitalize)((0, shared_1.camelize)(name))]) ?? [],
         ].filter(name => allVars.has(name)));
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
         return (0, script_1.generateScript)({
             vueCompilerOptions: getResolvedOptions(),
             fileName,
-            script: sfc.script,
-            scriptSetup: sfc.scriptSetup,
+            script: ir.script,
+            scriptSetup: ir.scriptSetup,
             exposed: getSetupExposed(),
             scriptRanges: getScriptRanges(),
             scriptSetupRanges: getScriptSetupRanges(),

package/lib/types.d.ts

@@ -16,6 +16,7 @@ export type RawPlugin = string | (Record<string, any> & {
 });
 export interface VueCodeInformation extends CodeInformation {
     __importCompletion?: boolean;
+    __propsCompletion?: boolean;
     __shorthandExpression?: 'html' | 'js';
     __combineToken?: symbol;
     __linkedToken?: symbol;
@@ -43,6 +44,7 @@ export interface VueCompilerOptions {
     inferTemplateDollarSlots: boolean;
     skipTemplateCodegen: boolean;
     fallthroughAttributes: boolean;
+    checkRequiredFallthroughAttributes: boolean;
     resolveStyleImports: boolean;
     resolveStyleClassNames: boolean | 'scoped';
     fallthroughComponentNames: string[];
@@ -85,17 +87,17 @@ export interface VueLanguagePluginReturn {
     resolveTemplateCompilerOptions?(options: CompilerDOM.CompilerOptions): CompilerDOM.CompilerOptions;
     compileSFCScript?(lang: string, script: string): ts.SourceFile | undefined;
     compileSFCTemplate?(lang: string, template: string, options: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult | undefined;
-    compileSFCStyle?(lang: string, style: string): Pick<Sfc['styles'][number], 'imports' | 'bindings' | 'classNames'> | undefined;
+    compileSFCStyle?(lang: string, style: string): Pick<IRStyle, 'imports' | 'bindings' | 'classNames'> | undefined;
     updateSFCTemplate?(oldResult: CompilerDOM.CodegenResult, textChange: {
         start: number;
         end: number;
         newText: string;
     }): CompilerDOM.CodegenResult | undefined;
-    getEmbeddedCodes?(fileName: string, sfc: Sfc): {
+    getEmbeddedCodes?(fileName: string, ir: IR): {
         id: string;
         lang: string;
     }[];
-    resolveEmbeddedCode?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedCode): void;
+    resolveEmbeddedCode?(fileName: string, ir: IR, embeddedFile: VueEmbeddedCode): void;
 }
 export type VueLanguagePlugin<T extends Record<string, any> = {}> = (ctx: {
     modules: {
@@ -107,7 +109,20 @@ export type VueLanguagePlugin<T extends Record<string, any> = {}> = (ctx: {
     vueCompilerOptions: VueCompilerOptions;
     config: T;
 }) => VueLanguagePluginReturn | VueLanguagePluginReturn[];
-export interface SfcBlock {
+export interface IR {
+    content: string;
+    comments: string[];
+    template: IRTemplate | undefined;
+    script: IRScript | undefined;
+    scriptSetup: IRScriptSetup | undefined;
+    styles: readonly IRStyle[];
+    customBlocks: readonly IRCustomBlock[];
+}
+export type IRAttr = true | {
+    text: string;
+    offset: number;
+};
+export interface IRBlock {
     name: string;
     start: number;
     end: number;
@@ -117,57 +132,48 @@ export interface SfcBlock {
     content: string;
     attrs: Record<string, string | true>;
 }
-export type SfcBlockAttr = true | {
-    text: string;
-    offset: number;
-    quotes: boolean;
-};
-export interface Sfc {
-    content: string;
-    comments: string[];
-    template: (SfcBlock & {
-        ast: CompilerDOM.RootNode | undefined;
-        errors: CompilerDOM.CompilerError[];
-        warnings: CompilerDOM.CompilerError[];
-    }) | undefined;
-    script: (SfcBlock & {
-        src: SfcBlockAttr | undefined;
-        ast: ts.SourceFile;
-    }) | undefined;
-    scriptSetup: (SfcBlock & {
-        generic: SfcBlockAttr | undefined;
-        ast: ts.SourceFile;
-    }) | undefined;
-    styles: readonly (SfcBlock & {
-        src: SfcBlockAttr | undefined;
-        module: SfcBlockAttr | undefined;
-        scoped: boolean;
-        imports: {
-            text: string;
-            offset: number;
-        }[];
-        bindings: {
-            text: string;
-            offset: number;
-        }[];
-        classNames: {
-            text: string;
-            offset: number;
-        }[];
-    })[];
-    customBlocks: readonly (SfcBlock & {
-        type: string;
-    })[];
+export interface IRTemplate extends IRBlock {
+    ast: CompilerDOM.RootNode | undefined;
+    errors: CompilerDOM.CompilerError[];
+    warnings: CompilerDOM.CompilerError[];
+}
+export interface IRScript extends IRBlock {
+    src: IRAttr | undefined;
+    ast: ts.SourceFile;
+}
+export interface IRScriptSetup extends IRBlock {
+    generic: IRAttr | undefined;
+    ast: ts.SourceFile;
+}
+export interface IRStyle extends IRBlock {
+    src: IRAttr | undefined;
+    module: IRAttr | undefined;
+    scoped: boolean;
+    imports: {
+        text: string;
+        offset: number;
+    }[];
+    bindings: {
+        text: string;
+        offset: number;
+    }[];
+    classNames: {
+        text: string;
+        offset: number;
+    }[];
+}
+export interface IRCustomBlock extends IRBlock {
+    type: string;
 }
 declare module '@vue/compiler-sfc' {
     interface SFCBlock {
-        __src?: SfcBlockAttr;
+        __src?: IRAttr;
     }
     interface SFCScriptBlock {
-        __generic?: SfcBlockAttr;
+        __generic?: IRAttr;
     }
     interface SFCStyleBlock {
-        __module?: SfcBlockAttr;
+        __module?: IRAttr;
     }
 }
 export interface TextRange<Node extends ts.Node = ts.Node> {

package/lib/utils/parseSfc.js

@@ -179,7 +179,6 @@ function parseAttr(p, node) {
     return {
         text: content,
         offset: offset - node.loc.start.offset,
-        quotes: offset > p.value.loc.start.offset,
     };
 }
 //# sourceMappingURL=parseSfc.js.map

package/lib/utils/shared.d.ts

@@ -1,9 +1,9 @@
 import type * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
-import type { Sfc, TextRange } from '../types';
+import type { IRTemplate, TextRange } from '../types';
 export { hyphenate as hyphenateTag } from '@vue/shared';
 export declare function hyphenateAttr(str: string): string;
 export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): readonly [string, number];
-export declare function getElementTagOffsets(node: CompilerDOM.ElementNode, template: NonNullable<Sfc['template']>): [number] | [number, number];
+export declare function getElementTagOffsets(node: CompilerDOM.ElementNode, template: IRTemplate): [number] | [number, number];
 export declare function getStartEnd<T extends ts.Node>(ts: typeof import('typescript'), node: T, ast: ts.SourceFile): TextRange<T>;
 export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;

package/lib/virtualCode/embeddedCodes.d.ts

@@ -1,5 +1,5 @@
 import type { Mapping, VirtualCode } from '@volar/language-core';
-import type { Code, Sfc, VueLanguagePluginReturn } from '../types';
+import type { Code, IR, VueLanguagePluginReturn } from '../types';
 export declare class VueEmbeddedCode {
     id: string;
     lang: string;
@@ -9,4 +9,4 @@ export declare class VueEmbeddedCode {
     embeddedCodes: VueEmbeddedCode[];
     constructor(id: string, lang: string, content: Code[]);
 }
-export declare function useEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): () => VirtualCode[];
+export declare function useEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, ir: IR): () => VirtualCode[];