(cb: SchedulerJobs)

()

(source: AsyncComponentLoader<T> | AsyncComponentOptions<T>)

( src: string, { filename, sourceMap, parserPlugins, importHelpersFrom = 'vue' }: RefTra

( source: string, options?: Partial<SFCStyleCompileOptions> )

(options: Partial<RootNode> = {})

( str: string, expectsLowerCase?: boolean )

(template: string, options: CompilerOptions = {})

( n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null,

(el: HostNode)

()

(template: string)

(html: string, render: () => any)

(template: string, options: CompilerOptions = {})

(node: VNode, arg: any, mods?: any)

( fn: Function, ctx: ComponentInternalInstance | null = currentRenderingInstance, isNonScopedSlot?: bool

(str: string)

()

(code: string, n: number)

(val: unknown)

()

( vnode: T, directives: DirectiveArguments )

(node: CodegenNode | symbol | string, context: CodegenContext)

( hook: ErrorCapturedHook<TError>, target: ComponentInternalInstance | null = currentInstance )

()

( effect: WatchEffect, options?: WatchOptionsBase )

()

( slots: Slots, name: string, props: Data = {}, // this is not a user-facing function, so the fallback

(source: string, searchString: string)

(key)

(template: string, options?: CompilerOptions)

()

(context: ParserContext, numberOfCharacters: number)

(condition: boolean, msg?: string)

(raw: string, asAttr = false)

(selector: string)

(template: string, options: CompilerOptions = {})

( name: string, maybeSelfReference?: boolean )

()

(type: string, el: Element)

(code: string)

( children: CompoundExpressionNode['children'], loc: SourceLocation = locStub )

(id: string, initialDef: HMRComponent)

( msg: string, node: Node, end: number = node.end! + startOffset )

( key: DeprecationTypes, instance: ComponentInternalInstance | null, ...args: any[] )

( properties: ObjectExpression['properties'], loc: SourceLocation = locStub )

()

(chunk: string | null)

( comp: Component, props: Props | null = null, children: Slots | SSRSlots | null = null, parentCompone

( body: BlockStatement['body'] )

(key: string)

(p: JSChildNode)

(cb: SchedulerJob)

( instance: ComponentInternalInstance | null )

( target: T )

( props: Record<string, unknown>, tag?: string )

()

(target: object, type: TrackOpTypes, key: unknown)

(template: string, options: CompilerOptions = {})

(msg: string)

(template: string)

( code: DOMErrorCodes, loc?: SourceLocation )

( context: TransformContext | null, tag: VNodeCall['tag'], props?: VNodeCall['props'], children?: VNod

( options: any, hydate?: RootHydrateFunction )

( node: ElementNode, name: string | RegExp, allowEmpty: boolean = false )

(source)

(source)

(source)

(name: string)

( hook: VNodeHook, instance: ComponentInternalInstance | null, vnode: VNode, prevVNode: VNode | null =

(value: any)

(node: TestNode)

(template: string, options: CompilerOptions = {})

( register: Function, hook?: Function | Function[] )

(vnode: VNode)

(value?: unknown)

(n: number)

( target: Element, event: string, process?: (e: any) => any )

(code: string, shouldAsync = true)

(binding: DirectiveBinding)

( node: ForCodegenNode, keyed: boolean = false, customReturn: boolean = false, disable

(src: string, options?: Partial<SFCScriptCompileOptions>)

(src: string)

( node: ElementNode, name: string, dynamicOnly: boolean = false, allowEmpty: boolean = false )

( source: string, start = 0, end = source.length )

(context: ParserContext)

( context: ParserContext, start: Position, end?: Position )

(name: symbol)

(extra: BaseTransitionProps = {}, withKeepAlive = false)

( props: BaseTransitionProps, slot: () => any, withKeepAlive = false )

(template: string, options: CompilerOptions = {})

( node: SimpleExpressionNode, context: TransformContext, // some expressions like v-slot props & v-for a

(key: InjectionKey<T> | string, value: T)

(renderChildren: () => VNode[])

(name: string)

(el: Element, cls: string)

(content: string)

( fn: Function | Function[], instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unkn

(str: string)

( text: string = '', // when used as the v-else branch, the comment node must be created as a // block t