🔧

node_modules/@vue/compiler-sfc/README.md

@@ -4,7 +4,7 @@
 
 **Note: as of 3.2.13+, this package is included as a dependency of the main `vue` package and can be accessed as `vue/compiler-sfc`. This means you no longer need to explicitly install this package and ensure its version match that of `vue`'s. Just use the main `vue/compiler-sfc` deep import instead.**
 
-This package contains lower level utilities that you can use if you are writing a plugin / transform for a bundler or module system that compiles Vue Single File Components (SFCs) into JavaScript. It is used in [vue-loader](https://github.com/vuejs/vue-loader), [rollup-plugin-vue](https://github.com/vuejs/rollup-plugin-vue) and [vite](https://github.com/vitejs/vite).
+This package contains lower level utilities that you can use if you are writing a plugin / transform for a bundler or module system that compiles Vue Single File Components (SFCs) into JavaScript. It is used in [vue-loader](https://github.com/vuejs/vue-loader) and [@vitejs/plugin-vue](https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue).
 
 ## API
 
@@ -77,4 +77,4 @@ export default script
 
 Options needed for these APIs can be passed via the query string.
 
-For detailed API references and options, check out the source type definitions. For actual usage of these APIs, check out [rollup-plugin-vue](https://github.com/vuejs/rollup-plugin-vue/tree/next) or [vue-loader](https://github.com/vuejs/vue-loader/tree/next).
+For detailed API references and options, check out the source type definitions. For actual usage of these APIs, check out [@vitejs/plugin-vue](https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue) or [vue-loader](https://github.com/vuejs/vue-loader/tree/next).

node_modules/@vue/compiler-sfc/dist/compiler-sfc.d.ts

@@ -1,27 +1,19 @@
-import { parse as babelParse } from '@babel/parser';
-import { BindingMetadata } from '@vue/compiler-core';
-import { CodegenResult } from '@vue/compiler-core';
-import { CompilerError } from '@vue/compiler-core';
-import { CompilerOptions } from '@vue/compiler-core';
-import { ElementNode } from '@vue/compiler-core';
-import { extractIdentifiers } from '@vue/compiler-core';
-import { generateCodeFrame } from '@vue/compiler-core';
-import { isInDestructureAssignment } from '@vue/compiler-core';
-import { isStaticProperty } from '@vue/compiler-core';
-import { LazyResult } from 'postcss';
-import MagicString from 'magic-string';
-import { ParserOptions } from '@vue/compiler-core';
+import * as _babel_types from '@babel/types';
+import { Statement, Expression, TSType, Node, Program, CallExpression, ObjectPattern, TSModuleDeclaration, TSPropertySignature, TSMethodSignature, TSCallSignatureDeclaration, TSFunctionType } from '@babel/types';
+import { RootNode, CompilerOptions, CodegenResult, ParserOptions, CompilerError, SourceLocation, BindingMetadata as BindingMetadata$1 } from '@vue/compiler-core';
+export { BindingMetadata, CompilerError, CompilerOptions, extractIdentifiers, generateCodeFrame, isInDestructureAssignment, isStaticProperty, walkIdentifiers } from '@vue/compiler-core';
+import { RawSourceMap } from 'source-map-js';
 import { ParserPlugin } from '@babel/parser';
-import { RawSourceMap } from 'source-map';
-import { Result } from 'postcss';
-import { RootNode } from '@vue/compiler-core';
-import { shouldTransform as shouldTransformRef } from '@vue/reactivity-transform';
-import { SourceLocation } from '@vue/compiler-core';
-import { transform as transformRef } from '@vue/reactivity-transform';
-import { transformAST as transformRefAST } from '@vue/reactivity-transform';
-import { walkIdentifiers } from '@vue/compiler-core';
+export { parse as babelParse } from '@babel/parser';
+import { Result, LazyResult } from 'postcss';
+import MagicString from 'magic-string';
+export { default as MagicString } from 'magic-string';
+import TS from 'typescript';
 
-export declare interface AssetURLOptions {
+export interface AssetURLTagConfig {
+    [name: string]: string[];
+}
+export interface AssetURLOptions {
     /**
      * If base is provided, instead of transforming relative asset urls into
      * imports, they will be directly rewritten to absolute urls.
@@ -34,240 +26,22 @@ export declare interface AssetURLOptions {
     tags?: AssetURLTagConfig;
 }
 
-export declare interface AssetURLTagConfig {
-    [name: string]: string[];
+export interface TemplateCompiler {
+    compile(source: string | RootNode, options: CompilerOptions): CodegenResult;
+    parse(template: string, options: ParserOptions): RootNode;
 }
-
-export { babelParse }
-
-export { BindingMetadata }
-
-export { CompilerError }
-
-export { CompilerOptions }
-
-/**
- * Compile `<script setup>`
- * It requires the whole SFC descriptor because we need to handle and merge
- * normal `<script>` + `<script setup>` if both are present.
- */
-export declare function compileScript(sfc: SFCDescriptor, options: SFCScriptCompileOptions): SFCScriptBlock;
-
-export declare function compileStyle(options: SFCStyleCompileOptions): SFCStyleCompileResults;
-
-export declare function compileStyleAsync(options: SFCAsyncStyleCompileOptions): Promise<SFCStyleCompileResults>;
-
-export declare function compileTemplate(options: SFCTemplateCompileOptions): SFCTemplateCompileResults;
-
-/**
- * Aligns with postcss-modules
- * https://github.com/css-modules/postcss-modules
- */
-declare interface CSSModulesOptions {
-    scopeBehaviour?: 'global' | 'local';
-    generateScopedName?: string | ((name: string, filename: string, css: string) => string);
-    hashPrefix?: string;
-    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly';
-    exportGlobals?: boolean;
-    globalModulePaths?: RegExp[];
-}
-
-export { extractIdentifiers }
-
-export { generateCodeFrame }
-
-declare interface ImportBinding {
-    isType: boolean;
-    imported: string;
-    source: string;
-    isFromSetup: boolean;
-    isUsedInTemplate: boolean;
-}
-
-export { isInDestructureAssignment }
-
-export { isStaticProperty }
-
-export { MagicString }
-
-export declare function parse(source: string, { sourceMap, filename, sourceRoot, pad, ignoreEmpty, compiler }?: SFCParseOptions): SFCParseResult;
-
-declare type PreprocessLang = 'less' | 'sass' | 'scss' | 'styl' | 'stylus';
-
-/**
- * Utility for rewriting `export default` in a script block into a variable
- * declaration so that we can inject things into it
- */
-export declare function rewriteDefault(input: string, as: string, parserPlugins?: ParserPlugin[]): string;
-
-export declare interface SFCAsyncStyleCompileOptions extends SFCStyleCompileOptions {
-    isAsync?: boolean;
-    modules?: boolean;
-    modulesOptions?: CSSModulesOptions;
-}
-
-export declare interface SFCBlock {
-    type: string;
-    content: string;
-    attrs: Record<string, string | true>;
-    loc: SourceLocation;
-    map?: RawSourceMap;
-    lang?: string;
-    src?: string;
-}
-
-export declare interface SFCDescriptor {
-    filename: string;
-    source: string;
-    template: SFCTemplateBlock | null;
-    script: SFCScriptBlock | null;
-    scriptSetup: SFCScriptBlock | null;
-    styles: SFCStyleBlock[];
-    customBlocks: SFCBlock[];
-    cssVars: string[];
-    /**
-     * whether the SFC uses :slotted() modifier.
-     * this is used as a compiler optimization hint.
-     */
-    slotted: boolean;
-    /**
-     * compare with an existing descriptor to determine whether HMR should perform
-     * a reload vs. re-render.
-     *
-     * Note: this comparison assumes the prev/next script are already identical,
-     * and only checks the special case where <script setup lang="ts"> unused import
-     * pruning result changes due to template changes.
-     */
-    shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean;
-}
-
-export declare interface SFCParseOptions {
-    filename?: string;
-    sourceMap?: boolean;
-    sourceRoot?: string;
-    pad?: boolean | 'line' | 'space';
-    ignoreEmpty?: boolean;
-    compiler?: TemplateCompiler;
-}
-
-export declare interface SFCParseResult {
-    descriptor: SFCDescriptor;
-    errors: (CompilerError | SyntaxError)[];
-}
-
-export declare interface SFCScriptBlock extends SFCBlock {
-    type: 'script';
-    setup?: string | boolean;
-    bindings?: BindingMetadata;
-    imports?: Record<string, ImportBinding>;
-    /**
-     * import('\@babel/types').Statement
-     */
-    scriptAst?: any[];
-    /**
-     * import('\@babel/types').Statement
-     */
-    scriptSetupAst?: any[];
-}
-
-export declare interface SFCScriptCompileOptions {
-    /**
-     * Scope ID for prefixing injected CSS variables.
-     * This must be consistent with the `id` passed to `compileStyle`.
-     */
-    id: string;
-    /**
-     * Production mode. Used to determine whether to generate hashed CSS variables
-     */
-    isProd?: boolean;
-    /**
-     * Enable/disable source map. Defaults to true.
-     */
-    sourceMap?: boolean;
-    /**
-     * https://babeljs.io/docs/en/babel-parser#plugins
-     */
-    babelParserPlugins?: ParserPlugin[];
-    /**
-     * (Experimental) Enable syntax transform for using refs without `.value` and
-     * using destructured props with reactivity
-     */
-    reactivityTransform?: boolean;
-    /**
-     * (Experimental) Enable syntax transform for using refs without `.value`
-     * https://github.com/vuejs/rfcs/discussions/369
-     * @deprecated now part of `reactivityTransform`
-     * @default false
-     */
-    refTransform?: boolean;
-    /**
-     * (Experimental) Enable syntax transform for destructuring from defineProps()
-     * https://github.com/vuejs/rfcs/discussions/394
-     * @deprecated now part of `reactivityTransform`
-     * @default false
-     */
-    propsDestructureTransform?: boolean;
-    /**
-     * @deprecated use `reactivityTransform` instead.
-     */
-    refSugar?: boolean;
-    /**
-     * Compile the template and inline the resulting render function
-     * directly inside setup().
-     * - Only affects `<script setup>`
-     * - This should only be used in production because it prevents the template
-     * from being hot-reloaded separately from component state.
-     */
-    inlineTemplate?: boolean;
-    /**
-     * Options for template compilation when inlining. Note these are options that
-     * would normally be passed to `compiler-sfc`'s own `compileTemplate()`, not
-     * options passed to `compiler-dom`.
-     */
-    templateOptions?: Partial<SFCTemplateCompileOptions>;
-}
-
-export declare interface SFCStyleBlock extends SFCBlock {
-    type: 'style';
-    scoped?: boolean;
-    module?: string | boolean;
-}
-
-export declare interface SFCStyleCompileOptions {
-    source: string;
-    filename: string;
-    id: string;
-    scoped?: boolean;
-    trim?: boolean;
-    isProd?: boolean;
-    inMap?: RawSourceMap;
-    preprocessLang?: PreprocessLang;
-    preprocessOptions?: any;
-    preprocessCustomRequire?: (id: string) => any;
-    postcssOptions?: any;
-    postcssPlugins?: any[];
-    /**
-     * @deprecated use `inMap` instead.
-     */
-    map?: RawSourceMap;
-}
-
-export declare interface SFCStyleCompileResults {
+export interface SFCTemplateCompileResults {
     code: string;
-    map: RawSourceMap | undefined;
-    rawResult: Result | LazyResult | undefined;
-    errors: Error[];
-    modules?: Record<string, string>;
-    dependencies: Set<string>;
-}
-
-export declare interface SFCTemplateBlock extends SFCBlock {
-    type: 'template';
-    ast: ElementNode;
-}
-
-export declare interface SFCTemplateCompileOptions {
+    ast?: RootNode;
+    preamble?: string;
     source: string;
+    tips: string[];
+    errors: (string | CompilerError)[];
+    map?: RawSourceMap;
+}
+export interface SFCTemplateCompileOptions {
+    source: string;
+    ast?: RootNode;
     filename: string;
     id: string;
     scoped?: boolean;
@@ -292,30 +66,477 @@ export declare interface SFCTemplateCompileOptions {
      */
     transformAssetUrls?: AssetURLOptions | AssetURLTagConfig | boolean;
 }
+export declare function compileTemplate(options: SFCTemplateCompileOptions): SFCTemplateCompileResults;
 
-export declare interface SFCTemplateCompileResults {
-    code: string;
-    ast?: RootNode;
-    preamble?: string;
+export interface SFCScriptCompileOptions {
+    /**
+     * Scope ID for prefixing injected CSS variables.
+     * This must be consistent with the `id` passed to `compileStyle`.
+     */
+    id: string;
+    /**
+     * Production mode. Used to determine whether to generate hashed CSS variables
+     */
+    isProd?: boolean;
+    /**
+     * Enable/disable source map. Defaults to true.
+     */
+    sourceMap?: boolean;
+    /**
+     * https://babeljs.io/docs/en/babel-parser#plugins
+     */
+    babelParserPlugins?: ParserPlugin[];
+    /**
+     * A list of files to parse for global types to be made available for type
+     * resolving in SFC macros. The list must be fully resolved file system paths.
+     */
+    globalTypeFiles?: string[];
+    /**
+     * Compile the template and inline the resulting render function
+     * directly inside setup().
+     * - Only affects `<script setup>`
+     * - This should only be used in production because it prevents the template
+     * from being hot-reloaded separately from component state.
+     */
+    inlineTemplate?: boolean;
+    /**
+     * Generate the final component as a variable instead of default export.
+     * This is useful in e.g. @vitejs/plugin-vue where the script needs to be
+     * placed inside the main module.
+     */
+    genDefaultAs?: string;
+    /**
+     * Options for template compilation when inlining. Note these are options that
+     * would normally be passed to `compiler-sfc`'s own `compileTemplate()`, not
+     * options passed to `compiler-dom`.
+     */
+    templateOptions?: Partial<SFCTemplateCompileOptions>;
+    /**
+     * Hoist <script setup> static constants.
+     * - Only enables when one `<script setup>` exists.
+     * @default true
+     */
+    hoistStatic?: boolean;
+    /**
+     * (**Experimental**) Enable reactive destructure for `defineProps`
+     * @default false
+     */
+    propsDestructure?: boolean;
+    /**
+     * File system access methods to be used when resolving types
+     * imported in SFC macros. Defaults to ts.sys in Node.js, can be overwritten
+     * to use a virtual file system for use in browsers (e.g. in REPLs)
+     */
+    fs?: {
+        fileExists(file: string): boolean;
+        readFile(file: string): string | undefined;
+        realpath?(file: string): string;
+    };
+    /**
+     * Transform Vue SFCs into custom elements.
+     */
+    customElement?: boolean | ((filename: string) => boolean);
+}
+interface ImportBinding {
+    isType: boolean;
+    imported: string;
+    local: string;
     source: string;
-    tips: string[];
-    errors: (string | CompilerError)[];
+    isFromSetup: boolean;
+    isUsedInTemplate: boolean;
+}
+/**
+ * Compile `<script setup>`
+ * It requires the whole SFC descriptor because we need to handle and merge
+ * normal `<script>` + `<script setup>` if both are present.
+ */
+export declare function compileScript(sfc: SFCDescriptor, options: SFCScriptCompileOptions): SFCScriptBlock;
+
+export interface SFCParseOptions {
+    filename?: string;
+    sourceMap?: boolean;
+    sourceRoot?: string;
+    pad?: boolean | 'line' | 'space';
+    ignoreEmpty?: boolean;
+    compiler?: TemplateCompiler;
+    templateParseOptions?: ParserOptions;
+    /**
+     * TODO remove in 3.5
+     * @deprecated use `templateParseOptions: { prefixIdentifiers: false }` instead
+     */
+    parseExpressions?: boolean;
+}
+export interface SFCBlock {
+    type: string;
+    content: string;
+    attrs: Record<string, string | true>;
+    loc: SourceLocation;
+    map?: RawSourceMap;
+    lang?: string;
+    src?: string;
+}
+export interface SFCTemplateBlock extends SFCBlock {
+    type: 'template';
+    ast?: RootNode;
+}
+export interface SFCScriptBlock extends SFCBlock {
+    type: 'script';
+    setup?: string | boolean;
+    bindings?: BindingMetadata$1;
+    imports?: Record<string, ImportBinding>;
+    scriptAst?: _babel_types.Statement[];
+    scriptSetupAst?: _babel_types.Statement[];
+    warnings?: string[];
+    /**
+     * Fully resolved dependency file paths (unix slashes) with imported types
+     * used in macros, used for HMR cache busting in @vitejs/plugin-vue and
+     * vue-loader.
+     */
+    deps?: string[];
+}
+export interface SFCStyleBlock extends SFCBlock {
+    type: 'style';
+    scoped?: boolean;
+    module?: string | boolean;
+}
+export interface SFCDescriptor {
+    filename: string;
+    source: string;
+    template: SFCTemplateBlock | null;
+    script: SFCScriptBlock | null;
+    scriptSetup: SFCScriptBlock | null;
+    styles: SFCStyleBlock[];
+    customBlocks: SFCBlock[];
+    cssVars: string[];
+    /**
+     * whether the SFC uses :slotted() modifier.
+     * this is used as a compiler optimization hint.
+     */
+    slotted: boolean;
+    /**
+     * compare with an existing descriptor to determine whether HMR should perform
+     * a reload vs. re-render.
+     *
+     * Note: this comparison assumes the prev/next script are already identical,
+     * and only checks the special case where <script setup lang="ts"> unused import
+     * pruning result changes due to template changes.
+     */
+    shouldForceReload: (prevImports: Record<string, ImportBinding>) => boolean;
+}
+export interface SFCParseResult {
+    descriptor: SFCDescriptor;
+    errors: (CompilerError | SyntaxError)[];
+}
+export declare function parse(source: string, options?: SFCParseOptions): SFCParseResult;
+
+type PreprocessLang = 'less' | 'sass' | 'scss' | 'styl' | 'stylus';
+
+export interface SFCStyleCompileOptions {
+    source: string;
+    filename: string;
+    id: string;
+    scoped?: boolean;
+    trim?: boolean;
+    isProd?: boolean;
+    inMap?: RawSourceMap;
+    preprocessLang?: PreprocessLang;
+    preprocessOptions?: any;
+    preprocessCustomRequire?: (id: string) => any;
+    postcssOptions?: any;
+    postcssPlugins?: any[];
+    /**
+     * @deprecated use `inMap` instead.
+     */
     map?: RawSourceMap;
 }
+/**
+ * Aligns with postcss-modules
+ * https://github.com/css-modules/postcss-modules
+ */
+interface CSSModulesOptions {
+    scopeBehaviour?: 'global' | 'local';
+    generateScopedName?: string | ((name: string, filename: string, css: string) => string);
+    hashPrefix?: string;
+    localsConvention?: 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly';
+    exportGlobals?: boolean;
+    globalModulePaths?: RegExp[];
+}
+export interface SFCAsyncStyleCompileOptions extends SFCStyleCompileOptions {
+    isAsync?: boolean;
+    modules?: boolean;
+    modulesOptions?: CSSModulesOptions;
+}
+export interface SFCStyleCompileResults {
+    code: string;
+    map: RawSourceMap | undefined;
+    rawResult: Result | LazyResult | undefined;
+    errors: Error[];
+    modules?: Record<string, string>;
+    dependencies: Set<string>;
+}
+export declare function compileStyle(options: SFCStyleCompileOptions): SFCStyleCompileResults;
+export declare function compileStyleAsync(options: SFCAsyncStyleCompileOptions): Promise<SFCStyleCompileResults>;
 
-export { shouldTransformRef }
+export declare function rewriteDefault(input: string, as: string, parserPlugins?: ParserPlugin[]): string;
+/**
+ * Utility for rewriting `export default` in a script block into a variable
+ * declaration so that we can inject things into it
+ */
+export declare function rewriteDefaultAST(ast: Statement[], s: MagicString, as: string): void;
 
-export declare interface TemplateCompiler {
-    compile(template: string, options: CompilerOptions): CodegenResult;
-    parse(template: string, options: ParserOptions): RootNode;
+type PropsDestructureBindings = Record<string, // public prop key
+{
+    local: string;
+    default?: Expression;
+}>;
+export declare function extractRuntimeProps(ctx: TypeResolveContext): string | undefined;
+
+interface ModelDecl {
+    type: TSType | undefined;
+    options: string | undefined;
+    identifier: string | undefined;
+    runtimeOptionNodes: Node[];
 }
 
-export { transformRef }
+declare enum BindingTypes {
+    /**
+     * returned from data()
+     */
+    DATA = "data",
+    /**
+     * declared as a prop
+     */
+    PROPS = "props",
+    /**
+     * a local alias of a `<script setup>` destructured prop.
+     * the original is stored in __propsAliases of the bindingMetadata object.
+     */
+    PROPS_ALIASED = "props-aliased",
+    /**
+     * a let binding (may or may not be a ref)
+     */
+    SETUP_LET = "setup-let",
+    /**
+     * a const binding that can never be a ref.
+     * these bindings don't need `unref()` calls when processed in inlined
+     * template expressions.
+     */
+    SETUP_CONST = "setup-const",
+    /**
+     * a const binding that does not need `unref()`, but may be mutated.
+     */
+    SETUP_REACTIVE_CONST = "setup-reactive-const",
+    /**
+     * a const binding that may be a ref.
+     */
+    SETUP_MAYBE_REF = "setup-maybe-ref",
+    /**
+     * bindings that are guaranteed to be refs
+     */
+    SETUP_REF = "setup-ref",
+    /**
+     * declared by other options, e.g. computed, inject
+     */
+    OPTIONS = "options",
+    /**
+     * a literal constant, e.g. 'foo', 1, true
+     */
+    LITERAL_CONST = "literal-const"
+}
+type BindingMetadata = {
+    [key: string]: BindingTypes | undefined;
+} & {
+    __isScriptSetup?: boolean;
+    __propsAliases?: Record<string, string>;
+};
 
-export { transformRefAST }
+export declare class ScriptCompileContext {
+    descriptor: SFCDescriptor;
+    options: Partial<SFCScriptCompileOptions>;
+    isJS: boolean;
+    isTS: boolean;
+    isCE: boolean;
+    scriptAst: Program | null;
+    scriptSetupAst: Program | null;
+    source: string;
+    filename: string;
+    s: MagicString;
+    startOffset: number | undefined;
+    endOffset: number | undefined;
+    scope?: TypeScope;
+    globalScopes?: TypeScope[];
+    userImports: Record<string, ImportBinding>;
+    hasDefinePropsCall: boolean;
+    hasDefineEmitCall: boolean;
+    hasDefineExposeCall: boolean;
+    hasDefaultExportName: boolean;
+    hasDefaultExportRender: boolean;
+    hasDefineOptionsCall: boolean;
+    hasDefineSlotsCall: boolean;
+    hasDefineModelCall: boolean;
+    propsCall: CallExpression | undefined;
+    propsDecl: Node | undefined;
+    propsRuntimeDecl: Node | undefined;
+    propsTypeDecl: Node | undefined;
+    propsDestructureDecl: ObjectPattern | undefined;
+    propsDestructuredBindings: PropsDestructureBindings;
+    propsDestructureRestId: string | undefined;
+    propsRuntimeDefaults: Node | undefined;
+    emitsRuntimeDecl: Node | undefined;
+    emitsTypeDecl: Node | undefined;
+    emitDecl: Node | undefined;
+    modelDecls: Record<string, ModelDecl>;
+    optionsRuntimeDecl: Node | undefined;
+    bindingMetadata: BindingMetadata;
+    helperImports: Set<string>;
+    helper(key: string): string;
+    /**
+     * to be exposed on compiled script block for HMR cache busting
+     */
+    deps?: Set<string>;
+    /**
+     * cache for resolved fs
+     */
+    fs?: NonNullable<SFCScriptCompileOptions['fs']>;
+    constructor(descriptor: SFCDescriptor, options: Partial<SFCScriptCompileOptions>);
+    getString(node: Node, scriptSetup?: boolean): string;
+    error(msg: string, node: Node, scope?: TypeScope): never;
+}
+
+export type SimpleTypeResolveOptions = Partial<Pick<SFCScriptCompileOptions, 'globalTypeFiles' | 'fs' | 'babelParserPlugins' | 'isProd'>>;
+/**
+ * TypeResolveContext is compatible with ScriptCompileContext
+ * but also allows a simpler version of it with minimal required properties
+ * when resolveType needs to be used in a non-SFC context, e.g. in a babel
+ * plugin. The simplest context can be just:
+ * ```ts
+ * const ctx: SimpleTypeResolveContext = {
+ *   filename: '...',
+ *   source: '...',
+ *   options: {},
+ *   error() {},
+ *   ast: []
+ * }
+ * ```
+ */
+export type SimpleTypeResolveContext = Pick<ScriptCompileContext, 'source' | 'filename' | 'error' | 'helper' | 'getString' | 'propsTypeDecl' | 'propsRuntimeDefaults' | 'propsDestructuredBindings' | 'emitsTypeDecl' | 'isCE'> & Partial<Pick<ScriptCompileContext, 'scope' | 'globalScopes' | 'deps' | 'fs'>> & {
+    ast: Statement[];
+    options: SimpleTypeResolveOptions;
+};
+export type TypeResolveContext = ScriptCompileContext | SimpleTypeResolveContext;
+type Import = Pick<ImportBinding, 'source' | 'imported'>;
+interface WithScope {
+    _ownerScope: TypeScope;
+}
+type ScopeTypeNode = Node & WithScope & {
+    _ns?: TSModuleDeclaration & WithScope;
+};
+declare class TypeScope {
+    filename: string;
+    source: string;
+    offset: number;
+    imports: Record<string, Import>;
+    types: Record<string, ScopeTypeNode>;
+    declares: Record<string, ScopeTypeNode>;
+    constructor(filename: string, source: string, offset?: number, imports?: Record<string, Import>, types?: Record<string, ScopeTypeNode>, declares?: Record<string, ScopeTypeNode>);
+    isGenericScope: boolean;
+    resolvedImportSources: Record<string, string>;
+    exportedTypes: Record<string, ScopeTypeNode>;
+    exportedDeclares: Record<string, ScopeTypeNode>;
+}
+interface MaybeWithScope {
+    _ownerScope?: TypeScope;
+}
+interface ResolvedElements {
+    props: Record<string, (TSPropertySignature | TSMethodSignature) & {
+        _ownerScope: TypeScope;
+    }>;
+    calls?: (TSCallSignatureDeclaration | TSFunctionType)[];
+}
+/**
+ * Resolve arbitrary type node to a list of type elements that can be then
+ * mapped to runtime props or emits.
+ */
+export declare function resolveTypeElements(ctx: TypeResolveContext, node: Node & MaybeWithScope & {
+    _resolvedElements?: ResolvedElements;
+}, scope?: TypeScope, typeParameters?: Record<string, Node>): ResolvedElements;
+/**
+ * @private
+ */
+export declare function registerTS(_loadTS: () => typeof TS): void;
+/**
+ * @private
+ */
+export declare function invalidateTypeCache(filename: string): void;
+export declare function inferRuntimeType(ctx: TypeResolveContext, node: Node & MaybeWithScope, scope?: TypeScope): string[];
+
+export declare function extractRuntimeEmits(ctx: TypeResolveContext): Set<string>;
+
+export declare const version: string;
+
+export declare const parseCache: Map<string, SFCParseResult>;
+export declare const errorMessages: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+    10: string;
+    11: string;
+    12: string;
+    13: string;
+    14: string;
+    15: string;
+    16: string;
+    17: string;
+    18: string;
+    19: string;
+    20: string;
+    21: string;
+    22: string;
+    23: string;
+    24: string;
+    25: string;
+    26: string;
+    27: string;
+    28: string;
+    29: string;
+    30: string;
+    31: string;
+    32: string;
+    33: string;
+    34: string;
+    35: string;
+    36: string;
+    37: string;
+    38: string;
+    39: string;
+    40: string;
+    41: string;
+    42: string;
+    43: string;
+    44: string;
+    45: string;
+    46: string;
+    47: string;
+    48: string;
+    49: string;
+    50: string;
+    51: string;
+    52: string;
+};
 
 export declare const walk: any;
 
-export { walkIdentifiers }
+/**
+ * @deprecated this is preserved to avoid breaking vite-plugin-vue < 5.0
+ * with reactivityTransform: true. The desired behavior should be silently
+ * ignoring the option instead of breaking.
+ */
+export declare const shouldTransformRef: () => boolean;
 
-export { }

node_modules/@vue/compiler-sfc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "3.2.36",
+  "version": "3.4.15",
   "description": "@vue/compiler-sfc",
   "main": "dist/compiler-sfc.cjs.js",
   "module": "dist/compiler-sfc.esm-browser.js",
@@ -8,6 +8,16 @@
   "files": [
     "dist"
   ],
+  "exports": {
+    ".": {
+      "types": "./dist/compiler-sfc.d.ts",
+      "node": "./dist/compiler-sfc.cjs.js",
+      "module": "./dist/compiler-sfc.esm-browser.js",
+      "import": "./dist/compiler-sfc.esm-browser.js",
+      "require": "./dist/compiler-sfc.cjs.js"
+    },
+    "./*": "./*"
+  },
   "buildOptions": {
     "name": "VueCompilerSFC",
     "formats": [
@@ -32,28 +42,26 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/compiler-sfc#readme",
   "dependencies": {
-    "@babel/parser": "^7.16.4",
-    "@vue/compiler-core": "3.2.36",
-    "@vue/compiler-dom": "3.2.36",
-    "@vue/compiler-ssr": "3.2.36",
-    "@vue/reactivity-transform": "3.2.36",
-    "@vue/shared": "3.2.36",
+    "@babel/parser": "^7.23.6",
     "estree-walker": "^2.0.2",
-    "magic-string": "^0.25.7",
-    "source-map": "^0.6.1",
-    "postcss": "^8.1.10"
+    "magic-string": "^0.30.5",
+    "postcss": "^8.4.33",
+    "source-map-js": "^1.0.2",
+    "@vue/compiler-core": "3.4.15",
+    "@vue/shared": "3.4.15",
+    "@vue/compiler-dom": "3.4.15",
+    "@vue/compiler-ssr": "3.4.15"
   },
   "devDependencies": {
-    "@types/estree": "^0.0.48",
-    "@babel/types": "^7.16.0",
-    "@types/lru-cache": "^5.1.0",
-    "pug": "^3.0.1",
-    "sass": "^1.26.9",
+    "@babel/types": "^7.23.6",
     "@vue/consolidate": "^0.17.3",
     "hash-sum": "^2.0.0",
-    "lru-cache": "^5.1.1",
+    "lru-cache": "^10.1.0",
     "merge-source-map": "^1.1.0",
-    "postcss-modules": "^4.0.0",
-    "postcss-selector-parser": "^6.0.4"
+    "minimatch": "^9.0.3",
+    "postcss-modules": "^6.0.0",
+    "postcss-selector-parser": "^6.0.15",
+    "pug": "^3.0.2",
+    "sass": "^1.69.7"
   }
-}
+}