@vue/language-core 3.1.5 → 3.1.6

package/lib/codegen/template/interpolation.js

@@ -5,12 +5,12 @@ const shared_1 = require("@vue/shared");
 const collectBindings_1 = require("../../utils/collectBindings");
 const shared_2 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
+const names = require("../names");
 const utils_1 = require("../utils");
 // https://github.com/vuejs/core/blob/fb0c3ca519f1fccf52049cd6b8db3a67a669afe9/packages/compiler-core/src/transforms/transformExpression.ts#L47
 const isLiteralWhitelisted = /*@__PURE__*/ (0, shared_1.makeMap)('true,false,null,this');
-function* generateInterpolation(options, ctx, source, data, code, start, prefix = '', suffix = '') {
-    const { ts, destructuredPropNames, templateRefNames, } = options;
-    for (const segment of forEachInterpolationSegment(ts, ctx.inlineTsAsts, destructuredPropNames, templateRefNames, ctx, code, start, prefix, suffix)) {
+function* generateInterpolation(options, ctx, block, data, code, start, prefix = '', suffix = '') {
+    for (const segment of forEachInterpolationSegment(options, ctx, block, code, start, prefix, suffix)) {
         if (typeof segment === 'string') {
             yield segment;
             continue;
@@ -28,222 +28,176 @@ function* generateInterpolation(options, ctx, source, data, code, start, prefix
             section = section.slice(-offset);
             offset = 0;
         }
-        const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
+        const shouldSkip = section.length === 0 && type === 'startEnd';
         if (!shouldSkip) {
-            if (start !== undefined && data) {
-                yield [
-                    section,
-                    source,
-                    start + offset,
-                    type === 'errorMappingOnly'
-                        ? codeFeatures_1.codeFeatures.verification
-                        : typeof data === 'function'
-                            ? data(start + offset)
-                            : data,
-                ];
-            }
-            else {
-                yield section;
-            }
+            yield [
+                section,
+                block.name,
+                start + offset,
+                type === 'errorMappingOnly'
+                    ? codeFeatures_1.codeFeatures.verification
+                    : data,
+            ];
         }
         yield addSuffix;
     }
 }
-function* forEachInterpolationSegment(ts, inlineTsAsts, destructuredPropNames, templateRefNames, ctx, originalCode, start, prefix, suffix) {
+function* forEachInterpolationSegment({ ts, setupRefs }, ctx, block, originalCode, start, prefix, suffix) {
     const code = prefix + originalCode + suffix;
-    const offset = start !== undefined ? start - prefix.length : undefined;
-    let ctxVars = [];
-    if (utils_1.identifierRegex.test(originalCode) && !shouldIdentifierSkipped(ctx, originalCode, destructuredPropNames)) {
-        ctxVars.push({
-            text: originalCode,
-            offset: prefix.length,
-        });
-    }
-    else {
-        const ast = (0, utils_1.createTsAst)(ts, inlineTsAsts, code);
-        const varCb = (id, isShorthand) => {
-            const text = (0, shared_2.getNodeText)(ts, id, ast);
-            if (!shouldIdentifierSkipped(ctx, text, destructuredPropNames)) {
-                ctxVars.push({
-                    text,
-                    offset: (0, shared_2.getStartEnd)(ts, id, ast).start,
-                    isShorthand,
-                });
-            }
-        };
-        ts.forEachChild(ast, node => walkIdentifiers(ts, node, ast, varCb, ctx, [], true));
-    }
-    ctxVars = ctxVars.sort((a, b) => a.offset - b.offset);
-    if (ctxVars.length) {
-        for (let i = 0; i < ctxVars.length; i++) {
-            const lastVar = ctxVars[i - 1];
-            const curVar = ctxVars[i];
-            const lastVarEnd = lastVar ? lastVar.offset + lastVar.text.length : 0;
-            if (curVar.isShorthand) {
-                yield [code.slice(lastVarEnd, curVar.offset + curVar.text.length), lastVarEnd];
-                yield `: `;
+    let prevEnd = 0;
+    for (const [name, offset, isShorthand] of forEachIdentifiers(ts, ctx, block, originalCode, code, prefix)) {
+        if (isShorthand) {
+            yield [code.slice(prevEnd, offset + name.length), prevEnd];
+            yield `: `;
+        }
+        else {
+            yield [code.slice(prevEnd, offset), prevEnd, prevEnd > 0 ? undefined : 'startEnd'];
+        }
+        if (setupRefs.has(name)) {
+            yield [name, offset];
+            yield `.value`;
+        }
+        else {
+            yield ['', offset, 'errorMappingOnly']; // #1205, #1264
+            if (ctx.dollarVars.has(name)) {
+                yield names.dollars;
             }
             else {
-                yield [code.slice(lastVarEnd, curVar.offset), lastVarEnd, i ? undefined : 'startText'];
+                ctx.recordComponentAccess(block.name, name, start - prefix.length + offset);
+                yield names.ctx;
             }
-            yield* generateVar(templateRefNames, ctx, code, offset, curVar);
-        }
-        const lastVar = ctxVars.at(-1);
-        if (lastVar.offset + lastVar.text.length < code.length) {
-            yield [code.slice(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length, 'endText'];
+            yield `.`;
+            yield [name, offset];
         }
+        prevEnd = offset + name.length;
     }
-    else {
-        yield [code, 0];
+    if (prevEnd < code.length) {
+        yield [code.slice(prevEnd), prevEnd, 'startEnd'];
     }
 }
-function* generateVar(templateRefNames, ctx, code, offset, curVar) {
-    // fix https://github.com/vuejs/language-tools/issues/1205
-    // fix https://github.com/vuejs/language-tools/issues/1264
-    yield ['', curVar.offset, 'errorMappingOnly'];
-    const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
-    if (isTemplateRef) {
-        yield `__VLS_unref(`;
-        yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
-        yield `)`;
-    }
-    else {
-        if (offset !== undefined) {
-            ctx.accessExternalVariable(curVar.text, offset + curVar.offset);
-        }
-        else {
-            ctx.accessExternalVariable(curVar.text);
-        }
-        if (ctx.dollarVars.has(curVar.text)) {
-            yield `__VLS_dollars.`;
-        }
-        else {
-            yield `__VLS_ctx.`;
+function* forEachIdentifiers(ts, ctx, block, originalCode, code, prefix) {
+    if (utils_1.identifierRegex.test(originalCode) && !shouldIdentifierSkipped(ctx, originalCode)) {
+        yield [originalCode, prefix.length, false];
+        return;
+    }
+    const endScope = ctx.startScope();
+    const ast = (0, utils_1.getTypeScriptAST)(ts, block, code);
+    for (const [id, isShorthand] of forEachDeclarations(ts, ast, ast, ctx)) {
+        const text = (0, shared_2.getNodeText)(ts, id, ast);
+        if (shouldIdentifierSkipped(ctx, text)) {
+            continue;
         }
-        yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+        yield [text, (0, shared_2.getStartEnd)(ts, id, ast).start, isShorthand];
     }
+    endScope();
 }
-function walkIdentifiers(ts, node, ast, cb, ctx, blockVars, isRoot = false) {
+function* forEachDeclarations(ts, node, ast, ctx) {
     if (ts.isIdentifier(node)) {
-        cb(node, false);
+        yield [node, false];
     }
     else if (ts.isShorthandPropertyAssignment(node)) {
-        cb(node.name, true);
+        yield [node.name, true];
     }
     else if (ts.isPropertyAccessExpression(node)) {
-        walkIdentifiers(ts, node.expression, ast, cb, ctx, blockVars);
+        yield* forEachDeclarations(ts, node.expression, ast, ctx);
     }
     else if (ts.isVariableDeclaration(node)) {
-        const bindingNames = (0, collectBindings_1.collectBindingNames)(ts, node.name, ast);
-        for (const name of bindingNames) {
-            ctx.addLocalVariable(name);
-            blockVars.push(name);
-        }
-        walkIdentifiersInBinding(ts, node, ast, cb, ctx, blockVars);
+        ctx.declare(...(0, collectBindings_1.collectBindingNames)(ts, node.name, ast));
+        yield* forEachDeclarationsInBinding(ts, node, ast, ctx);
     }
     else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
         for (const element of node.elements) {
             if (ts.isBindingElement(element)) {
-                walkIdentifiersInBinding(ts, element, ast, cb, ctx, blockVars);
+                yield* forEachDeclarationsInBinding(ts, element, ast, ctx);
             }
         }
     }
     else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-        walkIdentifiersInFunction(ts, node, ast, cb, ctx);
+        yield* forEachDeclarationsInFunction(ts, node, ast, ctx);
     }
     else if (ts.isObjectLiteralExpression(node)) {
         for (const prop of node.properties) {
             if (ts.isPropertyAssignment(prop)) {
                 // fix https://github.com/vuejs/language-tools/issues/1176
                 if (ts.isComputedPropertyName(prop.name)) {
-                    walkIdentifiers(ts, prop.name.expression, ast, cb, ctx, blockVars);
+                    yield* forEachDeclarations(ts, prop.name.expression, ast, ctx);
                 }
-                walkIdentifiers(ts, prop.initializer, ast, cb, ctx, blockVars);
+                yield* forEachDeclarations(ts, prop.initializer, ast, ctx);
             }
             // fix https://github.com/vuejs/language-tools/issues/1156
             else if (ts.isShorthandPropertyAssignment(prop)) {
-                walkIdentifiers(ts, prop, ast, cb, ctx, blockVars);
+                yield* forEachDeclarations(ts, prop, ast, ctx);
             }
             // fix https://github.com/vuejs/language-tools/issues/1148#issuecomment-1094378126
             else if (ts.isSpreadAssignment(prop)) {
                 // TODO: cannot report "Spread types may only be created from object types.ts(2698)"
-                walkIdentifiers(ts, prop.expression, ast, cb, ctx, blockVars);
+                yield* forEachDeclarations(ts, prop.expression, ast, ctx);
             }
             // fix https://github.com/vuejs/language-tools/issues/4604
             else if (ts.isFunctionLike(prop) && prop.body) {
-                walkIdentifiersInFunction(ts, prop, ast, cb, ctx);
+                yield* forEachDeclarationsInFunction(ts, prop, ast, ctx);
             }
         }
     }
     // fix https://github.com/vuejs/language-tools/issues/1422
     else if (ts.isTypeNode(node)) {
-        walkIdentifiersInTypeNode(ts, node, cb);
+        yield* forEachDeclarationsInTypeNode(ts, node);
     }
-    else {
-        const _blockVars = blockVars;
-        if (ts.isBlock(node)) {
-            blockVars = [];
-        }
-        ts.forEachChild(node, node => walkIdentifiers(ts, node, ast, cb, ctx, blockVars));
-        if (ts.isBlock(node)) {
-            for (const varName of blockVars) {
-                ctx.removeLocalVariable(varName);
-            }
+    else if (ts.isBlock(node)) {
+        const endScope = ctx.startScope();
+        for (const child of (0, utils_1.forEachNode)(ts, node)) {
+            yield* forEachDeclarations(ts, child, ast, ctx);
         }
-        blockVars = _blockVars;
+        endScope();
     }
-    if (isRoot) {
-        for (const varName of blockVars) {
-            ctx.removeLocalVariable(varName);
+    else {
+        for (const child of (0, utils_1.forEachNode)(ts, node)) {
+            yield* forEachDeclarations(ts, child, ast, ctx);
         }
     }
 }
-function walkIdentifiersInBinding(ts, node, ast, cb, ctx, blockVars) {
+function* forEachDeclarationsInBinding(ts, node, ast, ctx) {
     if ('type' in node && node.type) {
-        walkIdentifiersInTypeNode(ts, node.type, cb);
+        yield* forEachDeclarationsInTypeNode(ts, node.type);
     }
     if (!ts.isIdentifier(node.name)) {
-        walkIdentifiers(ts, node.name, ast, cb, ctx, blockVars);
+        yield* forEachDeclarations(ts, node.name, ast, ctx);
     }
     if (node.initializer) {
-        walkIdentifiers(ts, node.initializer, ast, cb, ctx, blockVars);
+        yield* forEachDeclarations(ts, node.initializer, ast, ctx);
     }
 }
-function walkIdentifiersInFunction(ts, node, ast, cb, ctx) {
-    const functionArgs = [];
+function* forEachDeclarationsInFunction(ts, node, ast, ctx) {
+    const endScope = ctx.startScope();
     for (const param of node.parameters) {
-        functionArgs.push(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
-        walkIdentifiersInBinding(ts, param, ast, cb, ctx, functionArgs);
-    }
-    for (const varName of functionArgs) {
-        ctx.addLocalVariable(varName);
+        ctx.declare(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
+        yield* forEachDeclarationsInBinding(ts, param, ast, ctx);
     }
     if (node.body) {
-        walkIdentifiers(ts, node.body, ast, cb, ctx, [], true);
-    }
-    for (const varName of functionArgs) {
-        ctx.removeLocalVariable(varName);
+        yield* forEachDeclarations(ts, node.body, ast, ctx);
     }
+    endScope();
 }
-function walkIdentifiersInTypeNode(ts, node, cb) {
+function* forEachDeclarationsInTypeNode(ts, node) {
     if (ts.isTypeQueryNode(node)) {
         let id = node.exprName;
         while (!ts.isIdentifier(id)) {
             id = id.left;
         }
-        cb(id, false);
+        yield [id, false];
     }
     else {
-        ts.forEachChild(node, node => walkIdentifiersInTypeNode(ts, node, cb));
+        for (const child of (0, utils_1.forEachNode)(ts, node)) {
+            yield* forEachDeclarationsInTypeNode(ts, child);
+        }
     }
 }
-function shouldIdentifierSkipped(ctx, text, destructuredPropNames) {
-    return ctx.hasLocalVariable(text)
+function shouldIdentifierSkipped(ctx, text) {
+    return ctx.scopes.some(scope => scope.has(text))
         // https://github.com/vuejs/core/blob/245230e135152900189f13a4281302de45fdcfaa/packages/compiler-core/src/transforms/transformExpression.ts#L342-L352
         || (0, shared_1.isGloballyAllowed)(text)
         || isLiteralWhitelisted(text)
         || text === 'require'
-        || text.startsWith('__VLS_')
-        || destructuredPropNames?.has(text);
+        || text.startsWith('__VLS_');
 }
 //# sourceMappingURL=interpolation.js.map

package/lib/codegen/template/objectProperty.js

@@ -3,17 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateObjectProperty = generateObjectProperty;
 const shared_1 = require("@vue/shared");
 const utils_1 = require("../utils");
+const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
 const stringLiteralKey_1 = require("../utils/stringLiteralKey");
-const wrapWith_1 = require("../utils/wrapWith");
 const interpolation_1 = require("./interpolation");
 function* generateObjectProperty(options, ctx, code, offset, features, shouldCamelize = false, shouldBeConstant = false) {
     if (code.startsWith('[') && code.endsWith(']')) {
         if (shouldBeConstant) {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code.slice(1, -1), offset + 1, `[__VLS_tryAsConstant(`, `)]`);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code.slice(1, -1), offset + 1, `[__VLS_tryAsConstant(`, `)]`);
         }
         else {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code, offset);
         }
     }
     else if (shouldCamelize) {
@@ -21,7 +21,11 @@ function* generateObjectProperty(options, ctx, code, offset, features, shouldCam
             yield* (0, camelized_1.generateCamelized)(code, 'template', offset, features);
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, 'template', offset, utils_1.combineLastMapping), `'`);
+            const token = yield* (0, boundary_1.startBoundary)('template', offset, features);
+            yield `'`;
+            yield* (0, camelized_1.generateCamelized)(code, 'template', offset, { __combineToken: token });
+            yield `'`;
+            yield (0, boundary_1.endBoundary)(token, offset + code.length);
         }
     }
     else {

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

@@ -1,4 +1,4 @@
 import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generatePropertyAccess(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset?: number, features?: VueCodeInformation): Generator<Code>;
+export declare function generatePropertyAccess(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/template/propertyAccess.js

@@ -5,14 +5,12 @@ const utils_1 = require("../utils");
 const stringLiteralKey_1 = require("../utils/stringLiteralKey");
 const interpolation_1 = require("./interpolation");
 function* generatePropertyAccess(options, ctx, code, offset, features) {
-    if (!options.compilerOptions.noPropertyAccessFromIndexSignature && utils_1.identifierRegex.test(code)) {
-        yield `.`;
-        yield offset !== undefined && features
-            ? [code, 'template', offset, features]
-            : code;
+    if (code.startsWith('[') && code.endsWith(']')) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code, offset);
     }
-    else if (code.startsWith('[') && code.endsWith(']')) {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset);
+    else if (utils_1.identifierRegex.test(code)) {
+        yield `.`;
+        yield [code, 'template', offset, features];
     }
     else {
         yield `[`;

package/lib/codegen/template/slotOutlet.js

@@ -5,12 +5,13 @@ const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const inlayHints_1 = require("../inlayHints");
+const names = require("../names");
 const utils_1 = require("../utils");
-const wrapWith_1 = require("../utils/wrapWith");
-const elementChildren_1 = require("./elementChildren");
+const boundary_1 = require("../utils/boundary");
 const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
 const propertyAccess_1 = require("./propertyAccess");
+const templateChild_1 = require("./templateChild");
 function* generateSlotOutlet(options, ctx, node) {
     const [startTagOffset] = (0, shared_1.getElementTagOffsets)(node, options.template);
     const startTagEndOffset = startTagOffset + node.tag.length;
@@ -29,7 +30,8 @@ function* generateSlotOutlet(options, ctx, node) {
         if (nameProp) {
             let codes;
             if (nameProp.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value) {
-                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, nameProp.value.content, (0, shared_1.getAttributeValueOffset)(nameProp.value), codeFeatures_1.codeFeatures.navigationAndVerification);
+                const [content, offset] = (0, shared_1.normalizeAttributeValue)(nameProp.value);
+                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, offset, codeFeatures_1.codeFeatures.navigationAndVerification);
             }
             else if (nameProp.type === CompilerDOM.NodeTypes.DIRECTIVE
                 && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -42,13 +44,26 @@ function* generateSlotOutlet(options, ctx, node) {
             else {
                 codes = [`['default']`];
             }
-            yield* (0, wrapWith_1.wrapWith)('template', nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification, options.slotsAssignName ?? '__VLS_slots', ...codes);
+            const token = yield* (0, boundary_1.startBoundary)('template', nameProp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            yield options.slotsAssignName ?? names.slots;
+            yield* codes;
+            yield (0, boundary_1.endBoundary)(token, nameProp.loc.end.offset);
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `'default'`), `]`);
+            const token = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+            yield `${options.slotsAssignName ?? names.slots}[`;
+            const token2 = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+            yield `'default'`;
+            yield (0, boundary_1.endBoundary)(token2, startTagEndOffset);
+            yield `]`;
+            yield (0, boundary_1.endBoundary)(token, startTagEndOffset);
         }
         yield `)(`;
-        yield* (0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true), `}`);
+        const token = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+        yield `{${utils_1.newLine}`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true);
+        yield `}`;
+        yield (0, boundary_1.endBoundary)(token, startTagEndOffset);
         yield `)${utils_1.endOfLine}`;
     }
     else {
@@ -73,7 +88,7 @@ function* generateSlotOutlet(options, ctx, node) {
             }
             const expVar = ctx.getInternalVariable();
             yield `var ${expVar} = __VLS_tryAsConstant(`;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset);
             yield `)${utils_1.endOfLine}`;
             ctx.dynamicSlots.push({
                 expVar: ctx.getHoistVariable(expVar),
@@ -89,6 +104,8 @@ function* generateSlotOutlet(options, ctx, node) {
             });
         }
     }
-    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node.children);
+    for (const child of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
+    }
 }
 //# sourceMappingURL=slotOutlet.js.map

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

@@ -1,6 +1,3 @@
-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 generateStyleScopedClassReferences(ctx: TemplateCodegenContext, withDot?: boolean): Generator<Code>;
-export declare function collectStyleScopedClassReferences(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): void;
+import type { Code, SfcBlock } from '../../types';
+export declare const references: WeakMap<SfcBlock, [version: string, [className: string, offset: number][]]>;
+export declare function generateStyleScopedClassReference(block: SfcBlock, className: string, offset: number, fullStart?: number): Generator<Code>;