\n var values = {name: 'misko', gender: 'male'};\n var log = [];\n angular.forEach(values, function(value, key){\n this.push(key + ': ' + value);\n }, log);\n expect(log).toEqual(['name: misko', 'gender:male']);\n \n *\n * @param {Object|Array} obj Object to iterate over.\n * @param {Function} iterator Iterator function.\n * @param {Object=} context Object to become context (`this`) for the iterator function.\n * @returns {Object|Array} Reference to `obj`.\n */\nfunction forEach(obj, iterator, context) {\n var key;\n if (obj) {\n if (isFunction(obj)){\n for (key in obj) {\n if (key != 'prototype' && key != 'length' && key != 'name' && obj.hasOwnProperty(key)) {\n iterator.call(context, obj[key], key);\n }\n }\n } else if (obj.forEach && obj.forEach !== forEach) {\n obj.forEach(iterator, context);\n } else if (isArrayLike(obj)) {\n for (key = 0; key < obj.length; key++)\n iterator.call(context, obj[key], key);\n } else {\n for (key in obj) {\n if (obj.hasOwnProperty(key)) {\n iterator.call(context, obj[key], key);\n }\n }\n }\n }\n return obj;\n}\n\nfunction sortedKeys(obj) {\n var keys = [];\n for (var key in obj) {\n if (obj.hasOwnProperty(key)) {\n keys.push(key);\n }\n }\n return keys.sort();\n}\n\nfunction forEachSorted(obj, iterator, context) {\n var keys = sortedKeys(obj);\n for ( var i = 0; i < keys.length; i++) {\n iterator.call(context, obj[keys[i]], keys[i]);\n }\n return keys;\n}\n\n\n/**\n * when using forEach the params are value, key, but it is often useful to have key, value.\n * @param {function(string, *)} iteratorFn\n * @returns {function(*, string)}\n */\nfunction reverseParams(iteratorFn) {\n return function(value, key) { iteratorFn(key, value) };\n}\n\n/**\n * A consistent way of creating unique IDs in angular. The ID is a sequence of alpha numeric\n * characters such as '012ABC'. The reason why we are not using simply a number counter is that\n * the number string gets longer over time, and it can also overflow, where as the nextId\n * will grow much slower, it is a string, and it will never overflow.\n *\n * @returns an unique alpha-numeric string\n */\nfunction nextUid() {\n var index = uid.length;\n var digit;\n\n while(index) {\n index--;\n digit = uid[index].charCodeAt(0);\n if (digit == 57 /*'9'*/) {\n uid[index] = 'A';\n return uid.join('');\n }\n if (digit == 90 /*'Z'*/) {\n uid[index] = '0';\n } else {\n uid[index] = String.fromCharCode(digit + 1);\n return uid.join('');\n }\n }\n uid.unshift('0');\n return uid.join('');\n}\n\n\n/**\n * Set or clear the hashkey for an object.\n * @param obj object \n * @param h the hashkey (!truthy to delete the hashkey)\n */\nfunction setHashKey(obj, h) {\n if (h) {\n obj.$$hashKey = h;\n }\n else {\n delete obj.$$hashKey;\n }\n}\n\n/**\n * @ngdoc function\n * @name angular.extend\n * @function\n *\n * @description\n * Extends the destination object `dst` by copying all of the properties from the `src` object(s)\n * to `dst`. You can specify multiple `src` objects.\n *\n * @param {Object} dst Destination object.\n * @param {...Object} src Source object(s).\n * @returns {Object} Reference to `dst`.\n */\nfunction extend(dst) {\n var h = dst.$$hashKey;\n forEach(arguments, function(obj){\n if (obj !== dst) {\n forEach(obj, function(value, key){\n dst[key] = value;\n });\n }\n });\n\n setHashKey(dst,h);\n return dst;\n}\n\nfunction int(str) {\n return parseInt(str, 10);\n}\n\n\nfunction inherit(parent, extra) {\n return extend(new (extend(function() {}, {prototype:parent}))(), extra);\n}\n\nvar START_SPACE = /^\\s*/;\nvar END_SPACE = /\\s*$/;\nfunction stripWhitespace(str) {\n return isString(str) ? str.replace(START_SPACE, '').replace(END_SPACE, '') : str;\n}\n\n/**\n * @ngdoc function\n * @name angular.noop\n * @function\n *\n * @description\n * A function that performs no operations. This function can be useful when writing code in the\n * functional style.\n \n function foo(callback) {\n var result = calculateResult();\n (callback || angular.noop)(result);\n }\n \n */\nfunction noop() {}\nnoop.$inject = [];\n\n\n/**\n * @ngdoc function\n * @name angular.identity\n * @function\n *\n * @description\n * A function that returns its first argument. This function is useful when writing code in the\n * functional style.\n *\n \n function transformer(transformationFn, value) {\n return (transformationFn || identity)(value);\n };\n \n */\nfunction identity($) {return $;}\nidentity.$inject = [];\n\n\nfunction valueFn(value) {return function() {return value;};}\n\n/**\n * @ngdoc function\n * @name angular.isUndefined\n * @function\n *\n * @description\n * Determines if a reference is undefined.\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is undefined.\n */\nfunction isUndefined(value){return typeof value == 'undefined';}\n\n\n/**\n * @ngdoc function\n * @name angular.isDefined\n * @function\n *\n * @description\n * Determines if a reference is defined.\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is defined.\n */\nfunction isDefined(value){return typeof value != 'undefined';}\n\n\n/**\n * @ngdoc function\n * @name angular.isObject\n * @function\n *\n * @description\n * Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not\n * considered to be objects.\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is an `Object` but not `null`.\n */\nfunction isObject(value){return value != null && typeof value == 'object';}\n\n\n/**\n * @ngdoc function\n * @name angular.isString\n * @function\n *\n * @description\n * Determines if a reference is a `String`.\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is a `String`.\n */\nfunction isString(value){return typeof value == 'string';}\n\n\n/**\n * @ngdoc function\n * @name angular.isNumber\n * @function\n *\n * @description\n * Determines if a reference is a `Number`.\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is a `Number`.\n */\nfunction isNumber(value){return typeof value == 'number';}\n\n\n/**\n * @ngdoc function\n * @name angular.isDate\n * @function\n *\n * @description\n * Determines if a value is a date.\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is a `Date`.\n */\nfunction isDate(value){\n return toString.apply(value) == '[object Date]';\n}\n\n\n/**\n * @ngdoc function\n * @name angular.isArray\n * @function\n *\n * @description\n * Determines if a reference is an `Array`.\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is an `Array`.\n */\nfunction isArray(value) {\n return toString.apply(value) == '[object Array]';\n}\n\n\n/**\n * @ngdoc function\n * @name angular.isFunction\n * @function\n *\n * @description\n * Determines if a reference is a `Function`.\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is a `Function`.\n */\nfunction isFunction(value){return typeof value == 'function';}\n\n\n/**\n * Checks if `obj` is a window object.\n *\n * @private\n * @param {*} obj Object to check\n * @returns {boolean} True if `obj` is a window obj.\n */\nfunction isWindow(obj) {\n return obj && obj.document && obj.location && obj.alert && obj.setInterval;\n}\n\n\nfunction isScope(obj) {\n return obj && obj.$evalAsync && obj.$watch;\n}\n\n\nfunction isFile(obj) {\n return toString.apply(obj) === '[object File]';\n}\n\n\nfunction isBoolean(value) {\n return typeof value == 'boolean';\n}\n\n\nfunction trim(value) {\n return isString(value) ? value.replace(/^\\s*/, '').replace(/\\s*$/, '') : value;\n}\n\n/**\n * @ngdoc function\n * @name angular.isElement\n * @function\n *\n * @description\n * Determines if a reference is a DOM element (or wrapped jQuery element).\n *\n * @param {*} value Reference to check.\n * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).\n */\nfunction isElement(node) {\n return node &&\n (node.nodeName // we are a direct element\n || (node.bind && node.find)); // we have a bind and find method part of jQuery API\n}\n\n/**\n * @param str 'key1,key2,...'\n * @returns {object} in the form of {key1:true, key2:true, ...}\n */\nfunction makeMap(str){\n var obj = {}, items = str.split(\",\"), i;\n for ( i = 0; i < items.length; i++ )\n obj[ items[i] ] = true;\n return obj;\n}\n\n\nif (msie < 9) {\n nodeName_ = function(element) {\n element = element.nodeName ? element : element[0];\n return (element.scopeName && element.scopeName != 'HTML')\n ? uppercase(element.scopeName + ':' + element.nodeName) : element.nodeName;\n };\n} else {\n nodeName_ = function(element) {\n return element.nodeName ? element.nodeName : element[0].nodeName;\n };\n}\n\n\nfunction map(obj, iterator, context) {\n var results = [];\n forEach(obj, function(value, index, list) {\n results.push(iterator.call(context, value, index, list));\n });\n return results;\n}\n\n\n/**\n * @description\n * Determines the number of elements in an array, the number of properties an object has, or\n * the length of a string.\n *\n * Note: This function is used to augment the Object type in Angular expressions. See\n * {@link angular.Object} for more information about Angular arrays.\n *\n * @param {Object|Array|string} obj Object, array, or string to inspect.\n * @param {boolean} [ownPropsOnly=false] Count only \"own\" properties in an object\n * @returns {number} The size of `obj` or `0` if `obj` is neither an object nor an array.\n */\nfunction size(obj, ownPropsOnly) {\n var size = 0, key;\n\n if (isArray(obj) || isString(obj)) {\n return obj.length;\n } else if (isObject(obj)){\n for (key in obj)\n if (!ownPropsOnly || obj.hasOwnProperty(key))\n size++;\n }\n\n return size;\n}\n\n\nfunction includes(array, obj) {\n return indexOf(array, obj) != -1;\n}\n\nfunction indexOf(array, obj) {\n if (array.indexOf) return array.indexOf(obj);\n\n for ( var i = 0; i < array.length; i++) {\n if (obj === array[i]) return i;\n }\n return -1;\n}\n\nfunction arrayRemove(array, value) {\n var index = indexOf(array, value);\n if (index >=0)\n array.splice(index, 1);\n return value;\n}\n\nfunction isLeafNode (node) {\n if (node) {\n switch (node.nodeName) {\n case \"OPTION\":\n case \"PRE\":\n case \"TITLE\":\n return true;\n }\n }\n return false;\n}\n\n/**\n * @ngdoc function\n * @name angular.copy\n * @function\n *\n * @description\n * Creates a deep copy of `source`, which should be an object or an array.\n *\n * * If no destination is supplied, a copy of the object or array is created.\n * * If a destination is provided, all of its elements (for array) or properties (for objects)\n * are deleted and then all elements/properties from the source are copied to it.\n * * If `source` is not an object or array, `source` is returned.\n *\n * Note: this function is used to augment the Object type in Angular expressions. See\n * {@link ng.$filter} for more information about Angular arrays.\n *\n * @param {*} source The source that will be used to make a copy.\n * Can be any type, including primitives, `null`, and `undefined`.\n * @param {(Object|Array)=} destination Destination into which the source is copied. If\n * provided, must be of the same type as `source`.\n * @returns {*} The copy or updated `destination`, if `destination` was specified.\n */\nfunction copy(source, destination){\n if (isWindow(source) || isScope(source)) throw Error(\"Can't copy Window or Scope\");\n if (!destination) {\n destination = source;\n if (source) {\n if (isArray(source)) {\n destination = copy(source, []);\n } else if (isDate(source)) {\n destination = new Date(source.getTime());\n } else if (isObject(source)) {\n destination = copy(source, {});\n }\n }\n } else {\n if (source === destination) throw Error(\"Can't copy equivalent objects or arrays\");\n if (isArray(source)) {\n destination.length = 0;\n for ( var i = 0; i < source.length; i++) {\n destination.push(copy(source[i]));\n }\n } else {\n var h = destination.$$hashKey;\n forEach(destination, function(value, key){\n delete destination[key];\n });\n for ( var key in source) {\n destination[key] = copy(source[key]);\n }\n setHashKey(destination,h);\n }\n }\n return destination;\n}\n\n/**\n * Create a shallow copy of an object\n */\nfunction shallowCopy(src, dst) {\n dst = dst || {};\n\n for(var key in src) {\n if (src.hasOwnProperty(key) && key.substr(0, 2) !== '$$') {\n dst[key] = src[key];\n }\n }\n\n return dst;\n}\n\n\n/**\n * @ngdoc function\n * @name angular.equals\n * @function\n *\n * @description\n * Determines if two objects or two values are equivalent. Supports value types, arrays and\n * objects.\n *\n * Two objects or values are considered equivalent if at least one of the following is true:\n *\n * * Both objects or values pass `===` comparison.\n * * Both objects or values are of the same type and all of their properties pass `===` comparison.\n * * Both values are NaN. (In JavasScript, NaN == NaN => false. But we consider two NaN as equal)\n *\n * During a property comparison, properties of `function` type and properties with names\n * that begin with `$` are ignored.\n *\n * Scope and DOMWindow objects are being compared only by identify (`===`).\n *\n * @param {*} o1 Object or value to compare.\n * @param {*} o2 Object or value to compare.\n * @returns {boolean} True if arguments are equal.\n */\nfunction equals(o1, o2) {\n if (o1 === o2) return true;\n if (o1 === null || o2 === null) return false;\n if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN\n var t1 = typeof o1, t2 = typeof o2, length, key, keySet;\n if (t1 == t2) {\n if (t1 == 'object') {\n if (isArray(o1)) {\n if ((length = o1.length) == o2.length) {\n for(key=0; key\n * // Create a new module\n * var myModule = angular.module('myModule', []);\n *\n * // register a new service\n * myModule.value('appName', 'MyCoolApp');\n *\n * // configure existing services inside initialization blocks.\n * myModule.config(function($locationProvider) {\n * // Configure existing providers\n * $locationProvider.hashPrefix('!');\n * });\n * \n *\n * Then you can create an injector and load your modules like this:\n *\n * \n * var injector = angular.injector(['ng', 'MyModule'])\n *\n *\n * However it's more likely that you'll just use\n * {@link ng.directive:ngApp ngApp} or\n * {@link angular.bootstrap} to simplify this process for you.\n *\n * @param {!string} name The name of the module to create or retrieve.\n * @param {Array.
\n * module.animation('animation-name', function($inject1, $inject2) {\n * return {\n * //this gets called in preparation to setup an animation\n * setup : function(element) { ... },\n *\n * //this gets called once the animation is run\n * start : function(element, done, memo) { ... }\n * }\n * })\n * \n *\n * See {@link ng.$animationProvider#register $animationProvider.register()} and\n * {@link ng.directive:ngAnimate ngAnimate} for more information.\n */\n animation: invokeLater('$animationProvider', 'register'),\n\n /**\n * @ngdoc method\n * @name angular.Module#filter\n * @methodOf angular.Module\n * @param {string} name Filter name.\n * @param {Function} filterFactory Factory function for creating new instance of filter.\n * @description\n * See {@link ng.$filterProvider#register $filterProvider.register()}.\n */\n filter: invokeLater('$filterProvider', 'register'),\n\n /**\n * @ngdoc method\n * @name angular.Module#controller\n * @methodOf angular.Module\n * @param {string} name Controller name.\n * @param {Function} constructor Controller constructor function.\n * @description\n * See {@link ng.$controllerProvider#register $controllerProvider.register()}.\n */\n controller: invokeLater('$controllerProvider', 'register'),\n\n /**\n * @ngdoc method\n * @name angular.Module#directive\n * @methodOf angular.Module\n * @param {string} name directive name\n * @param {Function} directiveFactory Factory function for creating new instance of\n * directives.\n * @description\n * See {@link ng.$compileProvider#directive $compileProvider.directive()}.\n */\n directive: invokeLater('$compileProvider', 'directive'),\n\n /**\n * @ngdoc method\n * @name angular.Module#config\n * @methodOf angular.Module\n * @param {Function} configFn Execute this function on module load. Useful for service\n * configuration.\n * @description\n * Use this method to register work which needs to be performed on module loading.\n */\n config: config,\n\n /**\n * @ngdoc method\n * @name angular.Module#run\n * @methodOf angular.Module\n * @param {Function} initializationFn Execute this function after injector creation.\n * Useful for application initialization.\n * @description\n * Use this method to register work which should be performed when the injector is done\n * loading all modules.\n */\n run: function(block) {\n runBlocks.push(block);\n return this;\n }\n };\n\n if (configFn) {\n config(configFn);\n }\n\n return moduleInstance;\n\n /**\n * @param {string} provider\n * @param {string} method\n * @param {String=} insertMethod\n * @returns {angular.Module}\n */\n function invokeLater(provider, method, insertMethod) {\n return function() {\n invokeQueue[insertMethod || 'push']([provider, method, arguments]);\n return moduleInstance;\n }\n }\n });\n };\n });\n\n}\n\n/**\n * @ngdoc property\n * @name angular.version\n * @description\n * An object that contains information about the current AngularJS version. This object has the\n * following properties:\n *\n * - `full` – `{string}` – Full version string, such as \"0.9.18\".\n * - `major` – `{number}` – Major version number, such as \"0\".\n * - `minor` – `{number}` – Minor version number, such as \"9\".\n * - `dot` – `{number}` – Dot version number, such as \"18\".\n * - `codeName` – `{string}` – Code name of the release, such as \"jiggling-armfat\".\n */\nvar version = {\n full: '1.1.5', // all of these placeholder strings will be replaced by grunt's\n major: 1, // package task\n minor: 1,\n dot: 5,\n codeName: 'triangle-squarification'\n};\n\n\nfunction publishExternalAPI(angular){\n extend(angular, {\n 'bootstrap': bootstrap,\n 'copy': copy,\n 'extend': extend,\n 'equals': equals,\n 'element': jqLite,\n 'forEach': forEach,\n 'injector': createInjector,\n 'noop':noop,\n 'bind':bind,\n 'toJson': toJson,\n 'fromJson': fromJson,\n 'identity':identity,\n 'isUndefined': isUndefined,\n 'isDefined': isDefined,\n 'isString': isString,\n 'isFunction': isFunction,\n 'isObject': isObject,\n 'isNumber': isNumber,\n 'isElement': isElement,\n 'isArray': isArray,\n 'version': version,\n 'isDate': isDate,\n 'lowercase': lowercase,\n 'uppercase': uppercase,\n 'callbacks': {counter: 0},\n 'noConflict': noConflict\n });\n\n angularModule = setupModuleLoader(window);\n try {\n angularModule('ngLocale');\n } catch (e) {\n angularModule('ngLocale', []).provider('$locale', $LocaleProvider);\n }\n\n angularModule('ng', ['ngLocale'], ['$provide',\n function ngModule($provide) {\n $provide.provider('$compile', $CompileProvider).\n directive({\n a: htmlAnchorDirective,\n input: inputDirective,\n textarea: inputDirective,\n form: formDirective,\n script: scriptDirective,\n select: selectDirective,\n style: styleDirective,\n option: optionDirective,\n ngBind: ngBindDirective,\n ngBindHtmlUnsafe: ngBindHtmlUnsafeDirective,\n ngBindTemplate: ngBindTemplateDirective,\n ngClass: ngClassDirective,\n ngClassEven: ngClassEvenDirective,\n ngClassOdd: ngClassOddDirective,\n ngCsp: ngCspDirective,\n ngCloak: ngCloakDirective,\n ngController: ngControllerDirective,\n ngForm: ngFormDirective,\n ngHide: ngHideDirective,\n ngIf: ngIfDirective,\n ngInclude: ngIncludeDirective,\n ngInit: ngInitDirective,\n ngNonBindable: ngNonBindableDirective,\n ngPluralize: ngPluralizeDirective,\n ngRepeat: ngRepeatDirective,\n ngShow: ngShowDirective,\n ngSubmit: ngSubmitDirective,\n ngStyle: ngStyleDirective,\n ngSwitch: ngSwitchDirective,\n ngSwitchWhen: ngSwitchWhenDirective,\n ngSwitchDefault: ngSwitchDefaultDirective,\n ngOptions: ngOptionsDirective,\n ngView: ngViewDirective,\n ngTransclude: ngTranscludeDirective,\n ngModel: ngModelDirective,\n ngList: ngListDirective,\n ngChange: ngChangeDirective,\n required: requiredDirective,\n ngRequired: requiredDirective,\n ngValue: ngValueDirective\n }).\n directive(ngAttributeAliasDirectives).\n directive(ngEventDirectives);\n $provide.provider({\n $anchorScroll: $AnchorScrollProvider,\n $animation: $AnimationProvider,\n $animator: $AnimatorProvider,\n $browser: $BrowserProvider,\n $cacheFactory: $CacheFactoryProvider,\n $controller: $ControllerProvider,\n $document: $DocumentProvider,\n $exceptionHandler: $ExceptionHandlerProvider,\n $filter: $FilterProvider,\n $interpolate: $InterpolateProvider,\n $http: $HttpProvider,\n $httpBackend: $HttpBackendProvider,\n $location: $LocationProvider,\n $log: $LogProvider,\n $parse: $ParseProvider,\n $route: $RouteProvider,\n $routeParams: $RouteParamsProvider,\n $rootScope: $RootScopeProvider,\n $q: $QProvider,\n $sniffer: $SnifferProvider,\n $templateCache: $TemplateCacheProvider,\n $timeout: $TimeoutProvider,\n $window: $WindowProvider\n });\n }\n ]);\n}\n\n//////////////////////////////////\n//JQLite\n//////////////////////////////////\n\n/**\n * @ngdoc function\n * @name angular.element\n * @function\n *\n * @description\n * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.\n * `angular.element` can be either an alias for [jQuery](http://api.jquery.com/jQuery/) function, if\n * jQuery is available, or a function that wraps the element or string in Angular's jQuery lite\n * implementation (commonly referred to as jqLite).\n *\n * Real jQuery always takes precedence over jqLite, provided it was loaded before `DOMContentLoaded`\n * event fired.\n *\n * jqLite is a tiny, API-compatible subset of jQuery that allows\n * Angular to manipulate the DOM. jqLite implements only the most commonly needed functionality\n * within a very small footprint, so only a subset of the jQuery API - methods, arguments and\n * invocation styles - are supported.\n *\n * Note: All element references in Angular are always wrapped with jQuery or jqLite; they are never\n * raw DOM references.\n *\n * ## Angular's jQuery lite provides the following methods:\n *\n * - [addClass()](http://api.jquery.com/addClass/)\n * - [after()](http://api.jquery.com/after/)\n * - [append()](http://api.jquery.com/append/)\n * - [attr()](http://api.jquery.com/attr/)\n * - [bind()](http://api.jquery.com/bind/) - Does not support namespaces\n * - [children()](http://api.jquery.com/children/) - Does not support selectors\n * - [clone()](http://api.jquery.com/clone/)\n * - [contents()](http://api.jquery.com/contents/)\n * - [css()](http://api.jquery.com/css/)\n * - [data()](http://api.jquery.com/data/)\n * - [eq()](http://api.jquery.com/eq/)\n * - [find()](http://api.jquery.com/find/) - Limited to lookups by tag name\n * - [hasClass()](http://api.jquery.com/hasClass/)\n * - [html()](http://api.jquery.com/html/)\n * - [next()](http://api.jquery.com/next/) - Does not support selectors\n * - [parent()](http://api.jquery.com/parent/) - Does not support selectors\n * - [prepend()](http://api.jquery.com/prepend/)\n * - [prop()](http://api.jquery.com/prop/)\n * - [ready()](http://api.jquery.com/ready/)\n * - [remove()](http://api.jquery.com/remove/)\n * - [removeAttr()](http://api.jquery.com/removeAttr/)\n * - [removeClass()](http://api.jquery.com/removeClass/)\n * - [removeData()](http://api.jquery.com/removeData/)\n * - [replaceWith()](http://api.jquery.com/replaceWith/)\n * - [text()](http://api.jquery.com/text/)\n * - [toggleClass()](http://api.jquery.com/toggleClass/)\n * - [triggerHandler()](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.\n * - [unbind()](http://api.jquery.com/unbind/) - Does not support namespaces\n * - [val()](http://api.jquery.com/val/)\n * - [wrap()](http://api.jquery.com/wrap/)\n *\n * ## In addition to the above, Angular provides additional methods to both jQuery and jQuery lite:\n *\n * - `controller(name)` - retrieves the controller of the current element or its parent. By default\n * retrieves controller associated with the `ngController` directive. If `name` is provided as\n * camelCase directive name, then the controller for this directive will be retrieved (e.g.\n * `'ngModel'`).\n * - `injector()` - retrieves the injector of the current element or its parent.\n * - `scope()` - retrieves the {@link api/ng.$rootScope.Scope scope} of the current\n * element or its parent.\n * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top\n * parent element is reached.\n *\n * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.\n * @returns {Object} jQuery object.\n */\n\nvar jqCache = JQLite.cache = {},\n jqName = JQLite.expando = 'ng-' + new Date().getTime(),\n jqId = 1,\n addEventListenerFn = (window.document.addEventListener\n ? function(element, type, fn) {element.addEventListener(type, fn, false);}\n : function(element, type, fn) {element.attachEvent('on' + type, fn);}),\n removeEventListenerFn = (window.document.removeEventListener\n ? function(element, type, fn) {element.removeEventListener(type, fn, false); }\n : function(element, type, fn) {element.detachEvent('on' + type, fn); });\n\nfunction jqNextId() { return ++jqId; }\n\n\nvar SPECIAL_CHARS_REGEXP = /([\\:\\-\\_]+(.))/g;\nvar MOZ_HACK_REGEXP = /^moz([A-Z])/;\n\n/**\n * Converts snake_case to camelCase.\n * Also there is special case for Moz prefix starting with upper case letter.\n * @param name Name to normalize\n */\nfunction camelCase(name) {\n return name.\n replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {\n return offset ? letter.toUpperCase() : letter;\n }).\n replace(MOZ_HACK_REGEXP, 'Moz$1');\n}\n\n/////////////////////////////////////////////\n// jQuery mutation patch\n//\n// In conjunction with bindJQuery intercepts all jQuery's DOM destruction apis and fires a\n// $destroy event on all DOM nodes being removed.\n//\n/////////////////////////////////////////////\n\nfunction JQLitePatchJQueryRemove(name, dispatchThis) {\n var originalJqFn = jQuery.fn[name];\n originalJqFn = originalJqFn.$original || originalJqFn;\n removePatch.$original = originalJqFn;\n jQuery.fn[name] = removePatch;\n\n function removePatch() {\n var list = [this],\n fireEvent = dispatchThis,\n set, setIndex, setLength,\n element, childIndex, childLength, children,\n fns, events;\n\n while(list.length) {\n set = list.shift();\n for(setIndex = 0, setLength = set.length; setIndex < setLength; setIndex++) {\n element = jqLite(set[setIndex]);\n if (fireEvent) {\n element.triggerHandler('$destroy');\n } else {\n fireEvent = !fireEvent;\n }\n for(childIndex = 0, childLength = (children = element.children()).length;\n childIndex < childLength;\n childIndex++) {\n list.push(jQuery(children[childIndex]));\n }\n }\n }\n return originalJqFn.apply(this, arguments);\n }\n}\n\n/////////////////////////////////////////////\nfunction JQLite(element) {\n if (element instanceof JQLite) {\n return element;\n }\n if (!(this instanceof JQLite)) {\n if (isString(element) && element.charAt(0) != '<') {\n throw Error('selectors not implemented');\n }\n return new JQLite(element);\n }\n\n if (isString(element)) {\n var div = document.createElement('div');\n // Read about the NoScope elements here:\n // http://msdn.microsoft.com/en-us/library/ms533897(VS.85).aspx\n div.innerHTML = '\n * // create an injector\n * var $injector = angular.injector(['ng']);\n *\n * // use the injector to kick off your application\n * // use the type inference to auto inject arguments, or use implicit injection\n * $injector.invoke(function($rootScope, $compile, $document){\n * $compile($document)($rootScope);\n * $rootScope.$digest();\n * });\n * \n */\n\n\n/**\n * @ngdoc overview\n * @name AUTO\n * @description\n *\n * Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.\n */\n\nvar FN_ARGS = /^function\\s*[^\\(]*\\(\\s*([^\\)]*)\\)/m;\nvar FN_ARG_SPLIT = /,/;\nvar FN_ARG = /^\\s*(_?)(\\S+?)\\1\\s*$/;\nvar STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/mg;\nfunction annotate(fn) {\n var $inject,\n fnText,\n argDecl,\n last;\n\n if (typeof fn == 'function') {\n if (!($inject = fn.$inject)) {\n $inject = [];\n fnText = fn.toString().replace(STRIP_COMMENTS, '');\n argDecl = fnText.match(FN_ARGS);\n forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg){\n arg.replace(FN_ARG, function(all, underscore, name){\n $inject.push(name);\n });\n });\n fn.$inject = $inject;\n }\n } else if (isArray(fn)) {\n last = fn.length - 1;\n assertArgFn(fn[last], 'fn');\n $inject = fn.slice(0, last);\n } else {\n assertArgFn(fn, 'fn', true);\n }\n return $inject;\n}\n\n///////////////////////////////////////\n\n/**\n * @ngdoc object\n * @name AUTO.$injector\n * @function\n *\n * @description\n *\n * `$injector` is used to retrieve object instances as defined by\n * {@link AUTO.$provide provider}, instantiate types, invoke methods,\n * and load modules.\n *\n * The following always holds true:\n *\n * \n * var $injector = angular.injector();\n * expect($injector.get('$injector')).toBe($injector);\n * expect($injector.invoke(function($injector){\n * return $injector;\n * }).toBe($injector);\n * \n *\n * # Injection Function Annotation\n *\n * JavaScript does not have annotations, and annotations are needed for dependency injection. The\n * following are all valid ways of annotating function with injection arguments and are equivalent.\n *\n * \n * // inferred (only works if code not minified/obfuscated)\n * $injector.invoke(function(serviceA){});\n *\n * // annotated\n * function explicit(serviceA) {};\n * explicit.$inject = ['serviceA'];\n * $injector.invoke(explicit);\n *\n * // inline\n * $injector.invoke(['serviceA', function(serviceA){}]);\n * \n *\n * ## Inference\n *\n * In JavaScript calling `toString()` on a function returns the function definition. The definition can then be\n * parsed and the function arguments can be extracted. *NOTE:* This does not work with minification, and obfuscation\n * tools since these tools change the argument names.\n *\n * ## `$inject` Annotation\n * By adding a `$inject` property onto a function the injection parameters can be specified.\n *\n * ## Inline\n * As an array of injection names, where the last item in the array is the function to call.\n */\n\n/**\n * @ngdoc method\n * @name AUTO.$injector#get\n * @methodOf AUTO.$injector\n *\n * @description\n * Return an instance of the service.\n *\n * @param {string} name The name of the instance to retrieve.\n * @return {*} The instance.\n */\n\n/**\n * @ngdoc method\n * @name AUTO.$injector#invoke\n * @methodOf AUTO.$injector\n *\n * @description\n * Invoke the method and supply the method arguments from the `$injector`.\n *\n * @param {!function} fn The function to invoke. The function arguments come form the function annotation.\n * @param {Object=} self The `this` for the invoked method.\n * @param {Object=} locals Optional object. If preset then any argument names are read from this object first, before\n * the `$injector` is consulted.\n * @returns {*} the value returned by the invoked `fn` function.\n */\n\n/**\n * @ngdoc method\n * @name AUTO.$injector#has\n * @methodOf AUTO.$injector\n *\n * @description\n * Allows the user to query if the particular service exist.\n *\n * @param {string} Name of the service to query.\n * @returns {boolean} returns true if injector has given service.\n */\n\n/**\n * @ngdoc method\n * @name AUTO.$injector#instantiate\n * @methodOf AUTO.$injector\n * @description\n * Create a new instance of JS type. The method takes a constructor function invokes the new operator and supplies\n * all of the arguments to the constructor function as specified by the constructor annotation.\n *\n * @param {function} Type Annotated constructor function.\n * @param {Object=} locals Optional object. If preset then any argument names are read from this object first, before\n * the `$injector` is consulted.\n * @returns {Object} new instance of `Type`.\n */\n\n/**\n * @ngdoc method\n * @name AUTO.$injector#annotate\n * @methodOf AUTO.$injector\n *\n * @description\n * Returns an array of service names which the function is requesting for injection. This API is used by the injector\n * to determine which services need to be injected into the function when the function is invoked. There are three\n * ways in which the function can be annotated with the needed dependencies.\n *\n * # Argument names\n *\n * The simplest form is to extract the dependencies from the arguments of the function. This is done by converting\n * the function into a string using `toString()` method and extracting the argument names.\n * \n * // Given\n * function MyController($scope, $route) {\n * // ...\n * }\n *\n * // Then\n * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);\n * \n *\n * This method does not work with code minfication / obfuscation. For this reason the following annotation strategies\n * are supported.\n *\n * # The `$inject` property\n *\n * If a function has an `$inject` property and its value is an array of strings, then the strings represent names of\n * services to be injected into the function.\n * \n * // Given\n * var MyController = function(obfuscatedScope, obfuscatedRoute) {\n * // ...\n * }\n * // Define function dependencies\n * MyController.$inject = ['$scope', '$route'];\n *\n * // Then\n * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);\n * \n *\n * # The array notation\n *\n * It is often desirable to inline Injected functions and that's when setting the `$inject` property is very\n * inconvenient. In these situations using the array notation to specify the dependencies in a way that survives\n * minification is a better choice:\n *\n * \n * // We wish to write this (not minification / obfuscation safe)\n * injector.invoke(function($compile, $rootScope) {\n * // ...\n * });\n *\n * // We are forced to write break inlining\n * var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {\n * // ...\n * };\n * tmpFn.$inject = ['$compile', '$rootScope'];\n * injector.invoke(tmpFn);\n *\n * // To better support inline function the inline annotation is supported\n * injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {\n * // ...\n * }]);\n *\n * // Therefore\n * expect(injector.annotate(\n * ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])\n * ).toEqual(['$compile', '$rootScope']);\n * \n *\n * @param {function|Array.\n * function GreetProvider() {\n * var salutation = 'Hello';\n *\n * this.salutation = function(text) {\n * salutation = text;\n * };\n *\n * this.$get = function() {\n * return function (name) {\n * return salutation + ' ' + name + '!';\n * };\n * };\n * }\n *\n * describe('Greeter', function(){\n *\n * beforeEach(module(function($provide) {\n * $provide.provider('greet', GreetProvider);\n * }));\n *\n * it('should greet', inject(function(greet) {\n * expect(greet('angular')).toEqual('Hello angular!');\n * }));\n *\n * it('should allow configuration of salutation', function() {\n * module(function(greetProvider) {\n * greetProvider.salutation('Ahoj');\n * });\n * inject(function(greet) {\n * expect(greet('angular')).toEqual('Ahoj angular!');\n * });\n * });\n * \n */\n\n/**\n * @ngdoc method\n * @name AUTO.$provide#provider\n * @methodOf AUTO.$provide\n * @description\n *\n * Register a provider for a service. The providers can be retrieved and can have additional configuration methods.\n *\n * @param {string} name The name of the instance. NOTE: the provider will be available under `name + 'Provider'` key.\n * @param {(Object|function())} provider If the provider is:\n *\n * - `Object`: then it should have a `$get` method. The `$get` method will be invoked using\n * {@link AUTO.$injector#invoke $injector.invoke()} when an instance needs to be created.\n * - `Constructor`: a new instance of the provider will be created using\n * {@link AUTO.$injector#instantiate $injector.instantiate()}, then treated as `object`.\n *\n * @returns {Object} registered provider instance\n */\n\n/**\n * @ngdoc method\n * @name AUTO.$provide#factory\n * @methodOf AUTO.$provide\n * @description\n *\n * A short hand for configuring services if only `$get` method is required.\n *\n * @param {string} name The name of the instance.\n * @param {function()} $getFn The $getFn for the instance creation. Internally this is a short hand for\n * `$provide.provider(name, {$get: $getFn})`.\n * @returns {Object} registered provider instance\n */\n\n\n/**\n * @ngdoc method\n * @name AUTO.$provide#service\n * @methodOf AUTO.$provide\n * @description\n *\n * A short hand for registering service of given class.\n *\n * @param {string} name The name of the instance.\n * @param {Function} constructor A class (constructor function) that will be instantiated.\n * @returns {Object} registered provider instance\n */\n\n\n/**\n * @ngdoc method\n * @name AUTO.$provide#value\n * @methodOf AUTO.$provide\n * @description\n *\n * A short hand for configuring services if the `$get` method is a constant.\n *\n * @param {string} name The name of the instance.\n * @param {*} value The value.\n * @returns {Object} registered provider instance\n */\n\n\n/**\n * @ngdoc method\n * @name AUTO.$provide#constant\n * @methodOf AUTO.$provide\n * @description\n *\n * A constant value, but unlike {@link AUTO.$provide#value value} it can be injected\n * into configuration function (other modules) and it is not interceptable by\n * {@link AUTO.$provide#decorator decorator}.\n *\n * @param {string} name The name of the constant.\n * @param {*} value The constant value.\n * @returns {Object} registered instance\n */\n\n\n/**\n * @ngdoc method\n * @name AUTO.$provide#decorator\n * @methodOf AUTO.$provide\n * @description\n *\n * Decoration of service, allows the decorator to intercept the service instance creation. The\n * returned instance may be the original instance, or a new instance which delegates to the\n * original instance.\n *\n * @param {string} name The name of the service to decorate.\n * @param {function()} decorator This function will be invoked when the service needs to be\n * instantiated. The function is called using the {@link AUTO.$injector#invoke\n * injector.invoke} method and is therefore fully injectable. Local injection arguments:\n *\n * * `$delegate` - The original service instance, which can be monkey patched, configured,\n * decorated or delegated to.\n */\n\n\nfunction createInjector(modulesToLoad) {\n var INSTANTIATING = {},\n providerSuffix = 'Provider',\n path = [],\n loadedModules = new HashMap(),\n providerCache = {\n $provide: {\n provider: supportObject(provider),\n factory: supportObject(factory),\n service: supportObject(service),\n value: supportObject(value),\n constant: supportObject(constant),\n decorator: decorator\n }\n },\n providerInjector = (providerCache.$injector =\n createInternalInjector(providerCache, function() {\n throw Error(\"Unknown provider: \" + path.join(' <- '));\n })),\n instanceCache = {},\n instanceInjector = (instanceCache.$injector =\n createInternalInjector(instanceCache, function(servicename) {\n var provider = providerInjector.get(servicename + providerSuffix);\n return instanceInjector.invoke(provider.$get, provider);\n }));\n\n\n forEach(loadModules(modulesToLoad), function(fn) { instanceInjector.invoke(fn || noop); });\n\n return instanceInjector;\n\n ////////////////////////////////////\n // $provider\n ////////////////////////////////////\n\n function supportObject(delegate) {\n return function(key, value) {\n if (isObject(key)) {\n forEach(key, reverseParams(delegate));\n } else {\n return delegate(key, value);\n }\n }\n }\n\n function provider(name, provider_) {\n if (isFunction(provider_) || isArray(provider_)) {\n provider_ = providerInjector.instantiate(provider_);\n }\n if (!provider_.$get) {\n throw Error('Provider ' + name + ' must define $get factory method.');\n }\n return providerCache[name + providerSuffix] = provider_;\n }\n\n function factory(name, factoryFn) { return provider(name, { $get: factoryFn }); }\n\n function service(name, constructor) {\n return factory(name, ['$injector', function($injector) {\n return $injector.instantiate(constructor);\n }]);\n }\n\n function value(name, value) { return factory(name, valueFn(value)); }\n\n function constant(name, value) {\n providerCache[name] = value;\n instanceCache[name] = value;\n }\n\n function decorator(serviceName, decorFn) {\n var origProvider = providerInjector.get(serviceName + providerSuffix),\n orig$get = origProvider.$get;\n\n origProvider.$get = function() {\n var origInstance = instanceInjector.invoke(orig$get, origProvider);\n return instanceInjector.invoke(decorFn, null, {$delegate: origInstance});\n };\n }\n\n ////////////////////////////////////\n // Module Loading\n ////////////////////////////////////\n function loadModules(modulesToLoad){\n var runBlocks = [];\n forEach(modulesToLoad, function(module) {\n if (loadedModules.get(module)) return;\n loadedModules.put(module, true);\n if (isString(module)) {\n var moduleFn = angularModule(module);\n runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);\n\n try {\n for(var invokeQueue = moduleFn._invokeQueue, i = 0, ii = invokeQueue.length; i < ii; i++) {\n var invokeArgs = invokeQueue[i],\n provider = providerInjector.get(invokeArgs[0]);\n\n provider[invokeArgs[1]].apply(provider, invokeArgs[2]);\n }\n } catch (e) {\n if (e.message) e.message += ' from ' + module;\n throw e;\n }\n } else if (isFunction(module)) {\n try {\n runBlocks.push(providerInjector.invoke(module));\n } catch (e) {\n if (e.message) e.message += ' from ' + module;\n throw e;\n }\n } else if (isArray(module)) {\n try {\n runBlocks.push(providerInjector.invoke(module));\n } catch (e) {\n if (e.message) e.message += ' from ' + String(module[module.length - 1]);\n throw e;\n }\n } else {\n assertArgFn(module, 'module');\n }\n });\n return runBlocks;\n }\n\n ////////////////////////////////////\n // internal Injector\n ////////////////////////////////////\n\n function createInternalInjector(cache, factory) {\n\n function getService(serviceName) {\n if (typeof serviceName !== 'string') {\n throw Error('Service name expected');\n }\n if (cache.hasOwnProperty(serviceName)) {\n if (cache[serviceName] === INSTANTIATING) {\n throw Error('Circular dependency: ' + path.join(' <- '));\n }\n return cache[serviceName];\n } else {\n try {\n path.unshift(serviceName);\n cache[serviceName] = INSTANTIATING;\n return cache[serviceName] = factory(serviceName);\n } finally {\n path.shift();\n }\n }\n }\n\n function invoke(fn, self, locals){\n var args = [],\n $inject = annotate(fn),\n length, i,\n key;\n\n for(i = 0, length = $inject.length; i < length; i++) {\n key = $inject[i];\n args.push(\n locals && locals.hasOwnProperty(key)\n ? locals[key]\n : getService(key)\n );\n }\n if (!fn.$inject) {\n // this means that we must be an array.\n fn = fn[length];\n }\n\n\n // Performance optimization: http://jsperf.com/apply-vs-call-vs-invoke\n switch (self ? -1 : args.length) {\n case 0: return fn();\n case 1: return fn(args[0]);\n case 2: return fn(args[0], args[1]);\n case 3: return fn(args[0], args[1], args[2]);\n case 4: return fn(args[0], args[1], args[2], args[3]);\n case 5: return fn(args[0], args[1], args[2], args[3], args[4]);\n case 6: return fn(args[0], args[1], args[2], args[3], args[4], args[5]);\n case 7: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n case 8: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);\n case 9: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);\n case 10: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]);\n default: return fn.apply(self, args);\n }\n }\n\n function instantiate(Type, locals) {\n var Constructor = function() {},\n instance, returnedValue;\n\n // Check if Type is annotated and use just the given function at n-1 as parameter\n // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);\n Constructor.prototype = (isArray(Type) ? Type[Type.length - 1] : Type).prototype;\n instance = new Constructor();\n returnedValue = invoke(Type, instance, locals);\n\n return isObject(returnedValue) ? returnedValue : instance;\n }\n\n return {\n invoke: invoke,\n instantiate: instantiate,\n get: getService,\n annotate: annotate,\n has: function(name) {\n return providerCache.hasOwnProperty(name + providerSuffix) || cache.hasOwnProperty(name);\n }\n };\n }\n}\n\n/**\n * @ngdoc function\n * @name ng.$anchorScroll\n * @requires $window\n * @requires $location\n * @requires $rootScope\n *\n * @description\n * When called, it checks current value of `$location.hash()` and scroll to related element,\n * according to rules specified in\n * {@link http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document Html5 spec}.\n *\n * It also watches the `$location.hash()` and scroll whenever it changes to match any anchor.\n * This can be disabled by calling `$anchorScrollProvider.disableAutoScrolling()`.\n */\nfunction $AnchorScrollProvider() {\n\n var autoScrollingEnabled = true;\n\n this.disableAutoScrolling = function() {\n autoScrollingEnabled = false;\n };\n\n this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) {\n var document = $window.document;\n\n // helper function to get first anchor from a NodeList\n // can't use filter.filter, as it accepts only instances of Array\n // and IE can't convert NodeList to an array using [].slice\n // TODO(vojta): use filter if we change it to accept lists as well\n function getFirstAnchor(list) {\n var result = null;\n forEach(list, function(element) {\n if (!result && lowercase(element.nodeName) === 'a') result = element;\n });\n return result;\n }\n\n function scroll() {\n var hash = $location.hash(), elm;\n\n // empty hash, scroll to the top of the page\n if (!hash) $window.scrollTo(0, 0);\n\n // element with given id\n else if ((elm = document.getElementById(hash))) elm.scrollIntoView();\n\n // first anchor with given name :-D\n else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) elm.scrollIntoView();\n\n // no element and hash == 'top', scroll to the top of the page\n else if (hash === 'top') $window.scrollTo(0, 0);\n }\n\n // does not scroll when user clicks on anchor link that is currently on\n // (no url change, no $location.hash() change), browser native does scroll\n if (autoScrollingEnabled) {\n $rootScope.$watch(function autoScrollWatch() {return $location.hash();},\n function autoScrollWatchAction() {\n $rootScope.$evalAsync(scroll);\n });\n }\n\n return scroll;\n }];\n}\n\n\n/**\n * @ngdoc object\n * @name ng.$animationProvider\n * @description\n *\n * The $AnimationProvider provider allows developers to register and access custom JavaScript animations directly inside\n * of a module.\n *\n */\n$AnimationProvider.$inject = ['$provide'];\nfunction $AnimationProvider($provide) {\n var suffix = 'Animation';\n\n /**\n * @ngdoc function\n * @name ng.$animation#register\n * @methodOf ng.$animationProvider\n *\n * @description\n * Registers a new injectable animation factory function. The factory function produces the animation object which\n * has these two properties:\n *\n * * `setup`: `function(Element):*` A function which receives the starting state of the element. The purpose\n * of this function is to get the element ready for animation. Optionally the function returns an memento which\n * is passed to the `start` function.\n * * `start`: `function(Element, doneFunction, *)` The element to animate, the `doneFunction` to be called on\n * element animation completion, and an optional memento from the `setup` function.\n *\n * @param {string} name The name of the animation.\n * @param {function} factory The factory function that will be executed to return the animation object.\n * \n */\n this.register = function(name, factory) {\n $provide.factory(camelCase(name) + suffix, factory);\n };\n\n this.$get = ['$injector', function($injector) {\n /**\n * @ngdoc function\n * @name ng.$animation\n * @function\n *\n * @description\n * The $animation service is used to retrieve any defined animation functions. When executed, the $animation service\n * will return a object that contains the setup and start functions that were defined for the animation.\n *\n * @param {String} name Name of the animation function to retrieve. Animation functions are registered and stored\n * inside of the AngularJS DI so a call to $animate('custom') is the same as injecting `customAnimation`\n * via dependency injection.\n * @return {Object} the animation object which contains the `setup` and `start` functions that perform the animation.\n */\n return function $animation(name) {\n if (name) {\n var animationName = camelCase(name) + suffix;\n if ($injector.has(animationName)) {\n return $injector.get(animationName);\n }\n }\n };\n }];\n}\n\n// NOTE: this is a pseudo directive.\n\n/**\n * @ngdoc directive\n * @name ng.directive:ngAnimate\n *\n * @description\n * The `ngAnimate` directive works as an attribute that is attached alongside pre-existing directives.\n * It effects how the directive will perform DOM manipulation. This allows for complex animations to take place\n * without burdening the directive which uses the animation with animation details. The built in directives\n * `ngRepeat`, `ngInclude`, `ngSwitch`, `ngShow`, `ngHide` and `ngView` already accept `ngAnimate` directive.\n * Custom directives can take advantage of animation through {@link ng.$animator $animator service}.\n *\n * Below is a more detailed breakdown of the supported callback events provided by pre-exisitng ng directives:\n *\n * | Directive | Supported Animations |\n * |========================================================== |====================================================|\n * | {@link ng.directive:ngRepeat#animations ngRepeat} | enter, leave and move |\n * | {@link ng.directive:ngView#animations ngView} | enter and leave |\n * | {@link ng.directive:ngInclude#animations ngInclude} | enter and leave |\n * | {@link ng.directive:ngSwitch#animations ngSwitch} | enter and leave |\n * | {@link ng.directive:ngIf#animations ngIf} | enter and leave |\n * | {@link ng.directive:ngShow#animations ngShow & ngHide} | show and hide |\n *\n * You can find out more information about animations upon visiting each directive page.\n *\n * Below is an example of a directive that makes use of the ngAnimate attribute:\n *\n * \n * \n *\n *\n * The `event1` and `event2` attributes refer to the animation events specific to the directive that has been assigned.\n *\n * Keep in mind that if an animation is running, no child element of such animation can also be animated.\n *\n *\n *\n * \n * \n * \n * \n *\n * \n * \n *
\n * \n *\n * \n *\n *\n * The following code below demonstrates how to perform animations using **CSS animations** with ngAnimate:\n *\n *
\n * \n *\n * \n *\n *\n * ngAnimate will first examine any CSS animation code and then fallback to using CSS transitions.\n *\n * Upon DOM mutation, the event class is added first, then the browser is allowed to reflow the content and then,\n * the active class is added to trigger the animation. The ngAnimate directive will automatically extract the duration\n * of the animation to determine when the animation ends. Once the animation is over then both CSS classes will be\n * removed from the DOM. If a browser does not support CSS transitions or CSS animations then the animation will start and end\n * immediately resulting in a DOM element that is at it's final state. This final state is when the DOM element\n * has no CSS transition/animation classes surrounding it.\n *\n *
\n * var ngModule = angular.module('YourApp', []);\n * ngModule.animation('animate-enter', function() {\n * return {\n * setup : function(element) {\n * //prepare the element for animation\n * element.css({ 'opacity': 0 });\n * var memo = \"...\"; //this value is passed to the start function\n * return memo;\n * },\n * start : function(element, done, memo) {\n * //start the animation\n * element.animate({\n * 'opacity' : 1\n * }, function() {\n * //call when the animation is complete\n * done()\n * });\n * }\n * }\n * });\n * \n *\n * As you can see, the JavaScript code follows a similar template to the CSS3 animations. Once defined, the animation\n * can be used in the same way with the ngAnimate attribute. Keep in mind that, when using JavaScript-enabled\n * animations, ngAnimate will also add in the same CSS classes that CSS-enabled animations do (even if you're not using\n * CSS animations) to animated the element, but it will not attempt to find any CSS3 transition or animation duration/delay values.\n * It will instead close off the animation once the provided done function is executed. So it's important that you\n * make sure your animations remember to fire off the done function once the animations are complete.\n *\n * @param {expression} ngAnimate Used to configure the DOM manipulation animations.\n *\n */\n\nvar $AnimatorProvider = function() {\n var NG_ANIMATE_CONTROLLER = '$ngAnimateController';\n var rootAnimateController = {running:true};\n\n this.$get = ['$animation', '$window', '$sniffer', '$rootElement', '$rootScope',\n function($animation, $window, $sniffer, $rootElement, $rootScope) {\n $rootElement.data(NG_ANIMATE_CONTROLLER, rootAnimateController);\n\n /**\n * @ngdoc function\n * @name ng.$animator\n * @function\n *\n * @description\n * The $animator.create service provides the DOM manipulation API which is decorated with animations.\n *\n * @param {Scope} scope the scope for the ng-animate.\n * @param {Attributes} attr the attributes object which contains the ngAnimate key / value pair. (The attributes are\n * passed into the linking function of the directive using the `$animator`.)\n * @return {object} the animator object which contains the enter, leave, move, show, hide and animate methods.\n */\n var AnimatorService = function(scope, attrs) {\n var animator = {};\n \n /**\n * @ngdoc function\n * @name ng.animator#enter\n * @methodOf ng.$animator\n * @function\n *\n * @description\n * Injects the element object into the DOM (inside of the parent element) and then runs the enter animation.\n *\n * @param {jQuery/jqLite element} element the element that will be the focus of the enter animation\n * @param {jQuery/jqLite element} parent the parent element of the element that will be the focus of the enter animation\n * @param {jQuery/jqLite element} after the sibling element (which is the previous element) of the element that will be the focus of the enter animation\n */\n animator.enter = animateActionFactory('enter', insert, noop);\n \n /**\n * @ngdoc function\n * @name ng.animator#leave\n * @methodOf ng.$animator\n * @function\n *\n * @description\n * Runs the leave animation operation and, upon completion, removes the element from the DOM.\n *\n * @param {jQuery/jqLite element} element the element that will be the focus of the leave animation\n * @param {jQuery/jqLite element} parent the parent element of the element that will be the focus of the leave animation\n */\n animator.leave = animateActionFactory('leave', noop, remove);\n \n /**\n * @ngdoc function\n * @name ng.animator#move\n * @methodOf ng.$animator\n * @function\n *\n * @description\n * Fires the move DOM operation. Just before the animation starts, the animator will either append it into the parent container or\n * add the element directly after the after element if present. Then the move animation will be run.\n *\n * @param {jQuery/jqLite element} element the element that will be the focus of the move animation\n * @param {jQuery/jqLite element} parent the parent element of the element that will be the focus of the move animation\n * @param {jQuery/jqLite element} after the sibling element (which is the previous element) of the element that will be the focus of the move animation\n */\n animator.move = animateActionFactory('move', move, noop);\n \n /**\n * @ngdoc function\n * @name ng.animator#show\n * @methodOf ng.$animator\n * @function\n *\n * @description\n * Reveals the element by setting the CSS property `display` to `block` and then starts the show animation directly after.\n *\n * @param {jQuery/jqLite element} element the element that will be rendered visible or hidden\n */\n animator.show = animateActionFactory('show', show, noop);\n \n /**\n * @ngdoc function\n * @name ng.animator#hide\n * @methodOf ng.$animator\n *\n * @description\n * Starts the hide animation first and sets the CSS `display` property to `none` upon completion.\n *\n * @param {jQuery/jqLite element} element the element that will be rendered visible or hidden\n */\n animator.hide = animateActionFactory('hide', noop, hide);\n\n /**\n * @ngdoc function\n * @name ng.animator#animate\n * @methodOf ng.$animator\n *\n * @description\n * Triggers a custom animation event to be executed on the given element\n *\n * @param {jQuery/jqLite element} element that will be animated\n */\n animator.animate = function(event, element) {\n animateActionFactory(event, noop, noop)(element);\n }\n return animator;\n \n function animateActionFactory(type, beforeFn, afterFn) {\n return function(element, parent, after) {\n var ngAnimateValue = scope.$eval(attrs.ngAnimate);\n var className = ngAnimateValue\n ? isObject(ngAnimateValue) ? ngAnimateValue[type] : ngAnimateValue + '-' + type\n : '';\n var animationPolyfill = $animation(className);\n var polyfillSetup = animationPolyfill && animationPolyfill.setup;\n var polyfillStart = animationPolyfill && animationPolyfill.start;\n var polyfillCancel = animationPolyfill && animationPolyfill.cancel;\n\n if (!className) {\n beforeFn(element, parent, after);\n afterFn(element, parent, after);\n } else {\n var activeClassName = className + '-active';\n\n if (!parent) {\n parent = after ? after.parent() : element.parent();\n }\n if ((!$sniffer.transitions && !polyfillSetup && !polyfillStart) ||\n (parent.inheritedData(NG_ANIMATE_CONTROLLER) || noop).running) {\n beforeFn(element, parent, after);\n afterFn(element, parent, after);\n return;\n }\n\n var animationData = element.data(NG_ANIMATE_CONTROLLER) || {};\n if(animationData.running) {\n (polyfillCancel || noop)(element);\n animationData.done();\n }\n\n element.data(NG_ANIMATE_CONTROLLER, {running:true, done:done});\n element.addClass(className);\n beforeFn(element, parent, after);\n if (element.length == 0) return done();\n\n var memento = (polyfillSetup || noop)(element);\n\n // $window.setTimeout(beginAnimation, 0); this was causing the element not to animate\n // keep at 1 for animation dom rerender\n $window.setTimeout(beginAnimation, 1);\n }\n\n function parseMaxTime(str) {\n var total = 0, values = isString(str) ? str.split(/\\s*,\\s*/) : [];\n forEach(values, function(value) {\n total = Math.max(parseFloat(value) || 0, total);\n });\n return total;\n }\n\n function beginAnimation() {\n element.addClass(activeClassName);\n if (polyfillStart) {\n polyfillStart(element, done, memento);\n } else if (isFunction($window.getComputedStyle)) {\n //one day all browsers will have these properties\n var w3cAnimationProp = 'animation'; \n var w3cTransitionProp = 'transition';\n\n //but some still use vendor-prefixed styles \n var vendorAnimationProp = $sniffer.vendorPrefix + 'Animation';\n var vendorTransitionProp = $sniffer.vendorPrefix + 'Transition';\n\n var durationKey = 'Duration',\n delayKey = 'Delay',\n animationIterationCountKey = 'IterationCount',\n duration = 0;\n \n //we want all the styles defined before and after\n var ELEMENT_NODE = 1;\n forEach(element, function(element) {\n if (element.nodeType == ELEMENT_NODE) {\n var w3cProp = w3cTransitionProp,\n vendorProp = vendorTransitionProp,\n iterations = 1,\n elementStyles = $window.getComputedStyle(element) || {};\n\n //use CSS Animations over CSS Transitions\n if(parseFloat(elementStyles[w3cAnimationProp + durationKey]) > 0 ||\n parseFloat(elementStyles[vendorAnimationProp + durationKey]) > 0) {\n w3cProp = w3cAnimationProp;\n vendorProp = vendorAnimationProp;\n iterations = Math.max(parseInt(elementStyles[w3cProp + animationIterationCountKey]) || 0,\n parseInt(elementStyles[vendorProp + animationIterationCountKey]) || 0,\n iterations);\n }\n\n var parsedDelay = Math.max(parseMaxTime(elementStyles[w3cProp + delayKey]),\n parseMaxTime(elementStyles[vendorProp + delayKey]));\n\n var parsedDuration = Math.max(parseMaxTime(elementStyles[w3cProp + durationKey]),\n parseMaxTime(elementStyles[vendorProp + durationKey]));\n\n duration = Math.max(parsedDelay + (iterations * parsedDuration), duration);\n }\n });\n $window.setTimeout(done, duration * 1000);\n } else {\n done();\n }\n }\n\n function done() {\n if(!done.run) {\n done.run = true;\n afterFn(element, parent, after);\n element.removeClass(className);\n element.removeClass(activeClassName);\n element.removeData(NG_ANIMATE_CONTROLLER);\n }\n }\n };\n }\n \n function show(element) {\n element.css('display', '');\n }\n \n function hide(element) {\n element.css('display', 'none');\n }\n \n function insert(element, parent, after) {\n if (after) {\n after.after(element);\n } else {\n parent.append(element);\n }\n }\n \n function remove(element) {\n element.remove();\n }\n \n function move(element, parent, after) {\n // Do not remove element before insert. Removing will cause data associated with the\n // element to be dropped. Insert will implicitly do the remove.\n insert(element, parent, after);\n }\n };\n\n /**\n * @ngdoc function\n * @name ng.animator#enabled\n * @methodOf ng.$animator\n * @function\n *\n * @param {Boolean=} If provided then set the animation on or off.\n * @return {Boolean} Current animation state.\n *\n * @description\n * Globally enables/disables animations.\n *\n */\n AnimatorService.enabled = function(value) {\n if (arguments.length) {\n rootAnimateController.running = !value;\n }\n return !rootAnimateController.running;\n };\n\n return AnimatorService;\n }];\n};\n\n/**\n * ! This is a private undocumented service !\n *\n * @name ng.$browser\n * @requires $log\n * @description\n * This object has two goals:\n *\n * - hide all the global state in the browser caused by the window object\n * - abstract away all the browser specific features and inconsistencies\n *\n * For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`\n * service, which can be used for convenient testing of the application without the interaction with\n * the real browser apis.\n */\n/**\n * @param {object} window The global window object.\n * @param {object} document jQuery wrapped document.\n * @param {function()} XHR XMLHttpRequest constructor.\n * @param {object} $log console.log or an object with the same interface.\n * @param {object} $sniffer $sniffer service\n */\nfunction Browser(window, document, $log, $sniffer) {\n var self = this,\n rawDocument = document[0],\n location = window.location,\n history = window.history,\n setTimeout = window.setTimeout,\n clearTimeout = window.clearTimeout,\n pendingDeferIds = {};\n\n self.isMock = false;\n\n var outstandingRequestCount = 0;\n var outstandingRequestCallbacks = [];\n\n // TODO(vojta): remove this temporary api\n self.$$completeOutstandingRequest = completeOutstandingRequest;\n self.$$incOutstandingRequestCount = function() { outstandingRequestCount++; };\n\n /**\n * Executes the `fn` function(supports currying) and decrements the `outstandingRequestCallbacks`\n * counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.\n */\n function completeOutstandingRequest(fn) {\n try {\n fn.apply(null, sliceArgs(arguments, 1));\n } finally {\n outstandingRequestCount--;\n if (outstandingRequestCount === 0) {\n while(outstandingRequestCallbacks.length) {\n try {\n outstandingRequestCallbacks.pop()();\n } catch (e) {\n $log.error(e);\n }\n }\n }\n }\n }\n\n /**\n * @private\n * Note: this method is used only by scenario runner\n * TODO(vojta): prefix this method with $$ ?\n * @param {function()} callback Function that will be called when no outstanding request\n */\n self.notifyWhenNoOutstandingRequests = function(callback) {\n // force browser to execute all pollFns - this is needed so that cookies and other pollers fire\n // at some deterministic time in respect to the test runner's actions. Leaving things up to the\n // regular poller would result in flaky tests.\n forEach(pollFns, function(pollFn){ pollFn(); });\n\n if (outstandingRequestCount === 0) {\n callback();\n } else {\n outstandingRequestCallbacks.push(callback);\n }\n };\n\n //////////////////////////////////////////////////////////////\n // Poll Watcher API\n //////////////////////////////////////////////////////////////\n var pollFns = [],\n pollTimeout;\n\n /**\n * @name ng.$browser#addPollFn\n * @methodOf ng.$browser\n *\n * @param {function()} fn Poll function to add\n *\n * @description\n * Adds a function to the list of functions that poller periodically executes,\n * and starts polling if not started yet.\n *\n * @returns {function()} the added function\n */\n self.addPollFn = function(fn) {\n if (isUndefined(pollTimeout)) startPoller(100, setTimeout);\n pollFns.push(fn);\n return fn;\n };\n\n /**\n * @param {number} interval How often should browser call poll functions (ms)\n * @param {function()} setTimeout Reference to a real or fake `setTimeout` function.\n *\n * @description\n * Configures the poller to run in the specified intervals, using the specified\n * setTimeout fn and kicks it off.\n */\n function startPoller(interval, setTimeout) {\n (function check() {\n forEach(pollFns, function(pollFn){ pollFn(); });\n pollTimeout = setTimeout(check, interval);\n })();\n }\n\n //////////////////////////////////////////////////////////////\n // URL API\n //////////////////////////////////////////////////////////////\n\n var lastBrowserUrl = location.href,\n baseElement = document.find('base');\n\n /**\n * @name ng.$browser#url\n * @methodOf ng.$browser\n *\n * @description\n * GETTER:\n * Without any argument, this method just returns current value of location.href.\n *\n * SETTER:\n * With at least one argument, this method sets url to new value.\n * If html5 history api supported, pushState/replaceState is used, otherwise\n * location.href/location.replace is used.\n * Returns its own instance to allow chaining\n *\n * NOTE: this api is intended for use only by the $location service. Please use the\n * {@link ng.$location $location service} to change url.\n *\n * @param {string} url New url (when used as setter)\n * @param {boolean=} replace Should new url replace current history record ?\n */\n self.url = function(url, replace) {\n // setter\n if (url) {\n if (lastBrowserUrl == url) return;\n lastBrowserUrl = url;\n if ($sniffer.history) {\n if (replace) history.replaceState(null, '', url);\n else {\n history.pushState(null, '', url);\n // Crazy Opera Bug: http://my.opera.com/community/forums/topic.dml?id=1185462\n baseElement.attr('href', baseElement.attr('href'));\n }\n } else {\n if (replace) location.replace(url);\n else location.href = url;\n }\n return self;\n // getter\n } else {\n // the replacement is a workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=407172\n return location.href.replace(/%27/g,\"'\");\n }\n };\n\n var urlChangeListeners = [],\n urlChangeInit = false;\n\n function fireUrlChange() {\n if (lastBrowserUrl == self.url()) return;\n\n lastBrowserUrl = self.url();\n forEach(urlChangeListeners, function(listener) {\n listener(self.url());\n });\n }\n\n /**\n * @name ng.$browser#onUrlChange\n * @methodOf ng.$browser\n * @TODO(vojta): refactor to use node's syntax for events\n *\n * @description\n * Register callback function that will be called, when url changes.\n *\n * It's only called when the url is changed by outside of angular:\n * - user types different url into address bar\n * - user clicks on history (forward/back) button\n * - user clicks on a link\n *\n * It's not called when url is changed by $browser.url() method\n *\n * The listener gets called with new url as parameter.\n *\n * NOTE: this api is intended for use only by the $location service. Please use the\n * {@link ng.$location $location service} to monitor url changes in angular apps.\n *\n * @param {function(string)} listener Listener function to be called when url changes.\n * @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.\n */\n self.onUrlChange = function(callback) {\n if (!urlChangeInit) {\n // We listen on both (hashchange/popstate) when available, as some browsers (e.g. Opera)\n // don't fire popstate when user change the address bar and don't fire hashchange when url\n // changed by push/replaceState\n\n // html5 history api - popstate event\n if ($sniffer.history) jqLite(window).bind('popstate', fireUrlChange);\n // hashchange event\n if ($sniffer.hashchange) jqLite(window).bind('hashchange', fireUrlChange);\n // polling\n else self.addPollFn(fireUrlChange);\n\n urlChangeInit = true;\n }\n\n urlChangeListeners.push(callback);\n return callback;\n };\n\n //////////////////////////////////////////////////////////////\n // Misc API\n //////////////////////////////////////////////////////////////\n\n /**\n * Returns current \n * var element = $compile('{{total}}
')(scope);\n * \n *\n * - if on the other hand, you need the element to be cloned, the view reference from the original\n * example would not point to the clone, but rather to the original template that was cloned. In\n * this case, you can access the clone via the cloneAttachFn:\n * \n * var templateHTML = angular.element('{{total}}
'),\n * scope = ....;\n *\n * var clonedElement = $compile(templateHTML)(scope, function(clonedElement, scope) {\n * //attach the clone to DOM document at the right place\n * });\n *\n * //now we have reference to the cloned DOM via `clone`\n * \n *\n *\n * For information on how the compiler works, see the\n * {@link guide/compiler Angular HTML Compiler} section of the Developer Guide.\n */\n\n\n/**\n * @ngdoc service\n * @name ng.$compileProvider\n * @function\n *\n * @description\n */\n$CompileProvider.$inject = ['$provide'];\nfunction $CompileProvider($provide) {\n var hasDirectives = {},\n Suffix = 'Directive',\n COMMENT_DIRECTIVE_REGEXP = /^\\s*directive\\:\\s*([\\d\\w\\-_]+)\\s+(.*)$/,\n CLASS_DIRECTIVE_REGEXP = /(([\\d\\w\\-_]+)(?:\\:([^;]+))?;?)/,\n MULTI_ROOT_TEMPLATE_ERROR = 'Template must have exactly one root element. was: ',\n urlSanitizationWhitelist = /^\\s*(https?|ftp|mailto|file):/;\n\n\n /**\n * @ngdoc function\n * @name ng.$compileProvider#directive\n * @methodOf ng.$compileProvider\n * @function\n *\n * @description\n * Register a new directives with the compiler.\n *\n * @param {string} name Name of the directive in camel-case. (ie ngBind which will match as\n * ng-bind).\n * @param {function} directiveFactory An injectable directive factory function. See {@link guide/directive} for more\n * info.\n * @returns {ng.$compileProvider} Self for chaining.\n */\n this.directive = function registerDirective(name, directiveFactory) {\n if (isString(name)) {\n assertArg(directiveFactory, 'directive');\n if (!hasDirectives.hasOwnProperty(name)) {\n hasDirectives[name] = [];\n $provide.factory(name + Suffix, ['$injector', '$exceptionHandler',\n function($injector, $exceptionHandler) {\n var directives = [];\n forEach(hasDirectives[name], function(directiveFactory) {\n try {\n var directive = $injector.invoke(directiveFactory);\n if (isFunction(directive)) {\n directive = { compile: valueFn(directive) };\n } else if (!directive.compile && directive.link) {\n directive.compile = valueFn(directive.link);\n }\n directive.priority = directive.priority || 0;\n directive.name = directive.name || name;\n directive.require = directive.require || (directive.controller && directive.name);\n directive.restrict = directive.restrict || 'A';\n directives.push(directive);\n } catch (e) {\n $exceptionHandler(e);\n }\n });\n return directives;\n }]);\n }\n hasDirectives[name].push(directiveFactory);\n } else {\n forEach(name, reverseParams(registerDirective));\n }\n return this;\n };\n\n\n /**\n * @ngdoc function\n * @name ng.$compileProvider#urlSanitizationWhitelist\n * @methodOf ng.$compileProvider\n * @function\n *\n * @description\n * Retrieves or overrides the default regular expression that is used for whitelisting of safe\n * urls during a[href] sanitization.\n *\n * The sanitization is a security measure aimed at prevent XSS attacks via html links.\n *\n * Any url about to be assigned to a[href] via data-binding is first normalized and turned into an\n * absolute url. Afterwards the url is matched against the `urlSanitizationWhitelist` regular\n * expression. If a match is found the original url is written into the dom. Otherwise the\n * absolute url is prefixed with `'unsafe:'` string and only then it is written into the DOM.\n *\n * @param {RegExp=} regexp New regexp to whitelist urls with.\n * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for\n * chaining otherwise.\n */\n this.urlSanitizationWhitelist = function(regexp) {\n if (isDefined(regexp)) {\n urlSanitizationWhitelist = regexp;\n return this;\n }\n return urlSanitizationWhitelist;\n };\n\n\n this.$get = [\n '$injector', '$interpolate', '$exceptionHandler', '$http', '$templateCache', '$parse',\n '$controller', '$rootScope', '$document',\n function($injector, $interpolate, $exceptionHandler, $http, $templateCache, $parse,\n $controller, $rootScope, $document) {\n\n var Attributes = function(element, attr) {\n this.$$element = element;\n this.$attr = attr || {};\n };\n\n Attributes.prototype = {\n $normalize: directiveNormalize,\n\n\n /**\n * Set a normalized attribute on the element in a way such that all directives\n * can share the attribute. This function properly handles boolean attributes.\n * @param {string} key Normalized key. (ie ngAttribute)\n * @param {string|boolean} value The value to set. If `null` attribute will be deleted.\n * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.\n * Defaults to true.\n * @param {string=} attrName Optional none normalized name. Defaults to key.\n */\n $set: function(key, value, writeAttr, attrName) {\n var booleanKey = getBooleanAttrName(this.$$element[0], key),\n $$observers = this.$$observers,\n normalizedVal;\n\n if (booleanKey) {\n this.$$element.prop(key, value);\n attrName = booleanKey;\n }\n\n this[key] = value;\n\n // translate normalized key to actual key\n if (attrName) {\n this.$attr[key] = attrName;\n } else {\n attrName = this.$attr[key];\n if (!attrName) {\n this.$attr[key] = attrName = snake_case(key, '-');\n }\n }\n\n\n // sanitize a[href] values\n if (nodeName_(this.$$element[0]) === 'A' && key === 'href') {\n urlSanitizationNode.setAttribute('href', value);\n\n // href property always returns normalized absolute url, so we can match against that\n normalizedVal = urlSanitizationNode.href;\n if (!normalizedVal.match(urlSanitizationWhitelist)) {\n this[key] = value = 'unsafe:' + normalizedVal;\n }\n }\n\n\n if (writeAttr !== false) {\n if (value === null || value === undefined) {\n this.$$element.removeAttr(attrName);\n } else {\n this.$$element.attr(attrName, value);\n }\n }\n\n // fire observers\n $$observers && forEach($$observers[key], function(fn) {\n try {\n fn(value);\n } catch (e) {\n $exceptionHandler(e);\n }\n });\n },\n\n\n /**\n * Observe an interpolated attribute.\n * The observer will never be called, if given attribute is not interpolated.\n *\n * @param {string} key Normalized key. (ie ngAttribute) .\n * @param {function(*)} fn Function that will be called whenever the attribute value changes.\n * @returns {function(*)} the `fn` Function passed in.\n */\n $observe: function(key, fn) {\n var attrs = this,\n $$observers = (attrs.$$observers || (attrs.$$observers = {})),\n listeners = ($$observers[key] || ($$observers[key] = []));\n\n listeners.push(fn);\n $rootScope.$evalAsync(function() {\n if (!listeners.$$inter) {\n // no one registered attribute interpolation function, so lets call it manually\n fn(attrs[key]);\n }\n });\n return fn;\n }\n };\n\n var urlSanitizationNode = $document[0].createElement('a'),\n startSymbol = $interpolate.startSymbol(),\n endSymbol = $interpolate.endSymbol(),\n denormalizeTemplate = (startSymbol == '{{' || endSymbol == '}}')\n ? identity\n : function denormalizeTemplate(template) {\n return template.replace(/\\{\\{/g, startSymbol).replace(/}}/g, endSymbol);\n },\n NG_ATTR_BINDING = /^ngAttr[A-Z]/;\n\n\n return compile;\n\n //================================\n\n function compile($compileNodes, transcludeFn, maxPriority) {\n if (!($compileNodes instanceof jqLite)) {\n // jquery always rewraps, whereas we need to preserve the original selector so that we can modify it.\n $compileNodes = jqLite($compileNodes);\n }\n // We can not compile top level text elements since text nodes can be merged and we will\n // not be able to attach scope data to them, so we will wrap them in \n forEach($compileNodes, function(node, index){\n if (node.nodeType == 3 /* text node */ && node.nodeValue.match(/\\S+/) /* non-empty */ ) {\n $compileNodes[index] = jqLite(node).wrap('').parent()[0];\n }\n });\n var compositeLinkFn = compileNodes($compileNodes, transcludeFn, $compileNodes, maxPriority);\n return function publicLinkFn(scope, cloneConnectFn){\n assertArg(scope, 'scope');\n // important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart\n // and sometimes changes the structure of the DOM.\n var $linkNode = cloneConnectFn\n ? JQLitePrototype.clone.call($compileNodes) // IMPORTANT!!!\n : $compileNodes;\n\n // Attach scope only to non-text nodes.\n for(var i = 0, ii = $linkNode.length; i\n var $interpolate = ...; // injected\n var exp = $interpolate('Hello {{name}}!');\n expect(exp({name:'Angular'}).toEqual('Hello Angular!');\n \n *\n *\n * @param {string} text The text with markup to interpolate.\n * @param {boolean=} mustHaveExpression if set to true then the interpolation string must have\n * embedded expression in order to return an interpolation function. Strings with no\n * embedded expression will return null for the interpolation function.\n * @returns {function(context)} an interpolation function which is used to compute the interpolated\n * string. The function has these parameters:\n *\n * * `context`: an object against which any expressions embedded in the strings are evaluated\n * against.\n *\n */\n function $interpolate(text, mustHaveExpression) {\n var startIndex,\n endIndex,\n index = 0,\n parts = [],\n length = text.length,\n hasInterpolation = false,\n fn,\n exp,\n concat = [];\n\n while(index < length) {\n if ( ((startIndex = text.indexOf(startSymbol, index)) != -1) &&\n ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1) ) {\n (index != startIndex) && parts.push(text.substring(index, startIndex));\n parts.push(fn = $parse(exp = text.substring(startIndex + startSymbolLength, endIndex)));\n fn.exp = exp;\n index = endIndex + endSymbolLength;\n hasInterpolation = true;\n } else {\n // we did not find anything, so we have to add the remainder to the parts array\n (index != length) && parts.push(text.substring(index));\n index = length;\n }\n }\n\n if (!(length = parts.length)) {\n // we added, nothing, must have been an empty string.\n parts.push('');\n length = 1;\n }\n\n if (!mustHaveExpression || hasInterpolation) {\n concat.length = length;\n fn = function(context) {\n try {\n for(var i = 0, ii = length, part; iReload this page with open console, enter text and hit the log button...
\n Message:\n \n \n \n \n \n\n * var getter = $parse('user.name');\n * var setter = getter.assign;\n * var context = {user:{name:'angular'}};\n * var locals = {user:{name:'local'}};\n *\n * expect(getter(context)).toEqual('angular');\n * setter(context, 'newValue');\n * expect(context.user.name).toEqual('newValue');\n * expect(getter(context, locals)).toEqual('local');\n * \n *\n *\n * @param {string} expression String expression to compile.\n * @returns {function(context, locals)} a function which represents the compiled expression:\n *\n * * `context` – `{object}` – an object against which any expressions embedded in the strings\n * are evaluated against (typically a scope object).\n * * `locals` – `{object=}` – local variables context object, useful for overriding values in\n * `context`.\n *\n * The returned function also has the following properties:\n * * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript\n * literal.\n * * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript\n * constant literals.\n * * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be\n * set to a function to change its value on the given context.\n *\n */\nfunction $ParseProvider() {\n var cache = {};\n this.$get = ['$filter', '$sniffer', function($filter, $sniffer) {\n return function(exp) {\n switch(typeof exp) {\n case 'string':\n return cache.hasOwnProperty(exp)\n ? cache[exp]\n : cache[exp] = parser(exp, false, $filter, $sniffer.csp);\n case 'function':\n return exp;\n default:\n return noop;\n }\n };\n }];\n}\n\n/**\n * @ngdoc service\n * @name ng.$q\n * @requires $rootScope\n *\n * @description\n * A promise/deferred implementation inspired by [Kris Kowal's Q](https://github.com/kriskowal/q).\n *\n * [The CommonJS Promise proposal](http://wiki.commonjs.org/wiki/Promises) describes a promise as an\n * interface for interacting with an object that represents the result of an action that is\n * performed asynchronously, and may or may not be finished at any given point in time.\n *\n * From the perspective of dealing with error handling, deferred and promise APIs are to\n * asynchronous programming what `try`, `catch` and `throw` keywords are to synchronous programming.\n *\n * \n * // for the purpose of this example let's assume that variables `$q` and `scope` are\n * // available in the current lexical scope (they could have been injected or passed in).\n *\n * function asyncGreet(name) {\n * var deferred = $q.defer();\n *\n * setTimeout(function() {\n * // since this fn executes async in a future turn of the event loop, we need to wrap\n * // our code into an $apply call so that the model changes are properly observed.\n * scope.$apply(function() {\n * if (okToGreet(name)) {\n * deferred.resolve('Hello, ' + name + '!');\n * } else {\n * deferred.reject('Greeting ' + name + ' is not allowed.');\n * }\n * });\n * }, 1000);\n *\n * return deferred.promise;\n * }\n *\n * var promise = asyncGreet('Robin Hood');\n * promise.then(function(greeting) {\n * alert('Success: ' + greeting);\n * }, function(reason) {\n * alert('Failed: ' + reason);\n * });\n * \n *\n * At first it might not be obvious why this extra complexity is worth the trouble. The payoff\n * comes in the way of\n * [guarantees that promise and deferred APIs make](https://github.com/kriskowal/uncommonjs/blob/master/promises/specification.md).\n *\n * Additionally the promise api allows for composition that is very hard to do with the\n * traditional callback ([CPS](http://en.wikipedia.org/wiki/Continuation-passing_style)) approach.\n * For more on this please see the [Q documentation](https://github.com/kriskowal/q) especially the\n * section on serial or parallel joining of promises.\n *\n *\n * # The Deferred API\n *\n * A new instance of deferred is constructed by calling `$q.defer()`.\n *\n * The purpose of the deferred object is to expose the associated Promise instance as well as APIs\n * that can be used for signaling the successful or unsuccessful completion of the task.\n *\n * **Methods**\n *\n * - `resolve(value)` – resolves the derived promise with the `value`. If the value is a rejection\n * constructed via `$q.reject`, the promise will be rejected instead.\n * - `reject(reason)` – rejects the derived promise with the `reason`. This is equivalent to\n * resolving it with a rejection constructed via `$q.reject`.\n *\n * **Properties**\n *\n * - promise – `{Promise}` – promise object associated with this deferred.\n *\n *\n * # The Promise API\n *\n * A new promise instance is created when a deferred instance is created and can be retrieved by\n * calling `deferred.promise`.\n *\n * The purpose of the promise object is to allow for interested parties to get access to the result\n * of the deferred task when it completes.\n *\n * **Methods**\n *\n * - `then(successCallback, errorCallback)` – regardless of when the promise was or will be resolved\n * or rejected calls one of the success or error callbacks asynchronously as soon as the result\n * is available. The callbacks are called with a single argument the result or rejection reason.\n *\n * This method *returns a new promise* which is resolved or rejected via the return value of the\n * `successCallback` or `errorCallback`.\n *\n * - `always(callback)` – allows you to observe either the fulfillment or rejection of a promise,\n * but to do so without modifying the final value. This is useful to release resources or do some\n * clean-up that needs to be done whether the promise was rejected or resolved. See the [full\n * specification](https://github.com/kriskowal/q/wiki/API-Reference#promisefinallycallback) for\n * more information.\n *\n * # Chaining promises\n *\n * Because calling `then` api of a promise returns a new derived promise, it is easily possible\n * to create a chain of promises:\n *\n * \n * promiseB = promiseA.then(function(result) {\n * return result + 1;\n * });\n *\n * // promiseB will be resolved immediately after promiseA is resolved and its value will be\n * // the result of promiseA incremented by 1\n * \n *\n * It is possible to create chains of any length and since a promise can be resolved with another\n * promise (which will defer its resolution further), it is possible to pause/defer resolution of\n * the promises at any point in the chain. This makes it possible to implement powerful apis like\n * $http's response interceptors.\n *\n *\n * # Differences between Kris Kowal's Q and $q\n *\n * There are three main differences:\n *\n * - $q is integrated with the {@link ng.$rootScope.Scope} Scope model observation\n * mechanism in angular, which means faster propagation of resolution or rejection into your\n * models and avoiding unnecessary browser repaints, which would result in flickering UI.\n * - $q promises are recognized by the templating engine in angular, which means that in templates\n * you can treat promises attached to a scope as if they were the resulting values.\n * - Q has many more features than $q, but that comes at a cost of bytes. $q is tiny, but contains\n * all the important functionality needed for common async tasks.\n * \n * # Testing\n * \n * \n * it('should simulate promise', inject(function($q, $rootScope) {\n * var deferred = $q.defer();\n * var promise = deferred.promise;\n * var resolvedValue;\n * \n * promise.then(function(value) { resolvedValue = value; });\n * expect(resolvedValue).toBeUndefined();\n * \n * // Simulate resolving of promise\n * deferred.resolve(123);\n * // Note that the 'then' function does not get called synchronously.\n * // This is because we want the promise API to always be async, whether or not\n * // it got called synchronously or asynchronously.\n * expect(resolvedValue).toBeUndefined();\n * \n * // Propagate promise resolution to 'then' functions using $apply().\n * $rootScope.$apply();\n * expect(resolvedValue).toEqual(123);\n * });\n * \n */\nfunction $QProvider() {\n\n this.$get = ['$rootScope', '$exceptionHandler', function($rootScope, $exceptionHandler) {\n return qFactory(function(callback) {\n $rootScope.$evalAsync(callback);\n }, $exceptionHandler);\n }];\n}\n\n\n/**\n * Constructs a promise manager.\n *\n * @param {function(function)} nextTick Function for executing functions in the next turn.\n * @param {function(...*)} exceptionHandler Function into which unexpected exceptions are passed for\n * debugging purposes.\n * @returns {object} Promise manager.\n */\nfunction qFactory(nextTick, exceptionHandler) {\n\n /**\n * @ngdoc\n * @name ng.$q#defer\n * @methodOf ng.$q\n * @description\n * Creates a `Deferred` object which represents a task which will finish in the future.\n *\n * @returns {Deferred} Returns a new instance of deferred.\n */\n var defer = function() {\n var pending = [],\n value, deferred;\n\n deferred = {\n\n resolve: function(val) {\n if (pending) {\n var callbacks = pending;\n pending = undefined;\n value = ref(val);\n\n if (callbacks.length) {\n nextTick(function() {\n var callback;\n for (var i = 0, ii = callbacks.length; i < ii; i++) {\n callback = callbacks[i];\n value.then(callback[0], callback[1]);\n }\n });\n }\n }\n },\n\n\n reject: function(reason) {\n deferred.resolve(reject(reason));\n },\n\n\n promise: {\n then: function(callback, errback) {\n var result = defer();\n\n var wrappedCallback = function(value) {\n try {\n result.resolve((callback || defaultCallback)(value));\n } catch(e) {\n exceptionHandler(e);\n result.reject(e);\n }\n };\n\n var wrappedErrback = function(reason) {\n try {\n result.resolve((errback || defaultErrback)(reason));\n } catch(e) {\n exceptionHandler(e);\n result.reject(e);\n }\n };\n\n if (pending) {\n pending.push([wrappedCallback, wrappedErrback]);\n } else {\n value.then(wrappedCallback, wrappedErrback);\n }\n\n return result.promise;\n },\n always: function(callback) {\n \n function makePromise(value, resolved) {\n var result = defer();\n if (resolved) {\n result.resolve(value);\n } else {\n result.reject(value);\n }\n return result.promise;\n }\n \n function handleCallback(value, isResolved) {\n var callbackOutput = null; \n try {\n callbackOutput = (callback ||defaultCallback)();\n } catch(e) {\n return makePromise(e, false);\n } \n if (callbackOutput && callbackOutput.then) {\n return callbackOutput.then(function() {\n return makePromise(value, isResolved);\n }, function(error) {\n return makePromise(error, false);\n });\n } else {\n return makePromise(value, isResolved);\n }\n }\n \n return this.then(function(value) {\n return handleCallback(value, true);\n }, function(error) {\n return handleCallback(error, false);\n });\n }\n }\n };\n\n return deferred;\n };\n\n\n var ref = function(value) {\n if (value && value.then) return value;\n return {\n then: function(callback) {\n var result = defer();\n nextTick(function() {\n result.resolve(callback(value));\n });\n return result.promise;\n }\n };\n };\n\n\n /**\n * @ngdoc\n * @name ng.$q#reject\n * @methodOf ng.$q\n * @description\n * Creates a promise that is resolved as rejected with the specified `reason`. This api should be\n * used to forward rejection in a chain of promises. If you are dealing with the last promise in\n * a promise chain, you don't need to worry about it.\n *\n * When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of\n * `reject` as the `throw` keyword in JavaScript. This also means that if you \"catch\" an error via\n * a promise error callback and you want to forward the error to the promise derived from the\n * current promise, you have to \"rethrow\" the error by returning a rejection constructed via\n * `reject`.\n *\n * \n * promiseB = promiseA.then(function(result) {\n * // success: do something and resolve promiseB\n * // with the old or a new result\n * return result;\n * }, function(reason) {\n * // error: handle the error if possible and\n * // resolve promiseB with newPromiseOrValue,\n * // otherwise forward the rejection to promiseB\n * if (canHandle(reason)) {\n * // handle the error and recover\n * return newPromiseOrValue;\n * }\n * return $q.reject(reason);\n * });\n * \n *\n * @param {*} reason Constant, message, exception or an object representing the rejection reason.\n * @returns {Promise} Returns a promise that was already resolved as rejected with the `reason`.\n */\n var reject = function(reason) {\n return {\n then: function(callback, errback) {\n var result = defer();\n nextTick(function() {\n result.resolve((errback || defaultErrback)(reason));\n });\n return result.promise;\n }\n };\n };\n\n\n /**\n * @ngdoc\n * @name ng.$q#when\n * @methodOf ng.$q\n * @description\n * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise.\n * This is useful when you are dealing with an object that might or might not be a promise, or if\n * the promise comes from a source that can't be trusted.\n *\n * @param {*} value Value or a promise\n * @returns {Promise} Returns a promise of the passed value or promise\n */\n var when = function(value, callback, errback) {\n var result = defer(),\n done;\n\n var wrappedCallback = function(value) {\n try {\n return (callback || defaultCallback)(value);\n } catch (e) {\n exceptionHandler(e);\n return reject(e);\n }\n };\n\n var wrappedErrback = function(reason) {\n try {\n return (errback || defaultErrback)(reason);\n } catch (e) {\n exceptionHandler(e);\n return reject(e);\n }\n };\n\n nextTick(function() {\n ref(value).then(function(value) {\n if (done) return;\n done = true;\n result.resolve(ref(value).then(wrappedCallback, wrappedErrback));\n }, function(reason) {\n if (done) return;\n done = true;\n result.resolve(wrappedErrback(reason));\n });\n });\n\n return result.promise;\n };\n\n\n function defaultCallback(value) {\n return value;\n }\n\n\n function defaultErrback(reason) {\n return reject(reason);\n }\n\n\n /**\n * @ngdoc\n * @name ng.$q#all\n * @methodOf ng.$q\n * @description\n * Combines multiple promises into a single promise that is resolved when all of the input\n * promises are resolved.\n *\n * @param {Array.$location.path() = {{main.$location.path()}}\n $route.current.templateUrl = {{main.$route.current.templateUrl}}\n $route.current.params = {{main.$route.current.params}}\n $route.current.scope.name = {{main.$route.current.scope.name}}\n $routeParams = {{main.$routeParams}}\n \n