\n \n\n"
},
{
"path": "chapter1/recipe1/js/angular.js",
"content": "/**\n * @license AngularJS v1.0.4\n * (c) 2010-2012 Google, Inc. http://angularjs.org\n * License: MIT\n */\n(function(window, document, undefined) {\n'use strict';\n\n////////////////////////////////////\n\n/**\n * @ngdoc function\n * @name angular.lowercase\n * @function\n *\n * @description Converts the specified string to lowercase.\n * @param {string} string String to be converted to lowercase.\n * @returns {string} Lowercased string.\n */\nvar lowercase = function(string){return isString(string) ? string.toLowerCase() : string;};\n\n\n/**\n * @ngdoc function\n * @name angular.uppercase\n * @function\n *\n * @description Converts the specified string to uppercase.\n * @param {string} string String to be converted to uppercase.\n * @returns {string} Uppercased string.\n */\nvar uppercase = function(string){return isString(string) ? string.toUpperCase() : string;};\n\n\nvar manualLowercase = function(s) {\n return isString(s)\n ? s.replace(/[A-Z]/g, function(ch) {return fromCharCode(ch.charCodeAt(0) | 32);})\n : s;\n};\nvar manualUppercase = function(s) {\n return isString(s)\n ? s.replace(/[a-z]/g, function(ch) {return fromCharCode(ch.charCodeAt(0) & ~32);})\n : s;\n};\n\n\n// String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish\n// locale, for this reason we need to detect this case and redefine lowercase/uppercase methods\n// with correct but slower alternatives.\nif ('i' !== 'I'.toLowerCase()) {\n lowercase = manualLowercase;\n uppercase = manualUppercase;\n}\n\nfunction fromCharCode(code) {return String.fromCharCode(code);}\n\n\nvar Error = window.Error,\n /** holds major version number for IE or NaN for real browsers */\n msie = int((/msie (\\d+)/.exec(lowercase(navigator.userAgent)) || [])[1]),\n jqLite, // delay binding since jQuery could be loaded after us.\n jQuery, // delay binding\n slice = [].slice,\n push = [].push,\n toString = Object.prototype.toString,\n\n /** @name angular */\n angular = window.angular || (window.angular = {}),\n angularModule,\n nodeName_,\n uid = ['0', '0', '0'];\n\n/**\n * @ngdoc function\n * @name angular.forEach\n * @function\n *\n * @description\n * Invokes the `iterator` function once for each item in `obj` collection, which can be either an\n * object or an array. The `iterator` function is invoked with `iterator(value, key)`, where `value`\n * is the value of an object property or an array element and `key` is the object property key or\n * array element index. Specifying a `context` for the function is optional.\n *\n * Note: this function was previously known as `angular.foreach`.\n *\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 (isObject(obj) && isNumber(obj.length)) {\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 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 * @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 */\nfunction extend(dst) {\n forEach(arguments, function(obj){\n if (obj !== dst) {\n forEach(obj, function(value, key){\n dst[key] = value;\n });\n }\n });\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\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 while(destination.length) {\n destination.pop();\n }\n for ( var i = 0; i < source.length; i++) {\n destination.push(copy(source[i]));\n }\n } else {\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 }\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 comparision, properties of `function` type and properties with names\n * that begin with `$` are ignored.\n *\n * Scope and DOMWindow objects are being compared only be 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 2 ? sliceArgs(arguments, 2) : [];\n if (isFunction(fn) && !(fn instanceof RegExp)) {\n return curryArgs.length\n ? function() {\n return arguments.length\n ? fn.apply(self, curryArgs.concat(slice.call(arguments, 0)))\n : fn.apply(self, curryArgs);\n }\n : function() {\n return arguments.length\n ? fn.apply(self, arguments)\n : fn.call(self);\n };\n } else {\n // in IE, native methods are not functions so they cannot be bound (note: they don't need to be)\n return fn;\n }\n}\n\n\nfunction toJsonReplacer(key, value) {\n var val = value;\n\n if (/^\\$+/.test(key)) {\n val = undefined;\n } else if (isWindow(value)) {\n val = '$WINDOW';\n } else if (value && document === value) {\n val = '$DOCUMENT';\n } else if (isScope(value)) {\n val = '$SCOPE';\n }\n\n return val;\n}\n\n\n/**\n * @ngdoc function\n * @name angular.toJson\n * @function\n *\n * @description\n * Serializes input into a JSON-formatted string.\n *\n * @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.\n * @param {boolean=} pretty If set to true, the JSON output will contain newlines and whitespace.\n * @returns {string} Jsonified string representing `obj`.\n */\nfunction toJson(obj, pretty) {\n return JSON.stringify(obj, toJsonReplacer, pretty ? ' ' : null);\n}\n\n\n/**\n * @ngdoc function\n * @name angular.fromJson\n * @function\n *\n * @description\n * Deserializes a JSON string.\n *\n * @param {string} json JSON string to deserialize.\n * @returns {Object|Array|Date|string|number} Deserialized thingy.\n */\nfunction fromJson(json) {\n return isString(json)\n ? JSON.parse(json)\n : json;\n}\n\n\nfunction toBoolean(value) {\n if (value && value.length !== 0) {\n var v = lowercase(\"\" + value);\n value = !(v == 'f' || v == '0' || v == 'false' || v == 'no' || v == 'n' || v == '[]');\n } else {\n value = false;\n }\n return value;\n}\n\n/**\n * @returns {string} Returns the string representation of the element.\n */\nfunction startingTag(element) {\n element = jqLite(element).clone();\n try {\n // turns out IE does not let you set .html() on elements which\n // are not allowed to have children. So we just ignore it.\n element.html('');\n } catch(e) {}\n return jqLite('
').append(element).html().\n match(/^(<[^>]+>)/)[1].\n replace(/^<([\\w\\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });\n}\n\n\n/////////////////////////////////////////////////\n\n/**\n * Parses an escaped url query string into key-value pairs.\n * @returns Object.<(string|boolean)>\n */\nfunction parseKeyValue(/**string*/keyValue) {\n var obj = {}, key_value, key;\n forEach((keyValue || \"\").split('&'), function(keyValue){\n if (keyValue) {\n key_value = keyValue.split('=');\n key = decodeURIComponent(key_value[0]);\n obj[key] = isDefined(key_value[1]) ? decodeURIComponent(key_value[1]) : true;\n }\n });\n return obj;\n}\n\nfunction toKeyValue(obj) {\n var parts = [];\n forEach(obj, function(value, key) {\n parts.push(encodeUriQuery(key, true) + (value === true ? '' : '=' + encodeUriQuery(value, true)));\n });\n return parts.length ? parts.join('&') : '';\n}\n\n\n/**\n * We need our custom method because encodeURIComponent is too agressive and doesn't follow\n * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path\n * segments:\n * segment = *pchar\n * pchar = unreserved / pct-encoded / sub-delims / \":\" / \"@\"\n * pct-encoded = \"%\" HEXDIG HEXDIG\n * unreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\n * sub-delims = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\"\n * / \"*\" / \"+\" / \",\" / \";\" / \"=\"\n */\nfunction encodeUriSegment(val) {\n return encodeUriQuery(val, true).\n replace(/%26/gi, '&').\n replace(/%3D/gi, '=').\n replace(/%2B/gi, '+');\n}\n\n\n/**\n * This method is intended for encoding *key* or *value* parts of query component. We need a custom\n * method becuase encodeURIComponent is too agressive and encodes stuff that doesn't have to be\n * encoded per http://tools.ietf.org/html/rfc3986:\n * query = *( pchar / \"/\" / \"?\" )\n * pchar = unreserved / pct-encoded / sub-delims / \":\" / \"@\"\n * unreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\n * pct-encoded = \"%\" HEXDIG HEXDIG\n * sub-delims = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\"\n * / \"*\" / \"+\" / \",\" / \";\" / \"=\"\n */\nfunction encodeUriQuery(val, pctEncodeSpaces) {\n return encodeURIComponent(val).\n replace(/%40/gi, '@').\n replace(/%3A/gi, ':').\n replace(/%24/g, '$').\n replace(/%2C/gi, ',').\n replace((pctEncodeSpaces ? null : /%20/g), '+');\n}\n\n\n/**\n * @ngdoc directive\n * @name ng.directive:ngApp\n *\n * @element ANY\n * @param {angular.Module} ngApp an optional application\n * {@link angular.module module} name to load.\n *\n * @description\n *\n * Use this directive to auto-bootstrap on application. Only\n * one directive can be used per HTML document. The directive\n * designates the root of the application and is typically placed\n * ot the root of the page.\n *\n * In the example below if the `ngApp` directive would not be placed\n * on the `html` element then the document would not be compiled\n * and the `{{ 1+2 }}` would not be resolved to `3`.\n *\n * `ngApp` is the easiest way to bootstrap an application.\n *\n \n \n I can add: 1 + 2 = {{ 1+2 }}\n \n \n *\n */\nfunction angularInit(element, bootstrap) {\n var elements = [element],\n appElement,\n module,\n names = ['ng:app', 'ng-app', 'x-ng-app', 'data-ng-app'],\n NG_APP_CLASS_REGEXP = /\\sng[:\\-]app(:\\s*([\\w\\d_]+);?)?\\s/;\n\n function append(element) {\n element && elements.push(element);\n }\n\n forEach(names, function(name) {\n names[name] = true;\n append(document.getElementById(name));\n name = name.replace(':', '\\\\:');\n if (element.querySelectorAll) {\n forEach(element.querySelectorAll('.' + name), append);\n forEach(element.querySelectorAll('.' + name + '\\\\:'), append);\n forEach(element.querySelectorAll('[' + name + ']'), append);\n }\n });\n\n forEach(elements, function(element) {\n if (!appElement) {\n var className = ' ' + element.className + ' ';\n var match = NG_APP_CLASS_REGEXP.exec(className);\n if (match) {\n appElement = element;\n module = (match[2] || '').replace(/\\s+/g, ',');\n } else {\n forEach(element.attributes, function(attr) {\n if (!appElement && names[attr.name]) {\n appElement = element;\n module = attr.value;\n }\n });\n }\n }\n });\n if (appElement) {\n bootstrap(appElement, module ? [module] : []);\n }\n}\n\n/**\n * @ngdoc function\n * @name angular.bootstrap\n * @description\n * Use this function to manually start up angular application.\n *\n * See: {@link guide/bootstrap Bootstrap}\n *\n * @param {Element} element DOM element which is the root of angular application.\n * @param {Array=} modules an array of module declarations. See: {@link angular.module modules}\n * @returns {AUTO.$injector} Returns the newly created injector for this app.\n */\nfunction bootstrap(element, modules) {\n element = jqLite(element);\n modules = modules || [];\n modules.unshift(['$provide', function($provide) {\n $provide.value('$rootElement', element);\n }]);\n modules.unshift('ng');\n var injector = createInjector(modules);\n injector.invoke(\n ['$rootScope', '$rootElement', '$compile', '$injector', function(scope, element, compile, injector){\n scope.$apply(function() {\n element.data('$injector', injector);\n compile(element)(scope);\n });\n }]\n );\n return injector;\n}\n\nvar SNAKE_CASE_REGEXP = /[A-Z]/g;\nfunction snake_case(name, separator){\n separator = separator || '_';\n return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {\n return (pos ? separator : '') + letter.toLowerCase();\n });\n}\n\nfunction bindJQuery() {\n // bind to jQuery if present;\n jQuery = window.jQuery;\n // reset to jQuery or default to us.\n if (jQuery) {\n jqLite = jQuery;\n extend(jQuery.fn, {\n scope: JQLitePrototype.scope,\n controller: JQLitePrototype.controller,\n injector: JQLitePrototype.injector,\n inheritedData: JQLitePrototype.inheritedData\n });\n JQLitePatchJQueryRemove('remove', true);\n JQLitePatchJQueryRemove('empty');\n JQLitePatchJQueryRemove('html');\n } else {\n jqLite = JQLite;\n }\n angular.element = jqLite;\n}\n\n/**\n * throw error of the argument is falsy.\n */\nfunction assertArg(arg, name, reason) {\n if (!arg) {\n throw new Error(\"Argument '\" + (name || '?') + \"' is \" + (reason || \"required\"));\n }\n return arg;\n}\n\nfunction assertArgFn(arg, name, acceptArrayAnnotation) {\n if (acceptArrayAnnotation && isArray(arg)) {\n arg = arg[arg.length - 1];\n }\n\n assertArg(isFunction(arg), name, 'not a function, got ' +\n (arg && typeof arg == 'object' ? arg.constructor.name || 'Object' : typeof arg));\n return arg;\n}\n\n/**\n * @ngdoc interface\n * @name angular.Module\n * @description\n *\n * Interface for configuring angular {@link angular.module modules}.\n */\n\nfunction setupModuleLoader(window) {\n\n function ensure(obj, name, factory) {\n return obj[name] || (obj[name] = factory());\n }\n\n return ensure(ensure(window, 'angular', Object), 'module', function() {\n /** @type {Object.} */\n var modules = {};\n\n /**\n * @ngdoc function\n * @name angular.module\n * @description\n *\n * The `angular.module` is a global place for creating and registering Angular modules. All\n * modules (angular core or 3rd party) that should be available to an application must be\n * registered using this mechanism.\n *\n *\n * # Module\n *\n * A module is a collocation of services, directives, filters, and configuration information. Module\n * is used to configure the {@link AUTO.$injector $injector}.\n *\n *
\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.=} requires If specified then new module is being created. If unspecified then the\n * the module is being retrieved for further configuration.\n * @param {Function} configFn Optional configuration function for the module. Same as\n * {@link angular.Module#config Module#config()}.\n * @returns {module} new module with the {@link angular.Module} api.\n */\n return function module(name, requires, configFn) {\n if (requires && modules.hasOwnProperty(name)) {\n modules[name] = null;\n }\n return ensure(modules, name, function() {\n if (!requires) {\n throw Error('No module: ' + name);\n }\n\n /** @type {!Array.>} */\n var invokeQueue = [];\n\n /** @type {!Array.} */\n var runBlocks = [];\n\n var config = invokeLater('$injector', 'invoke');\n\n /** @type {angular.Module} */\n var moduleInstance = {\n // Private state\n _invokeQueue: invokeQueue,\n _runBlocks: runBlocks,\n\n /**\n * @ngdoc property\n * @name angular.Module#requires\n * @propertyOf angular.Module\n * @returns {Array.} List of module names which must be loaded before this module.\n * @description\n * Holds the list of modules which the injector will load before the current module is loaded.\n */\n requires: requires,\n\n /**\n * @ngdoc property\n * @name angular.Module#name\n * @propertyOf angular.Module\n * @returns {string} Name of the module.\n * @description\n */\n name: name,\n\n\n /**\n * @ngdoc method\n * @name angular.Module#provider\n * @methodOf angular.Module\n * @param {string} name service name\n * @param {Function} providerType Construction function for creating new instance of the service.\n * @description\n * See {@link AUTO.$provide#provider $provide.provider()}.\n */\n provider: invokeLater('$provide', 'provider'),\n\n /**\n * @ngdoc method\n * @name angular.Module#factory\n * @methodOf angular.Module\n * @param {string} name service name\n * @param {Function} providerFunction Function for creating new instance of the service.\n * @description\n * See {@link AUTO.$provide#factory $provide.factory()}.\n */\n factory: invokeLater('$provide', 'factory'),\n\n /**\n * @ngdoc method\n * @name angular.Module#service\n * @methodOf angular.Module\n * @param {string} name service name\n * @param {Function} constructor A constructor function that will be instantiated.\n * @description\n * See {@link AUTO.$provide#service $provide.service()}.\n */\n service: invokeLater('$provide', 'service'),\n\n /**\n * @ngdoc method\n * @name angular.Module#value\n * @methodOf angular.Module\n * @param {string} name service name\n * @param {*} object Service instance object.\n * @description\n * See {@link AUTO.$provide#value $provide.value()}.\n */\n value: invokeLater('$provide', 'value'),\n\n /**\n * @ngdoc method\n * @name angular.Module#constant\n * @methodOf angular.Module\n * @param {string} name constant name\n * @param {*} object Constant value.\n * @description\n * Because the constant are fixed, they get applied before other provide methods.\n * See {@link AUTO.$provide#constant $provide.constant()}.\n */\n constant: invokeLater('$provide', 'constant', 'unshift'),\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.0.4', // all of these placeholder strings will be replaced by rake's\n major: 1, // compile task\n minor: 0,\n dot: 4,\n codeName: 'bewildering-hair'\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 });\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 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 $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/)\n * - [children()](http://api.jquery.com/children/)\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/)\n * - [parent()](http://api.jquery.com/parent/)\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/) - Doesn't pass native event objects to handlers.\n * - [unbind()](http://api.jquery.com/unbind/)\n * - [val()](http://api.jquery.com/val/)\n * - [wrap()](http://api.jquery.com/wrap/)\n *\n * ## In addtion 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 = '
' + element; // IE insanity to make NoScope elements work!\n div.removeChild(div.firstChild); // remove the superfluous div\n JQLiteAddNodes(this, div.childNodes);\n this.remove(); // detach the elements from the temporary DOM div.\n } else {\n JQLiteAddNodes(this, element);\n }\n}\n\nfunction JQLiteClone(element) {\n return element.cloneNode(true);\n}\n\nfunction JQLiteDealoc(element){\n JQLiteRemoveData(element);\n for ( var i = 0, children = element.childNodes || []; i < children.length; i++) {\n JQLiteDealoc(children[i]);\n }\n}\n\nfunction JQLiteUnbind(element, type, fn) {\n var events = JQLiteExpandoStore(element, 'events'),\n handle = JQLiteExpandoStore(element, 'handle');\n\n if (!handle) return; //no listeners registered\n\n if (isUndefined(type)) {\n forEach(events, function(eventHandler, type) {\n removeEventListenerFn(element, type, eventHandler);\n delete events[type];\n });\n } else {\n if (isUndefined(fn)) {\n removeEventListenerFn(element, type, events[type]);\n delete events[type];\n } else {\n arrayRemove(events[type], fn);\n }\n }\n}\n\nfunction JQLiteRemoveData(element) {\n var expandoId = element[jqName],\n expandoStore = jqCache[expandoId];\n\n if (expandoStore) {\n if (expandoStore.handle) {\n expandoStore.events.$destroy && expandoStore.handle({}, '$destroy');\n JQLiteUnbind(element);\n }\n delete jqCache[expandoId];\n element[jqName] = undefined; // ie does not allow deletion of attributes on elements.\n }\n}\n\nfunction JQLiteExpandoStore(element, key, value) {\n var expandoId = element[jqName],\n expandoStore = jqCache[expandoId || -1];\n\n if (isDefined(value)) {\n if (!expandoStore) {\n element[jqName] = expandoId = jqNextId();\n expandoStore = jqCache[expandoId] = {};\n }\n expandoStore[key] = value;\n } else {\n return expandoStore && expandoStore[key];\n }\n}\n\nfunction JQLiteData(element, key, value) {\n var data = JQLiteExpandoStore(element, 'data'),\n isSetter = isDefined(value),\n keyDefined = !isSetter && isDefined(key),\n isSimpleGetter = keyDefined && !isObject(key);\n\n if (!data && !isSimpleGetter) {\n JQLiteExpandoStore(element, 'data', data = {});\n }\n\n if (isSetter) {\n data[key] = value;\n } else {\n if (keyDefined) {\n if (isSimpleGetter) {\n // don't create data in this case.\n return data && data[key];\n } else {\n extend(data, key);\n }\n } else {\n return data;\n }\n }\n}\n\nfunction JQLiteHasClass(element, selector) {\n return ((\" \" + element.className + \" \").replace(/[\\n\\t]/g, \" \").\n indexOf( \" \" + selector + \" \" ) > -1);\n}\n\nfunction JQLiteRemoveClass(element, cssClasses) {\n if (cssClasses) {\n forEach(cssClasses.split(' '), function(cssClass) {\n element.className = trim(\n (\" \" + element.className + \" \")\n .replace(/[\\n\\t]/g, \" \")\n .replace(\" \" + trim(cssClass) + \" \", \" \")\n );\n });\n }\n}\n\nfunction JQLiteAddClass(element, cssClasses) {\n if (cssClasses) {\n forEach(cssClasses.split(' '), function(cssClass) {\n if (!JQLiteHasClass(element, cssClass)) {\n element.className = trim(element.className + ' ' + trim(cssClass));\n }\n });\n }\n}\n\nfunction JQLiteAddNodes(root, elements) {\n if (elements) {\n elements = (!elements.nodeName && isDefined(elements.length) && !isWindow(elements))\n ? elements\n : [ elements ];\n for(var i=0; i < elements.length; i++) {\n root.push(elements[i]);\n }\n }\n}\n\nfunction JQLiteController(element, name) {\n return JQLiteInheritedData(element, '$' + (name || 'ngController' ) + 'Controller');\n}\n\nfunction JQLiteInheritedData(element, name, value) {\n element = jqLite(element);\n\n // if element is the document object work with the html element instead\n // this makes $(document).scope() possible\n if(element[0].nodeType == 9) {\n element = element.find('html');\n }\n\n while (element.length) {\n if (value = element.data(name)) return value;\n element = element.parent();\n }\n}\n\n//////////////////////////////////////////\n// Functions which are declared directly.\n//////////////////////////////////////////\nvar JQLitePrototype = JQLite.prototype = {\n ready: function(fn) {\n var fired = false;\n\n function trigger() {\n if (fired) return;\n fired = true;\n fn();\n }\n\n this.bind('DOMContentLoaded', trigger); // works for modern browsers and IE9\n // we can not use jqLite since we are not done loading and jQuery could be loaded later.\n JQLite(window).bind('load', trigger); // fallback to window.onload for others\n },\n toString: function() {\n var value = [];\n forEach(this, function(e){ value.push('' + e);});\n return '[' + value.join(', ') + ']';\n },\n\n eq: function(index) {\n return (index >= 0) ? jqLite(this[index]) : jqLite(this[this.length + index]);\n },\n\n length: 0,\n push: push,\n sort: [].sort,\n splice: [].splice\n};\n\n//////////////////////////////////////////\n// Functions iterating getter/setters.\n// these functions return self on setter and\n// value on get.\n//////////////////////////////////////////\nvar BOOLEAN_ATTR = {};\nforEach('multiple,selected,checked,disabled,readOnly,required'.split(','), function(value) {\n BOOLEAN_ATTR[lowercase(value)] = value;\n});\nvar BOOLEAN_ELEMENTS = {};\nforEach('input,select,option,textarea,button,form'.split(','), function(value) {\n BOOLEAN_ELEMENTS[uppercase(value)] = true;\n});\n\nfunction getBooleanAttrName(element, name) {\n // check dom last since we will most likely fail on name\n var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];\n\n // booleanAttr is here twice to minimize DOM access\n return booleanAttr && BOOLEAN_ELEMENTS[element.nodeName] && booleanAttr;\n}\n\nforEach({\n data: JQLiteData,\n inheritedData: JQLiteInheritedData,\n\n scope: function(element) {\n return JQLiteInheritedData(element, '$scope');\n },\n\n controller: JQLiteController ,\n\n injector: function(element) {\n return JQLiteInheritedData(element, '$injector');\n },\n\n removeAttr: function(element,name) {\n element.removeAttribute(name);\n },\n\n hasClass: JQLiteHasClass,\n\n css: function(element, name, value) {\n name = camelCase(name);\n\n if (isDefined(value)) {\n element.style[name] = value;\n } else {\n var val;\n\n if (msie <= 8) {\n // this is some IE specific weirdness that jQuery 1.6.4 does not sure why\n val = element.currentStyle && element.currentStyle[name];\n if (val === '') val = 'auto';\n }\n\n val = val || element.style[name];\n\n if (msie <= 8) {\n // jquery weirdness :-/\n val = (val === '') ? undefined : val;\n }\n\n return val;\n }\n },\n\n attr: function(element, name, value){\n var lowercasedName = lowercase(name);\n if (BOOLEAN_ATTR[lowercasedName]) {\n if (isDefined(value)) {\n if (!!value) {\n element[name] = true;\n element.setAttribute(name, lowercasedName);\n } else {\n element[name] = false;\n element.removeAttribute(lowercasedName);\n }\n } else {\n return (element[name] ||\n (element.attributes.getNamedItem(name)|| noop).specified)\n ? lowercasedName\n : undefined;\n }\n } else if (isDefined(value)) {\n element.setAttribute(name, value);\n } else if (element.getAttribute) {\n // the extra argument \"2\" is to get the right thing for a.href in IE, see jQuery code\n // some elements (e.g. Document) don't have get attribute, so return undefined\n var ret = element.getAttribute(name, 2);\n // normalize non-existing attributes to undefined (as jQuery)\n return ret === null ? undefined : ret;\n }\n },\n\n prop: function(element, name, value) {\n if (isDefined(value)) {\n element[name] = value;\n } else {\n return element[name];\n }\n },\n\n text: extend((msie < 9)\n ? function(element, value) {\n if (element.nodeType == 1 /** Element */) {\n if (isUndefined(value))\n return element.innerText;\n element.innerText = value;\n } else {\n if (isUndefined(value))\n return element.nodeValue;\n element.nodeValue = value;\n }\n }\n : function(element, value) {\n if (isUndefined(value)) {\n return element.textContent;\n }\n element.textContent = value;\n }, {$dv:''}),\n\n val: function(element, value) {\n if (isUndefined(value)) {\n return element.value;\n }\n element.value = value;\n },\n\n html: function(element, value) {\n if (isUndefined(value)) {\n return element.innerHTML;\n }\n for (var i = 0, childNodes = element.childNodes; i < childNodes.length; i++) {\n JQLiteDealoc(childNodes[i]);\n }\n element.innerHTML = value;\n }\n}, function(fn, name){\n /**\n * Properties: writes return selection, reads return first value\n */\n JQLite.prototype[name] = function(arg1, arg2) {\n var i, key;\n\n // JQLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it\n // in a way that survives minification.\n if (((fn.length == 2 && (fn !== JQLiteHasClass && fn !== JQLiteController)) ? arg1 : arg2) === undefined) {\n if (isObject(arg1)) {\n\n // we are a write, but the object properties are the key/values\n for(i=0; i < this.length; i++) {\n if (fn === JQLiteData) {\n // data() takes the whole object in jQuery\n fn(this[i], arg1);\n } else {\n for (key in arg1) {\n fn(this[i], key, arg1[key]);\n }\n }\n }\n // return self for chaining\n return this;\n } else {\n // we are a read, so read the first child.\n if (this.length)\n return fn(this[0], arg1, arg2);\n }\n } else {\n // we are a write, so apply to all children\n for(i=0; i < this.length; i++) {\n fn(this[i], arg1, arg2);\n }\n // return self for chaining\n return this;\n }\n return fn.$dv;\n };\n});\n\nfunction createEventHandler(element, events) {\n var eventHandler = function (event, type) {\n if (!event.preventDefault) {\n event.preventDefault = function() {\n event.returnValue = false; //ie\n };\n }\n\n if (!event.stopPropagation) {\n event.stopPropagation = function() {\n event.cancelBubble = true; //ie\n };\n }\n\n if (!event.target) {\n event.target = event.srcElement || document;\n }\n\n if (isUndefined(event.defaultPrevented)) {\n var prevent = event.preventDefault;\n event.preventDefault = function() {\n event.defaultPrevented = true;\n prevent.call(event);\n };\n event.defaultPrevented = false;\n }\n\n event.isDefaultPrevented = function() {\n return event.defaultPrevented;\n };\n\n forEach(events[type || event.type], function(fn) {\n fn.call(element, event);\n });\n\n // Remove monkey-patched methods (IE),\n // as they would cause memory leaks in IE8.\n if (msie <= 8) {\n // IE7/8 does not allow to delete property on native object\n event.preventDefault = null;\n event.stopPropagation = null;\n event.isDefaultPrevented = null;\n } else {\n // It shouldn't affect normal browsers (native methods are defined on prototype).\n delete event.preventDefault;\n delete event.stopPropagation;\n delete event.isDefaultPrevented;\n }\n };\n eventHandler.elem = element;\n return eventHandler;\n}\n\n//////////////////////////////////////////\n// Functions iterating traversal.\n// These functions chain results into a single\n// selector.\n//////////////////////////////////////////\nforEach({\n removeData: JQLiteRemoveData,\n\n dealoc: JQLiteDealoc,\n\n bind: function bindFn(element, type, fn){\n var events = JQLiteExpandoStore(element, 'events'),\n handle = JQLiteExpandoStore(element, 'handle');\n\n if (!events) JQLiteExpandoStore(element, 'events', events = {});\n if (!handle) JQLiteExpandoStore(element, 'handle', handle = createEventHandler(element, events));\n\n forEach(type.split(' '), function(type){\n var eventFns = events[type];\n\n if (!eventFns) {\n if (type == 'mouseenter' || type == 'mouseleave') {\n var counter = 0;\n\n events.mouseenter = [];\n events.mouseleave = [];\n\n bindFn(element, 'mouseover', function(event) {\n counter++;\n if (counter == 1) {\n handle(event, 'mouseenter');\n }\n });\n bindFn(element, 'mouseout', function(event) {\n counter --;\n if (counter == 0) {\n handle(event, 'mouseleave');\n }\n });\n } else {\n addEventListenerFn(element, type, handle);\n events[type] = [];\n }\n eventFns = events[type]\n }\n eventFns.push(fn);\n });\n },\n\n unbind: JQLiteUnbind,\n\n replaceWith: function(element, replaceNode) {\n var index, parent = element.parentNode;\n JQLiteDealoc(element);\n forEach(new JQLite(replaceNode), function(node){\n if (index) {\n parent.insertBefore(node, index.nextSibling);\n } else {\n parent.replaceChild(node, element);\n }\n index = node;\n });\n },\n\n children: function(element) {\n var children = [];\n forEach(element.childNodes, function(element){\n if (element.nodeType === 1)\n children.push(element);\n });\n return children;\n },\n\n contents: function(element) {\n return element.childNodes || [];\n },\n\n append: function(element, node) {\n forEach(new JQLite(node), function(child){\n if (element.nodeType === 1)\n element.appendChild(child);\n });\n },\n\n prepend: function(element, node) {\n if (element.nodeType === 1) {\n var index = element.firstChild;\n forEach(new JQLite(node), function(child){\n if (index) {\n element.insertBefore(child, index);\n } else {\n element.appendChild(child);\n index = child;\n }\n });\n }\n },\n\n wrap: function(element, wrapNode) {\n wrapNode = jqLite(wrapNode)[0];\n var parent = element.parentNode;\n if (parent) {\n parent.replaceChild(wrapNode, element);\n }\n wrapNode.appendChild(element);\n },\n\n remove: function(element) {\n JQLiteDealoc(element);\n var parent = element.parentNode;\n if (parent) parent.removeChild(element);\n },\n\n after: function(element, newElement) {\n var index = element, parent = element.parentNode;\n forEach(new JQLite(newElement), function(node){\n parent.insertBefore(node, index.nextSibling);\n index = node;\n });\n },\n\n addClass: JQLiteAddClass,\n removeClass: JQLiteRemoveClass,\n\n toggleClass: function(element, selector, condition) {\n if (isUndefined(condition)) {\n condition = !JQLiteHasClass(element, selector);\n }\n (condition ? JQLiteAddClass : JQLiteRemoveClass)(element, selector);\n },\n\n parent: function(element) {\n var parent = element.parentNode;\n return parent && parent.nodeType !== 11 ? parent : null;\n },\n\n next: function(element) {\n if (element.nextElementSibling) {\n return element.nextElementSibling;\n }\n\n // IE8 doesn't have nextElementSibling\n var elm = element.nextSibling;\n while (elm != null && elm.nodeType !== 1) {\n elm = elm.nextSibling;\n }\n return elm;\n },\n\n find: function(element, selector) {\n return element.getElementsByTagName(selector);\n },\n\n clone: JQLiteClone,\n\n triggerHandler: function(element, eventName) {\n var eventFns = (JQLiteExpandoStore(element, 'events') || {})[eventName];\n\n forEach(eventFns, function(fn) {\n fn.call(element, null);\n });\n }\n}, function(fn, name){\n /**\n * chaining functions\n */\n JQLite.prototype[name] = function(arg1, arg2) {\n var value;\n for(var i=0; i < this.length; i++) {\n if (value == undefined) {\n value = fn(this[i], arg1, arg2);\n if (value !== undefined) {\n // any function which returns a value needs to be wrapped\n value = jqLite(value);\n }\n } else {\n JQLiteAddNodes(value, fn(this[i], arg1, arg2));\n }\n }\n return value == undefined ? this : value;\n };\n});\n\n/**\n * Computes a hash of an 'obj'.\n * Hash of a:\n * string is string\n * number is number as string\n * object is either result of calling $$hashKey function on the object or uniquely generated id,\n * that is also assigned to the $$hashKey property of the object.\n *\n * @param obj\n * @returns {string} hash string such that the same input will have the same hash string.\n * The resulting string key is in 'type:hashKey' format.\n */\nfunction hashKey(obj) {\n var objType = typeof obj,\n key;\n\n if (objType == 'object' && obj !== null) {\n if (typeof (key = obj.$$hashKey) == 'function') {\n // must invoke on object to keep the right this\n key = obj.$$hashKey();\n } else if (key === undefined) {\n key = obj.$$hashKey = nextUid();\n }\n } else {\n key = obj;\n }\n\n return objType + ':' + key;\n}\n\n/**\n * HashMap which can use objects as keys\n */\nfunction HashMap(array){\n forEach(array, this.put, this);\n}\nHashMap.prototype = {\n /**\n * Store key value pair\n * @param key key to store can be any type\n * @param value value to store can be any type\n */\n put: function(key, value) {\n this[hashKey(key)] = value;\n },\n\n /**\n * @param key\n * @returns the value for the key\n */\n get: function(key) {\n return this[hashKey(key)];\n },\n\n /**\n * Remove the key/value pair\n * @param key\n */\n remove: function(key) {\n var value = this[key = hashKey(key)];\n delete this[key];\n return value;\n }\n};\n\n/**\n * A map where multiple values can be added to the same key such that they form a queue.\n * @returns {HashQueueMap}\n */\nfunction HashQueueMap() {}\nHashQueueMap.prototype = {\n /**\n * Same as array push, but using an array as the value for the hash\n */\n push: function(key, value) {\n var array = this[key = hashKey(key)];\n if (!array) {\n this[key] = [value];\n } else {\n array.push(value);\n }\n },\n\n /**\n * Same as array shift, but using an array as the value for the hash\n */\n shift: function(key) {\n var array = this[key = hashKey(key)];\n if (array) {\n if (array.length == 1) {\n delete this[key];\n return array[0];\n } else {\n return array.shift();\n }\n }\n },\n\n /**\n * return the first item without deleting it\n */\n peek: function(key) {\n var array = this[hashKey(key)];\n if (array) {\n return array[0];\n }\n }\n};\n\n/**\n * @ngdoc function\n * @name angular.injector\n * @function\n *\n * @description\n * Creates an injector function that can be used for retrieving services as well as for\n * dependency injection (see {@link guide/di dependency injection}).\n *\n\n * @param {Array.} modules A list of module functions or their aliases. See\n * {@link angular.module}. The `ng` module must be explicitly added.\n * @returns {function()} Injector function. See {@link AUTO.$injector $injector}.\n *\n * @example\n * Typical usage\n *
\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 *\n * # Injection Function Annotation\n *\n * JavaScript does not have annotations, and annotations are needed for dependency injection. The\n * following ways are all valid way of annotating function with injection arguments and are equivalent.\n *\n *
\n * // inferred (only works if code not minified/obfuscated)\n * $inject.invoke(function(serviceA){});\n *\n * // annotated\n * function explicit(serviceA) {};\n * explicit.$inject = ['serviceA'];\n * $inject.invoke(explicit);\n *\n * // inline\n * $inject.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#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 *\n * This method does not work with code minfication / obfuscation. For this reason the following annotation strategies\n * are supported.\n *\n * # The `$injector` 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 *\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(tempFn);\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.} fn Function for which dependent service names need to be retrieved as described\n * above.\n *\n * @returns {Array.} The names of the services which the function requires.\n */\n\n\n\n\n/**\n * @ngdoc object\n * @name AUTO.$provide\n *\n * @description\n *\n * Use `$provide` to register new providers with the `$injector`. The providers are the factories for the instance.\n * The providers share the same name as the instance they create with the `Provider` suffixed to them.\n *\n * A provider is an object with a `$get()` method. The injector calls the `$get` method to create a new instance of\n * a service. The Provider can have additional methods which would allow for configuration of the provider.\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 * instanciated. 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 = 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 = invokeArgs[0] == '$injector'\n ? providerInjector\n : 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 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 };\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 * ! 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 * (always relative - without domain)\n *\n * @returns {string=}\n */\n self.baseHref = function() {\n var href = baseElement.attr('href');\n return href ? href.replace(/^https?\\:\\/\\/[^\\/]*/, '') : href;\n };\n\n //////////////////////////////////////////////////////////////\n // Cookies API\n //////////////////////////////////////////////////////////////\n var lastCookies = {};\n var lastCookieString = '';\n var cookiePath = self.baseHref();\n\n /**\n * @name ng.$browser#cookies\n * @methodOf ng.$browser\n *\n * @param {string=} name Cookie name\n * @param {string=} value Cokkie value\n *\n * @description\n * The cookies method provides a 'private' low level access to browser cookies.\n * It is not meant to be used directly, use the $cookie service instead.\n *\n * The return values vary depending on the arguments that the method was called with as follows:\n *
\n *
cookies() -> hash of all cookies, this is NOT a copy of the internal state, so do not modify it
\n *
cookies(name, value) -> set name to value, if value is undefined delete the cookie
\n *
cookies(name) -> the same as (name, undefined) == DELETES (no one calls it right now that way)
\n *
\n *\n * @returns {Object} Hash of all cookies (if called without any parameter)\n */\n self.cookies = function(name, value) {\n var cookieLength, cookieArray, cookie, i, index;\n\n if (name) {\n if (value === undefined) {\n rawDocument.cookie = escape(name) + \"=;path=\" + cookiePath + \";expires=Thu, 01 Jan 1970 00:00:00 GMT\";\n } else {\n if (isString(value)) {\n cookieLength = (rawDocument.cookie = escape(name) + '=' + escape(value) + ';path=' + cookiePath).length + 1;\n\n // per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum:\n // - 300 cookies\n // - 20 cookies per unique domain\n // - 4096 bytes per cookie\n if (cookieLength > 4096) {\n $log.warn(\"Cookie '\"+ name +\"' possibly not set or overflowed because it was too large (\"+\n cookieLength + \" > 4096 bytes)!\");\n }\n }\n }\n } else {\n if (rawDocument.cookie !== lastCookieString) {\n lastCookieString = rawDocument.cookie;\n cookieArray = lastCookieString.split(\"; \");\n lastCookies = {};\n\n for (i = 0; i < cookieArray.length; i++) {\n cookie = cookieArray[i];\n index = cookie.indexOf('=');\n if (index > 0) { //ignore nameless cookies\n lastCookies[unescape(cookie.substring(0, index))] = unescape(cookie.substring(index + 1));\n }\n }\n }\n return lastCookies;\n }\n };\n\n\n /**\n * @name ng.$browser#defer\n * @methodOf ng.$browser\n * @param {function()} fn A function, who's execution should be defered.\n * @param {number=} [delay=0] of milliseconds to defer the function execution.\n * @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.\n *\n * @description\n * Executes a fn asynchroniously via `setTimeout(fn, delay)`.\n *\n * Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using\n * `setTimeout` in tests, the fns are queued in an array, which can be programmatically flushed\n * via `$browser.defer.flush()`.\n *\n */\n self.defer = function(fn, delay) {\n var timeoutId;\n outstandingRequestCount++;\n timeoutId = setTimeout(function() {\n delete pendingDeferIds[timeoutId];\n completeOutstandingRequest(fn);\n }, delay || 0);\n pendingDeferIds[timeoutId] = true;\n return timeoutId;\n };\n\n\n /**\n * @name ng.$browser#defer.cancel\n * @methodOf ng.$browser.defer\n *\n * @description\n * Cancels a defered task identified with `deferId`.\n *\n * @param {*} deferId Token returned by the `$browser.defer` function.\n * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfuly canceled.\n */\n self.defer.cancel = function(deferId) {\n if (pendingDeferIds[deferId]) {\n delete pendingDeferIds[deferId];\n clearTimeout(deferId);\n completeOutstandingRequest(noop);\n return true;\n }\n return false;\n };\n\n}\n\nfunction $BrowserProvider(){\n this.$get = ['$window', '$log', '$sniffer', '$document',\n function( $window, $log, $sniffer, $document){\n return new Browser($window, $document, $log, $sniffer);\n }];\n}\n/**\n * @ngdoc object\n * @name ng.$cacheFactory\n *\n * @description\n * Factory that constructs cache objects.\n *\n *\n * @param {string} cacheId Name or id of the newly created cache.\n * @param {object=} options Options object that specifies the cache behavior. Properties:\n *\n * - `{number=}` `capacity` — turns the cache into LRU cache.\n *\n * @returns {object} Newly created cache object with the following set of methods:\n *\n * - `{object}` `info()` — Returns id, size, and options of cache.\n * - `{void}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache.\n * - `{{*}}` `get({string} key)` — Returns cached value for `key` or undefined for cache miss.\n * - `{void}` `remove({string} key)` — Removes a key-value pair from the cache.\n * - `{void}` `removeAll()` — Removes all cached values.\n * - `{void}` `destroy()` — Removes references to this cache from $cacheFactory.\n *\n */\nfunction $CacheFactoryProvider() {\n\n this.$get = function() {\n var caches = {};\n\n function cacheFactory(cacheId, options) {\n if (cacheId in caches) {\n throw Error('cacheId ' + cacheId + ' taken');\n }\n\n var size = 0,\n stats = extend({}, options, {id: cacheId}),\n data = {},\n capacity = (options && options.capacity) || Number.MAX_VALUE,\n lruHash = {},\n freshEnd = null,\n staleEnd = null;\n\n return caches[cacheId] = {\n\n put: function(key, value) {\n var lruEntry = lruHash[key] || (lruHash[key] = {key: key});\n\n refresh(lruEntry);\n\n if (isUndefined(value)) return;\n if (!(key in data)) size++;\n data[key] = value;\n\n if (size > capacity) {\n this.remove(staleEnd.key);\n }\n },\n\n\n get: function(key) {\n var lruEntry = lruHash[key];\n\n if (!lruEntry) return;\n\n refresh(lruEntry);\n\n return data[key];\n },\n\n\n remove: function(key) {\n var lruEntry = lruHash[key];\n\n if (!lruEntry) return;\n\n if (lruEntry == freshEnd) freshEnd = lruEntry.p;\n if (lruEntry == staleEnd) staleEnd = lruEntry.n;\n link(lruEntry.n,lruEntry.p);\n\n delete lruHash[key];\n delete data[key];\n size--;\n },\n\n\n removeAll: function() {\n data = {};\n size = 0;\n lruHash = {};\n freshEnd = staleEnd = null;\n },\n\n\n destroy: function() {\n data = null;\n stats = null;\n lruHash = null;\n delete caches[cacheId];\n },\n\n\n info: function() {\n return extend({}, stats, {size: size});\n }\n };\n\n\n /**\n * makes the `entry` the freshEnd of the LRU linked list\n */\n function refresh(entry) {\n if (entry != freshEnd) {\n if (!staleEnd) {\n staleEnd = entry;\n } else if (staleEnd == entry) {\n staleEnd = entry.n;\n }\n\n link(entry.n, entry.p);\n link(entry, freshEnd);\n freshEnd = entry;\n freshEnd.n = null;\n }\n }\n\n\n /**\n * bidirectionally links two entries of the LRU linked list\n */\n function link(nextEntry, prevEntry) {\n if (nextEntry != prevEntry) {\n if (nextEntry) nextEntry.p = prevEntry; //p stands for previous, 'prev' didn't minify\n if (prevEntry) prevEntry.n = nextEntry; //n stands for next, 'next' didn't minify\n }\n }\n }\n\n\n cacheFactory.info = function() {\n var info = {};\n forEach(caches, function(cache, cacheId) {\n info[cacheId] = cache.info();\n });\n return info;\n };\n\n\n cacheFactory.get = function(cacheId) {\n return caches[cacheId];\n };\n\n\n return cacheFactory;\n };\n}\n\n/**\n * @ngdoc object\n * @name ng.$templateCache\n *\n * @description\n * Cache used for storing html templates.\n *\n * See {@link ng.$cacheFactory $cacheFactory}.\n *\n */\nfunction $TemplateCacheProvider() {\n this.$get = ['$cacheFactory', function($cacheFactory) {\n return $cacheFactory('templates');\n }];\n}\n\n/* ! VARIABLE/FUNCTION NAMING CONVENTIONS THAT APPLY TO THIS FILE!\n *\n * DOM-related variables:\n *\n * - \"node\" - DOM Node\n * - \"element\" - DOM Element or Node\n * - \"$node\" or \"$element\" - jqLite-wrapped node or element\n *\n *\n * Compiler related stuff:\n *\n * - \"linkFn\" - linking fn of a single directive\n * - \"nodeLinkFn\" - function that aggregates all linking fns for a particular node\n * - \"childLinkFn\" - function that aggregates all linking fns for child nodes of a particular node\n * - \"compositeLinkFn\" - function that aggregates all linking fns for a compilation root (nodeList)\n */\n\n\nvar NON_ASSIGNABLE_MODEL_EXPRESSION = 'Non-assignable model expression: ';\n\n\n/**\n * @ngdoc function\n * @name ng.$compile\n * @function\n *\n * @description\n * Compiles a piece of HTML string or DOM into a template and produces a template function, which\n * can then be used to link {@link ng.$rootScope.Scope scope} and the template together.\n *\n * The compilation is a process of walking the DOM tree and trying to match DOM elements to\n * {@link ng.$compileProvider#directive directives}. For each match it\n * executes corresponding template function and collects the\n * instance functions into a single template function which is then returned.\n *\n * The template function can then be used once to produce the view or as it is the case with\n * {@link ng.directive:ngRepeat repeater} many-times, in which\n * case each call results in a view that is a DOM clone of the original template.\n *\n \n \n \n
\n \n \n \n
\n \n \n it('should auto compile', function() {\n expect(element('div[compile]').text()).toBe('Hello Angular');\n input('html').enter('{{name}}!');\n expect(element('div[compile]').text()).toBe('Angular!');\n });\n \n \n\n *\n *\n * @param {string|DOMElement} element Element or HTML string to compile into a template function.\n * @param {function(angular.Scope[, cloneAttachFn]} transclude function available to directives.\n * @param {number} maxPriority only apply directives lower then given priority (Only effects the\n * root element(s), not their children)\n * @returns {function(scope[, cloneAttachFn])} a link function which is used to bind template\n * (a DOM element/tree) to a scope. Where:\n *\n * * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to.\n * * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the\n * `template` and call the `cloneAttachFn` function allowing the caller to attach the\n * cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is\n * called as: `cloneAttachFn(clonedElement, scope)` where:\n *\n * * `clonedElement` - is a clone of the original `element` passed into the compiler.\n * * `scope` - is the current scope with which the linking function is working with.\n *\n * Calling the linking function returns the element of the template. It is either the original element\n * passed in, or the clone of the element if the `cloneAttachFn` is provided.\n *\n * After linking the view is not updated until after a call to $digest which typically is done by\n * Angular automatically.\n *\n * If you need access to the bound view, there are two ways to do it:\n *\n * - If you are not asking the linking function to clone the template, create the DOM element(s)\n * before you send them to the compiler and keep this reference around.\n *
\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\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 factroy 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 this.$get = [\n '$injector', '$interpolate', '$exceptionHandler', '$http', '$templateCache', '$parse',\n '$controller', '$rootScope',\n function($injector, $interpolate, $exceptionHandler, $http, $templateCache, $parse,\n $controller, $rootScope) {\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\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 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 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\n\n return compile;\n\n //================================\n\n function compile($compileNodes, transcludeFn, maxPriority) {\n if (!($compileNodes instanceof jqLite)) {\n // jquery always rewraps, where as 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 $linkNode.data('$scope', scope);\n safeAddClass($linkNode, 'ng-scope');\n if (cloneConnectFn) cloneConnectFn($linkNode, scope);\n if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode);\n return $linkNode;\n };\n }\n\n function wrongMode(localName, mode) {\n throw Error(\"Unsupported '\" + mode + \"' for '\" + localName + \"'.\");\n }\n\n function safeAddClass($element, className) {\n try {\n $element.addClass(className);\n } catch(e) {\n // ignore, since it means that we are trying to set class on\n // SVG element, where class name is read-only.\n }\n }\n\n /**\n * Compile function matches each node in nodeList against the directives. Once all directives\n * for a particular node are collected their compile functions are executed. The compile\n * functions return values - the linking functions - are combined into a composite linking\n * function, which is the a linking function for the node.\n *\n * @param {NodeList} nodeList an array of nodes to compile\n * @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the\n * scope argument is auto-generated to the new child of the transcluded parent scope.\n * @param {DOMElement=} $rootElement If the nodeList is the root of the compilation tree then the\n * rootElement must be set the jqLite collection of the compile root. This is\n * needed so that the jqLite collection items can be replaced with widgets.\n * @param {number=} max directive priority\n * @returns {?function} A composite linking function of all of the matched directives or null.\n */\n function compileNodes(nodeList, transcludeFn, $rootElement, maxPriority) {\n var linkFns = [],\n nodeLinkFn, childLinkFn, directives, attrs, linkFnFound;\n\n for(var i = 0; i < nodeList.length; i++) {\n attrs = new Attributes();\n\n // we must always refer to nodeList[i] since the nodes can be replaced underneath us.\n directives = collectDirectives(nodeList[i], [], attrs, maxPriority);\n\n nodeLinkFn = (directives.length)\n ? applyDirectivesToNode(directives, nodeList[i], attrs, transcludeFn, $rootElement)\n : null;\n\n childLinkFn = (nodeLinkFn && nodeLinkFn.terminal || !nodeList[i].childNodes.length)\n ? null\n : compileNodes(nodeList[i].childNodes,\n nodeLinkFn ? nodeLinkFn.transclude : transcludeFn);\n\n linkFns.push(nodeLinkFn);\n linkFns.push(childLinkFn);\n linkFnFound = (linkFnFound || nodeLinkFn || childLinkFn);\n }\n\n // return a linking function if we have found anything, null otherwise\n return linkFnFound ? compositeLinkFn : null;\n\n function compositeLinkFn(scope, nodeList, $rootElement, boundTranscludeFn) {\n var nodeLinkFn, childLinkFn, node, childScope, childTranscludeFn, i, ii, n;\n\n // copy nodeList so that linking doesn't break due to live list updates.\n var stableNodeList = [];\n for (i = 0, ii = nodeList.length; i < ii; i++) {\n stableNodeList.push(nodeList[i]);\n }\n\n for(i = 0, n = 0, ii = linkFns.length; i < ii; n++) {\n node = stableNodeList[n];\n nodeLinkFn = linkFns[i++];\n childLinkFn = linkFns[i++];\n\n if (nodeLinkFn) {\n if (nodeLinkFn.scope) {\n childScope = scope.$new(isObject(nodeLinkFn.scope));\n jqLite(node).data('$scope', childScope);\n } else {\n childScope = scope;\n }\n childTranscludeFn = nodeLinkFn.transclude;\n if (childTranscludeFn || (!boundTranscludeFn && transcludeFn)) {\n nodeLinkFn(childLinkFn, childScope, node, $rootElement,\n (function(transcludeFn) {\n return function(cloneFn) {\n var transcludeScope = scope.$new();\n\n return transcludeFn(transcludeScope, cloneFn).\n bind('$destroy', bind(transcludeScope, transcludeScope.$destroy));\n };\n })(childTranscludeFn || transcludeFn)\n );\n } else {\n nodeLinkFn(childLinkFn, childScope, node, undefined, boundTranscludeFn);\n }\n } else if (childLinkFn) {\n childLinkFn(scope, node.childNodes, undefined, boundTranscludeFn);\n }\n }\n }\n }\n\n\n /**\n * Looks for directives on the given node and adds them to the directive collection which is\n * sorted.\n *\n * @param node Node to search.\n * @param directives An array to which the directives are added to. This array is sorted before\n * the function returns.\n * @param attrs The shared attrs object which is used to populate the normalized attributes.\n * @param {number=} maxPriority Max directive priority.\n */\n function collectDirectives(node, directives, attrs, maxPriority) {\n var nodeType = node.nodeType,\n attrsMap = attrs.$attr,\n match,\n className;\n\n switch(nodeType) {\n case 1: /* Element */\n // use the node name: \n addDirective(directives,\n directiveNormalize(nodeName_(node).toLowerCase()), 'E', maxPriority);\n\n // iterate over the attributes\n for (var attr, name, nName, value, nAttrs = node.attributes,\n j = 0, jj = nAttrs && nAttrs.length; j < jj; j++) {\n attr = nAttrs[j];\n if (attr.specified) {\n name = attr.name;\n nName = directiveNormalize(name.toLowerCase());\n attrsMap[nName] = name;\n attrs[nName] = value = trim((msie && name == 'href')\n ? decodeURIComponent(node.getAttribute(name, 2))\n : attr.value);\n if (getBooleanAttrName(node, nName)) {\n attrs[nName] = true; // presence means true\n }\n addAttrInterpolateDirective(node, directives, value, nName);\n addDirective(directives, nName, 'A', maxPriority);\n }\n }\n\n // use class as directive\n className = node.className;\n if (isString(className) && className !== '') {\n while (match = CLASS_DIRECTIVE_REGEXP.exec(className)) {\n nName = directiveNormalize(match[2]);\n if (addDirective(directives, nName, 'C', maxPriority)) {\n attrs[nName] = trim(match[3]);\n }\n className = className.substr(match.index + match[0].length);\n }\n }\n break;\n case 3: /* Text Node */\n addTextInterpolateDirective(directives, node.nodeValue);\n break;\n case 8: /* Comment */\n try {\n match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue);\n if (match) {\n nName = directiveNormalize(match[1]);\n if (addDirective(directives, nName, 'M', maxPriority)) {\n attrs[nName] = trim(match[2]);\n }\n }\n } catch (e) {\n // turns out that under some circumstances IE9 throws errors when one attempts to read comment's node value.\n // Just ignore it and continue. (Can't seem to reproduce in test case.)\n }\n break;\n }\n\n directives.sort(byPriority);\n return directives;\n }\n\n\n /**\n * Once the directives have been collected their compile functions is executed. This method\n * is responsible for inlining directive templates as well as terminating the application\n * of the directives if the terminal directive has been reached..\n *\n * @param {Array} directives Array of collected directives to execute their compile function.\n * this needs to be pre-sorted by priority order.\n * @param {Node} compileNode The raw DOM node to apply the compile functions to\n * @param {Object} templateAttrs The shared attribute function\n * @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the\n * scope argument is auto-generated to the new child of the transcluded parent scope.\n * @param {DOMElement} $rootElement If we are working on the root of the compile tree then this\n * argument has the root jqLite array so that we can replace widgets on it.\n * @returns linkFn\n */\n function applyDirectivesToNode(directives, compileNode, templateAttrs, transcludeFn, $rootElement) {\n var terminalPriority = -Number.MAX_VALUE,\n preLinkFns = [],\n postLinkFns = [],\n newScopeDirective = null,\n newIsolateScopeDirective = null,\n templateDirective = null,\n $compileNode = templateAttrs.$$element = jqLite(compileNode),\n directive,\n directiveName,\n $template,\n transcludeDirective,\n childTranscludeFn = transcludeFn,\n controllerDirectives,\n linkFn,\n directiveValue;\n\n // executes all directives on the current element\n for(var i = 0, ii = directives.length; i < ii; i++) {\n directive = directives[i];\n $template = undefined;\n\n if (terminalPriority > directive.priority) {\n break; // prevent further processing of directives\n }\n\n if (directiveValue = directive.scope) {\n assertNoDuplicate('isolated scope', newIsolateScopeDirective, directive, $compileNode);\n if (isObject(directiveValue)) {\n safeAddClass($compileNode, 'ng-isolate-scope');\n newIsolateScopeDirective = directive;\n }\n safeAddClass($compileNode, 'ng-scope');\n newScopeDirective = newScopeDirective || directive;\n }\n\n directiveName = directive.name;\n\n if (directiveValue = directive.controller) {\n controllerDirectives = controllerDirectives || {};\n assertNoDuplicate(\"'\" + directiveName + \"' controller\",\n controllerDirectives[directiveName], directive, $compileNode);\n controllerDirectives[directiveName] = directive;\n }\n\n if (directiveValue = directive.transclude) {\n assertNoDuplicate('transclusion', transcludeDirective, directive, $compileNode);\n transcludeDirective = directive;\n terminalPriority = directive.priority;\n if (directiveValue == 'element') {\n $template = jqLite(compileNode);\n $compileNode = templateAttrs.$$element =\n jqLite(document.createComment(' ' + directiveName + ': ' + templateAttrs[directiveName] + ' '));\n compileNode = $compileNode[0];\n replaceWith($rootElement, jqLite($template[0]), compileNode);\n childTranscludeFn = compile($template, transcludeFn, terminalPriority);\n } else {\n $template = jqLite(JQLiteClone(compileNode)).contents();\n $compileNode.html(''); // clear contents\n childTranscludeFn = compile($template, transcludeFn);\n }\n }\n\n if ((directiveValue = directive.template)) {\n assertNoDuplicate('template', templateDirective, directive, $compileNode);\n templateDirective = directive;\n directiveValue = denormalizeTemplate(directiveValue);\n\n if (directive.replace) {\n $template = jqLite('
' +\n trim(directiveValue) +\n '
').contents();\n compileNode = $template[0];\n\n if ($template.length != 1 || compileNode.nodeType !== 1) {\n throw new Error(MULTI_ROOT_TEMPLATE_ERROR + directiveValue);\n }\n\n replaceWith($rootElement, $compileNode, compileNode);\n\n var newTemplateAttrs = {$attr: {}};\n\n // combine directives from the original node and from the template:\n // - take the array of directives for this element\n // - split it into two parts, those that were already applied and those that weren't\n // - collect directives from the template, add them to the second group and sort them\n // - append the second group with new directives to the first group\n directives = directives.concat(\n collectDirectives(\n compileNode,\n directives.splice(i + 1, directives.length - (i + 1)),\n newTemplateAttrs\n )\n );\n mergeTemplateAttributes(templateAttrs, newTemplateAttrs);\n\n ii = directives.length;\n } else {\n $compileNode.html(directiveValue);\n }\n }\n\n if (directive.templateUrl) {\n assertNoDuplicate('template', templateDirective, directive, $compileNode);\n templateDirective = directive;\n nodeLinkFn = compileTemplateUrl(directives.splice(i, directives.length - i),\n nodeLinkFn, $compileNode, templateAttrs, $rootElement, directive.replace,\n childTranscludeFn);\n ii = directives.length;\n } else if (directive.compile) {\n try {\n linkFn = directive.compile($compileNode, templateAttrs, childTranscludeFn);\n if (isFunction(linkFn)) {\n addLinkFns(null, linkFn);\n } else if (linkFn) {\n addLinkFns(linkFn.pre, linkFn.post);\n }\n } catch (e) {\n $exceptionHandler(e, startingTag($compileNode));\n }\n }\n\n if (directive.terminal) {\n nodeLinkFn.terminal = true;\n terminalPriority = Math.max(terminalPriority, directive.priority);\n }\n\n }\n\n nodeLinkFn.scope = newScopeDirective && newScopeDirective.scope;\n nodeLinkFn.transclude = transcludeDirective && childTranscludeFn;\n\n // might be normal or delayed nodeLinkFn depending on if templateUrl is present\n return nodeLinkFn;\n\n ////////////////////\n\n function addLinkFns(pre, post) {\n if (pre) {\n pre.require = directive.require;\n preLinkFns.push(pre);\n }\n if (post) {\n post.require = directive.require;\n postLinkFns.push(post);\n }\n }\n\n\n function getControllers(require, $element) {\n var value, retrievalMethod = 'data', optional = false;\n if (isString(require)) {\n while((value = require.charAt(0)) == '^' || value == '?') {\n require = require.substr(1);\n if (value == '^') {\n retrievalMethod = 'inheritedData';\n }\n optional = optional || value == '?';\n }\n value = $element[retrievalMethod]('$' + require + 'Controller');\n if (!value && !optional) {\n throw Error(\"No controller: \" + require);\n }\n return value;\n } else if (isArray(require)) {\n value = [];\n forEach(require, function(require) {\n value.push(getControllers(require, $element));\n });\n }\n return value;\n }\n\n\n function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn) {\n var attrs, $element, i, ii, linkFn, controller;\n\n if (compileNode === linkNode) {\n attrs = templateAttrs;\n } else {\n attrs = shallowCopy(templateAttrs, new Attributes(jqLite(linkNode), templateAttrs.$attr));\n }\n $element = attrs.$$element;\n\n if (newIsolateScopeDirective) {\n var LOCAL_REGEXP = /^\\s*([@=&])\\s*(\\w*)\\s*$/;\n\n var parentScope = scope.$parent || scope;\n\n forEach(newIsolateScopeDirective.scope, function(definiton, scopeName) {\n var match = definiton.match(LOCAL_REGEXP) || [],\n attrName = match[2]|| scopeName,\n mode = match[1], // @, =, or &\n lastValue,\n parentGet, parentSet;\n\n switch (mode) {\n\n case '@': {\n attrs.$observe(attrName, function(value) {\n scope[scopeName] = value;\n });\n attrs.$$observers[attrName].$$scope = parentScope;\n break;\n }\n\n case '=': {\n parentGet = $parse(attrs[attrName]);\n parentSet = parentGet.assign || function() {\n // reset the change, or we will throw this exception on every $digest\n lastValue = scope[scopeName] = parentGet(parentScope);\n throw Error(NON_ASSIGNABLE_MODEL_EXPRESSION + attrs[attrName] +\n ' (directive: ' + newIsolateScopeDirective.name + ')');\n };\n lastValue = scope[scopeName] = parentGet(parentScope);\n scope.$watch(function parentValueWatch() {\n var parentValue = parentGet(parentScope);\n\n if (parentValue !== scope[scopeName]) {\n // we are out of sync and need to copy\n if (parentValue !== lastValue) {\n // parent changed and it has precedence\n lastValue = scope[scopeName] = parentValue;\n } else {\n // if the parent can be assigned then do so\n parentSet(parentScope, parentValue = lastValue = scope[scopeName]);\n }\n }\n return parentValue;\n });\n break;\n }\n\n case '&': {\n parentGet = $parse(attrs[attrName]);\n scope[scopeName] = function(locals) {\n return parentGet(parentScope, locals);\n }\n break;\n }\n\n default: {\n throw Error('Invalid isolate scope definition for directive ' +\n newIsolateScopeDirective.name + ': ' + definiton);\n }\n }\n });\n }\n\n if (controllerDirectives) {\n forEach(controllerDirectives, function(directive) {\n var locals = {\n $scope: scope,\n $element: $element,\n $attrs: attrs,\n $transclude: boundTranscludeFn\n };\n\n controller = directive.controller;\n if (controller == '@') {\n controller = attrs[directive.name];\n }\n\n $element.data(\n '$' + directive.name + 'Controller',\n $controller(controller, locals));\n });\n }\n\n // PRELINKING\n for(i = 0, ii = preLinkFns.length; i < ii; i++) {\n try {\n linkFn = preLinkFns[i];\n linkFn(scope, $element, attrs,\n linkFn.require && getControllers(linkFn.require, $element));\n } catch (e) {\n $exceptionHandler(e, startingTag($element));\n }\n }\n\n // RECURSION\n childLinkFn && childLinkFn(scope, linkNode.childNodes, undefined, boundTranscludeFn);\n\n // POSTLINKING\n for(i = 0, ii = postLinkFns.length; i < ii; i++) {\n try {\n linkFn = postLinkFns[i];\n linkFn(scope, $element, attrs,\n linkFn.require && getControllers(linkFn.require, $element));\n } catch (e) {\n $exceptionHandler(e, startingTag($element));\n }\n }\n }\n }\n\n\n /**\n * looks up the directive and decorates it with exception handling and proper parameters. We\n * call this the boundDirective.\n *\n * @param {string} name name of the directive to look up.\n * @param {string} location The directive must be found in specific format.\n * String containing any of theses characters:\n *\n * * `E`: element name\n * * `A': attribute\n * * `C`: class\n * * `M`: comment\n * @returns true if directive was added.\n */\n function addDirective(tDirectives, name, location, maxPriority) {\n var match = false;\n if (hasDirectives.hasOwnProperty(name)) {\n for(var directive, directives = $injector.get(name + Suffix),\n i = 0, ii = directives.length; i directive.priority) &&\n directive.restrict.indexOf(location) != -1) {\n tDirectives.push(directive);\n match = true;\n }\n } catch(e) { $exceptionHandler(e); }\n }\n }\n return match;\n }\n\n\n /**\n * When the element is replaced with HTML template then the new attributes\n * on the template need to be merged with the existing attributes in the DOM.\n * The desired effect is to have both of the attributes present.\n *\n * @param {object} dst destination attributes (original DOM)\n * @param {object} src source attributes (from the directive template)\n */\n function mergeTemplateAttributes(dst, src) {\n var srcAttr = src.$attr,\n dstAttr = dst.$attr,\n $element = dst.$$element;\n\n // reapply the old attributes to the new element\n forEach(dst, function(value, key) {\n if (key.charAt(0) != '$') {\n if (src[key]) {\n value += (key === 'style' ? ';' : ' ') + src[key];\n }\n dst.$set(key, value, true, srcAttr[key]);\n }\n });\n\n // copy the new attributes on the old attrs object\n forEach(src, function(value, key) {\n if (key == 'class') {\n safeAddClass($element, value);\n dst['class'] = (dst['class'] ? dst['class'] + ' ' : '') + value;\n } else if (key == 'style') {\n $element.attr('style', $element.attr('style') + ';' + value);\n } else if (key.charAt(0) != '$' && !dst.hasOwnProperty(key)) {\n dst[key] = value;\n dstAttr[key] = srcAttr[key];\n }\n });\n }\n\n\n function compileTemplateUrl(directives, beforeTemplateNodeLinkFn, $compileNode, tAttrs,\n $rootElement, replace, childTranscludeFn) {\n var linkQueue = [],\n afterTemplateNodeLinkFn,\n afterTemplateChildLinkFn,\n beforeTemplateCompileNode = $compileNode[0],\n origAsyncDirective = directives.shift(),\n // The fact that we have to copy and patch the directive seems wrong!\n derivedSyncDirective = extend({}, origAsyncDirective, {\n controller: null, templateUrl: null, transclude: null, scope: null\n });\n\n $compileNode.html('');\n\n $http.get(origAsyncDirective.templateUrl, {cache: $templateCache}).\n success(function(content) {\n var compileNode, tempTemplateAttrs, $template;\n\n content = denormalizeTemplate(content);\n\n if (replace) {\n $template = jqLite('
' + trim(content) + '
').contents();\n compileNode = $template[0];\n\n if ($template.length != 1 || compileNode.nodeType !== 1) {\n throw new Error(MULTI_ROOT_TEMPLATE_ERROR + content);\n }\n\n tempTemplateAttrs = {$attr: {}};\n replaceWith($rootElement, $compileNode, compileNode);\n collectDirectives(compileNode, directives, tempTemplateAttrs);\n mergeTemplateAttributes(tAttrs, tempTemplateAttrs);\n } else {\n compileNode = beforeTemplateCompileNode;\n $compileNode.html(content);\n }\n\n directives.unshift(derivedSyncDirective);\n afterTemplateNodeLinkFn = applyDirectivesToNode(directives, $compileNode, tAttrs, childTranscludeFn);\n afterTemplateChildLinkFn = compileNodes($compileNode.contents(), childTranscludeFn);\n\n\n while(linkQueue.length) {\n var controller = linkQueue.pop(),\n linkRootElement = linkQueue.pop(),\n beforeTemplateLinkNode = linkQueue.pop(),\n scope = linkQueue.pop(),\n linkNode = compileNode;\n\n if (beforeTemplateLinkNode !== beforeTemplateCompileNode) {\n // it was cloned therefore we have to clone as well.\n linkNode = JQLiteClone(compileNode);\n replaceWith(linkRootElement, jqLite(beforeTemplateLinkNode), linkNode);\n }\n\n afterTemplateNodeLinkFn(function() {\n beforeTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, linkNode, $rootElement, controller);\n }, scope, linkNode, $rootElement, controller);\n }\n linkQueue = null;\n }).\n error(function(response, code, headers, config) {\n throw Error('Failed to load template: ' + config.url);\n });\n\n return function delayedNodeLinkFn(ignoreChildLinkFn, scope, node, rootElement, controller) {\n if (linkQueue) {\n linkQueue.push(scope);\n linkQueue.push(node);\n linkQueue.push(rootElement);\n linkQueue.push(controller);\n } else {\n afterTemplateNodeLinkFn(function() {\n beforeTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, controller);\n }, scope, node, rootElement, controller);\n }\n };\n }\n\n\n /**\n * Sorting function for bound directives.\n */\n function byPriority(a, b) {\n return b.priority - a.priority;\n }\n\n\n function assertNoDuplicate(what, previousDirective, directive, element) {\n if (previousDirective) {\n throw Error('Multiple directives [' + previousDirective.name + ', ' +\n directive.name + '] asking for ' + what + ' on: ' + startingTag(element));\n }\n }\n\n\n function addTextInterpolateDirective(directives, text) {\n var interpolateFn = $interpolate(text, true);\n if (interpolateFn) {\n directives.push({\n priority: 0,\n compile: valueFn(function textInterpolateLinkFn(scope, node) {\n var parent = node.parent(),\n bindings = parent.data('$binding') || [];\n bindings.push(interpolateFn);\n safeAddClass(parent.data('$binding', bindings), 'ng-binding');\n scope.$watch(interpolateFn, function interpolateFnWatchAction(value) {\n node[0].nodeValue = value;\n });\n })\n });\n }\n }\n\n\n function addAttrInterpolateDirective(node, directives, value, name) {\n var interpolateFn = $interpolate(value, true);\n\n\n // no interpolation found -> ignore\n if (!interpolateFn) return;\n\n directives.push({\n priority: 100,\n compile: valueFn(function attrInterpolateLinkFn(scope, element, attr) {\n var $$observers = (attr.$$observers || (attr.$$observers = {}));\n\n if (name === 'class') {\n // we need to interpolate classes again, in the case the element was replaced\n // and therefore the two class attrs got merged - we want to interpolate the result\n interpolateFn = $interpolate(attr[name], true);\n }\n\n attr[name] = undefined;\n ($$observers[name] || ($$observers[name] = [])).$$inter = true;\n (attr.$$observers && attr.$$observers[name].$$scope || scope).\n $watch(interpolateFn, function interpolateFnWatchAction(value) {\n attr.$set(name, value);\n });\n })\n });\n }\n\n\n /**\n * This is a special jqLite.replaceWith, which can replace items which\n * have no parents, provided that the containing jqLite collection is provided.\n *\n * @param {JqLite=} $rootElement The root of the compile tree. Used so that we can replace nodes\n * in the root of the tree.\n * @param {JqLite} $element The jqLite element which we are going to replace. We keep the shell,\n * but replace its DOM node reference.\n * @param {Node} newNode The new DOM node.\n */\n function replaceWith($rootElement, $element, newNode) {\n var oldNode = $element[0],\n parent = oldNode.parentNode,\n i, ii;\n\n if ($rootElement) {\n for(i = 0, ii = $rootElement.length; i < ii; i++) {\n if ($rootElement[i] == oldNode) {\n $rootElement[i] = newNode;\n break;\n }\n }\n }\n\n if (parent) {\n parent.replaceChild(newNode, oldNode);\n }\n\n newNode[jqLite.expando] = oldNode[jqLite.expando];\n $element[0] = newNode;\n }\n }];\n}\n\nvar PREFIX_REGEXP = /^(x[\\:\\-_]|data[\\:\\-_])/i;\n/**\n * Converts all accepted directives format into proper directive name.\n * All of these will become 'myDirective':\n * my:DiRective\n * my-directive\n * x-my-directive\n * data-my:directive\n *\n * Also there is special case for Moz prefix starting with upper case letter.\n * @param name Name to normalize\n */\nfunction directiveNormalize(name) {\n return camelCase(name.replace(PREFIX_REGEXP, ''));\n}\n\n/**\n * @ngdoc object\n * @name ng.$compile.directive.Attributes\n * @description\n *\n * A shared object between directive compile / linking functions which contains normalized DOM element\n * attributes. The the values reflect current binding state `{{ }}`. The normalization is needed\n * since all of these are treated as equivalent in Angular:\n *\n * \n */\n\n/**\n * @ngdoc property\n * @name ng.$compile.directive.Attributes#$attr\n * @propertyOf ng.$compile.directive.Attributes\n * @returns {object} A map of DOM element attribute names to the normalized name. This is\n * needed to do reverse lookup from normalized name back to actual name.\n */\n\n\n/**\n * @ngdoc function\n * @name ng.$compile.directive.Attributes#$set\n * @methodOf ng.$compile.directive.Attributes\n * @function\n *\n * @description\n * Set DOM element attribute value.\n *\n *\n * @param {string} name Normalized element attribute name of the property to modify. The name is\n * revers translated using the {@link ng.$compile.directive.Attributes#$attr $attr}\n * property to the original name.\n * @param {string} value Value to set the attribute to.\n */\n\n\n\n/**\n * Closure compiler type information\n */\n\nfunction nodesetLinkingFn(\n /* angular.Scope */ scope,\n /* NodeList */ nodeList,\n /* Element */ rootElement,\n /* function(Function) */ boundTranscludeFn\n){}\n\nfunction directiveLinkingFn(\n /* nodesetLinkingFn */ nodesetLinkingFn,\n /* angular.Scope */ scope,\n /* Node */ node,\n /* Element */ rootElement,\n /* function(Function) */ boundTranscludeFn\n){}\n\n/**\n * @ngdoc object\n * @name ng.$controllerProvider\n * @description\n * The {@link ng.$controller $controller service} is used by Angular to create new\n * controllers.\n *\n * This provider allows controller registration via the\n * {@link ng.$controllerProvider#register register} method.\n */\nfunction $ControllerProvider() {\n var controllers = {};\n\n\n /**\n * @ngdoc function\n * @name ng.$controllerProvider#register\n * @methodOf ng.$controllerProvider\n * @param {string} name Controller name\n * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI\n * annotations in the array notation).\n */\n this.register = function(name, constructor) {\n if (isObject(name)) {\n extend(controllers, name)\n } else {\n controllers[name] = constructor;\n }\n };\n\n\n this.$get = ['$injector', '$window', function($injector, $window) {\n\n /**\n * @ngdoc function\n * @name ng.$controller\n * @requires $injector\n *\n * @param {Function|string} constructor If called with a function then it's considered to be the\n * controller constructor function. Otherwise it's considered to be a string which is used\n * to retrieve the controller constructor using the following steps:\n *\n * * check if a controller with given name is registered via `$controllerProvider`\n * * check if evaluating the string on the current scope returns a constructor\n * * check `window[constructor]` on the global `window` object\n *\n * @param {Object} locals Injection locals for Controller.\n * @return {Object} Instance of given controller.\n *\n * @description\n * `$controller` service is responsible for instantiating controllers.\n *\n * It's just simple call to {@link AUTO.$injector $injector}, but extracted into\n * a service, so that one can override this service with {@link https://gist.github.com/1649788\n * BC version}.\n */\n return function(constructor, locals) {\n if(isString(constructor)) {\n var name = constructor;\n constructor = controllers.hasOwnProperty(name)\n ? controllers[name]\n : getter(locals.$scope, name, true) || getter($window, name, true);\n\n assertArgFn(constructor, name, true);\n }\n\n return $injector.instantiate(constructor, locals);\n };\n }];\n}\n\n/**\n * @ngdoc object\n * @name ng.$document\n * @requires $window\n *\n * @description\n * A {@link angular.element jQuery (lite)}-wrapped reference to the browser's `window.document`\n * element.\n */\nfunction $DocumentProvider(){\n this.$get = ['$window', function(window){\n return jqLite(window.document);\n }];\n}\n\n/**\n * @ngdoc function\n * @name ng.$exceptionHandler\n * @requires $log\n *\n * @description\n * Any uncaught exception in angular expressions is delegated to this service.\n * The default implementation simply delegates to `$log.error` which logs it into\n * the browser console.\n *\n * In unit tests, if `angular-mocks.js` is loaded, this service is overridden by\n * {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing.\n *\n * @param {Error} exception Exception associated with the error.\n * @param {string=} cause optional information about the context in which\n * the error was thrown.\n *\n */\nfunction $ExceptionHandlerProvider() {\n this.$get = ['$log', function($log){\n return function(exception, cause) {\n $log.error.apply($log, arguments);\n };\n }];\n}\n\n/**\n * @ngdoc object\n * @name ng.$interpolateProvider\n * @function\n *\n * @description\n *\n * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.\n */\nfunction $InterpolateProvider() {\n var startSymbol = '{{';\n var endSymbol = '}}';\n\n /**\n * @ngdoc method\n * @name ng.$interpolateProvider#startSymbol\n * @methodOf ng.$interpolateProvider\n * @description\n * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.\n *\n * @param {string=} value new value to set the starting symbol to.\n * @returns {string|self} Returns the symbol when used as getter and self if used as setter.\n */\n this.startSymbol = function(value){\n if (value) {\n startSymbol = value;\n return this;\n } else {\n return startSymbol;\n }\n };\n\n /**\n * @ngdoc method\n * @name ng.$interpolateProvider#endSymbol\n * @methodOf ng.$interpolateProvider\n * @description\n * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.\n *\n * @param {string=} value new value to set the ending symbol to.\n * @returns {string|self} Returns the symbol when used as getter and self if used as setter.\n */\n this.endSymbol = function(value){\n if (value) {\n endSymbol = value;\n return this;\n } else {\n return endSymbol;\n }\n };\n\n\n this.$get = ['$parse', function($parse) {\n var startSymbolLength = startSymbol.length,\n endSymbolLength = endSymbol.length;\n\n /**\n * @ngdoc function\n * @name ng.$interpolate\n * @function\n *\n * @requires $parse\n *\n * @description\n *\n * Compiles a string with markup into an interpolation function. This service is used by the\n * HTML {@link ng.$compile $compile} service for data binding. See\n * {@link ng.$interpolateProvider $interpolateProvider} for configuring the\n * interpolation markup.\n *\n *\n
\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 for(var i = 0, ii = length, part; i html5 url\n } else {\n return composeProtocolHostPort(match.protocol, match.host, match.port) +\n pathPrefixFromBase(basePath) + match.hash.substr(hashPrefix.length);\n }\n}\n\n\nfunction convertToHashbangUrl(url, basePath, hashPrefix) {\n var match = matchUrl(url);\n\n // already hashbang url\n if (decodeURIComponent(match.path) == basePath) {\n return url;\n // convert html5 url -> hashbang url\n } else {\n var search = match.search && '?' + match.search || '',\n hash = match.hash && '#' + match.hash || '',\n pathPrefix = pathPrefixFromBase(basePath),\n path = match.path.substr(pathPrefix.length);\n\n if (match.path.indexOf(pathPrefix) !== 0) {\n throw Error('Invalid url \"' + url + '\", missing path prefix \"' + pathPrefix + '\" !');\n }\n\n return composeProtocolHostPort(match.protocol, match.host, match.port) + basePath +\n '#' + hashPrefix + path + search + hash;\n }\n}\n\n\n/**\n * LocationUrl represents an url\n * This object is exposed as $location service when HTML5 mode is enabled and supported\n *\n * @constructor\n * @param {string} url HTML5 url\n * @param {string} pathPrefix\n */\nfunction LocationUrl(url, pathPrefix, appBaseUrl) {\n pathPrefix = pathPrefix || '';\n\n /**\n * Parse given html5 (regular) url string into properties\n * @param {string} newAbsoluteUrl HTML5 url\n * @private\n */\n this.$$parse = function(newAbsoluteUrl) {\n var match = matchUrl(newAbsoluteUrl, this);\n\n if (match.path.indexOf(pathPrefix) !== 0) {\n throw Error('Invalid url \"' + newAbsoluteUrl + '\", missing path prefix \"' + pathPrefix + '\" !');\n }\n\n this.$$path = decodeURIComponent(match.path.substr(pathPrefix.length));\n this.$$search = parseKeyValue(match.search);\n this.$$hash = match.hash && decodeURIComponent(match.hash) || '';\n\n this.$$compose();\n };\n\n /**\n * Compose url and update `absUrl` property\n * @private\n */\n this.$$compose = function() {\n var search = toKeyValue(this.$$search),\n hash = this.$$hash ? '#' + encodeUriSegment(this.$$hash) : '';\n\n this.$$url = encodePath(this.$$path) + (search ? '?' + search : '') + hash;\n this.$$absUrl = composeProtocolHostPort(this.$$protocol, this.$$host, this.$$port) +\n pathPrefix + this.$$url;\n };\n\n\n this.$$rewriteAppUrl = function(absoluteLinkUrl) {\n if(absoluteLinkUrl.indexOf(appBaseUrl) == 0) {\n return absoluteLinkUrl;\n }\n }\n\n\n this.$$parse(url);\n}\n\n\n/**\n * LocationHashbangUrl represents url\n * This object is exposed as $location service when html5 history api is disabled or not supported\n *\n * @constructor\n * @param {string} url Legacy url\n * @param {string} hashPrefix Prefix for hash part (containing path and search)\n */\nfunction LocationHashbangUrl(url, hashPrefix, appBaseUrl) {\n var basePath;\n\n /**\n * Parse given hashbang url into properties\n * @param {string} url Hashbang url\n * @private\n */\n this.$$parse = function(url) {\n var match = matchUrl(url, this);\n\n\n if (match.hash && match.hash.indexOf(hashPrefix) !== 0) {\n throw Error('Invalid url \"' + url + '\", missing hash prefix \"' + hashPrefix + '\" !');\n }\n\n basePath = match.path + (match.search ? '?' + match.search : '');\n match = HASH_MATCH.exec((match.hash || '').substr(hashPrefix.length));\n if (match[1]) {\n this.$$path = (match[1].charAt(0) == '/' ? '' : '/') + decodeURIComponent(match[1]);\n } else {\n this.$$path = '';\n }\n\n this.$$search = parseKeyValue(match[3]);\n this.$$hash = match[5] && decodeURIComponent(match[5]) || '';\n\n this.$$compose();\n };\n\n /**\n * Compose hashbang url and update `absUrl` property\n * @private\n */\n this.$$compose = function() {\n var search = toKeyValue(this.$$search),\n hash = this.$$hash ? '#' + encodeUriSegment(this.$$hash) : '';\n\n this.$$url = encodePath(this.$$path) + (search ? '?' + search : '') + hash;\n this.$$absUrl = composeProtocolHostPort(this.$$protocol, this.$$host, this.$$port) +\n basePath + (this.$$url ? '#' + hashPrefix + this.$$url : '');\n };\n\n this.$$rewriteAppUrl = function(absoluteLinkUrl) {\n if(absoluteLinkUrl.indexOf(appBaseUrl) == 0) {\n return absoluteLinkUrl;\n }\n }\n\n\n this.$$parse(url);\n}\n\n\nLocationUrl.prototype = {\n\n /**\n * Has any change been replacing ?\n * @private\n */\n $$replace: false,\n\n /**\n * @ngdoc method\n * @name ng.$location#absUrl\n * @methodOf ng.$location\n *\n * @description\n * This method is getter only.\n *\n * Return full url representation with all segments encoded according to rules specified in\n * {@link http://www.ietf.org/rfc/rfc3986.txt RFC 3986}.\n *\n * @return {string} full url\n */\n absUrl: locationGetter('$$absUrl'),\n\n /**\n * @ngdoc method\n * @name ng.$location#url\n * @methodOf ng.$location\n *\n * @description\n * This method is getter / setter.\n *\n * Return url (e.g. `/path?a=b#hash`) when called without any parameter.\n *\n * Change path, search and hash, when called with parameter and return `$location`.\n *\n * @param {string=} url New url without base prefix (e.g. `/path?a=b#hash`)\n * @return {string} url\n */\n url: function(url, replace) {\n if (isUndefined(url))\n return this.$$url;\n\n var match = PATH_MATCH.exec(url);\n if (match[1]) this.path(decodeURIComponent(match[1]));\n if (match[2] || match[1]) this.search(match[3] || '');\n this.hash(match[5] || '', replace);\n\n return this;\n },\n\n /**\n * @ngdoc method\n * @name ng.$location#protocol\n * @methodOf ng.$location\n *\n * @description\n * This method is getter only.\n *\n * Return protocol of current url.\n *\n * @return {string} protocol of current url\n */\n protocol: locationGetter('$$protocol'),\n\n /**\n * @ngdoc method\n * @name ng.$location#host\n * @methodOf ng.$location\n *\n * @description\n * This method is getter only.\n *\n * Return host of current url.\n *\n * @return {string} host of current url.\n */\n host: locationGetter('$$host'),\n\n /**\n * @ngdoc method\n * @name ng.$location#port\n * @methodOf ng.$location\n *\n * @description\n * This method is getter only.\n *\n * Return port of current url.\n *\n * @return {Number} port\n */\n port: locationGetter('$$port'),\n\n /**\n * @ngdoc method\n * @name ng.$location#path\n * @methodOf ng.$location\n *\n * @description\n * This method is getter / setter.\n *\n * Return path of current url when called without any parameter.\n *\n * Change path when called with parameter and return `$location`.\n *\n * Note: Path should always begin with forward slash (/), this method will add the forward slash\n * if it is missing.\n *\n * @param {string=} path New path\n * @return {string} path\n */\n path: locationGetterSetter('$$path', function(path) {\n return path.charAt(0) == '/' ? path : '/' + path;\n }),\n\n /**\n * @ngdoc method\n * @name ng.$location#search\n * @methodOf ng.$location\n *\n * @description\n * This method is getter / setter.\n *\n * Return search part (as object) of current url when called without any parameter.\n *\n * Change search part when called with parameter and return `$location`.\n *\n * @param {string|object=} search New search params - string or hash object\n * @param {string=} paramValue If `search` is a string, then `paramValue` will override only a\n * single search parameter. If the value is `null`, the parameter will be deleted.\n *\n * @return {string} search\n */\n search: function(search, paramValue) {\n if (isUndefined(search))\n return this.$$search;\n\n if (isDefined(paramValue)) {\n if (paramValue === null) {\n delete this.$$search[search];\n } else {\n this.$$search[search] = paramValue;\n }\n } else {\n this.$$search = isString(search) ? parseKeyValue(search) : search;\n }\n\n this.$$compose();\n return this;\n },\n\n /**\n * @ngdoc method\n * @name ng.$location#hash\n * @methodOf ng.$location\n *\n * @description\n * This method is getter / setter.\n *\n * Return hash fragment when called without any parameter.\n *\n * Change hash fragment when called with parameter and return `$location`.\n *\n * @param {string=} hash New hash fragment\n * @return {string} hash\n */\n hash: locationGetterSetter('$$hash', identity),\n\n /**\n * @ngdoc method\n * @name ng.$location#replace\n * @methodOf ng.$location\n *\n * @description\n * If called, all changes to $location during current `$digest` will be replacing current history\n * record, instead of adding new one.\n */\n replace: function() {\n this.$$replace = true;\n return this;\n }\n};\n\nLocationHashbangUrl.prototype = inherit(LocationUrl.prototype);\n\nfunction LocationHashbangInHtml5Url(url, hashPrefix, appBaseUrl, baseExtra) {\n LocationHashbangUrl.apply(this, arguments);\n\n\n this.$$rewriteAppUrl = function(absoluteLinkUrl) {\n if (absoluteLinkUrl.indexOf(appBaseUrl) == 0) {\n return appBaseUrl + baseExtra + '#' + hashPrefix + absoluteLinkUrl.substr(appBaseUrl.length);\n }\n }\n}\n\nLocationHashbangInHtml5Url.prototype = inherit(LocationHashbangUrl.prototype);\n\nfunction locationGetter(property) {\n return function() {\n return this[property];\n };\n}\n\n\nfunction locationGetterSetter(property, preprocess) {\n return function(value) {\n if (isUndefined(value))\n return this[property];\n\n this[property] = preprocess(value);\n this.$$compose();\n\n return this;\n };\n}\n\n\n/**\n * @ngdoc object\n * @name ng.$location\n *\n * @requires $browser\n * @requires $sniffer\n * @requires $rootElement\n *\n * @description\n * The $location service parses the URL in the browser address bar (based on the\n * {@link https://developer.mozilla.org/en/window.location window.location}) and makes the URL\n * available to your application. Changes to the URL in the address bar are reflected into\n * $location service and changes to $location are reflected into the browser address bar.\n *\n * **The $location service:**\n *\n * - Exposes the current URL in the browser address bar, so you can\n * - Watch and observe the URL.\n * - Change the URL.\n * - Synchronizes the URL with the browser when the user\n * - Changes the address bar.\n * - Clicks the back or forward button (or clicks a History link).\n * - Clicks on a link.\n * - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).\n *\n * For more information see {@link guide/dev_guide.services.$location Developer Guide: Angular\n * Services: Using $location}\n */\n\n/**\n * @ngdoc object\n * @name ng.$locationProvider\n * @description\n * Use the `$locationProvider` to configure how the application deep linking paths are stored.\n */\nfunction $LocationProvider(){\n var hashPrefix = '',\n html5Mode = false;\n\n /**\n * @ngdoc property\n * @name ng.$locationProvider#hashPrefix\n * @methodOf ng.$locationProvider\n * @description\n * @param {string=} prefix Prefix for hash part (containing path and search)\n * @returns {*} current value if used as getter or itself (chaining) if used as setter\n */\n this.hashPrefix = function(prefix) {\n if (isDefined(prefix)) {\n hashPrefix = prefix;\n return this;\n } else {\n return hashPrefix;\n }\n };\n\n /**\n * @ngdoc property\n * @name ng.$locationProvider#html5Mode\n * @methodOf ng.$locationProvider\n * @description\n * @param {string=} mode Use HTML5 strategy if available.\n * @returns {*} current value if used as getter or itself (chaining) if used as setter\n */\n this.html5Mode = function(mode) {\n if (isDefined(mode)) {\n html5Mode = mode;\n return this;\n } else {\n return html5Mode;\n }\n };\n\n this.$get = ['$rootScope', '$browser', '$sniffer', '$rootElement',\n function( $rootScope, $browser, $sniffer, $rootElement) {\n var $location,\n basePath,\n pathPrefix,\n initUrl = $browser.url(),\n initUrlParts = matchUrl(initUrl),\n appBaseUrl;\n\n if (html5Mode) {\n basePath = $browser.baseHref() || '/';\n pathPrefix = pathPrefixFromBase(basePath);\n appBaseUrl =\n composeProtocolHostPort(initUrlParts.protocol, initUrlParts.host, initUrlParts.port) +\n pathPrefix + '/';\n\n if ($sniffer.history) {\n $location = new LocationUrl(\n convertToHtml5Url(initUrl, basePath, hashPrefix),\n pathPrefix, appBaseUrl);\n } else {\n $location = new LocationHashbangInHtml5Url(\n convertToHashbangUrl(initUrl, basePath, hashPrefix),\n hashPrefix, appBaseUrl, basePath.substr(pathPrefix.length + 1));\n }\n } else {\n appBaseUrl =\n composeProtocolHostPort(initUrlParts.protocol, initUrlParts.host, initUrlParts.port) +\n (initUrlParts.path || '') +\n (initUrlParts.search ? ('?' + initUrlParts.search) : '') +\n '#' + hashPrefix + '/';\n\n $location = new LocationHashbangUrl(initUrl, hashPrefix, appBaseUrl);\n }\n\n $rootElement.bind('click', function(event) {\n // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)\n // currently we open nice url link and redirect then\n\n if (event.ctrlKey || event.metaKey || event.which == 2) return;\n\n var elm = jqLite(event.target);\n\n // traverse the DOM up to find first A tag\n while (lowercase(elm[0].nodeName) !== 'a') {\n // ignore rewriting if no A tag (reached root element, or no parent - removed from document)\n if (elm[0] === $rootElement[0] || !(elm = elm.parent())[0]) return;\n }\n\n var absHref = elm.prop('href'),\n rewrittenUrl = $location.$$rewriteAppUrl(absHref);\n\n if (absHref && !elm.attr('target') && rewrittenUrl) {\n // update location manually\n $location.$$parse(rewrittenUrl);\n $rootScope.$apply();\n event.preventDefault();\n // hack to work around FF6 bug 684208 when scenario runner clicks on links\n window.angular['ff-684208-preventDefault'] = true;\n }\n });\n\n\n // rewrite hashbang url <> html5 url\n if ($location.absUrl() != initUrl) {\n $browser.url($location.absUrl(), true);\n }\n\n // update $location when $browser url changes\n $browser.onUrlChange(function(newUrl) {\n if ($location.absUrl() != newUrl) {\n $rootScope.$evalAsync(function() {\n var oldUrl = $location.absUrl();\n\n $location.$$parse(newUrl);\n afterLocationChange(oldUrl);\n });\n if (!$rootScope.$$phase) $rootScope.$digest();\n }\n });\n\n // update browser\n var changeCounter = 0;\n $rootScope.$watch(function $locationWatch() {\n var oldUrl = $browser.url();\n var currentReplace = $location.$$replace;\n\n if (!changeCounter || oldUrl != $location.absUrl()) {\n changeCounter++;\n $rootScope.$evalAsync(function() {\n if ($rootScope.$broadcast('$locationChangeStart', $location.absUrl(), oldUrl).\n defaultPrevented) {\n $location.$$parse(oldUrl);\n } else {\n $browser.url($location.absUrl(), currentReplace);\n afterLocationChange(oldUrl);\n }\n });\n }\n $location.$$replace = false;\n\n return changeCounter;\n });\n\n return $location;\n\n function afterLocationChange(oldUrl) {\n $rootScope.$broadcast('$locationChangeSuccess', $location.absUrl(), oldUrl);\n }\n}];\n}\n\n/**\n * @ngdoc object\n * @name ng.$log\n * @requires $window\n *\n * @description\n * Simple service for logging. Default implementation writes the message\n * into the browser's console (if present).\n *\n * The main purpose of this service is to simplify debugging and troubleshooting.\n *\n * @example\n \n \n function LogCtrl($scope, $log) {\n $scope.$log = $log;\n $scope.message = 'Hello World!';\n }\n \n \n
\n
Reload this page with open console, enter text and hit the log button...
\n Message:\n \n \n \n \n \n
\n \n \n */\n\nfunction $LogProvider(){\n this.$get = ['$window', function($window){\n return {\n /**\n * @ngdoc method\n * @name ng.$log#log\n * @methodOf ng.$log\n *\n * @description\n * Write a log message\n */\n log: consoleLog('log'),\n\n /**\n * @ngdoc method\n * @name ng.$log#warn\n * @methodOf ng.$log\n *\n * @description\n * Write a warning message\n */\n warn: consoleLog('warn'),\n\n /**\n * @ngdoc method\n * @name ng.$log#info\n * @methodOf ng.$log\n *\n * @description\n * Write an information message\n */\n info: consoleLog('info'),\n\n /**\n * @ngdoc method\n * @name ng.$log#error\n * @methodOf ng.$log\n *\n * @description\n * Write an error message\n */\n error: consoleLog('error')\n };\n\n function formatError(arg) {\n if (arg instanceof Error) {\n if (arg.stack) {\n arg = (arg.message && arg.stack.indexOf(arg.message) === -1)\n ? 'Error: ' + arg.message + '\\n' + arg.stack\n : arg.stack;\n } else if (arg.sourceURL) {\n arg = arg.message + '\\n' + arg.sourceURL + ':' + arg.line;\n }\n }\n return arg;\n }\n\n function consoleLog(type) {\n var console = $window.console || {},\n logFn = console[type] || console.log || noop;\n\n if (logFn.apply) {\n return function() {\n var args = [];\n forEach(arguments, function(arg) {\n args.push(formatError(arg));\n });\n return logFn.apply(console, args);\n };\n }\n\n // we are IE which either doesn't have window.console => this is noop and we do nothing,\n // or we are IE where console.log doesn't have apply so we log at least first 2 args\n return function(arg1, arg2) {\n logFn(arg1, arg2);\n }\n }\n }];\n}\n\nvar OPERATORS = {\n 'null':function(){return null;},\n 'true':function(){return true;},\n 'false':function(){return false;},\n undefined:noop,\n '+':function(self, locals, a,b){\n a=a(self, locals); b=b(self, locals);\n if (isDefined(a)) {\n if (isDefined(b)) {\n return a + b;\n }\n return a;\n }\n return isDefined(b)?b:undefined;},\n '-':function(self, locals, a,b){a=a(self, locals); b=b(self, locals); return (isDefined(a)?a:0)-(isDefined(b)?b:0);},\n '*':function(self, locals, a,b){return a(self, locals)*b(self, locals);},\n '/':function(self, locals, a,b){return a(self, locals)/b(self, locals);},\n '%':function(self, locals, a,b){return a(self, locals)%b(self, locals);},\n '^':function(self, locals, a,b){return a(self, locals)^b(self, locals);},\n '=':noop,\n '==':function(self, locals, a,b){return a(self, locals)==b(self, locals);},\n '!=':function(self, locals, a,b){return a(self, locals)!=b(self, locals);},\n '<':function(self, locals, a,b){return a(self, locals)':function(self, locals, a,b){return a(self, locals)>b(self, locals);},\n '<=':function(self, locals, a,b){return a(self, locals)<=b(self, locals);},\n '>=':function(self, locals, a,b){return a(self, locals)>=b(self, locals);},\n '&&':function(self, locals, a,b){return a(self, locals)&&b(self, locals);},\n '||':function(self, locals, a,b){return a(self, locals)||b(self, locals);},\n '&':function(self, locals, a,b){return a(self, locals)&b(self, locals);},\n// '|':function(self, locals, a,b){return a|b;},\n '|':function(self, locals, a,b){return b(self, locals)(self, locals, a(self, locals));},\n '!':function(self, locals, a){return !a(self, locals);}\n};\nvar ESCAPE = {\"n\":\"\\n\", \"f\":\"\\f\", \"r\":\"\\r\", \"t\":\"\\t\", \"v\":\"\\v\", \"'\":\"'\", '\"':'\"'};\n\nfunction lex(text, csp){\n var tokens = [],\n token,\n index = 0,\n json = [],\n ch,\n lastCh = ':'; // can start regexp\n\n while (index < text.length) {\n ch = text.charAt(index);\n if (is('\"\\'')) {\n readString(ch);\n } else if (isNumber(ch) || is('.') && isNumber(peek())) {\n readNumber();\n } else if (isIdent(ch)) {\n readIdent();\n // identifiers can only be if the preceding char was a { or ,\n if (was('{,') && json[0]=='{' &&\n (token=tokens[tokens.length-1])) {\n token.json = token.text.indexOf('.') == -1;\n }\n } else if (is('(){}[].,;:')) {\n tokens.push({\n index:index,\n text:ch,\n json:(was(':[,') && is('{[')) || is('}]:,')\n });\n if (is('{[')) json.unshift(ch);\n if (is('}]')) json.shift();\n index++;\n } else if (isWhitespace(ch)) {\n index++;\n continue;\n } else {\n var ch2 = ch + peek(),\n fn = OPERATORS[ch],\n fn2 = OPERATORS[ch2];\n if (fn2) {\n tokens.push({index:index, text:ch2, fn:fn2});\n index += 2;\n } else if (fn) {\n tokens.push({index:index, text:ch, fn:fn, json: was('[,:') && is('+-')});\n index += 1;\n } else {\n throwError(\"Unexpected next character \", index, index+1);\n }\n }\n lastCh = ch;\n }\n return tokens;\n\n function is(chars) {\n return chars.indexOf(ch) != -1;\n }\n\n function was(chars) {\n return chars.indexOf(lastCh) != -1;\n }\n\n function peek() {\n return index + 1 < text.length ? text.charAt(index + 1) : false;\n }\n function isNumber(ch) {\n return '0' <= ch && ch <= '9';\n }\n function isWhitespace(ch) {\n return ch == ' ' || ch == '\\r' || ch == '\\t' ||\n ch == '\\n' || ch == '\\v' || ch == '\\u00A0'; // IE treats non-breaking space as \\u00A0\n }\n function isIdent(ch) {\n return 'a' <= ch && ch <= 'z' ||\n 'A' <= ch && ch <= 'Z' ||\n '_' == ch || ch == '$';\n }\n function isExpOperator(ch) {\n return ch == '-' || ch == '+' || isNumber(ch);\n }\n\n function throwError(error, start, end) {\n end = end || index;\n throw Error(\"Lexer Error: \" + error + \" at column\" +\n (isDefined(start)\n ? \"s \" + start + \"-\" + index + \" [\" + text.substring(start, end) + \"]\"\n : \" \" + end) +\n \" in expression [\" + text + \"].\");\n }\n\n function readNumber() {\n var number = \"\";\n var start = index;\n while (index < text.length) {\n var ch = lowercase(text.charAt(index));\n if (ch == '.' || isNumber(ch)) {\n number += ch;\n } else {\n var peekCh = peek();\n if (ch == 'e' && isExpOperator(peekCh)) {\n number += ch;\n } else if (isExpOperator(ch) &&\n peekCh && isNumber(peekCh) &&\n number.charAt(number.length - 1) == 'e') {\n number += ch;\n } else if (isExpOperator(ch) &&\n (!peekCh || !isNumber(peekCh)) &&\n number.charAt(number.length - 1) == 'e') {\n throwError('Invalid exponent');\n } else {\n break;\n }\n }\n index++;\n }\n number = 1 * number;\n tokens.push({index:start, text:number, json:true,\n fn:function() {return number;}});\n }\n function readIdent() {\n var ident = \"\",\n start = index,\n lastDot, peekIndex, methodName;\n\n while (index < text.length) {\n var ch = text.charAt(index);\n if (ch == '.' || isIdent(ch) || isNumber(ch)) {\n if (ch == '.') lastDot = index;\n ident += ch;\n } else {\n break;\n }\n index++;\n }\n\n //check if this is not a method invocation and if it is back out to last dot\n if (lastDot) {\n peekIndex = index;\n while(peekIndex < text.length) {\n var ch = text.charAt(peekIndex);\n if (ch == '(') {\n methodName = ident.substr(lastDot - start + 1);\n ident = ident.substr(0, lastDot - start);\n index = peekIndex;\n break;\n }\n if(isWhitespace(ch)) {\n peekIndex++;\n } else {\n break;\n }\n }\n }\n\n\n var token = {\n index:start,\n text:ident\n };\n\n if (OPERATORS.hasOwnProperty(ident)) {\n token.fn = token.json = OPERATORS[ident];\n } else {\n var getter = getterFn(ident, csp);\n token.fn = extend(function(self, locals) {\n return (getter(self, locals));\n }, {\n assign: function(self, value) {\n return setter(self, ident, value);\n }\n });\n }\n\n tokens.push(token);\n\n if (methodName) {\n tokens.push({\n index:lastDot,\n text: '.',\n json: false\n });\n tokens.push({\n index: lastDot + 1,\n text: methodName,\n json: false\n });\n }\n }\n\n function readString(quote) {\n var start = index;\n index++;\n var string = \"\";\n var rawString = quote;\n var escape = false;\n while (index < text.length) {\n var ch = text.charAt(index);\n rawString += ch;\n if (escape) {\n if (ch == 'u') {\n var hex = text.substring(index + 1, index + 5);\n if (!hex.match(/[\\da-f]{4}/i))\n throwError( \"Invalid unicode escape [\\\\u\" + hex + \"]\");\n index += 4;\n string += String.fromCharCode(parseInt(hex, 16));\n } else {\n var rep = ESCAPE[ch];\n if (rep) {\n string += rep;\n } else {\n string += ch;\n }\n }\n escape = false;\n } else if (ch == '\\\\') {\n escape = true;\n } else if (ch == quote) {\n index++;\n tokens.push({\n index:start,\n text:rawString,\n string:string,\n json:true,\n fn:function() { return string; }\n });\n return;\n } else {\n string += ch;\n }\n index++;\n }\n throwError(\"Unterminated quote\", start);\n }\n}\n\n/////////////////////////////////////////\n\nfunction parser(text, json, $filter, csp){\n var ZERO = valueFn(0),\n value,\n tokens = lex(text, csp),\n assignment = _assignment,\n functionCall = _functionCall,\n fieldAccess = _fieldAccess,\n objectIndex = _objectIndex,\n filterChain = _filterChain;\n\n if(json){\n // The extra level of aliasing is here, just in case the lexer misses something, so that\n // we prevent any accidental execution in JSON.\n assignment = logicalOR;\n functionCall =\n fieldAccess =\n objectIndex =\n filterChain =\n function() { throwError(\"is not valid json\", {text:text, index:0}); };\n value = primary();\n } else {\n value = statements();\n }\n if (tokens.length !== 0) {\n throwError(\"is an unexpected token\", tokens[0]);\n }\n return value;\n\n ///////////////////////////////////\n function throwError(msg, token) {\n throw Error(\"Syntax Error: Token '\" + token.text +\n \"' \" + msg + \" at column \" +\n (token.index + 1) + \" of the expression [\" +\n text + \"] starting at [\" + text.substring(token.index) + \"].\");\n }\n\n function peekToken() {\n if (tokens.length === 0)\n throw Error(\"Unexpected end of expression: \" + text);\n return tokens[0];\n }\n\n function peek(e1, e2, e3, e4) {\n if (tokens.length > 0) {\n var token = tokens[0];\n var t = token.text;\n if (t==e1 || t==e2 || t==e3 || t==e4 ||\n (!e1 && !e2 && !e3 && !e4)) {\n return token;\n }\n }\n return false;\n }\n\n function expect(e1, e2, e3, e4){\n var token = peek(e1, e2, e3, e4);\n if (token) {\n if (json && !token.json) {\n throwError(\"is not valid json\", token);\n }\n tokens.shift();\n return token;\n }\n return false;\n }\n\n function consume(e1){\n if (!expect(e1)) {\n throwError(\"is unexpected, expecting [\" + e1 + \"]\", peek());\n }\n }\n\n function unaryFn(fn, right) {\n return function(self, locals) {\n return fn(self, locals, right);\n };\n }\n\n function binaryFn(left, fn, right) {\n return function(self, locals) {\n return fn(self, locals, left, right);\n };\n }\n\n function statements() {\n var statements = [];\n while(true) {\n if (tokens.length > 0 && !peek('}', ')', ';', ']'))\n statements.push(filterChain());\n if (!expect(';')) {\n // optimize for the common case where there is only one statement.\n // TODO(size): maybe we should not support multiple statements?\n return statements.length == 1\n ? statements[0]\n : function(self, locals){\n var value;\n for ( var i = 0; i < statements.length; i++) {\n var statement = statements[i];\n if (statement)\n value = statement(self, locals);\n }\n return value;\n };\n }\n }\n }\n\n function _filterChain() {\n var left = expression();\n var token;\n while(true) {\n if ((token = expect('|'))) {\n left = binaryFn(left, token.fn, filter());\n } else {\n return left;\n }\n }\n }\n\n function filter() {\n var token = expect();\n var fn = $filter(token.text);\n var argsFn = [];\n while(true) {\n if ((token = expect(':'))) {\n argsFn.push(expression());\n } else {\n var fnInvoke = function(self, locals, input){\n var args = [input];\n for ( var i = 0; i < argsFn.length; i++) {\n args.push(argsFn[i](self, locals));\n }\n return fn.apply(self, args);\n };\n return function() {\n return fnInvoke;\n };\n }\n }\n }\n\n function expression() {\n return assignment();\n }\n\n function _assignment() {\n var left = logicalOR();\n var right;\n var token;\n if ((token = expect('='))) {\n if (!left.assign) {\n throwError(\"implies assignment but [\" +\n text.substring(0, token.index) + \"] can not be assigned to\", token);\n }\n right = logicalOR();\n return function(self, locals){\n return left.assign(self, right(self, locals), locals);\n };\n } else {\n return left;\n }\n }\n\n function logicalOR() {\n var left = logicalAND();\n var token;\n while(true) {\n if ((token = expect('||'))) {\n left = binaryFn(left, token.fn, logicalAND());\n } else {\n return left;\n }\n }\n }\n\n function logicalAND() {\n var left = equality();\n var token;\n if ((token = expect('&&'))) {\n left = binaryFn(left, token.fn, logicalAND());\n }\n return left;\n }\n\n function equality() {\n var left = relational();\n var token;\n if ((token = expect('==','!='))) {\n left = binaryFn(left, token.fn, equality());\n }\n return left;\n }\n\n function relational() {\n var left = additive();\n var token;\n if ((token = expect('<', '>', '<=', '>='))) {\n left = binaryFn(left, token.fn, relational());\n }\n return left;\n }\n\n function additive() {\n var left = multiplicative();\n var token;\n while ((token = expect('+','-'))) {\n left = binaryFn(left, token.fn, multiplicative());\n }\n return left;\n }\n\n function multiplicative() {\n var left = unary();\n var token;\n while ((token = expect('*','/','%'))) {\n left = binaryFn(left, token.fn, unary());\n }\n return left;\n }\n\n function unary() {\n var token;\n if (expect('+')) {\n return primary();\n } else if ((token = expect('-'))) {\n return binaryFn(ZERO, token.fn, unary());\n } else if ((token = expect('!'))) {\n return unaryFn(token.fn, unary());\n } else {\n return primary();\n }\n }\n\n\n function primary() {\n var primary;\n if (expect('(')) {\n primary = filterChain();\n consume(')');\n } else if (expect('[')) {\n primary = arrayDeclaration();\n } else if (expect('{')) {\n primary = object();\n } else {\n var token = expect();\n primary = token.fn;\n if (!primary) {\n throwError(\"not a primary expression\", token);\n }\n }\n\n var next, context;\n while ((next = expect('(', '[', '.'))) {\n if (next.text === '(') {\n primary = functionCall(primary, context);\n context = null;\n } else if (next.text === '[') {\n context = primary;\n primary = objectIndex(primary);\n } else if (next.text === '.') {\n context = primary;\n primary = fieldAccess(primary);\n } else {\n throwError(\"IMPOSSIBLE\");\n }\n }\n return primary;\n }\n\n function _fieldAccess(object) {\n var field = expect().text;\n var getter = getterFn(field, csp);\n return extend(\n function(self, locals) {\n return getter(object(self, locals), locals);\n },\n {\n assign:function(self, value, locals) {\n return setter(object(self, locals), field, value);\n }\n }\n );\n }\n\n function _objectIndex(obj) {\n var indexFn = expression();\n consume(']');\n return extend(\n function(self, locals){\n var o = obj(self, locals),\n i = indexFn(self, locals),\n v, p;\n\n if (!o) return undefined;\n v = o[i];\n if (v && v.then) {\n p = v;\n if (!('$$v' in v)) {\n p.$$v = undefined;\n p.then(function(val) { p.$$v = val; });\n }\n v = v.$$v;\n }\n return v;\n }, {\n assign:function(self, value, locals){\n return obj(self, locals)[indexFn(self, locals)] = value;\n }\n });\n }\n\n function _functionCall(fn, contextGetter) {\n var argsFn = [];\n if (peekToken().text != ')') {\n do {\n argsFn.push(expression());\n } while (expect(','));\n }\n consume(')');\n return function(self, locals){\n var args = [],\n context = contextGetter ? contextGetter(self, locals) : self;\n\n for ( var i = 0; i < argsFn.length; i++) {\n args.push(argsFn[i](self, locals));\n }\n var fnPtr = fn(self, locals) || noop;\n // IE stupidity!\n return fnPtr.apply\n ? fnPtr.apply(context, args)\n : fnPtr(args[0], args[1], args[2], args[3], args[4]);\n };\n }\n\n // This is used with json array declaration\n function arrayDeclaration () {\n var elementFns = [];\n if (peekToken().text != ']') {\n do {\n elementFns.push(expression());\n } while (expect(','));\n }\n consume(']');\n return function(self, locals){\n var array = [];\n for ( var i = 0; i < elementFns.length; i++) {\n array.push(elementFns[i](self, locals));\n }\n return array;\n };\n }\n\n function object () {\n var keyValues = [];\n if (peekToken().text != '}') {\n do {\n var token = expect(),\n key = token.string || token.text;\n consume(\":\");\n var value = expression();\n keyValues.push({key:key, value:value});\n } while (expect(','));\n }\n consume('}');\n return function(self, locals){\n var object = {};\n for ( var i = 0; i < keyValues.length; i++) {\n var keyValue = keyValues[i];\n var value = keyValue.value(self, locals);\n object[keyValue.key] = value;\n }\n return object;\n };\n }\n}\n\n//////////////////////////////////////////////////\n// Parser helper functions\n//////////////////////////////////////////////////\n\nfunction setter(obj, path, setValue) {\n var element = path.split('.');\n for (var i = 0; element.length > 1; i++) {\n var key = element.shift();\n var propertyObj = obj[key];\n if (!propertyObj) {\n propertyObj = {};\n obj[key] = propertyObj;\n }\n obj = propertyObj;\n }\n obj[element.shift()] = setValue;\n return setValue;\n}\n\n/**\n * Return the value accesible from the object by path. Any undefined traversals are ignored\n * @param {Object} obj starting object\n * @param {string} path path to traverse\n * @param {boolean=true} bindFnToScope\n * @returns value as accesbile by path\n */\n//TODO(misko): this function needs to be removed\nfunction getter(obj, path, bindFnToScope) {\n if (!path) return obj;\n var keys = path.split('.');\n var key;\n var lastInstance = obj;\n var len = keys.length;\n\n for (var i = 0; i < len; i++) {\n key = keys[i];\n if (obj) {\n obj = (lastInstance = obj)[key];\n }\n }\n if (!bindFnToScope && isFunction(obj)) {\n return bind(lastInstance, obj);\n }\n return obj;\n}\n\nvar getterFnCache = {};\n\n/**\n * Implementation of the \"Black Hole\" variant from:\n * - http://jsperf.com/angularjs-parse-getter/4\n * - http://jsperf.com/path-evaluation-simplified/7\n */\nfunction cspSafeGetterFn(key0, key1, key2, key3, key4) {\n return function(scope, locals) {\n var pathVal = (locals && locals.hasOwnProperty(key0)) ? locals : scope,\n promise;\n\n if (pathVal === null || pathVal === undefined) return pathVal;\n\n pathVal = pathVal[key0];\n if (pathVal && pathVal.then) {\n if (!(\"$$v\" in pathVal)) {\n promise = pathVal;\n promise.$$v = undefined;\n promise.then(function(val) { promise.$$v = val; });\n }\n pathVal = pathVal.$$v;\n }\n if (!key1 || pathVal === null || pathVal === undefined) return pathVal;\n\n pathVal = pathVal[key1];\n if (pathVal && pathVal.then) {\n if (!(\"$$v\" in pathVal)) {\n promise = pathVal;\n promise.$$v = undefined;\n promise.then(function(val) { promise.$$v = val; });\n }\n pathVal = pathVal.$$v;\n }\n if (!key2 || pathVal === null || pathVal === undefined) return pathVal;\n\n pathVal = pathVal[key2];\n if (pathVal && pathVal.then) {\n if (!(\"$$v\" in pathVal)) {\n promise = pathVal;\n promise.$$v = undefined;\n promise.then(function(val) { promise.$$v = val; });\n }\n pathVal = pathVal.$$v;\n }\n if (!key3 || pathVal === null || pathVal === undefined) return pathVal;\n\n pathVal = pathVal[key3];\n if (pathVal && pathVal.then) {\n if (!(\"$$v\" in pathVal)) {\n promise = pathVal;\n promise.$$v = undefined;\n promise.then(function(val) { promise.$$v = val; });\n }\n pathVal = pathVal.$$v;\n }\n if (!key4 || pathVal === null || pathVal === undefined) return pathVal;\n\n pathVal = pathVal[key4];\n if (pathVal && pathVal.then) {\n if (!(\"$$v\" in pathVal)) {\n promise = pathVal;\n promise.$$v = undefined;\n promise.then(function(val) { promise.$$v = val; });\n }\n pathVal = pathVal.$$v;\n }\n return pathVal;\n };\n};\n\nfunction getterFn(path, csp) {\n if (getterFnCache.hasOwnProperty(path)) {\n return getterFnCache[path];\n }\n\n var pathKeys = path.split('.'),\n pathKeysLength = pathKeys.length,\n fn;\n\n if (csp) {\n fn = (pathKeysLength < 6)\n ? cspSafeGetterFn(pathKeys[0], pathKeys[1], pathKeys[2], pathKeys[3], pathKeys[4])\n : function(scope, locals) {\n var i = 0, val\n do {\n val = cspSafeGetterFn(\n pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++]\n )(scope, locals);\n\n locals = undefined; // clear after first iteration\n scope = val;\n } while (i < pathKeysLength);\n return val;\n }\n } else {\n var code = 'var l, fn, p;\\n';\n forEach(pathKeys, function(key, index) {\n code += 'if(s === null || s === undefined) return s;\\n' +\n 'l=s;\\n' +\n 's='+ (index\n // we simply dereference 's' on any .dot notation\n ? 's'\n // but if we are first then we check locals first, and if so read it first\n : '((k&&k.hasOwnProperty(\"' + key + '\"))?k:s)') + '[\"' + key + '\"]' + ';\\n' +\n 'if (s && s.then) {\\n' +\n ' if (!(\"$$v\" in s)) {\\n' +\n ' p=s;\\n' +\n ' p.$$v = undefined;\\n' +\n ' p.then(function(v) {p.$$v=v;});\\n' +\n '}\\n' +\n ' s=s.$$v\\n' +\n '}\\n';\n });\n code += 'return s;';\n fn = Function('s', 'k', code); // s=scope, k=locals\n fn.toString = function() { return code; };\n }\n\n return getterFnCache[path] = fn;\n}\n\n///////////////////////////////////\n\n/**\n * @ngdoc function\n * @name ng.$parse\n * @function\n *\n * @description\n *\n * Converts Angular {@link guide/expression expression} into a function.\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`: an object against which any expressions embedded in the strings are evaluated\n * against (Topically a scope object).\n * * `locals`: local variables context object, useful for overriding values in `context`.\n *\n * The return function also has an `assign` property, if the expression is assignable, which\n * allows one to set values to expressions.\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 *\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 it's 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 that $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 * defered.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 }\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 on 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 single promise that will be resolved with an array of values,\n * each value coresponding to the promise at the same index in the `promises` array. If any of\n * the promises is resolved with a rejection, this resulting promise will be resolved with the\n * same rejection.\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.} promises An array of promises.\n * @returns {Promise} Returns a single promise that will be resolved with an array of values,\n * each value coresponding to the promise at the same index in the `promises` array. If any of\n * the promises is resolved with a rejection, this resulting promise will be resolved with the\n * same rejection.\n */\n function all(promises) {\n var deferred = defer(),\n counter = promises.length,\n results = [];\n\n if (counter) {\n forEach(promises, function(promise, index) {\n ref(promise).then(function(value) {\n if (index in results) return;\n results[index] = value;\n if (!(--counter)) deferred.resolve(results);\n }, function(reason) {\n if (index in results) return;\n deferred.reject(reason);\n });\n });\n } else {\n deferred.resolve(results);\n }\n\n return deferred.promise;\n }\n\n return {\n defer: defer,\n reject: reject,\n when: when,\n all: all\n };\n}\n\n/**\n * @ngdoc object\n * @name ng.$routeProvider\n * @function\n *\n * @description\n *\n * Used for configuring routes. See {@link ng.$route $route} for an example.\n */\nfunction $RouteProvider(){\n var routes = {};\n\n /**\n * @ngdoc method\n * @name ng.$routeProvider#when\n * @methodOf ng.$routeProvider\n *\n * @param {string} path Route path (matched against `$location.path`). If `$location.path`\n * contains redundant trailing slash or is missing one, the route will still match and the\n * `$location.path` will be updated to add or drop the trailing slash to exactly match the\n * route definition.\n *\n * `path` can contain named groups starting with a colon (`:name`). All characters up to the\n * next slash are matched and stored in `$routeParams` under the given `name` when the route\n * matches.\n *\n * @param {Object} route Mapping information to be assigned to `$route.current` on route\n * match.\n *\n * Object properties:\n *\n * - `controller` – `{(string|function()=}` – Controller fn that should be associated with newly\n * created scope or the name of a {@link angular.Module#controller registered controller}\n * if passed as a string.\n * - `template` – `{string=}` – html template as a string that should be used by\n * {@link ng.directive:ngView ngView} or\n * {@link ng.directive:ngInclude ngInclude} directives.\n * this property takes precedence over `templateUrl`.\n * - `templateUrl` – `{string=}` – path to an html template that should be used by\n * {@link ng.directive:ngView ngView}.\n * - `resolve` - `{Object.=}` - An optional map of dependencies which should\n * be injected into the controller. If any of these dependencies are promises, they will be\n * resolved and converted to a value before the controller is instantiated and the\n * `$routeChangeSuccess` event is fired. The map object is:\n *\n * - `key` – `{string}`: a name of a dependency to be injected into the controller.\n * - `factory` - `{string|function}`: If `string` then it is an alias for a service.\n * Otherwise if function, then it is {@link api/AUTO.$injector#invoke injected}\n * and the return value is treated as the dependency. If the result is a promise, it is resolved\n * before its value is injected into the controller.\n *\n * - `redirectTo` – {(string|function())=} – value to update\n * {@link ng.$location $location} path with and trigger route redirection.\n *\n * If `redirectTo` is a function, it will be called with the following parameters:\n *\n * - `{Object.}` - route parameters extracted from the current\n * `$location.path()` by applying the current route templateUrl.\n * - `{string}` - current `$location.path()`\n * - `{Object}` - current `$location.search()`\n *\n * The custom `redirectTo` function is expected to return a string which will be used\n * to update `$location.path()` and `$location.search()`.\n *\n * - `[reloadOnSearch=true]` - {boolean=} - reload route when only $location.search()\n * changes.\n *\n * If the option is set to `false` and url in the browser changes, then\n * `$routeUpdate` event is broadcasted on the root scope.\n *\n * @returns {Object} self\n *\n * @description\n * Adds a new route definition to the `$route` service.\n */\n this.when = function(path, route) {\n routes[path] = extend({reloadOnSearch: true}, route);\n\n // create redirection for trailing slashes\n if (path) {\n var redirectPath = (path[path.length-1] == '/')\n ? path.substr(0, path.length-1)\n : path +'/';\n\n routes[redirectPath] = {redirectTo: path};\n }\n\n return this;\n };\n\n /**\n * @ngdoc method\n * @name ng.$routeProvider#otherwise\n * @methodOf ng.$routeProvider\n *\n * @description\n * Sets route definition that will be used on route change when no other route definition\n * is matched.\n *\n * @param {Object} params Mapping information to be assigned to `$route.current`.\n * @returns {Object} self\n */\n this.otherwise = function(params) {\n this.when(null, params);\n return this;\n };\n\n\n this.$get = ['$rootScope', '$location', '$routeParams', '$q', '$injector', '$http', '$templateCache',\n function( $rootScope, $location, $routeParams, $q, $injector, $http, $templateCache) {\n\n /**\n * @ngdoc object\n * @name ng.$route\n * @requires $location\n * @requires $routeParams\n *\n * @property {Object} current Reference to the current route definition.\n * The route definition contains:\n *\n * - `controller`: The controller constructor as define in route definition.\n * - `locals`: A map of locals which is used by {@link ng.$controller $controller} service for\n * controller instantiation. The `locals` contain\n * the resolved values of the `resolve` map. Additionally the `locals` also contain:\n *\n * - `$scope` - The current route scope.\n * - `$template` - The current route template HTML.\n *\n * @property {Array.