* Check if an element is a component. If yes, return * a component link function. * * @param {Element} el * @param {Object} options * @return {Fu

* Check if an element is a component, if yes return its * component id. * * @param {Element} el * @param {Object} options * @return {Object|undef

* Check for element directives (custom elements that should * be resovled as terminal directives). * * @param {Element} el * @param {Object} optio

* Check an element for terminal directives in fixed order. * If it finds one, return a terminal link function. * * @param {Element} el * @param {O

* Compile link props on an instance. * * @param {Vue} vm * @param {Element} el * @param {Object} props * @param {Object} [scope] * @return {Func

* Compile an element and return a nodeLinkFn. * * @param {Element} el * @param {Object} options * @return {Function|null}

* Rewrite an expression, prefixing all path accessors with * `scope.` and generate getter/setter functions. * * @param {String} exp * @return {Fun

* Compile a node list and return a childLinkFn. * * @param {NodeList} nodeList * @param {Object} options * @return {Function|undefined}

* Compile props on a root element and return * a props link function. * * @param {Element|DocumentFragment} el * @param {Array} propOptions * @re

* Compile the root element of an instance. * * 1. attrs on context container (context scope) * 2. attrs on the component template root node, if *

* Compile a textNode and return a nodeLinkFn. * * @param {TextNode} node * @param {Object} options * @return {Function|null} textNodeLinkFn

* A function that returns a sub-class constructor with the * given name. This gives us much nicer output when * logging instances in the console

* Delete a property and trigger change if necessary. * * @param {Object} obj * @param {String} key

* Find a vm from a fragment. * * @param {Fragment} frag * @return {Vue|undefined}

* Format a subPath, return its plain form if it is * a literal string or number. Otherwise prepend the * dynamic indicator (*). * * @param {String

* Get the default value of a prop. * * @param {Vue} vm * @param {Object} options * @return {*}

* Determine the type of a character in a keypath. * * @param {Char} ch * @return {String} type

* Make sure component options get converted to actual * constructors. * * @param {Object} options

* Ensure all props option syntax are normalized into the * Object-based format. * * @param {Object} options

* Native Array.indexOf uses strict equal, but in this * case we need to match string/numbers with custom equal. * * @param {Array} arr * @param {*

* Check if an element is hidden - in that case we can just * skip the transition alltogether. * * @param {Element} el * @return {Boolean}

* Make a child link function for a node's childNodes. * * @param {Array<Function>} linkFns * @return {Function} childLinkFn

* Build a link function for all directives on a single node. * * @param {Array} directives * @return {Function} directivesLinkFn

* Build a function that applies props to a vm. * * @param {Array} props * @return {Function} propsLinkFn

* Build a function that processes a textNode. * * @param {Array<Object>} tokens * @param {DocumentFragment} frag

* Merge the attributes of two elements, and make sure * the class names are merged properly. * * @param {Element} from * @param {Element} to

* Normalize a CSS property name. * - cache result * - auto prefix * - camelCase -> dash-case * * @param {String} prop * @return {String}

* Parse modifiers from directive attribute name. * * @param {String} name * @return {Object}

* External parse that check for a cache hit first * * @param {String} path * @return {Array|undefined}

* Auto detect the appropriate prefix for a CSS property. * https://gist.github.com/paulirish/523692 * * @param {String} prop * @return {String}

* Process a single text token. * * @param {Object} token * @param {Object} options * @return {Node}

* Push a watcher into the watcher queue. * Jobs with duplicate IDs will be skipped unless it's * pushed when the queue is being flushed. * * @para

* Create a range array from given number. * * @param {Number} n * @return {Array}

* Register v-on events on a child component * * @param {Vue} vm * @param {Element} el

* Remove a component view from a Component's hot list * * @param {Function} Component * @param {Directive} view - view directive instance

* Reset the batcher's state.

* Set on an object from a path * * @param {Object} obj * @param {String | Array} path * @param {*} val

* Convert string boolean literals into real booleans. * * @param {*} value * @return {*|Boolean}

* Process an element or a DocumentFragment based on a * instance option object. This allows us to transclude * a template node/fragment before the i

* Process the template option. * If the replace option is true this will swap the $el. * * @param {Element} el * @param {Object} options * @retur

* Recrusively traverse an object to evoke all converted * getters, so that every nested property inside the object * is collected as a "deep" depend

* Update a component view instance * * @param {Directive} view * @param {Function} Component

* A dep is an observable that can have multiple * directives subscribing to it. * * @constructor

* A directive links a DOM element with a piece of data, * which is the result of evaluating an expression. * It registers a watcher with the express

* Abstraction for a partially-compiled fragment. * Can optionally compile content with a child scope. * * @param {Function} linker * @param {Vue}

* A factory that can be used to create instances of a * fragment. Caches the compiled linker if possible. * * @param {Vue} vm * @param {Element|St

* Observer class that are attached to each observed * object. Once attached, the observer converts target * object's property keys into getter/sette

* A Transition object that encapsulates the state and logic * of the transition. * * @param {Element} el * @param {String} id * @param {Object} h

* The exposed Vue constructor. * * API conventions: * - public API methods/properties are prefixed with `$` * - internal methods/properties are pr

* A watcher parses an expression, collects dependencies, * and fires callback when the expression value changes. * This is used for both the $watch(

* Append with transition. * * @param {Element} el * @param {Element} target * @param {Vue} vm * @param {Function} [cb]

* Call attach hook for a Vue instance. * * @param {Vue} child

* InsertBefore operation that takes a callback. * * @param {Node} el * @param {Node} target * @param {Vue} vm - unused * @param {Functi

* InsertBefore with transition. * * @param {Element} el * @param {Element} target * @param {Vue} vm * @param {Function} [cb]

* Iterator to call attached hook * * @param {Vue} child

* Iterator to call detached hook * * @param {Vue} child

* Augment an target Object or Array by defining * hidden properties. * * @param {Object|Array} target * @param {Object} proto

* Call destroy for all contained instances, * with remove:false and defer:true. * Defer is necessary because we need to * keep the children to call

* Call detach hook for a Vue instance. * * @param {Vue} child

* Directive priority sort comparator * * @param {Object} a * @param {Object} b

* Filter filter for arrays * * @param {String} search * @param {String} [delimiter] * @param {String} ...dataKeys

* Flush the queue, and do one forced reflow before * triggering transitions.

* Flush both queues and run the watchers.