* Quick object check - this is primarily used to tell * Objects from primitive values when we know the value * is a JSON-compliant type. * * @para

* Check whether the object has the property. * * @param {Object} obj * @param {String} key * @return {Boolean}

* Create an "anchor" for performing dom insertion/removals. * This is used in a number of scenarios: * - fragment instance * - v-html * - v-if *

* Check if a node is in the document. * Note: document.documentElement.contains should work here * but always returns false for comment nodes in pha

* Convert an Array-like object to a real Array. * * @param {Array-like} list * @param {Number} [start] - start index * @return {Array}

* Resolve an asset. * This function is used because child instances need access * to assets defined in its ancestor chain. * * @param {Object} opt

* Define a reactive property on an Object. * * @param {Object} obj * @param {String} key * @param {*} val

* Remove class with compatibility for IE & SVG * * @param {Element} el * @param {Strong} cls

* Replace target with el * * @param {Element} target * @param {Element} el

* Get and remove an attribute from a node. * * @param {Node} node * @param {String} _attr

* Define a non-enumerable property * * @param {Object} obj * @param {String} key * @param {*} val * @param {Boolean} [enumerable]

* Mix properties into target object. * * @param {Object} to * @param {Object} from

* Parse a directive value and extract the expression * and its filters into a descriptor. * * Example: * * "a + 1 | uppercase" will yield: * {

* Remove el from DOM * * @param {Element} el

* Add class with compatibility for IE & SVG * * @param {Element} el * @param {Strong} cls

* Insert el before target * * @param {Element} el * @param {Element} target

* Simple bind, faster than native * * @param {Function} fn * @param {Object} ctx * @return {Function}

* 1. Deal with Safari cloning nested <template> bug by * manually cloning all template instances. * 2. Deal with IE10/11 textarea placeholder bug

* Parse an expression into re-written getter/setters. * * @param {String} exp * @param {Boolean} needSet * @return {Function}

* Process the template option and normalizes it into a * a DocumentFragment that can be used as a partial or a * instance template. * * @param {*}

* Push a directive. * * @param {String} dirName * @param {Object|Function} def * @param {Boolean} [interp]

* Check and convert possible numeric strings to numbers * before setting back to data * * @param {*} value * @return {*|Number}

* Compile a template and return a reusable composite link * function, which recursively contains more link functions * inside. This top level compil

* Get an attribute with colon or v-bind: prefix. * * @param {Node} node * @param {String} name * @return {String|null}

* Set a prop's initial value on a vm and its data object. * * @param {Vue} vm * @param {Object} prop * @param {*} value

* Check if an element is a template tag. * Note if the template appears inside an SVG its tagName * will be in lowercase. * * @param {Element} el

* Attempt to create an observer instance for a value, * returns the new observer if successfully observed, * or the existing observer if the value a

* Query an element selector if it's not an element already. * * @param {String|Element} el * @return {Element}

* Apply transitions with an operation callback. * * @param {Element} el * @param {Number} direction * 1: enter *

* Assert asset exists

* Make a cancellable version of an async callback. * * @param {Function} fn * @return {Function}

* Compile the directives on an element and return a linker. * * @param {Array|NamedNodeMap} attrs * @param {Object} options * @return {Function}

* Escape a string so it can be used in a RegExp * constructor. * * @param {String} str

* Get from an object from a path string * * @param {Object} obj * @param {String} path

* Apply a linker to a vm/element pair and capture the * directives created during the process. * * @param {Function} linker * @param {Vue} vm

* Check if two values are loosely equal - that is, * if they are plain objects, do they have the same shape? * * @param {*} a * @param {*} b * @r

* Remove event listener shorthand. * * @param {Element} el * @param {String} event * @param {Function} cb

* Add event listener shorthand. * * @param {Element} el * @param {String} event * @param {Function} cb

* Parse a template text string into an array of tokens. * * @param {String} text * @return {Array<Object> | null} * - {String} type

* Trim possible empty head/tail textNodes inside a parent. * * @param {Node} node

* Guard text output, make sure undefined outputs * empty string * * @param {*} value * @return {String}

* String contain helper * * @param {*} val * @param {String} search

* Extract raw content inside an element into a temporary * container div * * @param {Element} el * @param {Boolean} asFragment * @return {Element

* Manual indexOf because it's slightly faster than * native. * * @param {Array} arr * @param {*} obj

* Check if an expression is a simple path. * * @param {String} exp * @return {Boolean}

* Linker functions return an unlink function that * tearsdown all directives instances generated during * the process. * * We create unlink functi

* Map a function to a range of nodes . * * @param {Node} node * @param {Node} end * @param {Function} op

* Merge two option objects into a new one. * Core utility used in both instantiation and inheritance. * * @param {Object} parent * @param {Object}

* Strip quotes from a string * * @param {String} str * @return {String | false}

* Debounce a function so it only gets called after the * input stops arriving after the given wait period. * * @param {Function} func * @param {Nu

* Append operation that takes a callback. * * @param {Node} el * @param {Node} target * @param {Vue} vm - unused * @param {Function} [c

* Assert whether a prop is valid. * * @param {Object} prop * @param {*} value

* "clean" a getter/setter converted object into a plain * object copy. * * @param {Object} - obj * @return {Object}

* Compile a node and return a nodeLinkFn based on the * node type. * * @param {Node} node * @param {Object} options * @return {Function|null}

* Compile a setter function for the expression. * * @param {String} exp * @return {Function|undefined}

* Helper to extract a component container's attributes * into a plain object array. * * @param {Element} el * @return {Array}

* Extract qualified content nodes from a node list. * * @param {NodeList} nodes * @param {Element} parent * @param {Boolean} main * @return {Docu

* Helper to find the previous element that is a fragment * anchor. This is necessary because a destroyed frag's * element could still be lingering i

* Format a single token. * * @param {Object} token * @param {Boolean} single * @return {String}

* Get "is" binding from an element. * * @param {Element} el * @return {Object|undefined}

* Get select value * * @param {SelectElement} el * @param {Boolean} multi * @param {Boolean} init * @return {Array|*}

* Guard an Array-format assets option and converted it * into the key-value Object format. * * @param {Object|Array} assets * @return {Object}

* Inject a hook to a hot reloadable component so that * we can keep track of it. * * @param {Object} options * @param {String} name * @param {Fun

* Shared DOM insertion function. * * @param {Vue} vm * @param {Element} target * @param {Function} [cb] * @param {Boolean} [withTransit

* Check if a node is a supported template node with a * DocumentFragment content. * * @param {Node} node * @return {Boolean}

* Check if a string starts with $ or _ * * @param {String} str * @return {Boolean}

* Build a getter function. Requires eval. * * We isolate the try/catch so it doesn't affect the * optimization of the parse function when it is not

* Make a Component options object hot. * * @param {String} id * @param {Object} options

* Build a node link function for a terminal directive. * A terminal link function terminates the current * compilation recursion and handles compila

* Helper that recursively merges two data objects together.

* Convert a template node to a DocumentFragment. * * @param {Node} node * @return {DocumentFragment}

* Parse a string path into an array of segments * * @param {String} path * @return {Array|undefined}

* Shim the view directive (component or router-view). * * @param {Object} View

* Prepend el to target * * @param {Element} el * @param {Element} target

* Push a filter to the current directive object

* Push a job into the queue. * * @param {Function} job

* Helper to register an event/watch callback. * * @param {Vue} vm * @param {String} action * @param {String} key * @param {Function|Str

* Register callbacks for option events and watchers. * * @param {Vue} vm * @param {String} action * @param {Object} hash

* Remove a range of nodes with transition, store * the nodes in a fragment with correct ordering, * and call callback when done. * * @param {Node}

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

* Run the watchers in a single queue. * * @param {Array} queue

* Convert a string template to a DocumentFragment. * Determines correct wrapping by tag types. Wrapping * strategy found in jQuery & component/domif

* Teardown partial linked directives. * * @param {Vue} vm * @param {Array} dirs * @param {Boolean} destroying

* Format a list of tokens into an expression. * e.g. tokens parsed from 'a {{b}} c' can be serialized * into one single expression as '"a " + b + "

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

* Insert el after target * * @param {Element} el * @param {Element} target