SYMBOL INDEX (445 symbols across 129 files)

FILE: vue-router-src/components/link.js
  method let (line 127) | let child

FILE: vue-router-src/components/view.js
  method render (line 17) | render (_, { props, children, parent, data }) {
  function resolveProps (line 111) | function resolveProps (route, config) {
  function extend (line 132) | function extend (to, from) {

FILE: vue-router-src/create-matcher.js
  function addRoutes (line 22) | function addRoutes (routes) {
  method for (line 49) | for (const key in currentRoute.params) {
  function matchRoute (line 175) | function matchRoute (
  function resolveRecordPath (line 199) | function resolveRecordPath (path: string, record: RouteRecord): string {

FILE: vue-router-src/create-route-map.js
  method if (line 142) | if (!nameMap[name]) {

FILE: vue-router-src/history/base.js
  function normalizeBase (line 195) | function normalizeBase (base: ?string): string {
  method if (line 226) | if (current[i] !== next[i]) {
  method if (line 258) | if (typeof def !== 'function') {
  method if (line 274) | if (instance) {

FILE: vue-router-src/history/hash.js
  function checkFallback (line 81) | function checkFallback (base) {
  function ensureSlash (line 91) | function ensureSlash (): boolean {
  function getHash (line 100) | function getHash (): string {
  function getUrl (line 108) | function getUrl (path) {
  function pushHash (line 115) | function pushHash (path) {
  function replaceHash (line 123) | function replaceHash (path) {

FILE: vue-router-src/history/html5.js
  function getLocation (line 74) | function getLocation (base: string): string {

FILE: vue-router-src/index.js
  method constructor (line 36) | constructor (options: RouterOptions = {}) {
  method apply (line 177) | apply([], route.matched.map(m => {

FILE: vue-router-src/install.js
  function install (line 7) | function install (Vue) {

FILE: vue-router-src/util/async.js
  function runQueue (line 3) | function runQueue (queue: Array<?NavigationGuard>, fn: Function, cb: Fun...

FILE: vue-router-src/util/location.js
  function assign (line 63) | function assign (a, b) {

FILE: vue-router-src/util/push-state.js
  function genKey (line 28) | function genKey (): string {
  function getStateKey (line 32) | function getStateKey () {
  function setStateKey (line 36) | function setStateKey (key: string) {

FILE: vue-router-src/util/resolve-components.js
  method return (line 7) | return (to, from, next) => {

FILE: vue-router-src/util/route.js
  function clone (line 37) | function clone (value) {
  constant START (line 53) | const START = createRoute(null, {
  function formatMatch (line 57) | function formatMatch (record: ?RouteRecord): Array<RouteRecord> {
  function getFullPath (line 66) | function getFullPath (
  function isObjectEqual (line 97) | function isObjectEqual (a = {}, b = {}): boolean {
  function isIncludedRoute (line 116) | function isIncludedRoute (current: Route, target: Route): boolean {
  method for (line 127) | for (const key in target) {

FILE: vue-router-src/util/scroll.js
  function setupScroll (line 9) | function setupScroll () {
  function handleScroll (line 20) | function handleScroll (
  function saveScrollPosition (line 62) | function saveScrollPosition () {
  function getElementPosition (line 79) | function getElementPosition (el: Element, offset: Object): Object {
  function isValidPosition (line 89) | function isValidPosition (obj: Object): boolean {
  function normalizePosition (line 93) | function normalizePosition (obj: Object): Object {
  function normalizeOffset (line 100) | function normalizeOffset (obj: Object): Object {
  function isNumber (line 107) | function isNumber (v: any): boolean {
  function scrollToPosition (line 111) | function scrollToPosition (shouldScroll, position) {

FILE: vue-router-src/util/warn.js
  function assert (line 3) | function assert (condition: any, message: string) {
  function warn (line 9) | function warn (condition: any, message: string) {
  function isError (line 15) | function isError (err: any): boolean {

FILE: vue-src/compiler/codegen/events.js
  function genHandlers (line 37) | function genHandlers (
  method if (line 64) | if (!handler) {
  method if (line 84) | if (modifierCode[key]) {

FILE: vue-src/compiler/codegen/index.js
  function generate (line 23) | function generate (
  function genElement (line 51) | function genElement (el: ASTElement): string {
  function genStatic (line 96) | function genStatic (el: ASTElement): string {
  function genOnce (line 105) | function genOnce (el: ASTElement): string {
  function genIf (line 140) | function genIf (el: any): string {
  function genIfConditions (line 147) | function genIfConditions (conditions: ASTIfConditions): string {
  function genFor (line 168) | function genFor (el: any): string {
  function genData (line 194) | function genData (el: ASTElement): string {
  function genDirectives (line 273) | function genDirectives (el: ASTElement): string | void {
  function genScopedSlots (line 321) | function genScopedSlots (slots: { [key: string]: ASTElement }): string {
  function genScopedSlot (line 327) | function genScopedSlot (key: string, el: ASTElement) {

FILE: vue-src/compiler/directives/bind.js
  function bind (line 3) | function bind (el: ASTElement, dir: ASTDirective) {

FILE: vue-src/compiler/directives/model.js
  function genAssignmentCode (line 36) | function genAssignmentCode (
  function parseModel (line 67) | function parseModel (val: string): Object {
  function next (line 95) | function next (): number {
  function eof (line 99) | function eof (): boolean {
  function isStringStart (line 103) | function isStringStart (chr: number): boolean {
  function parseBracket (line 107) | function parseBracket (chr: number): void {
  function parseString (line 125) | function parseString (chr: number): void {

FILE: vue-src/compiler/error-detector.js
  function checkNode (line 33) | function checkNode (node: ASTNode, errors: Array<string>) {
  function checkEvent (line 59) | function checkEvent (exp: string, text: string, errors: Array<string>) {
  function checkFor (line 71) | function checkFor (node: ASTElement, text: string, errors: Array<string>) {
  function checkIdentifier (line 78) | function checkIdentifier (ident: ?string, type: string, text: string, er...
  function checkExpression (line 84) | function checkExpression (exp: string, text: string, errors: Array<strin...

FILE: vue-src/compiler/helpers.js
  function baseWarn (line 6) | function baseWarn (msg: string) {
  function addProp (line 20) | function addProp (el: ASTElement, name: string, value: string) {
  function addAttr (line 25) | function addAttr (el: ASTElement, name: string, value: string) {
  method parseFilters (line 104) | parseFilters(dynamicValue)
  method let (line 116) | let val

FILE: vue-src/compiler/index.js
  function baseCompile (line 10) | function baseCompile (
  function makeFunction (line 34) | function makeFunction (code, errors) {
  method if (line 69) | if (options.modules) {
  method if (line 73) | if (options.directives) {
  method if (line 113) | if (e.toString().match(/unsafe-eval|CSP/)) {

FILE: vue-src/compiler/optimizer.js
  function genStaticKeys (line 45) | function genStaticKeys (keys: string): Function {
  function markStatic (line 53) | function markStatic (node: ASTNode) {
  function markStaticRoots (line 83) | function markStaticRoots (node: ASTNode, isInFor: boolean) {
  function walkThroughConditionsBlocks (line 119) | function walkThroughConditionsBlocks (conditionBlocks: ASTIfConditions, ...
  function isStatic (line 126) | function isStatic (node: ASTNode): boolean {
  function isDirectChildOfTemplateFor (line 143) | function isDirectChildOfTemplateFor (node: ASTElement): boolean {

FILE: vue-src/compiler/parser/entity-decoder.js
  function decode (line 5) | function decode (html: string): string {

FILE: vue-src/compiler/parser/filter-parser.js
  function parseFilters (line 6) | function parseFilters (exp: string): string {
  function wrapFilter (line 93) | function wrapFilter (exp: string, filter: string): string {

FILE: vue-src/compiler/parser/html-parser.js
  constant IS_REGEX_CAPTURING_BROKEN (line 45) | let IS_REGEX_CAPTURING_BROKEN = false
  function decodeAttr (line 66) | function decodeAttr (value, shouldDecodeNewlines) {
  function parseHTML (line 72) | function parseHTML (html, options) {

FILE: vue-src/compiler/parser/index.js
  function parse (line 53) | function parse (
  function processPre (line 344) | function processPre (el) {
  function processRawAttrs (line 351) | function processRawAttrs (el) {
  function processKey (line 368) | function processKey (el) {
  function processRef (line 379) | function processRef (el) {
  function processFor (line 393) | function processFor (el) {
  function processIf (line 434) | function processIf (el) {
  function processIfConditions (line 458) | function processIfConditions (el, parent) {
  method if (line 478) | if (children[i].type === 1) {
  method warn (line 482) | warn(

FILE: vue-src/core/components/keep-alive.js
  method if (line 17) | if (typeof pattern === 'string') {
  method for (line 71) | for (const key in this.cache) {

FILE: vue-src/core/global-api/assets.js
  method if (line 16) | if (!definition) {

FILE: vue-src/core/global-api/extend.js
  function initExtend (line 7) | function initExtend (Vue: GlobalAPI) {
  function initProps (line 122) | function initProps (Comp) {
  function initComputed (line 130) | function initComputed (Comp) {

FILE: vue-src/core/global-api/index.js
  function initGlobalAPI (line 20) | function initGlobalAPI (Vue: GlobalAPI) {

FILE: vue-src/core/global-api/mixin.js
  function initMixin (line 6) | function initMixin (Vue: GlobalAPI) {

FILE: vue-src/core/global-api/use.js
  function initUse (line 6) | function initUse (Vue: GlobalAPI) {

FILE: vue-src/core/instance/events.js
  function initEvents (line 7) | function initEvents (vm: Component) {
  function add (line 23) | function add (event, fn, once) {
  function remove (line 32) | function remove (event, fn) {
  function eventsMixin (line 47) | function eventsMixin (Vue: Class<Component>) {

FILE: vue-src/core/instance/index.js
  function Vue (line 8) | function Vue (options) {

FILE: vue-src/core/instance/init.js
  function initMixin (line 16) | function initMixin (Vue: Class<Component>) {
  function initInternalComponent (line 84) | function initInternalComponent (vm: Component, options: InternalComponen...
  function resolveConstructorOptions (line 101) | function resolveConstructorOptions (Ctor: Class<Component>) {
  method if (line 138) | if (latest[key] !== sealed[key]) {

FILE: vue-src/core/instance/inject.js
  function initProvide (line 7) | function initProvide (vm: Component) {
  function initInjections (line 16) | function initInjections (vm: Component) {

FILE: vue-src/core/instance/lifecycle.js
  function initLifecycle (line 23) | function initLifecycle (vm: Component) {
  function lifecycleMixin (line 50) | function lifecycleMixin (Vue: Class<Component>) {
  function isInInactiveTree (line 276) | function isInInactiveTree (vm) {
  function activateChildComponent (line 284) | function activateChildComponent (vm: Component, direct?: boolean) {
  function deactivateChildComponent (line 304) | function deactivateChildComponent (vm: Component, direct?: boolean) {
  function callHook (line 321) | function callHook (vm: Component, hook: string) {

FILE: vue-src/core/instance/proxy.js
  method set (line 33) | set (target, key, value) {
  method has (line 46) | has (target, key) {
  method get (line 57) | get (target, key) {

FILE: vue-src/core/instance/render-helpers/bind-object-props.js
  method if (line 16) | if (value) {

FILE: vue-src/core/instance/render-helpers/render-list.js
  method key (line 14) | key
  method isObject (line 25) | isObject(val)) {

FILE: vue-src/core/instance/render-helpers/resolve-filter.js
  function resolveFilter (line 9) | function resolveFilter (id: string): Function {

FILE: vue-src/core/instance/render-helpers/resolve-slots.js
  function isWhitespace (line 39) | function isWhitespace (node: VNode): boolean {

FILE: vue-src/core/instance/render.js
  function initRender (line 30) | function initRender (vm: Component) {
  function renderMixin (line 49) | function renderMixin (Vue: Class<Component>) {

FILE: vue-src/core/instance/state.js
  function proxy (line 34) | function proxy (target: Object, sourceKey: string, key: string) {
  function initState (line 45) | function initState (vm: Component) {
  function initProps (line 72) | function initProps (vm: Component, propsOptions: Object) {
  function initData (line 128) | function initData (vm: Component) {
  function getData (line 173) | function getData (data: Function, vm: Component): any {
  function initComputed (line 185) | function initComputed (vm: Component, computed: Object) {
  function defineComputed (line 231) | function defineComputed (target: any, key: string, userDef: Object | Fun...
  function createComputedGetter (line 258) | function createComputedGetter (key) {
  function initMethods (line 276) | function initMethods (vm: Component, methods: Object) {
  function initWatch (line 301) | function initWatch (vm: Component, watch: Object) {
  function createWatcher (line 316) | function createWatcher (vm: Component, key: string, handler: any) {
  function stateMixin (line 342) | function stateMixin (Vue: Class<Component>) {

FILE: vue-src/core/observer/dep.js
  function pushTarget (line 57) | function pushTarget (_target: Watcher) {
  function popTarget (line 63) | function popTarget () {

FILE: vue-src/core/observer/index.js
  method for (line 117) | for (let i = 0, l = keys.length; i < l; i++) {
  method if (line 132) | if (!isObject(value)) {

FILE: vue-src/core/observer/scheduler.js
  constant MAX_UPDATE_COUNT (line 13) | const MAX_UPDATE_COUNT = 100

FILE: vue-src/core/observer/watcher.js
  method if (line 183) | if (this.lazy) {
  method if (line 202) | if (this.active) {
  method if (line 261) | if (this.active) {

FILE: vue-src/core/util/env.js
  method get (line 26) | get () {
  function isNative (line 56) | function isNative (Ctor: any): boolean {
  function nextTickHandler (line 81) | function nextTickHandler () {

FILE: vue-src/core/util/error.js
  function handleError (line 7) | function handleError (err: Error, vm: any, info: string) {

FILE: vue-src/core/util/lang.js
  function isReserved (line 8) | function isReserved (str: string): boolean {

FILE: vue-src/core/util/options.js
  function mergeData (line 50) | function mergeData (to: Object, from: ?Object): Object {
  method if (line 75) | if (!vm) {
  method for (line 246) | for (const key in props) {
  method mergeField (line 315) | mergeField(key)
  method mergeField (line 323) | mergeField (key) {

FILE: vue-src/core/util/props.js
  method if (line 31) | if (absent && !hasOwn(prop, 'default')) {
  method if (line 66) | if (!hasOwn(prop, 'default')) {
  method if (line 120) | if (!Array.isArray(type)) {
  method if (line 140) | if (!validator(value)) {

FILE: vue-src/core/vdom/create-component.js
  method if (line 38) | if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {
  method if (line 108) | if (isUndef(Ctor)) {
  method if (line 124) | if (process.env.NODE_ENV !== 'production') {

FILE: vue-src/core/vdom/create-element.js
  constant SIMPLE_NORMALIZE (line 21) | const SIMPLE_NORMALIZE = 1
  constant ALWAYS_NORMALIZE (line 22) | const ALWAYS_NORMALIZE = 2
  function createElement (line 26) | function createElement (
  method if (line 61) | if (isDef(data) && isDef((data: any).__ob__)) {
  method for (line 136) | for (let i = 0, l = vnode.children.length; i < l; i++) {

FILE: vue-src/core/vdom/create-functional-component.js
  method for (line 24) | for (const key in propOptions) {
  function mergeProps (line 53) | function mergeProps (to, from) {

FILE: vue-src/core/vdom/helpers/extract-props.js
  method for (line 27) | for (const key in propOptions) {

FILE: vue-src/core/vdom/helpers/merge-hook.js
  function mergeVNodeHook (line 6) | function mergeVNodeHook (def: Object, hookKey: string, hook: Function) {

FILE: vue-src/core/vdom/helpers/normalize-children.js
  function simpleNormalizeChildren (line 18) | function simpleNormalizeChildren (children: any) {
  method if (line 50) | if (isDef(last) && isDef(last.text)) {
  method if (line 57) | if (isDef(c.text) && isDef(last) && isDef(last.text)) {

FILE: vue-src/core/vdom/helpers/resolve-async-component.js
  function ensureCtor (line 12) | function ensureCtor (comp, base) {
  function resolveAsyncComponent (line 18) | function resolveAsyncComponent (

FILE: vue-src/core/vdom/modules/directives.js
  function updateDirectives (line 15) | function updateDirectives (oldVnode: VNodeWithData, vnode: VNodeWithData) {
  function _update (line 21) | function _update (oldVnode, vnode) {
  function normalizeDirectives (line 83) | function normalizeDirectives (
  function getRawDirName (line 103) | function getRawDirName (dir: VNodeDirective): string {
  function callHook (line 107) | function callHook (dir, hook, vnode, oldVnode, isDestroy) {

FILE: vue-src/core/vdom/patch.js
  function sameVnode (line 42) | function sameVnode (a, b) {
  function sameInputType (line 58) | function sameInputType (a, b) {
  function createKeyToOldIdx (line 71) | function createKeyToOldIdx (children, beginIdx, endIdx) {
  function createPatchFunction (line 82) | function createPatchFunction (backend) {

FILE: vue-src/core/vdom/vnode.js
  function createTextVNode (line 86) | function createTextVNode (val: string | number) {
  function cloneVNode (line 95) | function cloneVNode (vnode: VNode): VNode {

FILE: vue-src/platforms/web/compiler/directives/html.js
  function html (line 5) | function html (el: ASTElement, dir: ASTDirective) {

FILE: vue-src/platforms/web/compiler/directives/model.js
  constant RANGE_TOKEN (line 11) | const RANGE_TOKEN = '__r'
  constant CHECKBOX_RADIO_TOKEN (line 12) | const CHECKBOX_RADIO_TOKEN = '__c'
  function genCheckboxModel (line 68) | function genCheckboxModel (
  function genRadioModel (line 99) | function genRadioModel (
  function genSelect (line 111) | function genSelect (

FILE: vue-src/platforms/web/compiler/directives/text.js
  function text (line 5) | function text (el: ASTElement, dir: ASTDirective) {

FILE: vue-src/platforms/web/compiler/modules/class.js
  function transformNode (line 10) | function transformNode (el: ASTElement, options: CompilerOptions) {
  function genData (line 33) | function genData (el: ASTElement): string {

FILE: vue-src/platforms/web/compiler/modules/style.js
  function transformNode (line 11) | function transformNode (el: ASTElement, options: CompilerOptions) {
  function genData (line 36) | function genData (el: ASTElement): string {

FILE: vue-src/platforms/web/runtime/components/transition-group.js
  method if (line 47) | if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
  method if (line 127) | if (!hasTransition) {

FILE: vue-src/platforms/web/runtime/components/transition.js
  function componentOptions (line 30) | function getRealChild (vnode: ?VNode): ?VNode {
  function isSameChild (line 71) | function isSameChild (child: VNode, oldChild: VNode): boolean {

FILE: vue-src/platforms/web/runtime/directives/model.js
  method inserted (line 21) | inserted (el, binding, vnode) {
  method componentUpdated (line 50) | componentUpdated (el, binding, vnode) {
  function setSelected (line 67) | function setSelected (el, binding, vm) {
  function hasNoMatchingOption (line 102) | function hasNoMatchingOption (value, options) {
  function getValue (line 111) | function getValue (option) {
  function onCompositionStart (line 117) | function onCompositionStart (e) {
  function onCompositionEnd (line 121) | function onCompositionEnd (e) {
  function trigger (line 126) | function trigger (el, type) {

FILE: vue-src/platforms/web/runtime/directives/show.js
  function locateNode (line 7) | function locateNode (vnode: VNode): VNodeWithData {

FILE: vue-src/platforms/web/runtime/modules/attrs.js
  function updateAttrs (line 21) | function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {
  function setAttr (line 64) | function setAttr (el: Element, key: string, value: any) {

FILE: vue-src/platforms/web/runtime/modules/class.js
  function updateClass (line 15) | function updateClass (oldVnode: any, vnode: any) {

FILE: vue-src/platforms/web/runtime/modules/dom-props.js
  function updateDOMProps (line 5) | function updateDOMProps (oldVnode: VNodeWithData, vnode: VNodeWithData) {
  function shouldUpdateValue (line 51) | function shouldUpdateValue (
  function isDirty (line 63) | function isDirty (elm: acceptValueElm, checkVal: string): boolean {
  function isInputChanged (line 68) | function isInputChanged (elm: any, newVal: string): boolean {

FILE: vue-src/platforms/web/runtime/modules/events.js
  function normalizeEvents (line 12) | function normalizeEvents (on) {
  function add (line 31) | function add (

FILE: vue-src/platforms/web/runtime/modules/style.js
  function updateStyle (line 47) | function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {

FILE: vue-src/platforms/web/runtime/modules/transition.js
  function leave (line 173) | function leave (vnode: VNodeWithData, rm: Function) {
  function checkDuration (line 278) | function checkDuration (val, name, vnode) {
  function isValidDuration (line 294) | function isValidDuration (val) {
  function getHookArgumentsLength (line 304) | function getHookArgumentsLength (fn: Function): boolean {
  function _enter (line 321) | function _enter (_: any, vnode: VNodeWithData) {
  method if (line 332) | if (vnode.data.show !== true) {

FILE: vue-src/platforms/web/runtime/node-ops.js
  function createElement (line 7) | function createElement (tagName: string, vnode: VNode): Element {
  function createElementNS (line 19) | function createElementNS (namespace: string, tagName: string): Element {
  function createTextNode (line 23) | function createTextNode (text: string): Text {
  function createComment (line 27) | function createComment (text: string): Comment {
  function insertBefore (line 31) | function insertBefore (parentNode: Node, newNode: Node, referenceNode: N...
  function removeChild (line 35) | function removeChild (node: Node, child: Node) {
  function appendChild (line 39) | function appendChild (node: Node, child: Node) {
  function tagName (line 51) | function tagName (node: Element): string {
  function setTextContent (line 55) | function setTextContent (node: Node, text: string) {
  function setAttribute (line 59) | function setAttribute (node: Element, key: string, val: string) {

FILE: vue-src/platforms/web/runtime/transition-util.js
  method if (line 8) | if (!def) {
  method if (line 46) | if (window.ontransitionend === undefined &&
  method if (line 130) | if (transitionTimeout > 0) {
  method if (line 136) | if (animationTimeout > 0) {
  method while (line 167) | while (delays.length < durations.length) {

FILE: vue-src/platforms/web/server/directives/show.js
  function show (line 3) | function show (node: VNodeWithData, dir: VNodeDirective) {

FILE: vue-src/platforms/web/server/modules/attrs.js
  function renderAttrs (line 16) | function renderAttrs (node: VNodeWithData): string {
  function renderAttr (line 42) | function renderAttr (key: string, value: string): string {

FILE: vue-src/platforms/web/server/modules/dom-props.js
  function renderDOMProps (line 8) | function renderDOMProps (node: VNodeWithData): string {
  function setText (line 42) | function setText (node, text, raw) {

FILE: vue-src/platforms/web/server/modules/style.js
  function genStyleText (line 7) | function genStyleText (vnode: VNode): string {

FILE: vue-src/platforms/web/util/class.js
  function genClassForVnode (line 5) | function genClassForVnode (vnode: VNode): string {
  function mergeClassData (line 23) | function mergeClassData (child: VNodeData, parent: VNodeData): {
  function genClassFromData (line 35) | function genClassFromData (data: Object): string {
  function stringifyClass (line 49) | function stringifyClass (value: any): string {

FILE: vue-src/platforms/web/util/compat.js
  function shouldDecode (line 6) | function shouldDecode (content: string, encoded: string): boolean {

FILE: vue-src/platforms/web/util/element.js
  function isUnknownElement (line 52) | function isUnknownElement (tag: string): boolean {

FILE: vue-src/platforms/web/util/index.js
  method if (line 14) | if (typeof el === 'string') {

FILE: vue-src/platforms/web/util/style.js
  function getStyle (line 43) | function getStyle (vnode: VNode, checkChild: boolean): Object {

FILE: vue-src/platforms/weex/compiler/modules/append.js
  function preTransformNode (line 3) | function preTransformNode (el: ASTElement, options: CompilerOptions) {
  function genData (line 13) | function genData (el: ASTElement): string {

FILE: vue-src/platforms/weex/compiler/modules/class.js
  function transformNode (line 15) | function transformNode (el: ASTElement, options: CompilerOptions) {
  function genData (line 37) | function genData (el: ASTElement): string {
  function parseStaticClass (line 48) | function parseStaticClass (staticClass: ?string, options: CompilerOption...

FILE: vue-src/platforms/weex/compiler/modules/props.js
  function normalizeKeyName (line 7) | function normalizeKeyName (str: string) : string {
  function transformNode (line 16) | function transformNode (el: ASTElement, options: CompilerOptions) {

FILE: vue-src/platforms/weex/compiler/modules/style.js
  function transformNode (line 18) | function transformNode (el: ASTElement, options: CompilerOptions) {
  function genData (line 40) | function genData (el: ASTElement): string {
  function parseStaticStyle (line 51) | function parseStaticStyle (staticStyle: ?string, options: CompilerOption...

FILE: vue-src/platforms/weex/framework.js
  function init (line 21) | function init (cfg) {
  function reset (line 31) | function reset () {
  function clear (line 45) | function clear (obj) {
  function createInstance (line 59) | function createInstance (
  function destroyInstance (line 117) | function destroyInstance (instanceId) {
  function refreshInstance (line 132) | function refreshInstance (instanceId, data) {
  function getRoot (line 148) | function getRoot (instanceId) {
  function receiveTasks (line 163) | function receiveTasks (instanceId, tasks) {
  function registerModules (line 197) | function registerModules (newModules) {
  function registerComponents (line 216) | function registerComponents (newComponents) {
  function createVueModuleInstance (line 234) | function createVueModuleInstance (instanceId, moduleGetter) {
  function genModuleGetter (line 297) | function genModuleGetter (instanceId) {
  function getInstanceTimer (line 323) | function getInstanceTimer (instanceId, moduleGetter) {
  function callFunction (line 357) | function callFunction (globalObjects, body) {
  function normalize (line 380) | function normalize (v, instance) {
  function typof (line 414) | function typof (v) {

FILE: vue-src/platforms/weex/runtime/components/transition-group.js
  method created (line 14) | created () {
  method render (line 32) | render (h) {
  method beforeUpdate (line 78) | beforeUpdate () {
  method updated (line 89) | updated () {
  method getMoveData (line 132) | getMoveData (context, moveClass) {

FILE: vue-src/platforms/weex/runtime/modules/attrs.js
  function updateAttrs (line 5) | function updateAttrs (oldVnode: VNodeWithData, vnode: VNodeWithData) {

FILE: vue-src/platforms/weex/runtime/modules/class.js
  function updateClass (line 5) | function updateClass (oldVnode: VNodeWithData, vnode: VNodeWithData) {
  function getStyle (line 42) | function getStyle (oldClassList: Array<string>, classList: Array<string>...

FILE: vue-src/platforms/weex/runtime/modules/events.js
  function add (line 7) | function add (

FILE: vue-src/platforms/weex/runtime/modules/style.js
  function createStyle (line 7) | function createStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
  function updateStyle (line 22) | function updateStyle (oldVnode: VNodeWithData, vnode: VNodeWithData) {
  function toObject (line 55) | function toObject (arr) {

FILE: vue-src/platforms/weex/runtime/modules/transition.js
  function enter (line 12) | function enter (_, vnode) {
  function leave (line 131) | function leave (vnode, rm) {
  function getEnterTargetState (line 227) | function getEnterTargetState (el, stylesheet, startClass, endClass, acti...

FILE: vue-src/platforms/weex/runtime/node-ops.js
  function createElement (line 8) | function createElement (tagName) {
  function createElementNS (line 12) | function createElementNS (namespace, tagName) {
  function createTextNode (line 16) | function createTextNode (text) {
  function createComment (line 20) | function createComment (text) {
  function insertBefore (line 24) | function insertBefore (node, target, before) {
  function removeChild (line 39) | function removeChild (node, child) {
  function appendChild (line 47) | function appendChild (node, child) {
  function parentNode (line 63) | function parentNode (node) {
  function nextSibling (line 67) | function nextSibling (node) {
  function tagName (line 71) | function tagName (node) {
  function setTextContent (line 75) | function setTextContent (node, text) {
  function setAttribute (line 79) | function setAttribute (node, key, val) {

FILE: vue-src/platforms/weex/runtime/text-node.js
  function TextNode (line 3) | function TextNode (text) {

FILE: vue-src/platforms/weex/util/index.js
  function mustUseProp (line 28) | function mustUseProp () { /* console.log('mustUseProp') */ }
  function getTagNamespace (line 29) | function getTagNamespace () { /* console.log('getTagNamespace') */ }
  function isUnknownElement (line 30) | function isUnknownElement () { /* console.log('isUnknownElement') */ }
  function query (line 32) | function query (el, document) {

FILE: vue-src/server/bundle-renderer/create-bundle-renderer.js
  constant INVALID_MSG (line 11) | const INVALID_MSG =
  method if (line 83) | if (typeof context === 'function') {

FILE: vue-src/server/bundle-renderer/create-bundle-runner.js
  function createContext (line 8) | function createContext (context) {
  function compileModule (line 25) | function compileModule (files, basedir) {
  function deepClone (line 75) | function deepClone (val) {
  function createBundleRunner (line 89) | function createBundleRunner (entry, files, basedir, runInNewContext) {

FILE: vue-src/server/bundle-renderer/source-map-support.js
  function createSourceMapConsumers (line 7) | function createSourceMapConsumers (rawMaps: Object) {
  function rewriteErrorTrace (line 15) | function rewriteErrorTrace (e: any, mapConsumers: {
  function rewriteTraceLine (line 25) | function rewriteTraceLine (trace: string, mapConsumers: {

FILE: vue-src/server/render-context.js
  function normalizeAsync (line 111) | function normalizeAsync (cache, method) {

FILE: vue-src/server/render-stream.js
  class RenderStream (line 16) | class RenderStream extends stream.Readable {
    method constructor (line 25) | constructor (render: Function) {
    method pushBySize (line 51) | pushBySize (n: number) {
    method tryRender (line 57) | tryRender () {
    method tryNext (line 65) | tryNext () {
    method _read (line 73) | _read (n: number) {

FILE: vue-src/server/render.js
  function renderNode (line 42) | function renderNode (node, isRoot, context) {
  function renderComponent (line 62) | function renderComponent (node, isRoot, context) {
  function renderComponentWithCache (line 127) | function renderComponentWithCache (node, isRoot, key, context) {
  function renderComponentInner (line 144) | function renderComponentInner (node, isRoot, context) {
  function renderElement (line 163) | function renderElement (el, isRoot, context) {
  function hasAncestorData (line 188) | function hasAncestorData (node: VNode) {
  function tmp (line 193) | function getVShowDirectiveInfo (node: VNode): ?VNodeDirective {
  function renderStartingTag (line 209) | function renderStartingTag (node: VNode, context) {

FILE: vue-src/server/template-renderer/create-async-file-mapper.js
  method for (line 23) | for (let j = 0; j < mapped.length; j++) {

FILE: vue-src/server/template-renderer/index.js
  method constructor (line 50) | constructor (options: TemplateRendererOptions) {
  method bindRenderFns (line 71) | bindRenderFns (context: Object) {
  method if (line 220) | if (!context._mappedfiles && context._registeredComponents && this.mapFi...
  method if (line 228) | if (!this.parsedTemplate) {

FILE: vue-src/server/template-renderer/parse-template.js
  method if (line 19) | if (typeof template === 'object') {

FILE: vue-src/server/template-renderer/template-stream.js
  class TemplateStream (line 7) | class TemplateStream extends Transform {
    method constructor (line 14) | constructor (
    method _transform (line 27) | _transform (data: Buffer | string, encoding: string, done: Function) {
    method start (line 36) | start () {
    method _flush (line 62) | _flush (done: Function) {

FILE: vue-src/server/webpack-plugin/client.js
  class VueSSRClientPlugin (line 5) | class VueSSRClientPlugin {
    method constructor (line 6) | constructor (options = {}) {
    method apply (line 12) | apply (compiler) {

FILE: vue-src/server/webpack-plugin/server.js
  class VueSSRServerPlugin (line 3) | class VueSSRServerPlugin {
    method constructor (line 4) | constructor (options = {}) {
    method apply (line 10) | apply (compiler) {

FILE: vue-src/server/write.js
  constant MAX_STACK_DEPTH (line 3) | const MAX_STACK_DEPTH = 1000
  function createWriteFunction (line 5) | function createWriteFunction (

FILE: vue-src/sfc/parser.js
  method for (line 66) | for (let i = 0; i < attrs.length; i++) {

FILE: vue-src/shared/constants.js
  constant SSR_ATTR (line 2) | const SSR_ATTR = 'data-server-rendered'
  constant ASSET_TYPES (line 5) | const ASSET_TYPES = [
  constant LIFECYCLE_HOOKS (line 12) | const LIFECYCLE_HOOKS = [

FILE: vue-src/shared/util.js
  function isPlainObject (line 40) | function isPlainObject (obj: any): boolean {
  function isRegExp (line 44) | function isRegExp (v: any): boolean {
  function toString (line 52) | function toString (val: any): string {
  method if (line 112) | if (arr.length) {
  method for (line 205) | for (const key in _from) {
  method if (line 218) | if (arr[i]) {

FILE: vuex-src/helpers.js
  function normalizeMap (line 117) | function normalizeMap (map) {
  function normalizeNamespace (line 123) | function normalizeNamespace (fn) {
  function getModuleByNamespace (line 138) | function getModuleByNamespace (store, helper, namespace) {

FILE: vuex-src/mixin.js
  function vuexInit (line 25) | function vuexInit () {

FILE: vuex-src/module/module-collection.js
  class ModuleCollection (line 5) | class ModuleCollection {
    method constructor (line 6) | constructor (rawRootModule) {
    method get (line 12) | get (path) {
    method getNamespace (line 24) | getNamespace (path) {
    method update (line 32) | update (rawRootModule) {
    method register (line 37) | register (path, rawModule, runtime = true) {
    method unregister (line 64) | unregister (path) {
  function update (line 74) | function update (path, targetModule, newModule) {
  function assertRawModule (line 105) | function assertRawModule (path, rawModule) {
  function makeAssertionMessage (line 118) | function makeAssertionMessage (path, key, type, value) {

FILE: vuex-src/module/module.js
  class Module (line 4) | class Module {
    method constructor (line 5) | constructor (rawModule, runtime) {
    method namespaced (line 16) | get namespaced () {
    method addChild (line 21) | addChild (key, module) {
    method removeChild (line 26) | removeChild (key) {
    method getChild (line 31) | getChild (key) {
    method update (line 36) | update (rawModule) {
    method forEachChild (line 50) | forEachChild (fn) {
    method forEachGetter (line 55) | forEachGetter (fn) {
    method forEachAction (line 62) | forEachAction (fn) {
    method forEachMutation (line 69) | forEachMutation (fn) {

FILE: vuex-src/plugins/devtool.js
  function devtoolPlugin (line 6) | function devtoolPlugin (store) {

FILE: vuex-src/plugins/logger.js
  function createLogger (line 5) | function createLogger ({
  function repeat (line 52) | function repeat (str, times) {
  function pad (line 56) | function pad (num, maxLength) {

FILE: vuex-src/store.js
  class Store (line 9) | class Store {
    method constructor (line 10) | constructor (options = {}) {
    method state (line 98) | get state () {
    method state (line 102) | set state (v) {
    method commit (line 109) | commit (_type, _payload, _options) {
    method dispatch (line 148) | dispatch (_type, _payload) {
    method subscribe (line 171) | subscribe (fn) {
    method watch (line 185) | watch (getter, cb, options) {
    method replaceState (line 193) | replaceState (state) {
    method registerModule (line 200) | registerModule (path, rawModule) {
    method unregisterModule (line 219) | unregisterModule (path) {
    method hotUpdate (line 240) | hotUpdate (newOptions) {
    method _withCommit (line 248) | _withCommit (fn) {
  function resetStore (line 258) | function resetStore (store, hot) {
  function resetStoreVM (line 271) | function resetStoreVM (store, state, hot) {
  function installModule (line 325) | function installModule (store, rootState, path, module, hot) {
  function makeLocalContext (line 379) | function makeLocalContext (store, namespace, path) {
  function makeLocalGetters (line 433) | function makeLocalGetters (store, namespace) {
  function registerMutation (line 457) | function registerMutation (store, type, handler, local) {
  function registerAction (line 466) | function registerAction (store, type, handler, local) {
  function registerGetter (line 496) | function registerGetter (store, type, rawGetter, local) {
  function enableStrictMode (line 517) | function enableStrictMode (store) {
  function getNestedState (line 526) | function getNestedState (state, path) {
  function unifyObjectStyle (line 532) | function unifyObjectStyle (type, payload, options) {
  function install (line 547) | function install (_Vue) {

FILE: vuex-src/util.js
  function find (line 9) | function find (list, f) {
  function deepCopy (line 22) | function deepCopy (obj, cache = []) {
  function forEachValue (line 52) | function forEachValue (obj, fn) {
  function isObject (line 56) | function isObject (obj) {
  function isPromise (line 61) | function isPromise (val) {
  function assert (line 65) | function assert (condition, msg) {