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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

* 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. * * @p

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

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

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

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

* Check if a node is a DocumentFragment. * * @param {Node} node * @return {Boolean}

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

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

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

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

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

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

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

* 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 {Fun

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

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

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

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

* 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 * @param {Boolean} [useCapture]

* Trim possible empty head/tail text and comment * nodes inside a parent. * * @param {Node} node

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

* 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 * @retur

* Get the track by key for an item. * * @param {Number} index * @param {String} key * @param {*} value * @param {String} [trackByKey]

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

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

* 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

* In IE9, setAttribute('class') will result in empty class * if the element also has the :class attribute; However in * PhantomJS, setting `clas

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

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

* 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

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

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

* Add or remove a class/classes on an element * * @param {Element} el * @param {String} key The class name. This may or may not *

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

* 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 * @return {DocumentFragment}

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

* Format a single token. * * @param {Object} token * @param {Vue} [vm] * @param {Boolean} [single] * @return {String}

* For IE9 compat: when both class and :class are present * getAttribute('class') returns wrong value... * * @param {Element} el * @return

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