@vue/language-core 2.1.10 → 2.2.2

package/lib/codegen/template/templateChild.js

@@ -4,12 +4,13 @@ exports.generateTemplateChild = generateTemplateChild;
 exports.getVForNode = getVForNode;
 exports.parseInterpolationNode = parseInterpolationNode;
 const CompilerDOM = require("@vue/compiler-dom");
-const common_1 = require("../common");
+const utils_1 = require("../utils");
 const element_1 = require("./element");
 const interpolation_1 = require("./interpolation");
 const slotOutlet_1 = require("./slotOutlet");
 const vFor_1 = require("./vFor");
 const vIf_1 = require("./vIf");
+const vSlot_1 = require("./vSlot");
 // @ts-ignore
 const transformContext = {
     onError: () => { },
@@ -25,19 +26,29 @@ const transformContext = {
     },
     expressionPlugins: ['typescript'],
 };
-function* generateTemplateChild(options, ctx, node, currentComponent, prevNode, componentCtxVar, isVForChild = false) {
+function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = false) {
     if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
         const commentText = prevNode.content.trim().split(' ')[0];
-        if (commentText.match(/^@vue-skip\b[\s\S]*/)) {
-            yield `// @vue-skip${common_1.newLine}`;
+        if (/^@vue-skip\b[\s\S]*/.test(commentText)) {
+            yield `// @vue-skip${utils_1.newLine}`;
             return;
         }
-        else if (commentText.match(/^@vue-ignore\b[\s\S]*/)) {
+        else if (/^@vue-ignore\b[\s\S]*/.test(commentText)) {
             yield* ctx.ignoreError();
         }
-        else if (commentText.match(/^@vue-expect-error\b[\s\S]*/)) {
+        else if (/^@vue-expect-error\b[\s\S]*/.test(commentText)) {
             yield* ctx.expectError(prevNode);
         }
+        else {
+            const match = prevNode.loc.source.match(/^<!--\s*@vue-generic\b\s*\{(?<content>[^}]*)\}/);
+            if (match) {
+                const { content } = match.groups ?? {};
+                ctx.lastGenericComment = {
+                    content,
+                    offset: prevNode.loc.start.offset + match[0].indexOf(content)
+                };
+            }
+        }
     }
     const shouldInheritRootNodeAttrs = options.inheritAttrs;
     const cur = node;
@@ -50,7 +61,7 @@ function* generateTemplateChild(options, ctx, node, currentComponent, prevNode,
             ctx.singleRootNode = node.children[0];
         }
         for (const childNode of node.children) {
-            yield* generateTemplateChild(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+            yield* generateTemplateChild(options, ctx, childNode, prev);
             prev = childNode;
         }
         yield* ctx.resetDirectiveComments('end of root');
@@ -59,49 +70,57 @@ function* generateTemplateChild(options, ctx, node, currentComponent, prevNode,
         const vForNode = getVForNode(node);
         const vIfNode = getVIfNode(node);
         if (vForNode) {
-            yield* (0, vFor_1.generateVFor)(options, ctx, vForNode, currentComponent, componentCtxVar);
+            yield* (0, vFor_1.generateVFor)(options, ctx, vForNode);
         }
         else if (vIfNode) {
-            yield* (0, vIf_1.generateVIf)(options, ctx, vIfNode, currentComponent, componentCtxVar);
+            yield* (0, vIf_1.generateVIf)(options, ctx, vIfNode);
+        }
+        else if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
+            yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
         }
         else {
-            if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
-                yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node, currentComponent, componentCtxVar);
+            const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
+            if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE
+                && ctx.currentComponent
+                && slotDir) {
+                yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir);
             }
             else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
                 || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
-                yield* (0, element_1.generateElement)(options, ctx, node, currentComponent, componentCtxVar, isVForChild);
+                yield* (0, element_1.generateElement)(options, ctx, node, isVForChild);
             }
             else {
-                yield* (0, element_1.generateComponent)(options, ctx, node, currentComponent);
+                const { currentComponent } = ctx;
+                yield* (0, element_1.generateComponent)(options, ctx, node);
+                ctx.currentComponent = currentComponent;
             }
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
         // {{ var }}
-        yield* generateTemplateChild(options, ctx, node.content, currentComponent, undefined, componentCtxVar);
+        yield* generateTemplateChild(options, ctx, node.content, undefined);
     }
     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
         // {{ ... }} {{ ... }}
         for (const childNode of node.children) {
             if (typeof childNode === 'object') {
-                yield* generateTemplateChild(options, ctx, childNode, currentComponent, undefined, componentCtxVar);
+                yield* generateTemplateChild(options, ctx, childNode, undefined);
             }
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
         // {{ ... }}
         const [content, start] = parseInterpolationNode(node, options.template.content);
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, content, node.content.loc, start, ctx.codeFeatures.all, `(`, `)${common_1.endOfLine}`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, content, start, node.content.loc, `(`, `)${utils_1.endOfLine}`);
         yield* ctx.resetDirectiveComments('end of INTERPOLATION');
     }
     else if (node.type === CompilerDOM.NodeTypes.IF) {
         // v-if / v-else-if / v-else
-        yield* (0, vIf_1.generateVIf)(options, ctx, node, currentComponent, componentCtxVar);
+        yield* (0, vIf_1.generateVIf)(options, ctx, node);
     }
     else if (node.type === CompilerDOM.NodeTypes.FOR) {
         // v-for
-        yield* (0, vFor_1.generateVFor)(options, ctx, node, currentComponent, componentCtxVar);
+        yield* (0, vFor_1.generateVFor)(options, ctx, node);
     }
     else if (node.type === CompilerDOM.NodeTypes.TEXT) {
         // not needed progress
@@ -152,11 +171,11 @@ function parseInterpolationNode(node, template) {
     let leftCharacter;
     let rightCharacter;
     // fix https://github.com/vuejs/language-tools/issues/1787
-    while ((leftCharacter = template.substring(start - 1, start)).trim() === '' && leftCharacter.length) {
+    while ((leftCharacter = template.slice(start - 1, start)).trim() === '' && leftCharacter.length) {
         start--;
         content = leftCharacter + content;
     }
-    while ((rightCharacter = template.substring(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
+    while ((rightCharacter = template.slice(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
         content = content + rightCharacter;
     }
     return [

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

@@ -2,7 +2,7 @@ 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 generateVFor(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ForNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateVFor(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ForNode): Generator<Code>;
 export declare function parseVForNode(node: CompilerDOM.ForNode): {
     leftExpressionRange: {
         start: number;

package/lib/codegen/template/vFor.js

@@ -3,17 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVFor = generateVFor;
 exports.parseVForNode = parseVForNode;
 const CompilerDOM = require("@vue/compiler-dom");
-const common_1 = require("../common");
+const utils_1 = require("../utils");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
-function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
+function* generateVFor(options, ctx, node) {
     const { source } = node.parseResult;
     const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
     const forBlockVars = [];
     yield `for (const [`;
     if (leftExpressionRange && leftExpressionText) {
-        const collectAst = (0, common_1.createTsAst)(options.ts, node.parseResult, `const [${leftExpressionText}]`);
-        (0, common_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
+        const collectAst = (0, utils_1.createTsAst)(options.ts, node.parseResult, `const [${leftExpressionText}]`);
+        (0, utils_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
         yield [
             leftExpressionText,
             'template',
@@ -24,13 +24,13 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
     yield `] of `;
     if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         yield `__VLS_getVForSourceType(`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, source.content, source.loc, source.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, source.content, source.loc.start.offset, source.loc, '(', ')');
         yield `!)`; // #3102
     }
     else {
         yield `{} as any`;
     }
-    yield `) {${common_1.newLine}`;
+    yield `) {${utils_1.newLine}`;
     for (const varName of forBlockVars) {
         ctx.addLocalVariable(varName);
     }
@@ -46,8 +46,8 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
             for (const prop of argument.returns.props.properties) {
                 if (prop.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                     && !prop.value.isStatic) {
-                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.value.content, prop.value.loc, prop.value.loc.start.offset, ctx.codeFeatures.all, '(', ')');
-                    yield common_1.endOfLine;
+                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, prop.value.loc, '(', ')');
+                    yield utils_1.endOfLine;
                 }
             }
         }
@@ -57,14 +57,14 @@ function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
     }
     let prev;
     for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar, true);
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev, true);
         prev = childNode;
     }
     for (const varName of forBlockVars) {
         ctx.removeLocalVariable(varName);
     }
     yield* ctx.generateAutoImportCompletion();
-    yield `}${common_1.newLine}`;
+    yield `}${utils_1.newLine}`;
 }
 function parseVForNode(node) {
     const { value, key, index } = node.parseResult;
@@ -75,7 +75,7 @@ function parseVForNode(node) {
         }
         : undefined;
     const leftExpressionText = leftExpressionRange
-        ? node.loc.source.substring(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
+        ? node.loc.source.slice(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
         : undefined;
     return {
         leftExpressionRange,

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

@@ -2,4 +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 generateVIf(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.IfNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function generateVIf(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.IfNode): Generator<Code>;

package/lib/codegen/template/vIf.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVIf = generateVIf;
 const CompilerDOM = require("@vue/compiler-dom");
 const muggle_string_1 = require("muggle-string");
-const common_1 = require("../common");
+const utils_1 = require("../utils");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
-function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
+function* generateVIf(options, ctx, node) {
     let originalBlockConditionsLength = ctx.blockConditions.length;
     for (let i = 0; i < node.branches.length; i++) {
         const branch = node.branches[i];
@@ -22,7 +22,7 @@ function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
         let addedBlockCondition = false;
         if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
             const codes = [
-                ...(0, interpolation_1.generateInterpolation)(options, ctx, branch.condition.content, branch.condition.loc, branch.condition.loc.start.offset, ctx.codeFeatures.all, '(', ')'),
+                ...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, branch.condition.loc, '(', ')'),
             ];
             for (const code of codes) {
                 yield code;
@@ -31,17 +31,17 @@ function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
             addedBlockCondition = true;
             yield ` `;
         }
-        yield `{${common_1.newLine}`;
+        yield `{${utils_1.newLine}`;
         if (isFragment(node)) {
             yield* ctx.resetDirectiveComments('end of v-if start');
         }
         let prev;
         for (const childNode of branch.children) {
-            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
             prev = childNode;
         }
         yield* ctx.generateAutoImportCompletion();
-        yield `}${common_1.newLine}`;
+        yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {
             ctx.blockConditions[ctx.blockConditions.length - 1] = `!(${ctx.blockConditions[ctx.blockConditions.length - 1]})`;
         }

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

@@ -0,0 +1,5 @@
+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>;

package/lib/codegen/template/vSlot.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVSlot = generateVSlot;
+const CompilerDOM = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+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);
+    }
+    else {
+        yield* (0, utils_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+    }
+    yield `: __VLS_thisSlot } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
+    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}`;
+        }
+        else {
+            yield `const `;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${utils_1.endOfLine}`;
+        }
+    }
+    for (const varName of slotBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    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;
+    }
+    for (const varName of slotBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    let isStatic = true;
+    if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        isStatic = slotDir.arg.isStatic;
+    }
+    if (isStatic && !slotDir.arg) {
+        yield `${ctx.currentComponent.ctxVar}.slots!['`;
+        yield [
+            '',
+            'template',
+            slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+                ? '#'.length
+                : slotDir.loc.source.startsWith('v-slot:')
+                    ? 'v-slot:'.length
+                    : 0),
+            ctx.codeFeatures.completion,
+        ];
+        yield `'/* empty slot name completion */]${utils_1.endOfLine}`;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${utils_1.newLine}`;
+}
+//# sourceMappingURL=vSlot.js.map

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

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateCamelized(code: string, offset: number, info: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/camelized.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCamelized = generateCamelized;
+const shared_1 = require("@vue/shared");
+const index_1 = require("./index");
+function* generateCamelized(code, offset, info) {
+    const parts = code.split('-');
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part !== '') {
+            if (i === 0) {
+                yield [
+                    part,
+                    'template',
+                    offset,
+                    info,
+                ];
+            }
+            else {
+                yield [
+                    (0, shared_1.capitalize)(part),
+                    'template',
+                    offset,
+                    index_1.combineLastMapping,
+                ];
+            }
+        }
+        offset += part.length + 1;
+    }
+}
+//# sourceMappingURL=camelized.js.map

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

@@ -0,0 +1,21 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import type { Code, SfcBlock, VueCodeInformation } from '../../types';
+export declare const newLine = "\n";
+export declare const endOfLine = ";\n";
+export declare const combineLastMapping: VueCodeInformation;
+export declare const variableNameRegex: RegExp;
+export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
+export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[]): string[];
+export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[], isRest?: boolean, initializer?: ts.Expression | undefined): {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[];
+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;

package/lib/codegen/utils/index.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
+exports.wrapWith = wrapWith;
+exports.collectVars = collectVars;
+exports.collectIdentifiers = collectIdentifiers;
+exports.normalizeAttributeValue = normalizeAttributeValue;
+exports.createTsAst = createTsAst;
+exports.generateSfcBlockSection = generateSfcBlockSection;
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+exports.newLine = `\n`;
+exports.endOfLine = `;${exports.newLine}`;
+exports.combineLastMapping = { __combineLastMapping: true };
+exports.variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
+    yield ['', 'template', startOffset, features];
+    let offset = 1;
+    for (const wrapCode of wrapCodes) {
+        if (typeof wrapCode !== 'string') {
+            offset++;
+        }
+        yield wrapCode;
+    }
+    yield ['', 'template', endOffset, { __combineOffsetMapping: offset }];
+}
+function collectVars(ts, node, ast, results = []) {
+    const identifiers = collectIdentifiers(ts, node, []);
+    for (const { id } of identifiers) {
+        results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
+    }
+    return results;
+}
+function collectIdentifiers(ts, node, results = [], isRest = false, initializer = undefined) {
+    if (ts.isIdentifier(node)) {
+        results.push({ id: node, isRest, initializer });
+    }
+    else if (ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken, el.initializer);
+        }
+    }
+    else if (ts.isArrayBindingPattern(node)) {
+        for (const el of node.elements) {
+            if (ts.isBindingElement(el)) {
+                collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
+            }
+        }
+    }
+    else {
+        ts.forEachChild(node, node => collectIdentifiers(ts, node, results, false));
+    }
+    return results;
+}
+function normalizeAttributeValue(node) {
+    let offset = node.loc.start.offset;
+    let content = node.loc.source;
+    if ((content.startsWith(`'`) && content.endsWith(`'`))
+        || (content.startsWith(`"`) && content.endsWith(`"`))) {
+        offset++;
+        content = content.slice(1, -1);
+    }
+    return [content, offset];
+}
+function createTsAst(ts, astHolder, text) {
+    if (astHolder.__volar_ast_text !== text) {
+        astHolder.__volar_ast_text = text;
+        astHolder.__volar_ast = ts.createSourceFile('/a.ts', text, 99);
+    }
+    return astHolder.__volar_ast;
+}
+function generateSfcBlockSection(block, start, end, features) {
+    return [
+        block.content.slice(start, end),
+        block.name,
+        start,
+        features,
+    ];
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,2 @@
+import { Code, SfcBlockAttr, VueCodeInformation } from "../../types";
+export declare function generateSfcBlockSrc(src: SfcBlockAttr & object, text: string, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/src.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSfcBlockSrc = generateSfcBlockSrc;
+function* generateSfcBlockSrc(src, text, features) {
+    const { offset, quotes } = src;
+    if (!quotes) {
+        yield [``, 'main', offset, { verification: true }];
+    }
+    yield [
+        quotes ? text : `'${text}'`,
+        'main',
+        quotes ? offset : offset - 1,
+        features
+    ];
+    if (!quotes) {
+        yield [``, 'main', offset + text.length, { __combineOffsetMapping: 2 }];
+    }
+}
+//# sourceMappingURL=src.js.map

package/lib/codegen/{template → utils}/stringLiteralKey.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStringLiteralKey = generateStringLiteralKey;
-const common_1 = require("../common");
+const index_1 = require("./index");
 function* generateStringLiteralKey(code, offset, info) {
     if (offset === undefined || !info) {
-        yield `"${code}"`;
+        yield `'${code}'`;
     }
     else {
-        yield* (0, common_1.wrapWith)(offset, offset + code.length, info, `"`, [code, 'template', offset, common_1.combineLastMapping], `"`);
+        yield* (0, index_1.wrapWith)(offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
     }
 }
 //# sourceMappingURL=stringLiteralKey.js.map

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

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateUnicode(code: string, offset: number, info: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/unicode.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnicode = generateUnicode;
+const index_1 = require("./index");
+function* generateUnicode(code, offset, info) {
+    if (needToUnicode(code)) {
+        yield* (0, index_1.wrapWith)(offset, offset + code.length, info, toUnicode(code));
+    }
+    else {
+        yield [code, 'template', offset, info];
+    }
+}
+function needToUnicode(str) {
+    return str.includes('\\') || str.includes('\n');
+}
+function toUnicode(str) {
+    return str.split('').map(value => {
+        const temp = value.charCodeAt(0).toString(16).padStart(4, '0');
+        if (temp.length > 2) {
+            return '\\u' + temp;
+        }
+        return value;
+    }).join('');
+}
+//# sourceMappingURL=unicode.js.map

package/lib/languagePlugin.js

@@ -90,7 +90,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
             getServiceScript(root) {
                 for (const code of (0, language_core_1.forEachEmbeddedCode)(root)) {
                     if (/script_(js|jsx|ts|tsx)/.test(code.id)) {
-                        const lang = code.id.substring('script_'.length);
+                        const lang = code.id.slice('script_'.length);
                         return {
                             code,
                             extension: '.' + lang,

package/lib/parsers/scriptRanges.d.ts

@@ -1,5 +1,5 @@
-import type { TextRange } from '../types';
 import type * as ts from 'typescript';
+import type { TextRange } from '../types';
 export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 }
 export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean, withNode: boolean): {
@@ -14,5 +14,10 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), ast:
         inheritAttrsOption: string | undefined;
     }) | undefined;
     classBlockEnd: number | undefined;
-    bindings: TextRange[];
+    bindings: {
+        range: TextRange;
+        moduleName?: string;
+        isDefaultImport?: boolean;
+        isNamespace?: boolean;
+    }[];
 };