').append(element).html();\r\n try {\r\n return element[0].nodeType === TEXT_NODE ? lowercase(elemHtml) :\r\n elemHtml.\r\n match(/^(<[^>]+>)/)[1].\r\n replace(/^<([\\w\\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });\r\n } catch(e) {\r\n return lowercase(elemHtml);\r\n }\r\n\r\n}\r\n\r\n\r\n/////////////////////////////////////////////////\r\n\r\n/**\r\n * Tries to decode the URI component without throwing an exception.\r\n *\r\n * @private\r\n * @param str value potential URI component to check.\r\n * @returns {boolean} True if `value` can be decoded\r\n * with the decodeURIComponent function.\r\n */\r\nfunction tryDecodeURIComponent(value) {\r\n try {\r\n return decodeURIComponent(value);\r\n } catch(e) {\r\n // Ignore any invalid uri component\r\n }\r\n}\r\n\r\n\r\n/**\r\n * Parses an escaped url query string into key-value pairs.\r\n * @returns {Object.}\r\n */\r\nfunction parseKeyValue(/**string*/keyValue) {\r\n var obj = {}, key_value, key;\r\n forEach((keyValue || \"\").split('&'), function(keyValue) {\r\n if ( keyValue ) {\r\n key_value = keyValue.replace(/\\+/g,'%20').split('=');\r\n key = tryDecodeURIComponent(key_value[0]);\r\n if ( isDefined(key) ) {\r\n var val = isDefined(key_value[1]) ? tryDecodeURIComponent(key_value[1]) : true;\r\n if (!hasOwnProperty.call(obj, key)) {\r\n obj[key] = val;\r\n } else if(isArray(obj[key])) {\r\n obj[key].push(val);\r\n } else {\r\n obj[key] = [obj[key],val];\r\n }\r\n }\r\n }\r\n });\r\n return obj;\r\n}\r\n\r\nfunction toKeyValue(obj) {\r\n var parts = [];\r\n forEach(obj, function(value, key) {\r\n if (isArray(value)) {\r\n forEach(value, function(arrayValue) {\r\n parts.push(encodeUriQuery(key, true) +\r\n (arrayValue === true ? '' : '=' + encodeUriQuery(arrayValue, true)));\r\n });\r\n } else {\r\n parts.push(encodeUriQuery(key, true) +\r\n (value === true ? '' : '=' + encodeUriQuery(value, true)));\r\n }\r\n });\r\n return parts.length ? parts.join('&') : '';\r\n}\r\n\r\n\r\n/**\r\n * We need our custom method because encodeURIComponent is too aggressive and doesn't follow\r\n * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path\r\n * segments:\r\n * segment = *pchar\r\n * pchar = unreserved / pct-encoded / sub-delims / \":\" / \"@\"\r\n * pct-encoded = \"%\" HEXDIG HEXDIG\r\n * unreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\r\n * sub-delims = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\"\r\n * / \"*\" / \"+\" / \",\" / \";\" / \"=\"\r\n */\r\nfunction encodeUriSegment(val) {\r\n return encodeUriQuery(val, true).\r\n replace(/%26/gi, '&').\r\n replace(/%3D/gi, '=').\r\n replace(/%2B/gi, '+');\r\n}\r\n\r\n\r\n/**\r\n * This method is intended for encoding *key* or *value* parts of query component. We need a custom\r\n * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be\r\n * encoded per http://tools.ietf.org/html/rfc3986:\r\n * query = *( pchar / \"/\" / \"?\" )\r\n * pchar = unreserved / pct-encoded / sub-delims / \":\" / \"@\"\r\n * unreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\r\n * pct-encoded = \"%\" HEXDIG HEXDIG\r\n * sub-delims = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\"\r\n * / \"*\" / \"+\" / \",\" / \";\" / \"=\"\r\n */\r\nfunction encodeUriQuery(val, pctEncodeSpaces) {\r\n return encodeURIComponent(val).\r\n replace(/%40/gi, '@').\r\n replace(/%3A/gi, ':').\r\n replace(/%24/g, '$').\r\n replace(/%2C/gi, ',').\r\n replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));\r\n}\r\n\r\n\r\n/**\r\n * @ngdoc directive\r\n * @name ngApp\r\n * @module ng\r\n *\r\n * @element ANY\r\n * @param {angular.Module} ngApp an optional application\r\n * {@link angular.module module} name to load.\r\n *\r\n * @description\r\n *\r\n * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive\r\n * designates the **root element** of the application and is typically placed near the root element\r\n * of the page - e.g. on the `` or `` tags.\r\n *\r\n * Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`\r\n * found in the document will be used to define the root element to auto-bootstrap as an\r\n * application. To run multiple applications in an HTML document you must manually bootstrap them using\r\n * {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.\r\n *\r\n * You can specify an **AngularJS module** to be used as the root module for the application. This\r\n * module will be loaded into the {@link auto.$injector} when the application is bootstrapped and\r\n * should contain the application code needed or have dependencies on other modules that will\r\n * contain the code. See {@link angular.module} for more information.\r\n *\r\n * In the example below if the `ngApp` directive were not placed on the `html` element then the\r\n * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`\r\n * would not be resolved to `3`.\r\n *\r\n * `ngApp` is the easiest, and most common, way to bootstrap an application.\r\n *\r\n \r\n \r\n \r\n \r\n angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {\r\n $scope.a = 1;\r\n $scope.b = 2;\r\n });\r\n \r\n \r\n *\r\n */\r\nfunction angularInit(element, bootstrap) {\r\n var elements = [element],\r\n appElement,\r\n module,\r\n names = ['ng:app', 'ng-app', 'x-ng-app', 'data-ng-app'],\r\n NG_APP_CLASS_REGEXP = /\\sng[:\\-]app(:\\s*([\\w\\d_]+);?)?\\s/;\r\n\r\n function append(element) {\r\n element && elements.push(element);\r\n }\r\n\r\n forEach(names, function(name) {\r\n names[name] = true;\r\n append(document.getElementById(name));\r\n name = name.replace(':', '\\\\:');\r\n if (element.querySelectorAll) {\r\n forEach(element.querySelectorAll('.' + name), append);\r\n forEach(element.querySelectorAll('.' + name + '\\\\:'), append);\r\n forEach(element.querySelectorAll('[' + name + ']'), append);\r\n }\r\n });\r\n\r\n forEach(elements, function(element) {\r\n if (!appElement) {\r\n var className = ' ' + element.className + ' ';\r\n var match = NG_APP_CLASS_REGEXP.exec(className);\r\n if (match) {\r\n appElement = element;\r\n module = (match[2] || '').replace(/\\s+/g, ',');\r\n } else {\r\n forEach(element.attributes, function(attr) {\r\n if (!appElement && names[attr.name]) {\r\n appElement = element;\r\n module = attr.value;\r\n }\r\n });\r\n }\r\n }\r\n });\r\n if (appElement) {\r\n bootstrap(appElement, module ? [module] : []);\r\n }\r\n}\r\n\r\n/**\r\n * @ngdoc function\r\n * @name angular.bootstrap\r\n * @module ng\r\n * @description\r\n * Use this function to manually start up angular application.\r\n *\r\n * See: {@link guide/bootstrap Bootstrap}\r\n *\r\n * Note that ngScenario-based end-to-end tests cannot use this function to bootstrap manually.\r\n * They must use {@link ng.directive:ngApp ngApp}.\r\n *\r\n * Angular will detect if it has been loaded into the browser more than once and only allow the\r\n * first loaded script to be bootstrapped and will report a warning to the browser console for\r\n * each of the subsequent scripts. This prevents strange results in applications, where otherwise\r\n * multiple instances of Angular try to work on the DOM.\r\n *\r\n * \r\n * \r\n * \r\n * \r\n * \r\n * var app = angular.module('multi-bootstrap', [])\r\n *\r\n * .controller('BrokenTable', function($scope) {\r\n * $scope.headings = ['One', 'Two', 'Three'];\r\n * $scope.fillings = [[1, 2, 3], ['A', 'B', 'C'], [7, 8, 9]];\r\n * });\r\n * \r\n * \r\n * it('should only insert one table cell for each item in $scope.fillings', function() {\r\n * expect(element.all(by.css('td')).count())\r\n * .toBe(9);\r\n * });\r\n * \r\n * \r\n *\r\n * @param {DOMElement} element DOM element which is the root of angular application.\r\n * @param {Array=} modules an array of modules to load into the application.\r\n * Each item in the array should be the name of a predefined module or a (DI annotated)\r\n * function that will be invoked by the injector as a run block.\r\n * See: {@link angular.module modules}\r\n * @returns {auto.$injector} Returns the newly created injector for this app.\r\n */\r\nfunction bootstrap(element, modules) {\r\n var doBootstrap = function() {\r\n element = jqLite(element);\r\n\r\n if (element.injector()) {\r\n var tag = (element[0] === document) ? 'document' : startingTag(element);\r\n //Encode angle brackets to prevent input from being sanitized to empty string #8683\r\n throw ngMinErr(\r\n 'btstrpd',\r\n \"App Already Bootstrapped with this Element '{0}'\",\r\n tag.replace(//,'>'));\r\n }\r\n\r\n modules = modules || [];\r\n modules.unshift(['$provide', function($provide) {\r\n $provide.value('$rootElement', element);\r\n }]);\r\n modules.unshift('ng');\r\n var injector = createInjector(modules);\r\n injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector', '$animate',\r\n function(scope, element, compile, injector, animate) {\r\n scope.$apply(function() {\r\n element.data('$injector', injector);\r\n compile(element)(scope);\r\n });\r\n }]\r\n );\r\n return injector;\r\n };\r\n\r\n var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;\r\n\r\n if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {\r\n return doBootstrap();\r\n }\r\n\r\n window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');\r\n angular.resumeBootstrap = function(extraModules) {\r\n forEach(extraModules, function(module) {\r\n modules.push(module);\r\n });\r\n doBootstrap();\r\n };\r\n}\r\n\r\nvar SNAKE_CASE_REGEXP = /[A-Z]/g;\r\nfunction snake_case(name, separator) {\r\n separator = separator || '_';\r\n return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {\r\n return (pos ? separator : '') + letter.toLowerCase();\r\n });\r\n}\r\n\r\nfunction bindJQuery() {\r\n // bind to jQuery if present;\r\n jQuery = window.jQuery;\r\n // Use jQuery if it exists with proper functionality, otherwise default to us.\r\n // Angular 1.2+ requires jQuery 1.7.1+ for on()/off() support.\r\n if (jQuery && jQuery.fn.on) {\r\n jqLite = jQuery;\r\n extend(jQuery.fn, {\r\n scope: JQLitePrototype.scope,\r\n isolateScope: JQLitePrototype.isolateScope,\r\n controller: JQLitePrototype.controller,\r\n injector: JQLitePrototype.injector,\r\n inheritedData: JQLitePrototype.inheritedData\r\n });\r\n // Method signature:\r\n // jqLitePatchJQueryRemove(name, dispatchThis, filterElems, getterIfNoArguments)\r\n jqLitePatchJQueryRemove('remove', true, true, false);\r\n jqLitePatchJQueryRemove('empty', false, false, false);\r\n jqLitePatchJQueryRemove('html', false, false, true);\r\n } else {\r\n jqLite = JQLite;\r\n }\r\n angular.element = jqLite;\r\n}\r\n\r\n/**\r\n * throw error if the argument is falsy.\r\n */\r\nfunction assertArg(arg, name, reason) {\r\n if (!arg) {\r\n throw ngMinErr('areq', \"Argument '{0}' is {1}\", (name || '?'), (reason || \"required\"));\r\n }\r\n return arg;\r\n}\r\n\r\nfunction assertArgFn(arg, name, acceptArrayAnnotation) {\r\n if (acceptArrayAnnotation && isArray(arg)) {\r\n arg = arg[arg.length - 1];\r\n }\r\n\r\n assertArg(isFunction(arg), name, 'not a function, got ' +\r\n (arg && typeof arg === 'object' ? arg.constructor.name || 'Object' : typeof arg));\r\n return arg;\r\n}\r\n\r\n/**\r\n * throw error if the name given is hasOwnProperty\r\n * @param {String} name the name to test\r\n * @param {String} context the context in which the name is used, such as module or directive\r\n */\r\nfunction assertNotHasOwnProperty(name, context) {\r\n if (name === 'hasOwnProperty') {\r\n throw ngMinErr('badname', \"hasOwnProperty is not a valid {0} name\", context);\r\n }\r\n}\r\n\r\n/**\r\n * Return the value accessible from the object by path. Any undefined traversals are ignored\r\n * @param {Object} obj starting object\r\n * @param {String} path path to traverse\r\n * @param {boolean} [bindFnToScope=true]\r\n * @returns {Object} value as accessible by path\r\n */\r\n//TODO(misko): this function needs to be removed\r\nfunction getter(obj, path, bindFnToScope) {\r\n if (!path) return obj;\r\n var keys = path.split('.');\r\n var key;\r\n var lastInstance = obj;\r\n var len = keys.length;\r\n\r\n for (var i = 0; i < len; i++) {\r\n key = keys[i];\r\n if (obj) {\r\n obj = (lastInstance = obj)[key];\r\n }\r\n }\r\n if (!bindFnToScope && isFunction(obj)) {\r\n return bind(lastInstance, obj);\r\n }\r\n return obj;\r\n}\r\n\r\n/**\r\n * Return the DOM siblings between the first and last node in the given array.\r\n * @param {Array} array like object\r\n * @returns {DOMElement} object containing the elements\r\n */\r\nfunction getBlockElements(nodes) {\r\n var startNode = nodes[0],\r\n endNode = nodes[nodes.length - 1];\r\n if (startNode === endNode) {\r\n return jqLite(startNode);\r\n }\r\n\r\n var element = startNode;\r\n var elements = [element];\r\n\r\n do {\r\n element = element.nextSibling;\r\n if (!element) break;\r\n elements.push(element);\r\n } while (element !== endNode);\r\n\r\n return jqLite(elements);\r\n}\r\n\r\n/**\r\n * @ngdoc type\r\n * @name angular.Module\r\n * @module ng\r\n * @description\r\n *\r\n * Interface for configuring angular {@link angular.module modules}.\r\n */\r\n\r\nfunction setupModuleLoader(window) {\r\n\r\n var $injectorMinErr = minErr('$injector');\r\n var ngMinErr = minErr('ng');\r\n\r\n function ensure(obj, name, factory) {\r\n return obj[name] || (obj[name] = factory());\r\n }\r\n\r\n var angular = ensure(window, 'angular', Object);\r\n\r\n // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap\r\n angular.$$minErr = angular.$$minErr || minErr;\r\n\r\n return ensure(angular, 'module', function() {\r\n /** @type {Object.} */\r\n var modules = {};\r\n\r\n /**\r\n * @ngdoc function\r\n * @name angular.module\r\n * @module ng\r\n * @description\r\n *\r\n * The `angular.module` is a global place for creating, registering and retrieving Angular\r\n * modules.\r\n * All modules (angular core or 3rd party) that should be available to an application must be\r\n * registered using this mechanism.\r\n *\r\n * When passed two or more arguments, a new module is created. If passed only one argument, an\r\n * existing module (the name passed as the first argument to `module`) is retrieved.\r\n *\r\n *\r\n * # Module\r\n *\r\n * A module is a collection of services, directives, controllers, filters, and configuration information.\r\n * `angular.module` is used to configure the {@link auto.$injector $injector}.\r\n *\r\n * ```js\r\n * // Create a new module\r\n * var myModule = angular.module('myModule', []);\r\n *\r\n * // register a new service\r\n * myModule.value('appName', 'MyCoolApp');\r\n *\r\n * // configure existing services inside initialization blocks.\r\n * myModule.config(['$locationProvider', function($locationProvider) {\r\n * // Configure existing providers\r\n * $locationProvider.hashPrefix('!');\r\n * }]);\r\n * ```\r\n *\r\n * Then you can create an injector and load your modules like this:\r\n *\r\n * ```js\r\n * var injector = angular.injector(['ng', 'myModule'])\r\n * ```\r\n *\r\n * However it's more likely that you'll just use\r\n * {@link ng.directive:ngApp ngApp} or\r\n * {@link angular.bootstrap} to simplify this process for you.\r\n *\r\n * @param {!string} name The name of the module to create or retrieve.\r\n * @param {!Array.=} requires If specified then new module is being created. If\r\n * unspecified then the module is being retrieved for further configuration.\r\n * @param {Function=} configFn Optional configuration function for the module. Same as\r\n * {@link angular.Module#config Module#config()}.\r\n * @returns {module} new module with the {@link angular.Module} api.\r\n */\r\n return function module(name, requires, configFn) {\r\n var assertNotHasOwnProperty = function(name, context) {\r\n if (name === 'hasOwnProperty') {\r\n throw ngMinErr('badname', 'hasOwnProperty is not a valid {0} name', context);\r\n }\r\n };\r\n\r\n assertNotHasOwnProperty(name, 'module');\r\n if (requires && modules.hasOwnProperty(name)) {\r\n modules[name] = null;\r\n }\r\n return ensure(modules, name, function() {\r\n if (!requires) {\r\n throw $injectorMinErr('nomod', \"Module '{0}' is not available! You either misspelled \" +\r\n \"the module name or forgot to load it. If registering a module ensure that you \" +\r\n \"specify the dependencies as the second argument.\", name);\r\n }\r\n\r\n /** @type {!Array.>} */\r\n var invokeQueue = [];\r\n\r\n /** @type {!Array.} */\r\n var runBlocks = [];\r\n\r\n var config = invokeLater('$injector', 'invoke');\r\n\r\n /** @type {angular.Module} */\r\n var moduleInstance = {\r\n // Private state\r\n _invokeQueue: invokeQueue,\r\n _runBlocks: runBlocks,\r\n\r\n /**\r\n * @ngdoc property\r\n * @name angular.Module#requires\r\n * @module ng\r\n *\r\n * @description\r\n * Holds the list of modules which the injector will load before the current module is\r\n * loaded.\r\n */\r\n requires: requires,\r\n\r\n /**\r\n * @ngdoc property\r\n * @name angular.Module#name\r\n * @module ng\r\n *\r\n * @description\r\n * Name of the module.\r\n */\r\n name: name,\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#provider\r\n * @module ng\r\n * @param {string} name service name\r\n * @param {Function} providerType Construction function for creating new instance of the\r\n * service.\r\n * @description\r\n * See {@link auto.$provide#provider $provide.provider()}.\r\n */\r\n provider: invokeLater('$provide', 'provider'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#factory\r\n * @module ng\r\n * @param {string} name service name\r\n * @param {Function} providerFunction Function for creating new instance of the service.\r\n * @description\r\n * See {@link auto.$provide#factory $provide.factory()}.\r\n */\r\n factory: invokeLater('$provide', 'factory'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#service\r\n * @module ng\r\n * @param {string} name service name\r\n * @param {Function} constructor A constructor function that will be instantiated.\r\n * @description\r\n * See {@link auto.$provide#service $provide.service()}.\r\n */\r\n service: invokeLater('$provide', 'service'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#value\r\n * @module ng\r\n * @param {string} name service name\r\n * @param {*} object Service instance object.\r\n * @description\r\n * See {@link auto.$provide#value $provide.value()}.\r\n */\r\n value: invokeLater('$provide', 'value'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#constant\r\n * @module ng\r\n * @param {string} name constant name\r\n * @param {*} object Constant value.\r\n * @description\r\n * Because the constant are fixed, they get applied before other provide methods.\r\n * See {@link auto.$provide#constant $provide.constant()}.\r\n */\r\n constant: invokeLater('$provide', 'constant', 'unshift'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#animation\r\n * @module ng\r\n * @param {string} name animation name\r\n * @param {Function} animationFactory Factory function for creating new instance of an\r\n * animation.\r\n * @description\r\n *\r\n * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.\r\n *\r\n *\r\n * Defines an animation hook that can be later used with\r\n * {@link ngAnimate.$animate $animate} service and directives that use this service.\r\n *\r\n * ```js\r\n * module.animation('.animation-name', function($inject1, $inject2) {\r\n * return {\r\n * eventName : function(element, done) {\r\n * //code to run the animation\r\n * //once complete, then run done()\r\n * return function cancellationFunction(element) {\r\n * //code to cancel the animation\r\n * }\r\n * }\r\n * }\r\n * })\r\n * ```\r\n *\r\n * See {@link ngAnimate.$animateProvider#register $animateProvider.register()} and\r\n * {@link ngAnimate ngAnimate module} for more information.\r\n */\r\n animation: invokeLater('$animateProvider', 'register'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#filter\r\n * @module ng\r\n * @param {string} name Filter name.\r\n * @param {Function} filterFactory Factory function for creating new instance of filter.\r\n * @description\r\n * See {@link ng.$filterProvider#register $filterProvider.register()}.\r\n */\r\n filter: invokeLater('$filterProvider', 'register'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#controller\r\n * @module ng\r\n * @param {string|Object} name Controller name, or an object map of controllers where the\r\n * keys are the names and the values are the constructors.\r\n * @param {Function} constructor Controller constructor function.\r\n * @description\r\n * See {@link ng.$controllerProvider#register $controllerProvider.register()}.\r\n */\r\n controller: invokeLater('$controllerProvider', 'register'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#directive\r\n * @module ng\r\n * @param {string|Object} name Directive name, or an object map of directives where the\r\n * keys are the names and the values are the factories.\r\n * @param {Function} directiveFactory Factory function for creating new instance of\r\n * directives.\r\n * @description\r\n * See {@link ng.$compileProvider#directive $compileProvider.directive()}.\r\n */\r\n directive: invokeLater('$compileProvider', 'directive'),\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#config\r\n * @module ng\r\n * @param {Function} configFn Execute this function on module load. Useful for service\r\n * configuration.\r\n * @description\r\n * Use this method to register work which needs to be performed on module loading.\r\n * For more about how to configure services, see\r\n * {@link providers#providers_provider-recipe Provider Recipe}.\r\n */\r\n config: config,\r\n\r\n /**\r\n * @ngdoc method\r\n * @name angular.Module#run\r\n * @module ng\r\n * @param {Function} initializationFn Execute this function after injector creation.\r\n * Useful for application initialization.\r\n * @description\r\n * Use this method to register work which should be performed when the injector is done\r\n * loading all modules.\r\n */\r\n run: function(block) {\r\n runBlocks.push(block);\r\n return this;\r\n }\r\n };\r\n\r\n if (configFn) {\r\n config(configFn);\r\n }\r\n\r\n return moduleInstance;\r\n\r\n /**\r\n * @param {string} provider\r\n * @param {string} method\r\n * @param {String=} insertMethod\r\n * @returns {angular.Module}\r\n */\r\n function invokeLater(provider, method, insertMethod) {\r\n return function() {\r\n invokeQueue[insertMethod || 'push']([provider, method, arguments]);\r\n return moduleInstance;\r\n };\r\n }\r\n });\r\n };\r\n });\r\n\r\n}\r\n\r\n/* global angularModule: true,\r\n version: true,\r\n\r\n $LocaleProvider,\r\n $CompileProvider,\r\n\r\n htmlAnchorDirective,\r\n inputDirective,\r\n inputDirective,\r\n formDirective,\r\n scriptDirective,\r\n selectDirective,\r\n styleDirective,\r\n optionDirective,\r\n ngBindDirective,\r\n ngBindHtmlDirective,\r\n ngBindTemplateDirective,\r\n ngClassDirective,\r\n ngClassEvenDirective,\r\n ngClassOddDirective,\r\n ngCspDirective,\r\n ngCloakDirective,\r\n ngControllerDirective,\r\n ngFormDirective,\r\n ngHideDirective,\r\n ngIfDirective,\r\n ngIncludeDirective,\r\n ngIncludeFillContentDirective,\r\n ngInitDirective,\r\n ngNonBindableDirective,\r\n ngPluralizeDirective,\r\n ngRepeatDirective,\r\n ngShowDirective,\r\n ngStyleDirective,\r\n ngSwitchDirective,\r\n ngSwitchWhenDirective,\r\n ngSwitchDefaultDirective,\r\n ngOptionsDirective,\r\n ngTranscludeDirective,\r\n ngModelDirective,\r\n ngListDirective,\r\n ngChangeDirective,\r\n requiredDirective,\r\n requiredDirective,\r\n ngValueDirective,\r\n ngAttributeAliasDirectives,\r\n ngEventDirectives,\r\n\r\n $AnchorScrollProvider,\r\n $AnimateProvider,\r\n $BrowserProvider,\r\n $CacheFactoryProvider,\r\n $ControllerProvider,\r\n $DocumentProvider,\r\n $ExceptionHandlerProvider,\r\n $FilterProvider,\r\n $InterpolateProvider,\r\n $IntervalProvider,\r\n $HttpProvider,\r\n $HttpBackendProvider,\r\n $LocationProvider,\r\n $LogProvider,\r\n $ParseProvider,\r\n $RootScopeProvider,\r\n $QProvider,\r\n $$SanitizeUriProvider,\r\n $SceProvider,\r\n $SceDelegateProvider,\r\n $SnifferProvider,\r\n $TemplateCacheProvider,\r\n $TimeoutProvider,\r\n $$RAFProvider,\r\n $$AsyncCallbackProvider,\r\n $WindowProvider\r\n*/\r\n\r\n\r\n/**\r\n * @ngdoc object\r\n * @name angular.version\r\n * @module ng\r\n * @description\r\n * An object that contains information about the current AngularJS version. This object has the\r\n * following properties:\r\n *\r\n * - `full` – `{string}` – Full version string, such as \"0.9.18\".\r\n * - `major` – `{number}` – Major version number, such as \"0\".\r\n * - `minor` – `{number}` – Minor version number, such as \"9\".\r\n * - `dot` – `{number}` – Dot version number, such as \"18\".\r\n * - `codeName` – `{string}` – Code name of the release, such as \"jiggling-armfat\".\r\n */\r\nvar version = {\r\n full: '1.2.27', // all of these placeholder strings will be replaced by grunt's\r\n major: 1, // package task\r\n minor: 2,\r\n dot: 27,\r\n codeName: 'prime-factorization'\r\n};\r\n\r\n\r\nfunction publishExternalAPI(angular){\r\n extend(angular, {\r\n 'bootstrap': bootstrap,\r\n 'copy': copy,\r\n 'extend': extend,\r\n 'equals': equals,\r\n 'element': jqLite,\r\n 'forEach': forEach,\r\n 'injector': createInjector,\r\n 'noop': noop,\r\n 'bind': bind,\r\n 'toJson': toJson,\r\n 'fromJson': fromJson,\r\n 'identity': identity,\r\n 'isUndefined': isUndefined,\r\n 'isDefined': isDefined,\r\n 'isString': isString,\r\n 'isFunction': isFunction,\r\n 'isObject': isObject,\r\n 'isNumber': isNumber,\r\n 'isElement': isElement,\r\n 'isArray': isArray,\r\n 'version': version,\r\n 'isDate': isDate,\r\n 'lowercase': lowercase,\r\n 'uppercase': uppercase,\r\n 'callbacks': {counter: 0},\r\n '$$minErr': minErr,\r\n '$$csp': csp\r\n });\r\n\r\n angularModule = setupModuleLoader(window);\r\n try {\r\n angularModule('ngLocale');\r\n } catch (e) {\r\n angularModule('ngLocale', []).provider('$locale', $LocaleProvider);\r\n }\r\n\r\n angularModule('ng', ['ngLocale'], ['$provide',\r\n function ngModule($provide) {\r\n // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.\r\n $provide.provider({\r\n $$sanitizeUri: $$SanitizeUriProvider\r\n });\r\n $provide.provider('$compile', $CompileProvider).\r\n directive({\r\n a: htmlAnchorDirective,\r\n input: inputDirective,\r\n textarea: inputDirective,\r\n form: formDirective,\r\n script: scriptDirective,\r\n select: selectDirective,\r\n style: styleDirective,\r\n option: optionDirective,\r\n ngBind: ngBindDirective,\r\n ngBindHtml: ngBindHtmlDirective,\r\n ngBindTemplate: ngBindTemplateDirective,\r\n ngClass: ngClassDirective,\r\n ngClassEven: ngClassEvenDirective,\r\n ngClassOdd: ngClassOddDirective,\r\n ngCloak: ngCloakDirective,\r\n ngController: ngControllerDirective,\r\n ngForm: ngFormDirective,\r\n ngHide: ngHideDirective,\r\n ngIf: ngIfDirective,\r\n ngInclude: ngIncludeDirective,\r\n ngInit: ngInitDirective,\r\n ngNonBindable: ngNonBindableDirective,\r\n ngPluralize: ngPluralizeDirective,\r\n ngRepeat: ngRepeatDirective,\r\n ngShow: ngShowDirective,\r\n ngStyle: ngStyleDirective,\r\n ngSwitch: ngSwitchDirective,\r\n ngSwitchWhen: ngSwitchWhenDirective,\r\n ngSwitchDefault: ngSwitchDefaultDirective,\r\n ngOptions: ngOptionsDirective,\r\n ngTransclude: ngTranscludeDirective,\r\n ngModel: ngModelDirective,\r\n ngList: ngListDirective,\r\n ngChange: ngChangeDirective,\r\n required: requiredDirective,\r\n ngRequired: requiredDirective,\r\n ngValue: ngValueDirective\r\n }).\r\n directive({\r\n ngInclude: ngIncludeFillContentDirective\r\n }).\r\n directive(ngAttributeAliasDirectives).\r\n directive(ngEventDirectives);\r\n $provide.provider({\r\n $anchorScroll: $AnchorScrollProvider,\r\n $animate: $AnimateProvider,\r\n $browser: $BrowserProvider,\r\n $cacheFactory: $CacheFactoryProvider,\r\n $controller: $ControllerProvider,\r\n $document: $DocumentProvider,\r\n $exceptionHandler: $ExceptionHandlerProvider,\r\n $filter: $FilterProvider,\r\n $interpolate: $InterpolateProvider,\r\n $interval: $IntervalProvider,\r\n $http: $HttpProvider,\r\n $httpBackend: $HttpBackendProvider,\r\n $location: $LocationProvider,\r\n $log: $LogProvider,\r\n $parse: $ParseProvider,\r\n $rootScope: $RootScopeProvider,\r\n $q: $QProvider,\r\n $sce: $SceProvider,\r\n $sceDelegate: $SceDelegateProvider,\r\n $sniffer: $SnifferProvider,\r\n $templateCache: $TemplateCacheProvider,\r\n $timeout: $TimeoutProvider,\r\n $window: $WindowProvider,\r\n $$rAF: $$RAFProvider,\r\n $$asyncCallback : $$AsyncCallbackProvider\r\n });\r\n }\r\n ]);\r\n}\r\n\r\n/* global JQLitePrototype: true,\r\n addEventListenerFn: true,\r\n removeEventListenerFn: true,\r\n BOOLEAN_ATTR: true\r\n*/\r\n\r\n//////////////////////////////////\r\n//JQLite\r\n//////////////////////////////////\r\n\r\n/**\r\n * @ngdoc function\r\n * @name angular.element\r\n * @module ng\r\n * @kind function\r\n *\r\n * @description\r\n * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.\r\n *\r\n * If jQuery is available, `angular.element` is an alias for the\r\n * [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`\r\n * delegates to Angular's built-in subset of jQuery, called \"jQuery lite\" or \"jqLite.\"\r\n *\r\n * ', '
'],\r\n 'col': [2, '
'],\r\n 'tr': [2, '', '
'],\r\n 'td': [3, '
'],\r\n '_default': [0, \"\", \"\"]\r\n};\r\n\r\nwrapMap.optgroup = wrapMap.option;\r\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\r\nwrapMap.th = wrapMap.td;\r\n\r\nfunction jqLiteIsTextNode(html) {\r\n return !HTML_REGEXP.test(html);\r\n}\r\n\r\nfunction jqLiteBuildFragment(html, context) {\r\n var elem, tmp, tag, wrap,\r\n fragment = context.createDocumentFragment(),\r\n nodes = [], i, j, jj;\r\n\r\n if (jqLiteIsTextNode(html)) {\r\n // Convert non-html into a text node\r\n nodes.push(context.createTextNode(html));\r\n } else {\r\n tmp = fragment.appendChild(context.createElement('div'));\r\n // Convert html into DOM nodes\r\n tag = (TAG_NAME_REGEXP.exec(html) || [\"\", \"\"])[1].toLowerCase();\r\n wrap = wrapMap[tag] || wrapMap._default;\r\n tmp.innerHTML = ' ' +\r\n wrap[1] + html.replace(XHTML_TAG_REGEXP, \"<$1>\") + wrap[2];\r\n tmp.removeChild(tmp.firstChild);\r\n\r\n // Descend through wrappers to the right content\r\n i = wrap[0];\r\n while (i--) {\r\n tmp = tmp.lastChild;\r\n }\r\n\r\n for (j=0, jj=tmp.childNodes.length; j -1);\r\n}\r\n\r\nfunction jqLiteRemoveClass(element, cssClasses) {\r\n if (cssClasses && element.setAttribute) {\r\n forEach(cssClasses.split(' '), function(cssClass) {\r\n element.setAttribute('class', trim(\r\n (\" \" + (element.getAttribute('class') || '') + \" \")\r\n .replace(/[\\n\\t]/g, \" \")\r\n .replace(\" \" + trim(cssClass) + \" \", \" \"))\r\n );\r\n });\r\n }\r\n}\r\n\r\nfunction jqLiteAddClass(element, cssClasses) {\r\n if (cssClasses && element.setAttribute) {\r\n var existingClasses = (' ' + (element.getAttribute('class') || '') + ' ')\r\n .replace(/[\\n\\t]/g, \" \");\r\n\r\n forEach(cssClasses.split(' '), function(cssClass) {\r\n cssClass = trim(cssClass);\r\n if (existingClasses.indexOf(' ' + cssClass + ' ') === -1) {\r\n existingClasses += cssClass + ' ';\r\n }\r\n });\r\n\r\n element.setAttribute('class', trim(existingClasses));\r\n }\r\n}\r\n\r\nfunction jqLiteAddNodes(root, elements) {\r\n if (elements) {\r\n elements = (!elements.nodeName && isDefined(elements.length) && !isWindow(elements))\r\n ? elements\r\n : [ elements ];\r\n for(var i=0; i < elements.length; i++) {\r\n root.push(elements[i]);\r\n }\r\n }\r\n}\r\n\r\nfunction jqLiteController(element, name) {\r\n return jqLiteInheritedData(element, '$' + (name || 'ngController' ) + 'Controller');\r\n}\r\n\r\nfunction jqLiteInheritedData(element, name, value) {\r\n // if element is the document object work with the html element instead\r\n // this makes $(document).scope() possible\r\n if(element.nodeType == 9) {\r\n element = element.documentElement;\r\n }\r\n var names = isArray(name) ? name : [name];\r\n\r\n while (element) {\r\n for (var i = 0, ii = names.length; i < ii; i++) {\r\n if ((value = jqLite.data(element, names[i])) !== undefined) return value;\r\n }\r\n\r\n // If dealing with a document fragment node with a host element, and no parent, use the host\r\n // element as the parent. This enables directives within a Shadow DOM or polyfilled Shadow DOM\r\n // to lookup parent controllers.\r\n element = element.parentNode || (element.nodeType === 11 && element.host);\r\n }\r\n}\r\n\r\nfunction jqLiteEmpty(element) {\r\n for (var i = 0, childNodes = element.childNodes; i < childNodes.length; i++) {\r\n jqLiteDealoc(childNodes[i]);\r\n }\r\n while (element.firstChild) {\r\n element.removeChild(element.firstChild);\r\n }\r\n}\r\n\r\n//////////////////////////////////////////\r\n// Functions which are declared directly.\r\n//////////////////////////////////////////\r\nvar JQLitePrototype = JQLite.prototype = {\r\n ready: function(fn) {\r\n var fired = false;\r\n\r\n function trigger() {\r\n if (fired) return;\r\n fired = true;\r\n fn();\r\n }\r\n\r\n // check if document already is loaded\r\n if (document.readyState === 'complete'){\r\n setTimeout(trigger);\r\n } else {\r\n this.on('DOMContentLoaded', trigger); // works for modern browsers and IE9\r\n // we can not use jqLite since we are not done loading and jQuery could be loaded later.\r\n // jshint -W064\r\n JQLite(window).on('load', trigger); // fallback to window.onload for others\r\n // jshint +W064\r\n }\r\n },\r\n toString: function() {\r\n var value = [];\r\n forEach(this, function(e){ value.push('' + e);});\r\n return '[' + value.join(', ') + ']';\r\n },\r\n\r\n eq: function(index) {\r\n return (index >= 0) ? jqLite(this[index]) : jqLite(this[this.length + index]);\r\n },\r\n\r\n length: 0,\r\n push: push,\r\n sort: [].sort,\r\n splice: [].splice\r\n};\r\n\r\n//////////////////////////////////////////\r\n// Functions iterating getter/setters.\r\n// these functions return self on setter and\r\n// value on get.\r\n//////////////////////////////////////////\r\nvar BOOLEAN_ATTR = {};\r\nforEach('multiple,selected,checked,disabled,readOnly,required,open'.split(','), function(value) {\r\n BOOLEAN_ATTR[lowercase(value)] = value;\r\n});\r\nvar BOOLEAN_ELEMENTS = {};\r\nforEach('input,select,option,textarea,button,form,details'.split(','), function(value) {\r\n BOOLEAN_ELEMENTS[uppercase(value)] = true;\r\n});\r\n\r\nfunction getBooleanAttrName(element, name) {\r\n // check dom last since we will most likely fail on name\r\n var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];\r\n\r\n // booleanAttr is here twice to minimize DOM access\r\n return booleanAttr && BOOLEAN_ELEMENTS[element.nodeName] && booleanAttr;\r\n}\r\n\r\nforEach({\r\n data: jqLiteData,\r\n removeData: jqLiteRemoveData\r\n}, function(fn, name) {\r\n JQLite[name] = fn;\r\n});\r\n\r\nforEach({\r\n data: jqLiteData,\r\n inheritedData: jqLiteInheritedData,\r\n\r\n scope: function(element) {\r\n // Can't use jqLiteData here directly so we stay compatible with jQuery!\r\n return jqLite.data(element, '$scope') || jqLiteInheritedData(element.parentNode || element, ['$isolateScope', '$scope']);\r\n },\r\n\r\n isolateScope: function(element) {\r\n // Can't use jqLiteData here directly so we stay compatible with jQuery!\r\n return jqLite.data(element, '$isolateScope') || jqLite.data(element, '$isolateScopeNoTemplate');\r\n },\r\n\r\n controller: jqLiteController,\r\n\r\n injector: function(element) {\r\n return jqLiteInheritedData(element, '$injector');\r\n },\r\n\r\n removeAttr: function(element,name) {\r\n element.removeAttribute(name);\r\n },\r\n\r\n hasClass: jqLiteHasClass,\r\n\r\n css: function(element, name, value) {\r\n name = camelCase(name);\r\n\r\n if (isDefined(value)) {\r\n element.style[name] = value;\r\n } else {\r\n var val;\r\n\r\n if (msie <= 8) {\r\n // this is some IE specific weirdness that jQuery 1.6.4 does not sure why\r\n val = element.currentStyle && element.currentStyle[name];\r\n if (val === '') val = 'auto';\r\n }\r\n\r\n val = val || element.style[name];\r\n\r\n if (msie <= 8) {\r\n // jquery weirdness :-/\r\n val = (val === '') ? undefined : val;\r\n }\r\n\r\n return val;\r\n }\r\n },\r\n\r\n attr: function(element, name, value){\r\n var lowercasedName = lowercase(name);\r\n if (BOOLEAN_ATTR[lowercasedName]) {\r\n if (isDefined(value)) {\r\n if (!!value) {\r\n element[name] = true;\r\n element.setAttribute(name, lowercasedName);\r\n } else {\r\n element[name] = false;\r\n element.removeAttribute(lowercasedName);\r\n }\r\n } else {\r\n return (element[name] ||\r\n (element.attributes.getNamedItem(name)|| noop).specified)\r\n ? lowercasedName\r\n : undefined;\r\n }\r\n } else if (isDefined(value)) {\r\n element.setAttribute(name, value);\r\n } else if (element.getAttribute) {\r\n // the extra argument \"2\" is to get the right thing for a.href in IE, see jQuery code\r\n // some elements (e.g. Document) don't have get attribute, so return undefined\r\n var ret = element.getAttribute(name, 2);\r\n // normalize non-existing attributes to undefined (as jQuery)\r\n return ret === null ? undefined : ret;\r\n }\r\n },\r\n\r\n prop: function(element, name, value) {\r\n if (isDefined(value)) {\r\n element[name] = value;\r\n } else {\r\n return element[name];\r\n }\r\n },\r\n\r\n text: (function() {\r\n var NODE_TYPE_TEXT_PROPERTY = [];\r\n if (msie < 9) {\r\n NODE_TYPE_TEXT_PROPERTY[1] = 'innerText'; /** Element **/\r\n NODE_TYPE_TEXT_PROPERTY[3] = 'nodeValue'; /** Text **/\r\n } else {\r\n NODE_TYPE_TEXT_PROPERTY[1] = /** Element **/\r\n NODE_TYPE_TEXT_PROPERTY[3] = 'textContent'; /** Text **/\r\n }\r\n getText.$dv = '';\r\n return getText;\r\n\r\n function getText(element, value) {\r\n var textProp = NODE_TYPE_TEXT_PROPERTY[element.nodeType];\r\n if (isUndefined(value)) {\r\n return textProp ? element[textProp] : '';\r\n }\r\n element[textProp] = value;\r\n }\r\n })(),\r\n\r\n val: function(element, value) {\r\n if (isUndefined(value)) {\r\n if (nodeName_(element) === 'SELECT' && element.multiple) {\r\n var result = [];\r\n forEach(element.options, function (option) {\r\n if (option.selected) {\r\n result.push(option.value || option.text);\r\n }\r\n });\r\n return result.length === 0 ? null : result;\r\n }\r\n return element.value;\r\n }\r\n element.value = value;\r\n },\r\n\r\n html: function(element, value) {\r\n if (isUndefined(value)) {\r\n return element.innerHTML;\r\n }\r\n for (var i = 0, childNodes = element.childNodes; i < childNodes.length; i++) {\r\n jqLiteDealoc(childNodes[i]);\r\n }\r\n element.innerHTML = value;\r\n },\r\n\r\n empty: jqLiteEmpty\r\n}, function(fn, name){\r\n /**\r\n * Properties: writes return selection, reads return first value\r\n */\r\n JQLite.prototype[name] = function(arg1, arg2) {\r\n var i, key;\r\n var nodeCount = this.length;\r\n\r\n // jqLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it\r\n // in a way that survives minification.\r\n // jqLiteEmpty takes no arguments but is a setter.\r\n if (fn !== jqLiteEmpty &&\r\n (((fn.length == 2 && (fn !== jqLiteHasClass && fn !== jqLiteController)) ? arg1 : arg2) === undefined)) {\r\n if (isObject(arg1)) {\r\n\r\n // we are a write, but the object properties are the key/values\r\n for (i = 0; i < nodeCount; i++) {\r\n if (fn === jqLiteData) {\r\n // data() takes the whole object in jQuery\r\n fn(this[i], arg1);\r\n } else {\r\n for (key in arg1) {\r\n fn(this[i], key, arg1[key]);\r\n }\r\n }\r\n }\r\n // return self for chaining\r\n return this;\r\n } else {\r\n // we are a read, so read the first child.\r\n // TODO: do we still need this?\r\n var value = fn.$dv;\r\n // Only if we have $dv do we iterate over all, otherwise it is just the first element.\r\n var jj = (value === undefined) ? Math.min(nodeCount, 1) : nodeCount;\r\n for (var j = 0; j < jj; j++) {\r\n var nodeValue = fn(this[j], arg1, arg2);\r\n value = value ? value + nodeValue : nodeValue;\r\n }\r\n return value;\r\n }\r\n } else {\r\n // we are a write, so apply to all children\r\n for (i = 0; i < nodeCount; i++) {\r\n fn(this[i], arg1, arg2);\r\n }\r\n // return self for chaining\r\n return this;\r\n }\r\n };\r\n});\r\n\r\nfunction createEventHandler(element, events) {\r\n var eventHandler = function (event, type) {\r\n if (!event.preventDefault) {\r\n event.preventDefault = function() {\r\n event.returnValue = false; //ie\r\n };\r\n }\r\n\r\n if (!event.stopPropagation) {\r\n event.stopPropagation = function() {\r\n event.cancelBubble = true; //ie\r\n };\r\n }\r\n\r\n if (!event.target) {\r\n event.target = event.srcElement || document;\r\n }\r\n\r\n if (isUndefined(event.defaultPrevented)) {\r\n var prevent = event.preventDefault;\r\n event.preventDefault = function() {\r\n event.defaultPrevented = true;\r\n prevent.call(event);\r\n };\r\n event.defaultPrevented = false;\r\n }\r\n\r\n event.isDefaultPrevented = function() {\r\n return event.defaultPrevented || event.returnValue === false;\r\n };\r\n\r\n // Copy event handlers in case event handlers array is modified during execution.\r\n var eventHandlersCopy = shallowCopy(events[type || event.type] || []);\r\n\r\n forEach(eventHandlersCopy, function(fn) {\r\n fn.call(element, event);\r\n });\r\n\r\n // Remove monkey-patched methods (IE),\r\n // as they would cause memory leaks in IE8.\r\n if (msie <= 8) {\r\n // IE7/8 does not allow to delete property on native object\r\n event.preventDefault = null;\r\n event.stopPropagation = null;\r\n event.isDefaultPrevented = null;\r\n } else {\r\n // It shouldn't affect normal browsers (native methods are defined on prototype).\r\n delete event.preventDefault;\r\n delete event.stopPropagation;\r\n delete event.isDefaultPrevented;\r\n }\r\n };\r\n eventHandler.elem = element;\r\n return eventHandler;\r\n}\r\n\r\n//////////////////////////////////////////\r\n// Functions iterating traversal.\r\n// These functions chain results into a single\r\n// selector.\r\n//////////////////////////////////////////\r\nforEach({\r\n removeData: jqLiteRemoveData,\r\n\r\n dealoc: jqLiteDealoc,\r\n\r\n on: function onFn(element, type, fn, unsupported){\r\n if (isDefined(unsupported)) throw jqLiteMinErr('onargs', 'jqLite#on() does not support the `selector` or `eventData` parameters');\r\n\r\n var events = jqLiteExpandoStore(element, 'events'),\r\n handle = jqLiteExpandoStore(element, 'handle');\r\n\r\n if (!events) jqLiteExpandoStore(element, 'events', events = {});\r\n if (!handle) jqLiteExpandoStore(element, 'handle', handle = createEventHandler(element, events));\r\n\r\n forEach(type.split(' '), function(type){\r\n var eventFns = events[type];\r\n\r\n if (!eventFns) {\r\n if (type == 'mouseenter' || type == 'mouseleave') {\r\n var contains = document.body.contains || document.body.compareDocumentPosition ?\r\n function( a, b ) {\r\n // jshint bitwise: false\r\n var adown = a.nodeType === 9 ? a.documentElement : a,\r\n bup = b && b.parentNode;\r\n return a === bup || !!( bup && bup.nodeType === 1 && (\r\n adown.contains ?\r\n adown.contains( bup ) :\r\n a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\r\n ));\r\n } :\r\n function( a, b ) {\r\n if ( b ) {\r\n while ( (b = b.parentNode) ) {\r\n if ( b === a ) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n };\r\n\r\n events[type] = [];\r\n\r\n // Refer to jQuery's implementation of mouseenter & mouseleave\r\n // Read about mouseenter and mouseleave:\r\n // http://www.quirksmode.org/js/events_mouse.html#link8\r\n var eventmap = { mouseleave : \"mouseout\", mouseenter : \"mouseover\"};\r\n\r\n onFn(element, eventmap[type], function(event) {\r\n var target = this, related = event.relatedTarget;\r\n // For mousenter/leave call the handler if related is outside the target.\r\n // NB: No relatedTarget if the mouse left/entered the browser window\r\n if ( !related || (related !== target && !contains(target, related)) ){\r\n handle(event, type);\r\n }\r\n });\r\n\r\n } else {\r\n addEventListenerFn(element, type, handle);\r\n events[type] = [];\r\n }\r\n eventFns = events[type];\r\n }\r\n eventFns.push(fn);\r\n });\r\n },\r\n\r\n off: jqLiteOff,\r\n\r\n one: function(element, type, fn) {\r\n element = jqLite(element);\r\n\r\n //add the listener twice so that when it is called\r\n //you can remove the original function and still be\r\n //able to call element.off(ev, fn) normally\r\n element.on(type, function onFn() {\r\n element.off(type, fn);\r\n element.off(type, onFn);\r\n });\r\n element.on(type, fn);\r\n },\r\n\r\n replaceWith: function(element, replaceNode) {\r\n var index, parent = element.parentNode;\r\n jqLiteDealoc(element);\r\n forEach(new JQLite(replaceNode), function(node){\r\n if (index) {\r\n parent.insertBefore(node, index.nextSibling);\r\n } else {\r\n parent.replaceChild(node, element);\r\n }\r\n index = node;\r\n });\r\n },\r\n\r\n children: function(element) {\r\n var children = [];\r\n forEach(element.childNodes, function(element){\r\n if (element.nodeType === 1)\r\n children.push(element);\r\n });\r\n return children;\r\n },\r\n\r\n contents: function(element) {\r\n return element.contentDocument || element.childNodes || [];\r\n },\r\n\r\n append: function(element, node) {\r\n forEach(new JQLite(node), function(child){\r\n if (element.nodeType === 1 || element.nodeType === 11) {\r\n element.appendChild(child);\r\n }\r\n });\r\n },\r\n\r\n prepend: function(element, node) {\r\n if (element.nodeType === 1) {\r\n var index = element.firstChild;\r\n forEach(new JQLite(node), function(child){\r\n element.insertBefore(child, index);\r\n });\r\n }\r\n },\r\n\r\n wrap: function(element, wrapNode) {\r\n wrapNode = jqLite(wrapNode)[0];\r\n var parent = element.parentNode;\r\n if (parent) {\r\n parent.replaceChild(wrapNode, element);\r\n }\r\n wrapNode.appendChild(element);\r\n },\r\n\r\n remove: function(element) {\r\n jqLiteDealoc(element);\r\n var parent = element.parentNode;\r\n if (parent) parent.removeChild(element);\r\n },\r\n\r\n after: function(element, newElement) {\r\n var index = element, parent = element.parentNode;\r\n forEach(new JQLite(newElement), function(node){\r\n parent.insertBefore(node, index.nextSibling);\r\n index = node;\r\n });\r\n },\r\n\r\n addClass: jqLiteAddClass,\r\n removeClass: jqLiteRemoveClass,\r\n\r\n toggleClass: function(element, selector, condition) {\r\n if (selector) {\r\n forEach(selector.split(' '), function(className){\r\n var classCondition = condition;\r\n if (isUndefined(classCondition)) {\r\n classCondition = !jqLiteHasClass(element, className);\r\n }\r\n (classCondition ? jqLiteAddClass : jqLiteRemoveClass)(element, className);\r\n });\r\n }\r\n },\r\n\r\n parent: function(element) {\r\n var parent = element.parentNode;\r\n return parent && parent.nodeType !== 11 ? parent : null;\r\n },\r\n\r\n next: function(element) {\r\n if (element.nextElementSibling) {\r\n return element.nextElementSibling;\r\n }\r\n\r\n // IE8 doesn't have nextElementSibling\r\n var elm = element.nextSibling;\r\n while (elm != null && elm.nodeType !== 1) {\r\n elm = elm.nextSibling;\r\n }\r\n return elm;\r\n },\r\n\r\n find: function(element, selector) {\r\n if (element.getElementsByTagName) {\r\n return element.getElementsByTagName(selector);\r\n } else {\r\n return [];\r\n }\r\n },\r\n\r\n clone: jqLiteClone,\r\n\r\n triggerHandler: function(element, event, extraParameters) {\r\n\r\n var dummyEvent, eventFnsCopy, handlerArgs;\r\n var eventName = event.type || event;\r\n var eventFns = (jqLiteExpandoStore(element, 'events') || {})[eventName];\r\n\r\n if (eventFns) {\r\n\r\n // Create a dummy event to pass to the handlers\r\n dummyEvent = {\r\n preventDefault: function() { this.defaultPrevented = true; },\r\n isDefaultPrevented: function() { return this.defaultPrevented === true; },\r\n stopPropagation: noop,\r\n type: eventName,\r\n target: element\r\n };\r\n\r\n // If a custom event was provided then extend our dummy event with it\r\n if (event.type) {\r\n dummyEvent = extend(dummyEvent, event);\r\n }\r\n\r\n // Copy event handlers in case event handlers array is modified during execution.\r\n eventFnsCopy = shallowCopy(eventFns);\r\n handlerArgs = extraParameters ? [dummyEvent].concat(extraParameters) : [dummyEvent];\r\n\r\n forEach(eventFnsCopy, function(fn) {\r\n fn.apply(element, handlerArgs);\r\n });\r\n\r\n }\r\n }\r\n}, function(fn, name){\r\n /**\r\n * chaining functions\r\n */\r\n JQLite.prototype[name] = function(arg1, arg2, arg3) {\r\n var value;\r\n for(var i=0; i < this.length; i++) {\r\n if (isUndefined(value)) {\r\n value = fn(this[i], arg1, arg2, arg3);\r\n if (isDefined(value)) {\r\n // any function which returns a value needs to be wrapped\r\n value = jqLite(value);\r\n }\r\n } else {\r\n jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));\r\n }\r\n }\r\n return isDefined(value) ? value : this;\r\n };\r\n\r\n // bind legacy bind/unbind to on/off\r\n JQLite.prototype.bind = JQLite.prototype.on;\r\n JQLite.prototype.unbind = JQLite.prototype.off;\r\n});\r\n\r\n/**\r\n * Computes a hash of an 'obj'.\r\n * Hash of a:\r\n * string is string\r\n * number is number as string\r\n * object is either result of calling $$hashKey function on the object or uniquely generated id,\r\n * that is also assigned to the $$hashKey property of the object.\r\n *\r\n * @param obj\r\n * @returns {string} hash string such that the same input will have the same hash string.\r\n * The resulting string key is in 'type:hashKey' format.\r\n */\r\nfunction hashKey(obj, nextUidFn) {\r\n var objType = typeof obj,\r\n key;\r\n\r\n if (objType == 'function' || (objType == 'object' && obj !== null)) {\r\n if (typeof (key = obj.$$hashKey) == 'function') {\r\n // must invoke on object to keep the right this\r\n key = obj.$$hashKey();\r\n } else if (key === undefined) {\r\n key = obj.$$hashKey = (nextUidFn || nextUid)();\r\n }\r\n } else {\r\n key = obj;\r\n }\r\n\r\n return objType + ':' + key;\r\n}\r\n\r\n/**\r\n * HashMap which can use objects as keys\r\n */\r\nfunction HashMap(array, isolatedUid) {\r\n if (isolatedUid) {\r\n var uid = 0;\r\n this.nextUid = function() {\r\n return ++uid;\r\n };\r\n }\r\n forEach(array, this.put, this);\r\n}\r\nHashMap.prototype = {\r\n /**\r\n * Store key value pair\r\n * @param key key to store can be any type\r\n * @param value value to store can be any type\r\n */\r\n put: function(key, value) {\r\n this[hashKey(key, this.nextUid)] = value;\r\n },\r\n\r\n /**\r\n * @param key\r\n * @returns {Object} the value for the key\r\n */\r\n get: function(key) {\r\n return this[hashKey(key, this.nextUid)];\r\n },\r\n\r\n /**\r\n * Remove the key/value pair\r\n * @param key\r\n */\r\n remove: function(key) {\r\n var value = this[key = hashKey(key, this.nextUid)];\r\n delete this[key];\r\n return value;\r\n }\r\n};\r\n\r\n/**\r\n * @ngdoc function\r\n * @module ng\r\n * @name angular.injector\r\n * @kind function\r\n *\r\n * @description\r\n * Creates an injector object that can be used for retrieving services as well as for\r\n * dependency injection (see {@link guide/di dependency injection}).\r\n *\r\n\r\n * @param {Array.} modules A list of module functions or their aliases. See\r\n * {@link angular.module}. The `ng` module must be explicitly added.\r\n * @returns {injector} Injector object. See {@link auto.$injector $injector}.\r\n *\r\n * @example\r\n * Typical usage\r\n * ```js\r\n * // create an injector\r\n * var $injector = angular.injector(['ng']);\r\n *\r\n * // use the injector to kick off your application\r\n * // use the type inference to auto inject arguments, or use implicit injection\r\n * $injector.invoke(function($rootScope, $compile, $document){\r\n * $compile($document)($rootScope);\r\n * $rootScope.$digest();\r\n * });\r\n * ```\r\n *\r\n * Sometimes you want to get access to the injector of a currently running Angular app\r\n * from outside Angular. Perhaps, you want to inject and compile some markup after the\r\n * application has been bootstrapped. You can do this using the extra `injector()` added\r\n * to JQuery/jqLite elements. See {@link angular.element}.\r\n *\r\n * *This is fairly rare but could be the case if a third party library is injecting the\r\n * markup.*\r\n *\r\n * In the following example a new block of HTML containing a `ng-controller`\r\n * directive is added to the end of the document body by JQuery. We then compile and link\r\n * it into the current AngularJS scope.\r\n *\r\n * ```js\r\n * var $div = $('} fn Function for which dependent service names need to\r\n * be retrieved as described above.\r\n *\r\n * @returns {Array.} The names of the services which the function requires.\r\n */\r\n\r\n\r\n\r\n\r\n/**\r\n * @ngdoc service\r\n * @name $provide\r\n *\r\n * @description\r\n *\r\n * The {@link auto.$provide $provide} service has a number of methods for registering components\r\n * with the {@link auto.$injector $injector}. Many of these functions are also exposed on\r\n * {@link angular.Module}.\r\n *\r\n * An Angular **service** is a singleton object created by a **service factory**. These **service\r\n * factories** are functions which, in turn, are created by a **service provider**.\r\n * The **service providers** are constructor functions. When instantiated they must contain a\r\n * property called `$get`, which holds the **service factory** function.\r\n *\r\n * When you request a service, the {@link auto.$injector $injector} is responsible for finding the\r\n * correct **service provider**, instantiating it and then calling its `$get` **service factory**\r\n * function to get the instance of the **service**.\r\n *\r\n * Often services have no configuration options and there is no need to add methods to the service\r\n * provider. The provider will be no more than a constructor function with a `$get` property. For\r\n * these cases the {@link auto.$provide $provide} service has additional helper methods to register\r\n * services without specifying a provider.\r\n *\r\n * * {@link auto.$provide#provider provider(provider)} - registers a **service provider** with the\r\n * {@link auto.$injector $injector}\r\n * * {@link auto.$provide#constant constant(obj)} - registers a value/object that can be accessed by\r\n * providers and services.\r\n * * {@link auto.$provide#value value(obj)} - registers a value/object that can only be accessed by\r\n * services, not providers.\r\n * * {@link auto.$provide#factory factory(fn)} - registers a service **factory function**, `fn`,\r\n * that will be wrapped in a **service provider** object, whose `$get` property will contain the\r\n * given factory function.\r\n * * {@link auto.$provide#service service(class)} - registers a **constructor function**, `class`\r\n * that will be wrapped in a **service provider** object, whose `$get` property will instantiate\r\n * a new object using the given constructor function.\r\n *\r\n * See the individual methods for more information and examples.\r\n */\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $provide#provider\r\n * @description\r\n *\r\n * Register a **provider function** with the {@link auto.$injector $injector}. Provider functions\r\n * are constructor functions, whose instances are responsible for \"providing\" a factory for a\r\n * service.\r\n *\r\n * Service provider names start with the name of the service they provide followed by `Provider`.\r\n * For example, the {@link ng.$log $log} service has a provider called\r\n * {@link ng.$logProvider $logProvider}.\r\n *\r\n * Service provider objects can have additional methods which allow configuration of the provider\r\n * and its service. Importantly, you can configure what kind of service is created by the `$get`\r\n * method, or how that service will act. For example, the {@link ng.$logProvider $logProvider} has a\r\n * method {@link ng.$logProvider#debugEnabled debugEnabled}\r\n * which lets you specify whether the {@link ng.$log $log} service will log debug messages to the\r\n * console or not.\r\n *\r\n * @param {string} name The name of the instance. NOTE: the provider will be available under `name +\r\n 'Provider'` key.\r\n * @param {(Object|function())} provider If the provider is:\r\n *\r\n * - `Object`: then it should have a `$get` method. The `$get` method will be invoked using\r\n * {@link auto.$injector#invoke $injector.invoke()} when an instance needs to be created.\r\n * - `Constructor`: a new instance of the provider will be created using\r\n * {@link auto.$injector#instantiate $injector.instantiate()}, then treated as `object`.\r\n *\r\n * @returns {Object} registered provider instance\r\n\r\n * @example\r\n *\r\n * The following example shows how to create a simple event tracking service and register it using\r\n * {@link auto.$provide#provider $provide.provider()}.\r\n *\r\n * ```js\r\n * // Define the eventTracker provider\r\n * function EventTrackerProvider() {\r\n * var trackingUrl = '/track';\r\n *\r\n * // A provider method for configuring where the tracked events should been saved\r\n * this.setTrackingUrl = function(url) {\r\n * trackingUrl = url;\r\n * };\r\n *\r\n * // The service factory function\r\n * this.$get = ['$http', function($http) {\r\n * var trackedEvents = {};\r\n * return {\r\n * // Call this to track an event\r\n * event: function(event) {\r\n * var count = trackedEvents[event] || 0;\r\n * count += 1;\r\n * trackedEvents[event] = count;\r\n * return count;\r\n * },\r\n * // Call this to save the tracked events to the trackingUrl\r\n * save: function() {\r\n * $http.post(trackingUrl, trackedEvents);\r\n * }\r\n * };\r\n * }];\r\n * }\r\n *\r\n * describe('eventTracker', function() {\r\n * var postSpy;\r\n *\r\n * beforeEach(module(function($provide) {\r\n * // Register the eventTracker provider\r\n * $provide.provider('eventTracker', EventTrackerProvider);\r\n * }));\r\n *\r\n * beforeEach(module(function(eventTrackerProvider) {\r\n * // Configure eventTracker provider\r\n * eventTrackerProvider.setTrackingUrl('/custom-track');\r\n * }));\r\n *\r\n * it('tracks events', inject(function(eventTracker) {\r\n * expect(eventTracker.event('login')).toEqual(1);\r\n * expect(eventTracker.event('login')).toEqual(2);\r\n * }));\r\n *\r\n * it('saves to the tracking url', inject(function(eventTracker, $http) {\r\n * postSpy = spyOn($http, 'post');\r\n * eventTracker.event('login');\r\n * eventTracker.save();\r\n * expect(postSpy).toHaveBeenCalled();\r\n * expect(postSpy.mostRecentCall.args[0]).not.toEqual('/track');\r\n * expect(postSpy.mostRecentCall.args[0]).toEqual('/custom-track');\r\n * expect(postSpy.mostRecentCall.args[1]).toEqual({ 'login': 1 });\r\n * }));\r\n * });\r\n * ```\r\n */\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $provide#factory\r\n * @description\r\n *\r\n * Register a **service factory**, which will be called to return the service instance.\r\n * This is short for registering a service where its provider consists of only a `$get` property,\r\n * which is the given service factory function.\r\n * You should use {@link auto.$provide#factory $provide.factory(getFn)} if you do not need to\r\n * configure your service in a provider.\r\n *\r\n * @param {string} name The name of the instance.\r\n * @param {function()} $getFn The $getFn for the instance creation. Internally this is a short hand\r\n * for `$provide.provider(name, {$get: $getFn})`.\r\n * @returns {Object} registered provider instance\r\n *\r\n * @example\r\n * Here is an example of registering a service\r\n * ```js\r\n * $provide.factory('ping', ['$http', function($http) {\r\n * return function ping() {\r\n * return $http.send('/ping');\r\n * };\r\n * }]);\r\n * ```\r\n * You would then inject and use this service like this:\r\n * ```js\r\n * someModule.controller('Ctrl', ['ping', function(ping) {\r\n * ping();\r\n * }]);\r\n * ```\r\n */\r\n\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $provide#service\r\n * @description\r\n *\r\n * Register a **service constructor**, which will be invoked with `new` to create the service\r\n * instance.\r\n * This is short for registering a service where its provider's `$get` property is the service\r\n * constructor function that will be used to instantiate the service instance.\r\n *\r\n * You should use {@link auto.$provide#service $provide.service(class)} if you define your service\r\n * as a type/class.\r\n *\r\n * @param {string} name The name of the instance.\r\n * @param {Function} constructor A class (constructor function) that will be instantiated.\r\n * @returns {Object} registered provider instance\r\n *\r\n * @example\r\n * Here is an example of registering a service using\r\n * {@link auto.$provide#service $provide.service(class)}.\r\n * ```js\r\n * var Ping = function($http) {\r\n * this.$http = $http;\r\n * };\r\n *\r\n * Ping.$inject = ['$http'];\r\n *\r\n * Ping.prototype.send = function() {\r\n * return this.$http.get('/ping');\r\n * };\r\n * $provide.service('ping', Ping);\r\n * ```\r\n * You would then inject and use this service like this:\r\n * ```js\r\n * someModule.controller('Ctrl', ['ping', function(ping) {\r\n * ping.send();\r\n * }]);\r\n * ```\r\n */\r\n\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $provide#value\r\n * @description\r\n *\r\n * Register a **value service** with the {@link auto.$injector $injector}, such as a string, a\r\n * number, an array, an object or a function. This is short for registering a service where its\r\n * provider's `$get` property is a factory function that takes no arguments and returns the **value\r\n * service**.\r\n *\r\n * Value services are similar to constant services, except that they cannot be injected into a\r\n * module configuration function (see {@link angular.Module#config}) but they can be overridden by\r\n * an Angular\r\n * {@link auto.$provide#decorator decorator}.\r\n *\r\n * @param {string} name The name of the instance.\r\n * @param {*} value The value.\r\n * @returns {Object} registered provider instance\r\n *\r\n * @example\r\n * Here are some examples of creating value services.\r\n * ```js\r\n * $provide.value('ADMIN_USER', 'admin');\r\n *\r\n * $provide.value('RoleLookup', { admin: 0, writer: 1, reader: 2 });\r\n *\r\n * $provide.value('halfOf', function(value) {\r\n * return value / 2;\r\n * });\r\n * ```\r\n */\r\n\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $provide#constant\r\n * @description\r\n *\r\n * Register a **constant service**, such as a string, a number, an array, an object or a function,\r\n * with the {@link auto.$injector $injector}. Unlike {@link auto.$provide#value value} it can be\r\n * injected into a module configuration function (see {@link angular.Module#config}) and it cannot\r\n * be overridden by an Angular {@link auto.$provide#decorator decorator}.\r\n *\r\n * @param {string} name The name of the constant.\r\n * @param {*} value The constant value.\r\n * @returns {Object} registered instance\r\n *\r\n * @example\r\n * Here a some examples of creating constants:\r\n * ```js\r\n * $provide.constant('SHARD_HEIGHT', 306);\r\n *\r\n * $provide.constant('MY_COLOURS', ['red', 'blue', 'grey']);\r\n *\r\n * $provide.constant('double', function(value) {\r\n * return value * 2;\r\n * });\r\n * ```\r\n */\r\n\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $provide#decorator\r\n * @description\r\n *\r\n * Register a **service decorator** with the {@link auto.$injector $injector}. A service decorator\r\n * intercepts the creation of a service, allowing it to override or modify the behaviour of the\r\n * service. The object returned by the decorator may be the original service, or a new service\r\n * object which replaces or wraps and delegates to the original service.\r\n *\r\n * @param {string} name The name of the service to decorate.\r\n * @param {function()} decorator This function will be invoked when the service needs to be\r\n * instantiated and should return the decorated service instance. The function is called using\r\n * the {@link auto.$injector#invoke injector.invoke} method and is therefore fully injectable.\r\n * Local injection arguments:\r\n *\r\n * * `$delegate` - The original service instance, which can be monkey patched, configured,\r\n * decorated or delegated to.\r\n *\r\n * @example\r\n * Here we decorate the {@link ng.$log $log} service to convert warnings to errors by intercepting\r\n * calls to {@link ng.$log#error $log.warn()}.\r\n * ```js\r\n * $provide.decorator('$log', ['$delegate', function($delegate) {\r\n * $delegate.warn = $delegate.error;\r\n * return $delegate;\r\n * }]);\r\n * ```\r\n */\r\n\r\n\r\nfunction createInjector(modulesToLoad) {\r\n var INSTANTIATING = {},\r\n providerSuffix = 'Provider',\r\n path = [],\r\n loadedModules = new HashMap([], true),\r\n providerCache = {\r\n $provide: {\r\n provider: supportObject(provider),\r\n factory: supportObject(factory),\r\n service: supportObject(service),\r\n value: supportObject(value),\r\n constant: supportObject(constant),\r\n decorator: decorator\r\n }\r\n },\r\n providerInjector = (providerCache.$injector =\r\n createInternalInjector(providerCache, function() {\r\n throw $injectorMinErr('unpr', \"Unknown provider: {0}\", path.join(' <- '));\r\n })),\r\n instanceCache = {},\r\n instanceInjector = (instanceCache.$injector =\r\n createInternalInjector(instanceCache, function(servicename) {\r\n var provider = providerInjector.get(servicename + providerSuffix);\r\n return instanceInjector.invoke(provider.$get, provider);\r\n }));\r\n\r\n\r\n forEach(loadModules(modulesToLoad), function(fn) { instanceInjector.invoke(fn || noop); });\r\n\r\n return instanceInjector;\r\n\r\n ////////////////////////////////////\r\n // $provider\r\n ////////////////////////////////////\r\n\r\n function supportObject(delegate) {\r\n return function(key, value) {\r\n if (isObject(key)) {\r\n forEach(key, reverseParams(delegate));\r\n } else {\r\n return delegate(key, value);\r\n }\r\n };\r\n }\r\n\r\n function provider(name, provider_) {\r\n assertNotHasOwnProperty(name, 'service');\r\n if (isFunction(provider_) || isArray(provider_)) {\r\n provider_ = providerInjector.instantiate(provider_);\r\n }\r\n if (!provider_.$get) {\r\n throw $injectorMinErr('pget', \"Provider '{0}' must define $get factory method.\", name);\r\n }\r\n return providerCache[name + providerSuffix] = provider_;\r\n }\r\n\r\n function factory(name, factoryFn) { return provider(name, { $get: factoryFn }); }\r\n\r\n function service(name, constructor) {\r\n return factory(name, ['$injector', function($injector) {\r\n return $injector.instantiate(constructor);\r\n }]);\r\n }\r\n\r\n function value(name, val) { return factory(name, valueFn(val)); }\r\n\r\n function constant(name, value) {\r\n assertNotHasOwnProperty(name, 'constant');\r\n providerCache[name] = value;\r\n instanceCache[name] = value;\r\n }\r\n\r\n function decorator(serviceName, decorFn) {\r\n var origProvider = providerInjector.get(serviceName + providerSuffix),\r\n orig$get = origProvider.$get;\r\n\r\n origProvider.$get = function() {\r\n var origInstance = instanceInjector.invoke(orig$get, origProvider);\r\n return instanceInjector.invoke(decorFn, null, {$delegate: origInstance});\r\n };\r\n }\r\n\r\n ////////////////////////////////////\r\n // Module Loading\r\n ////////////////////////////////////\r\n function loadModules(modulesToLoad){\r\n var runBlocks = [], moduleFn, invokeQueue, i, ii;\r\n forEach(modulesToLoad, function(module) {\r\n if (loadedModules.get(module)) return;\r\n loadedModules.put(module, true);\r\n\r\n try {\r\n if (isString(module)) {\r\n moduleFn = angularModule(module);\r\n runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);\r\n\r\n for(invokeQueue = moduleFn._invokeQueue, i = 0, ii = invokeQueue.length; i < ii; i++) {\r\n var invokeArgs = invokeQueue[i],\r\n provider = providerInjector.get(invokeArgs[0]);\r\n\r\n provider[invokeArgs[1]].apply(provider, invokeArgs[2]);\r\n }\r\n } else if (isFunction(module)) {\r\n runBlocks.push(providerInjector.invoke(module));\r\n } else if (isArray(module)) {\r\n runBlocks.push(providerInjector.invoke(module));\r\n } else {\r\n assertArgFn(module, 'module');\r\n }\r\n } catch (e) {\r\n if (isArray(module)) {\r\n module = module[module.length - 1];\r\n }\r\n if (e.message && e.stack && e.stack.indexOf(e.message) == -1) {\r\n // Safari & FF's stack traces don't contain error.message content\r\n // unlike those of Chrome and IE\r\n // So if stack doesn't contain message, we create a new string that contains both.\r\n // Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.\r\n /* jshint -W022 */\r\n e = e.message + '\\n' + e.stack;\r\n }\r\n throw $injectorMinErr('modulerr', \"Failed to instantiate module {0} due to:\\n{1}\",\r\n module, e.stack || e.message || e);\r\n }\r\n });\r\n return runBlocks;\r\n }\r\n\r\n ////////////////////////////////////\r\n // internal Injector\r\n ////////////////////////////////////\r\n\r\n function createInternalInjector(cache, factory) {\r\n\r\n function getService(serviceName) {\r\n if (cache.hasOwnProperty(serviceName)) {\r\n if (cache[serviceName] === INSTANTIATING) {\r\n throw $injectorMinErr('cdep', 'Circular dependency found: {0}',\r\n serviceName + ' <- ' + path.join(' <- '));\r\n }\r\n return cache[serviceName];\r\n } else {\r\n try {\r\n path.unshift(serviceName);\r\n cache[serviceName] = INSTANTIATING;\r\n return cache[serviceName] = factory(serviceName);\r\n } catch (err) {\r\n if (cache[serviceName] === INSTANTIATING) {\r\n delete cache[serviceName];\r\n }\r\n throw err;\r\n } finally {\r\n path.shift();\r\n }\r\n }\r\n }\r\n\r\n function invoke(fn, self, locals){\r\n var args = [],\r\n $inject = annotate(fn),\r\n length, i,\r\n key;\r\n\r\n for(i = 0, length = $inject.length; i < length; i++) {\r\n key = $inject[i];\r\n if (typeof key !== 'string') {\r\n throw $injectorMinErr('itkn',\r\n 'Incorrect injection token! Expected service name as string, got {0}', key);\r\n }\r\n args.push(\r\n locals && locals.hasOwnProperty(key)\r\n ? locals[key]\r\n : getService(key)\r\n );\r\n }\r\n if (isArray(fn)) {\r\n fn = fn[length];\r\n }\r\n\r\n // http://jsperf.com/angularjs-invoke-apply-vs-switch\r\n // #5388\r\n return fn.apply(self, args);\r\n }\r\n\r\n function instantiate(Type, locals) {\r\n var Constructor = function() {},\r\n instance, returnedValue;\r\n\r\n // Check if Type is annotated and use just the given function at n-1 as parameter\r\n // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);\r\n Constructor.prototype = (isArray(Type) ? Type[Type.length - 1] : Type).prototype;\r\n instance = new Constructor();\r\n returnedValue = invoke(Type, instance, locals);\r\n\r\n return isObject(returnedValue) || isFunction(returnedValue) ? returnedValue : instance;\r\n }\r\n\r\n return {\r\n invoke: invoke,\r\n instantiate: instantiate,\r\n get: getService,\r\n annotate: annotate,\r\n has: function(name) {\r\n return providerCache.hasOwnProperty(name + providerSuffix) || cache.hasOwnProperty(name);\r\n }\r\n };\r\n }\r\n}\r\n\r\n/**\r\n * @ngdoc service\r\n * @name $anchorScroll\r\n * @kind function\r\n * @requires $window\r\n * @requires $location\r\n * @requires $rootScope\r\n *\r\n * @description\r\n * When called, it checks current value of `$location.hash()` and scrolls to the related element,\r\n * according to rules specified in\r\n * [Html5 spec](http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document).\r\n *\r\n * It also watches the `$location.hash()` and scrolls whenever it changes to match any anchor.\r\n * This can be disabled by calling `$anchorScrollProvider.disableAutoScrolling()`.\r\n *\r\n * @example\r\n \r\n \r\n \r\n \r\n function ScrollCtrl($scope, $location, $anchorScroll) {\r\n $scope.gotoBottom = function (){\r\n // set the location.hash to the id of\r\n // the element you wish to scroll to.\r\n $location.hash('bottom');\r\n\r\n // call $anchorScroll()\r\n $anchorScroll();\r\n };\r\n }\r\n \r\n \r\n #scrollArea {\r\n height: 350px;\r\n overflow: auto;\r\n }\r\n\r\n #bottom {\r\n display: block;\r\n margin-top: 2000px;\r\n }\r\n \r\n \r\n */\r\nfunction $AnchorScrollProvider() {\r\n\r\n var autoScrollingEnabled = true;\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $anchorScrollProvider#disableAutoScrolling\r\n *\r\n * @description\r\n * By default, {@link ng.$anchorScroll $anchorScroll()} will automatically detect changes to\r\n * {@link ng.$location#hash $location.hash()} and scroll to the element matching the new hash.
\r\n * Use this method to disable automatic scrolling.\r\n *\r\n * If automatic scrolling is disabled, one must explicitly call\r\n * {@link ng.$anchorScroll $anchorScroll()} in order to scroll to the element related to the\r\n * current hash.\r\n */\r\n this.disableAutoScrolling = function() {\r\n autoScrollingEnabled = false;\r\n };\r\n\r\n this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) {\r\n var document = $window.document;\r\n\r\n // helper function to get first anchor from a NodeList\r\n // can't use filter.filter, as it accepts only instances of Array\r\n // and IE can't convert NodeList to an array using [].slice\r\n // TODO(vojta): use filter if we change it to accept lists as well\r\n function getFirstAnchor(list) {\r\n var result = null;\r\n forEach(list, function(element) {\r\n if (!result && lowercase(element.nodeName) === 'a') result = element;\r\n });\r\n return result;\r\n }\r\n\r\n function scroll() {\r\n var hash = $location.hash(), elm;\r\n\r\n // empty hash, scroll to the top of the page\r\n if (!hash) $window.scrollTo(0, 0);\r\n\r\n // element with given id\r\n else if ((elm = document.getElementById(hash))) elm.scrollIntoView();\r\n\r\n // first anchor with given name :-D\r\n else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) elm.scrollIntoView();\r\n\r\n // no element and hash == 'top', scroll to the top of the page\r\n else if (hash === 'top') $window.scrollTo(0, 0);\r\n }\r\n\r\n // does not scroll when user clicks on anchor link that is currently on\r\n // (no url change, no $location.hash() change), browser native does scroll\r\n if (autoScrollingEnabled) {\r\n $rootScope.$watch(function autoScrollWatch() {return $location.hash();},\r\n function autoScrollWatchAction() {\r\n $rootScope.$evalAsync(scroll);\r\n });\r\n }\r\n\r\n return scroll;\r\n }];\r\n}\r\n\r\nvar $animateMinErr = minErr('$animate');\r\n\r\n/**\r\n * @ngdoc provider\r\n * @name $animateProvider\r\n *\r\n * @description\r\n * Default implementation of $animate that doesn't perform any animations, instead just\r\n * synchronously performs DOM\r\n * updates and calls done() callbacks.\r\n *\r\n * In order to enable animations the ngAnimate module has to be loaded.\r\n *\r\n * To see the functional implementation check out src/ngAnimate/animate.js\r\n */\r\nvar $AnimateProvider = ['$provide', function($provide) {\r\n\r\n\r\n this.$$selectors = {};\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $animateProvider#register\r\n *\r\n * @description\r\n * Registers a new injectable animation factory function. The factory function produces the\r\n * animation object which contains callback functions for each event that is expected to be\r\n * animated.\r\n *\r\n * * `eventFn`: `function(Element, doneFunction)` The element to animate, the `doneFunction`\r\n * must be called once the element animation is complete. If a function is returned then the\r\n * animation service will use this function to cancel the animation whenever a cancel event is\r\n * triggered.\r\n *\r\n *\r\n * ```js\r\n * return {\r\n * eventFn : function(element, done) {\r\n * //code to run the animation\r\n * //once complete, then run done()\r\n * return function cancellationFunction() {\r\n * //code to cancel the animation\r\n * }\r\n * }\r\n * }\r\n * ```\r\n *\r\n * @param {string} name The name of the animation.\r\n * @param {Function} factory The factory function that will be executed to return the animation\r\n * object.\r\n */\r\n this.register = function(name, factory) {\r\n var key = name + '-animation';\r\n if (name && name.charAt(0) != '.') throw $animateMinErr('notcsel',\r\n \"Expecting class selector starting with '.' got '{0}'.\", name);\r\n this.$$selectors[name.substr(1)] = key;\r\n $provide.factory(key, factory);\r\n };\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $animateProvider#classNameFilter\r\n *\r\n * @description\r\n * Sets and/or returns the CSS class regular expression that is checked when performing\r\n * an animation. Upon bootstrap the classNameFilter value is not set at all and will\r\n * therefore enable $animate to attempt to perform an animation on any element.\r\n * When setting the classNameFilter value, animations will only be performed on elements\r\n * that successfully match the filter expression. This in turn can boost performance\r\n * for low-powered devices as well as applications containing a lot of structural operations.\r\n * @param {RegExp=} expression The className expression which will be checked against all animations\r\n * @return {RegExp} The current CSS className expression value. If null then there is no expression value\r\n */\r\n this.classNameFilter = function(expression) {\r\n if(arguments.length === 1) {\r\n this.$$classNameFilter = (expression instanceof RegExp) ? expression : null;\r\n }\r\n return this.$$classNameFilter;\r\n };\r\n\r\n this.$get = ['$timeout', '$$asyncCallback', function($timeout, $$asyncCallback) {\r\n\r\n function async(fn) {\r\n fn && $$asyncCallback(fn);\r\n }\r\n\r\n /**\r\n *\r\n * @ngdoc service\r\n * @name $animate\r\n * @description The $animate service provides rudimentary DOM manipulation functions to\r\n * insert, remove and move elements within the DOM, as well as adding and removing classes.\r\n * This service is the core service used by the ngAnimate $animator service which provides\r\n * high-level animation hooks for CSS and JavaScript.\r\n *\r\n * $animate is available in the AngularJS core, however, the ngAnimate module must be included\r\n * to enable full out animation support. Otherwise, $animate will only perform simple DOM\r\n * manipulation operations.\r\n *\r\n * To learn more about enabling animation support, click here to visit the {@link ngAnimate\r\n * ngAnimate module page} as well as the {@link ngAnimate.$animate ngAnimate $animate service\r\n * page}.\r\n */\r\n return {\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#enter\r\n * @kind function\r\n * @description Inserts the element into the DOM either after the `after` element or within\r\n * the `parent` element. Once complete, the done() callback will be fired (if provided).\r\n * @param {DOMElement} element the element which will be inserted into the DOM\r\n * @param {DOMElement} parent the parent element which will append the element as\r\n * a child (if the after element is not present)\r\n * @param {DOMElement} after the sibling element which will append the element\r\n * after itself\r\n * @param {Function=} done callback function that will be called after the element has been\r\n * inserted into the DOM\r\n */\r\n enter : function(element, parent, after, done) {\r\n if (after) {\r\n after.after(element);\r\n } else {\r\n if (!parent || !parent[0]) {\r\n parent = after.parent();\r\n }\r\n parent.append(element);\r\n }\r\n async(done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#leave\r\n * @kind function\r\n * @description Removes the element from the DOM. Once complete, the done() callback will be\r\n * fired (if provided).\r\n * @param {DOMElement} element the element which will be removed from the DOM\r\n * @param {Function=} done callback function that will be called after the element has been\r\n * removed from the DOM\r\n */\r\n leave : function(element, done) {\r\n element.remove();\r\n async(done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#move\r\n * @kind function\r\n * @description Moves the position of the provided element within the DOM to be placed\r\n * either after the `after` element or inside of the `parent` element. Once complete, the\r\n * done() callback will be fired (if provided).\r\n *\r\n * @param {DOMElement} element the element which will be moved around within the\r\n * DOM\r\n * @param {DOMElement} parent the parent element where the element will be\r\n * inserted into (if the after element is not present)\r\n * @param {DOMElement} after the sibling element where the element will be\r\n * positioned next to\r\n * @param {Function=} done the callback function (if provided) that will be fired after the\r\n * element has been moved to its new position\r\n */\r\n move : function(element, parent, after, done) {\r\n // Do not remove element before insert. Removing will cause data associated with the\r\n // element to be dropped. Insert will implicitly do the remove.\r\n this.enter(element, parent, after, done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#addClass\r\n * @kind function\r\n * @description Adds the provided className CSS class value to the provided element. Once\r\n * complete, the done() callback will be fired (if provided).\r\n * @param {DOMElement} element the element which will have the className value\r\n * added to it\r\n * @param {string} className the CSS class which will be added to the element\r\n * @param {Function=} done the callback function (if provided) that will be fired after the\r\n * className value has been added to the element\r\n */\r\n addClass : function(element, className, done) {\r\n className = isString(className) ?\r\n className :\r\n isArray(className) ? className.join(' ') : '';\r\n forEach(element, function (element) {\r\n jqLiteAddClass(element, className);\r\n });\r\n async(done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#removeClass\r\n * @kind function\r\n * @description Removes the provided className CSS class value from the provided element.\r\n * Once complete, the done() callback will be fired (if provided).\r\n * @param {DOMElement} element the element which will have the className value\r\n * removed from it\r\n * @param {string} className the CSS class which will be removed from the element\r\n * @param {Function=} done the callback function (if provided) that will be fired after the\r\n * className value has been removed from the element\r\n */\r\n removeClass : function(element, className, done) {\r\n className = isString(className) ?\r\n className :\r\n isArray(className) ? className.join(' ') : '';\r\n forEach(element, function (element) {\r\n jqLiteRemoveClass(element, className);\r\n });\r\n async(done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#setClass\r\n * @kind function\r\n * @description Adds and/or removes the given CSS classes to and from the element.\r\n * Once complete, the done() callback will be fired (if provided).\r\n * @param {DOMElement} element the element which will have its CSS classes changed\r\n * removed from it\r\n * @param {string} add the CSS classes which will be added to the element\r\n * @param {string} remove the CSS class which will be removed from the element\r\n * @param {Function=} done the callback function (if provided) that will be fired after the\r\n * CSS classes have been set on the element\r\n */\r\n setClass : function(element, add, remove, done) {\r\n forEach(element, function (element) {\r\n jqLiteAddClass(element, add);\r\n jqLiteRemoveClass(element, remove);\r\n });\r\n async(done);\r\n },\r\n\r\n enabled : noop\r\n };\r\n }];\r\n}];\r\n\r\nfunction $$AsyncCallbackProvider(){\r\n this.$get = ['$$rAF', '$timeout', function($$rAF, $timeout) {\r\n return $$rAF.supported\r\n ? function(fn) { return $$rAF(fn); }\r\n : function(fn) {\r\n return $timeout(fn, 0, false);\r\n };\r\n }];\r\n}\r\n\r\n/* global stripHash: true */\r\n\r\n/**\r\n * ! This is a private undocumented service !\r\n *\r\n * @name $browser\r\n * @requires $log\r\n * @description\r\n * This object has two goals:\r\n *\r\n * - hide all the global state in the browser caused by the window object\r\n * - abstract away all the browser specific features and inconsistencies\r\n *\r\n * For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`\r\n * service, which can be used for convenient testing of the application without the interaction with\r\n * the real browser apis.\r\n */\r\n/**\r\n * @param {object} window The global window object.\r\n * @param {object} document jQuery wrapped document.\r\n * @param {function()} XHR XMLHttpRequest constructor.\r\n * @param {object} $log console.log or an object with the same interface.\r\n * @param {object} $sniffer $sniffer service\r\n */\r\nfunction Browser(window, document, $log, $sniffer) {\r\n var self = this,\r\n rawDocument = document[0],\r\n location = window.location,\r\n history = window.history,\r\n setTimeout = window.setTimeout,\r\n clearTimeout = window.clearTimeout,\r\n pendingDeferIds = {};\r\n\r\n self.isMock = false;\r\n\r\n var outstandingRequestCount = 0;\r\n var outstandingRequestCallbacks = [];\r\n\r\n // TODO(vojta): remove this temporary api\r\n self.$$completeOutstandingRequest = completeOutstandingRequest;\r\n self.$$incOutstandingRequestCount = function() { outstandingRequestCount++; };\r\n\r\n /**\r\n * Executes the `fn` function(supports currying) and decrements the `outstandingRequestCallbacks`\r\n * counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.\r\n */\r\n function completeOutstandingRequest(fn) {\r\n try {\r\n fn.apply(null, sliceArgs(arguments, 1));\r\n } finally {\r\n outstandingRequestCount--;\r\n if (outstandingRequestCount === 0) {\r\n while(outstandingRequestCallbacks.length) {\r\n try {\r\n outstandingRequestCallbacks.pop()();\r\n } catch (e) {\r\n $log.error(e);\r\n }\r\n }\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @private\r\n * Note: this method is used only by scenario runner\r\n * TODO(vojta): prefix this method with $$ ?\r\n * @param {function()} callback Function that will be called when no outstanding request\r\n */\r\n self.notifyWhenNoOutstandingRequests = function(callback) {\r\n // force browser to execute all pollFns - this is needed so that cookies and other pollers fire\r\n // at some deterministic time in respect to the test runner's actions. Leaving things up to the\r\n // regular poller would result in flaky tests.\r\n forEach(pollFns, function(pollFn){ pollFn(); });\r\n\r\n if (outstandingRequestCount === 0) {\r\n callback();\r\n } else {\r\n outstandingRequestCallbacks.push(callback);\r\n }\r\n };\r\n\r\n //////////////////////////////////////////////////////////////\r\n // Poll Watcher API\r\n //////////////////////////////////////////////////////////////\r\n var pollFns = [],\r\n pollTimeout;\r\n\r\n /**\r\n * @name $browser#addPollFn\r\n *\r\n * @param {function()} fn Poll function to add\r\n *\r\n * @description\r\n * Adds a function to the list of functions that poller periodically executes,\r\n * and starts polling if not started yet.\r\n *\r\n * @returns {function()} the added function\r\n */\r\n self.addPollFn = function(fn) {\r\n if (isUndefined(pollTimeout)) startPoller(100, setTimeout);\r\n pollFns.push(fn);\r\n return fn;\r\n };\r\n\r\n /**\r\n * @param {number} interval How often should browser call poll functions (ms)\r\n * @param {function()} setTimeout Reference to a real or fake `setTimeout` function.\r\n *\r\n * @description\r\n * Configures the poller to run in the specified intervals, using the specified\r\n * setTimeout fn and kicks it off.\r\n */\r\n function startPoller(interval, setTimeout) {\r\n (function check() {\r\n forEach(pollFns, function(pollFn){ pollFn(); });\r\n pollTimeout = setTimeout(check, interval);\r\n })();\r\n }\r\n\r\n //////////////////////////////////////////////////////////////\r\n // URL API\r\n //////////////////////////////////////////////////////////////\r\n\r\n var lastBrowserUrl = location.href,\r\n baseElement = document.find('base'),\r\n reloadLocation = null;\r\n\r\n /**\r\n * @name $browser#url\r\n *\r\n * @description\r\n * GETTER:\r\n * Without any argument, this method just returns current value of location.href.\r\n *\r\n * SETTER:\r\n * With at least one argument, this method sets url to new value.\r\n * If html5 history api supported, pushState/replaceState is used, otherwise\r\n * location.href/location.replace is used.\r\n * Returns its own instance to allow chaining\r\n *\r\n * NOTE: this api is intended for use only by the $location service. Please use the\r\n * {@link ng.$location $location service} to change url.\r\n *\r\n * @param {string} url New url (when used as setter)\r\n * @param {boolean=} replace Should new url replace current history record ?\r\n */\r\n self.url = function(url, replace) {\r\n // Android Browser BFCache causes location, history reference to become stale.\r\n if (location !== window.location) location = window.location;\r\n if (history !== window.history) history = window.history;\r\n\r\n // setter\r\n if (url) {\r\n if (lastBrowserUrl == url) return;\r\n var sameBase = lastBrowserUrl && stripHash(lastBrowserUrl) === stripHash(url);\r\n lastBrowserUrl = url;\r\n // Don't use history API if only the hash changed\r\n // due to a bug in IE10/IE11 which leads\r\n // to not firing a `hashchange` nor `popstate` event\r\n // in some cases (see #9143).\r\n if (!sameBase && $sniffer.history) {\r\n if (replace) history.replaceState(null, '', url);\r\n else {\r\n history.pushState(null, '', url);\r\n // Crazy Opera Bug: http://my.opera.com/community/forums/topic.dml?id=1185462\r\n baseElement.attr('href', baseElement.attr('href'));\r\n }\r\n } else {\r\n if (!sameBase) {\r\n reloadLocation = url;\r\n }\r\n if (replace) {\r\n location.replace(url);\r\n } else {\r\n location.href = url;\r\n }\r\n }\r\n return self;\r\n // getter\r\n } else {\r\n // - reloadLocation is needed as browsers don't allow to read out\r\n // the new location.href if a reload happened.\r\n // - the replacement is a workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=407172\r\n return reloadLocation || location.href.replace(/%27/g,\"'\");\r\n }\r\n };\r\n\r\n var urlChangeListeners = [],\r\n urlChangeInit = false;\r\n\r\n function fireUrlChange() {\r\n if (lastBrowserUrl == self.url()) return;\r\n\r\n lastBrowserUrl = self.url();\r\n forEach(urlChangeListeners, function(listener) {\r\n listener(self.url());\r\n });\r\n }\r\n\r\n /**\r\n * @name $browser#onUrlChange\r\n *\r\n * @description\r\n * Register callback function that will be called, when url changes.\r\n *\r\n * It's only called when the url is changed from outside of angular:\r\n * - user types different url into address bar\r\n * - user clicks on history (forward/back) button\r\n * - user clicks on a link\r\n *\r\n * It's not called when url is changed by $browser.url() method\r\n *\r\n * The listener gets called with new url as parameter.\r\n *\r\n * NOTE: this api is intended for use only by the $location service. Please use the\r\n * {@link ng.$location $location service} to monitor url changes in angular apps.\r\n *\r\n * @param {function(string)} listener Listener function to be called when url changes.\r\n * @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.\r\n */\r\n self.onUrlChange = function(callback) {\r\n // TODO(vojta): refactor to use node's syntax for events\r\n if (!urlChangeInit) {\r\n // We listen on both (hashchange/popstate) when available, as some browsers (e.g. Opera)\r\n // don't fire popstate when user change the address bar and don't fire hashchange when url\r\n // changed by push/replaceState\r\n\r\n // html5 history api - popstate event\r\n if ($sniffer.history) jqLite(window).on('popstate', fireUrlChange);\r\n // hashchange event\r\n if ($sniffer.hashchange) jqLite(window).on('hashchange', fireUrlChange);\r\n // polling\r\n else self.addPollFn(fireUrlChange);\r\n\r\n urlChangeInit = true;\r\n }\r\n\r\n urlChangeListeners.push(callback);\r\n return callback;\r\n };\r\n\r\n /**\r\n * Checks whether the url has changed outside of Angular.\r\n * Needs to be exported to be able to check for changes that have been done in sync,\r\n * as hashchange/popstate events fire in async.\r\n */\r\n self.$$checkUrlChange = fireUrlChange;\r\n\r\n //////////////////////////////////////////////////////////////\r\n // Misc API\r\n //////////////////////////////////////////////////////////////\r\n\r\n /**\r\n * @name $browser#baseHref\r\n *\r\n * @description\r\n * Returns current\r\n \r\n \r\n \r\n angular.module('cacheExampleApp', []).\r\n controller('CacheController', ['$scope', '$cacheFactory', function($scope, $cacheFactory) {\r\n $scope.keys = [];\r\n $scope.cache = $cacheFactory('cacheId');\r\n $scope.put = function(key, value) {\r\n if ($scope.cache.get(key) === undefined) {\r\n $scope.keys.push(key);\r\n }\r\n $scope.cache.put(key, value === undefined ? null : value);\r\n };\r\n }]);\r\n \r\n \r\n p {\r\n margin: 10px 0 3px;\r\n }\r\n \r\n \r\n */\r\nfunction $CacheFactoryProvider() {\r\n\r\n this.$get = function() {\r\n var caches = {};\r\n\r\n function cacheFactory(cacheId, options) {\r\n if (cacheId in caches) {\r\n throw minErr('$cacheFactory')('iid', \"CacheId '{0}' is already taken!\", cacheId);\r\n }\r\n\r\n var size = 0,\r\n stats = extend({}, options, {id: cacheId}),\r\n data = {},\r\n capacity = (options && options.capacity) || Number.MAX_VALUE,\r\n lruHash = {},\r\n freshEnd = null,\r\n staleEnd = null;\r\n\r\n /**\r\n * @ngdoc type\r\n * @name $cacheFactory.Cache\r\n *\r\n * @description\r\n * A cache object used to store and retrieve data, primarily used by\r\n * {@link $http $http} and the {@link ng.directive:script script} directive to cache\r\n * templates and other data.\r\n *\r\n * ```js\r\n * angular.module('superCache')\r\n * .factory('superCache', ['$cacheFactory', function($cacheFactory) {\r\n * return $cacheFactory('super-cache');\r\n * }]);\r\n * ```\r\n *\r\n * Example test:\r\n *\r\n * ```js\r\n * it('should behave like a cache', inject(function(superCache) {\r\n * superCache.put('key', 'value');\r\n * superCache.put('another key', 'another value');\r\n *\r\n * expect(superCache.info()).toEqual({\r\n * id: 'super-cache',\r\n * size: 2\r\n * });\r\n *\r\n * superCache.remove('another key');\r\n * expect(superCache.get('another key')).toBeUndefined();\r\n *\r\n * superCache.removeAll();\r\n * expect(superCache.info()).toEqual({\r\n * id: 'super-cache',\r\n * size: 0\r\n * });\r\n * }));\r\n * ```\r\n */\r\n return caches[cacheId] = {\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $cacheFactory.Cache#put\r\n * @kind function\r\n *\r\n * @description\r\n * Inserts a named entry into the {@link $cacheFactory.Cache Cache} object to be\r\n * retrieved later, and incrementing the size of the cache if the key was not already\r\n * present in the cache. If behaving like an LRU cache, it will also remove stale\r\n * entries from the set.\r\n *\r\n * It will not insert undefined values into the cache.\r\n *\r\n * @param {string} key the key under which the cached data is stored.\r\n * @param {*} value the value to store alongside the key. If it is undefined, the key\r\n * will not be stored.\r\n * @returns {*} the value stored.\r\n */\r\n put: function(key, value) {\r\n if (capacity < Number.MAX_VALUE) {\r\n var lruEntry = lruHash[key] || (lruHash[key] = {key: key});\r\n\r\n refresh(lruEntry);\r\n }\r\n\r\n if (isUndefined(value)) return;\r\n if (!(key in data)) size++;\r\n data[key] = value;\r\n\r\n if (size > capacity) {\r\n this.remove(staleEnd.key);\r\n }\r\n\r\n return value;\r\n },\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $cacheFactory.Cache#get\r\n * @kind function\r\n *\r\n * @description\r\n * Retrieves named data stored in the {@link $cacheFactory.Cache Cache} object.\r\n *\r\n * @param {string} key the key of the data to be retrieved\r\n * @returns {*} the value stored.\r\n */\r\n get: function(key) {\r\n if (capacity < Number.MAX_VALUE) {\r\n var lruEntry = lruHash[key];\r\n\r\n if (!lruEntry) return;\r\n\r\n refresh(lruEntry);\r\n }\r\n\r\n return data[key];\r\n },\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $cacheFactory.Cache#remove\r\n * @kind function\r\n *\r\n * @description\r\n * Removes an entry from the {@link $cacheFactory.Cache Cache} object.\r\n *\r\n * @param {string} key the key of the entry to be removed\r\n */\r\n remove: function(key) {\r\n if (capacity < Number.MAX_VALUE) {\r\n var lruEntry = lruHash[key];\r\n\r\n if (!lruEntry) return;\r\n\r\n if (lruEntry == freshEnd) freshEnd = lruEntry.p;\r\n if (lruEntry == staleEnd) staleEnd = lruEntry.n;\r\n link(lruEntry.n,lruEntry.p);\r\n\r\n delete lruHash[key];\r\n }\r\n\r\n delete data[key];\r\n size--;\r\n },\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $cacheFactory.Cache#removeAll\r\n * @kind function\r\n *\r\n * @description\r\n * Clears the cache object of any entries.\r\n */\r\n removeAll: function() {\r\n data = {};\r\n size = 0;\r\n lruHash = {};\r\n freshEnd = staleEnd = null;\r\n },\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $cacheFactory.Cache#destroy\r\n * @kind function\r\n *\r\n * @description\r\n * Destroys the {@link $cacheFactory.Cache Cache} object entirely,\r\n * removing it from the {@link $cacheFactory $cacheFactory} set.\r\n */\r\n destroy: function() {\r\n data = null;\r\n stats = null;\r\n lruHash = null;\r\n delete caches[cacheId];\r\n },\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $cacheFactory.Cache#info\r\n * @kind function\r\n *\r\n * @description\r\n * Retrieve information regarding a particular {@link $cacheFactory.Cache Cache}.\r\n *\r\n * @returns {object} an object with the following properties:\r\n * ` and widget definition\r\n * of `scope: { localName:'@myAttr' }`, then widget scope property `localName` will reflect\r\n * the interpolated value of `hello {{name}}`. As the `name` attribute changes so will the\r\n * `localName` property on the widget scope. The `name` is read from the parent scope (not\r\n * component scope).\r\n *\r\n * * `=` or `=attr` - set up bi-directional binding between a local scope property and the\r\n * parent scope property of name defined via the value of the `attr` attribute. If no `attr`\r\n * name is specified then the attribute name is assumed to be the same as the local name.\r\n * Given `` and widget definition of\r\n * `scope: { localModel:'=myAttr' }`, then widget scope property `localModel` will reflect the\r\n * value of `parentModel` on the parent scope. Any changes to `parentModel` will be reflected\r\n * in `localModel` and any changes in `localModel` will reflect in `parentModel`. If the parent\r\n * scope property doesn't exist, it will throw a NON_ASSIGNABLE_MODEL_EXPRESSION exception. You\r\n * can avoid this behavior using `=?` or `=?attr` in order to flag the property as optional.\r\n *\r\n * * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope.\r\n * If no `attr` name is specified then the attribute name is assumed to be the same as the\r\n * local name. Given `` and widget definition of\r\n * `scope: { localFn:'&myAttr' }`, then isolate scope property `localFn` will point to\r\n * a function wrapper for the `count = count + value` expression. Often it's desirable to\r\n * pass data from the isolated scope via an expression to the parent scope, this can be\r\n * done by passing a map of local variable names and values into the expression wrapper fn.\r\n * For example, if the expression is `increment(amount)` then we can specify the amount value\r\n * by calling the `localFn` as `localFn({amount: 22})`.\r\n *\r\n *\r\n *\r\n * #### `controller`\r\n * Controller constructor function. The controller is instantiated before the\r\n * pre-linking phase and it is shared with other directives (see\r\n * `require` attribute). This allows the directives to communicate with each other and augment\r\n * each other's behavior. The controller is injectable (and supports bracket notation) with the following locals:\r\n *\r\n * * `$scope` - Current scope associated with the element\r\n * * `$element` - Current element\r\n * * `$attrs` - Current attributes object for the element\r\n * * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope.\r\n * The scope can be overridden by an optional first argument.\r\n * `function([scope], cloneLinkingFn)`.\r\n *\r\n *\r\n * #### `require`\r\n * Require another directive and inject its controller as the fourth argument to the linking function. The\r\n * `require` takes a string name (or array of strings) of the directive(s) to pass in. If an array is used, the\r\n * injected argument will be an array in corresponding order. If no such directive can be\r\n * found, or if the directive does not have a controller, then an error is raised. The name can be prefixed with:\r\n *\r\n * * (no prefix) - Locate the required controller on the current element. Throw an error if not found.\r\n * * `?` - Attempt to locate the required controller or pass `null` to the `link` fn if not found.\r\n * * `^` - Locate the required controller by searching the element and its parents. Throw an error if not found.\r\n * * `?^` - Attempt to locate the required controller by searching the element and its parents or pass\r\n * `null` to the `link` fn if not found.\r\n *\r\n *\r\n * #### `controllerAs`\r\n * Controller alias at the directive scope. An alias for the controller so it\r\n * can be referenced at the directive template. The directive needs to define a scope for this\r\n * configuration to be used. Useful in the case when directive is used as component.\r\n *\r\n *\r\n * #### `restrict`\r\n * String of subset of `EACM` which restricts the directive to a specific directive\r\n * declaration style. If omitted, the default (attributes only) is used.\r\n *\r\n * * `E` - Element name: `\r\n \r\n \r\n \r\n \r\n it('should auto compile', function() {\r\n var textarea = $('textarea');\r\n var output = $('div[compile]');\r\n // The initial state reads 'Hello Angular'.\r\n expect(output.getText()).toBe('Hello Angular');\r\n textarea.clear();\r\n textarea.sendKeys('{{name}}!');\r\n expect(output.getText()).toBe('Angular!');\r\n });\r\n \r\n \r\n\r\n *\r\n *\r\n * @param {string|DOMElement} element Element or HTML string to compile into a template function.\r\n * @param {function(angular.Scope, cloneAttachFn=)} transclude function available to directives.\r\n * @param {number} maxPriority only apply directives lower than given priority (Only effects the\r\n * root element(s), not their children)\r\n * @returns {function(scope, cloneAttachFn=)} a link function which is used to bind template\r\n * (a DOM element/tree) to a scope. Where:\r\n *\r\n * * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to.\r\n * * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the\r\n * `template` and call the `cloneAttachFn` function allowing the caller to attach the\r\n * cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is\r\n * called as:
`cloneAttachFn(clonedElement, scope)` where:\r\n *\r\n * * `clonedElement` - is a clone of the original `element` passed into the compiler.\r\n * * `scope` - is the current scope with which the linking function is working with.\r\n *\r\n * Calling the linking function returns the element of the template. It is either the original\r\n * element passed in, or the clone of the element if the `cloneAttachFn` is provided.\r\n *\r\n * After linking the view is not updated until after a call to $digest which typically is done by\r\n * Angular automatically.\r\n *\r\n * If you need access to the bound view, there are two ways to do it:\r\n *\r\n * - If you are not asking the linking function to clone the template, create the DOM element(s)\r\n * before you send them to the compiler and keep this reference around.\r\n * ```js\r\n * var element = $compile('\r\n addDirective(directives,\r\n directiveNormalize(nodeName_(node).toLowerCase()), 'E', maxPriority, ignoreDirective);\r\n\r\n // iterate over the attributes\r\n for (var attr, name, nName, ngAttrName, value, isNgAttr, nAttrs = node.attributes,\r\n j = 0, jj = nAttrs && nAttrs.length; j < jj; j++) {\r\n var attrStartName = false;\r\n var attrEndName = false;\r\n\r\n attr = nAttrs[j];\r\n if (!msie || msie >= 8 || attr.specified) {\r\n name = attr.name;\r\n value = trim(attr.value);\r\n\r\n // support ngAttr attribute binding\r\n ngAttrName = directiveNormalize(name);\r\n if (isNgAttr = NG_ATTR_BINDING.test(ngAttrName)) {\r\n name = snake_case(ngAttrName.substr(6), '-');\r\n }\r\n\r\n var directiveNName = ngAttrName.replace(/(Start|End)$/, '');\r\n if (ngAttrName === directiveNName + 'Start') {\r\n attrStartName = name;\r\n attrEndName = name.substr(0, name.length - 5) + 'end';\r\n name = name.substr(0, name.length - 6);\r\n }\r\n\r\n nName = directiveNormalize(name.toLowerCase());\r\n attrsMap[nName] = name;\r\n if (isNgAttr || !attrs.hasOwnProperty(nName)) {\r\n attrs[nName] = value;\r\n if (getBooleanAttrName(node, nName)) {\r\n attrs[nName] = true; // presence means true\r\n }\r\n }\r\n addAttrInterpolateDirective(node, directives, value, nName);\r\n addDirective(directives, nName, 'A', maxPriority, ignoreDirective, attrStartName,\r\n attrEndName);\r\n }\r\n }\r\n\r\n // use class as directive\r\n className = node.className;\r\n if (isString(className) && className !== '') {\r\n while (match = CLASS_DIRECTIVE_REGEXP.exec(className)) {\r\n nName = directiveNormalize(match[2]);\r\n if (addDirective(directives, nName, 'C', maxPriority, ignoreDirective)) {\r\n attrs[nName] = trim(match[3]);\r\n }\r\n className = className.substr(match.index + match[0].length);\r\n }\r\n }\r\n break;\r\n case 3: /* Text Node */\r\n addTextInterpolateDirective(directives, node.nodeValue);\r\n break;\r\n case 8: /* Comment */\r\n try {\r\n match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue);\r\n if (match) {\r\n nName = directiveNormalize(match[1]);\r\n if (addDirective(directives, nName, 'M', maxPriority, ignoreDirective)) {\r\n attrs[nName] = trim(match[2]);\r\n }\r\n }\r\n } catch (e) {\r\n // turns out that under some circumstances IE9 throws errors when one attempts to read\r\n // comment's node value.\r\n // Just ignore it and continue. (Can't seem to reproduce in test case.)\r\n }\r\n break;\r\n }\r\n\r\n directives.sort(byPriority);\r\n return directives;\r\n }\r\n\r\n /**\r\n * Given a node with an directive-start it collects all of the siblings until it finds\r\n * directive-end.\r\n * @param node\r\n * @param attrStart\r\n * @param attrEnd\r\n * @returns {*}\r\n */\r\n function groupScan(node, attrStart, attrEnd) {\r\n var nodes = [];\r\n var depth = 0;\r\n if (attrStart && node.hasAttribute && node.hasAttribute(attrStart)) {\r\n var startNode = node;\r\n do {\r\n if (!node) {\r\n throw $compileMinErr('uterdir',\r\n \"Unterminated attribute, found '{0}' but no matching '{1}' found.\",\r\n attrStart, attrEnd);\r\n }\r\n if (node.nodeType == 1 /** Element **/) {\r\n if (node.hasAttribute(attrStart)) depth++;\r\n if (node.hasAttribute(attrEnd)) depth--;\r\n }\r\n nodes.push(node);\r\n node = node.nextSibling;\r\n } while (depth > 0);\r\n } else {\r\n nodes.push(node);\r\n }\r\n\r\n return jqLite(nodes);\r\n }\r\n\r\n /**\r\n * Wrapper for linking function which converts normal linking function into a grouped\r\n * linking function.\r\n * @param linkFn\r\n * @param attrStart\r\n * @param attrEnd\r\n * @returns {Function}\r\n */\r\n function groupElementsLinkFnWrapper(linkFn, attrStart, attrEnd) {\r\n return function(scope, element, attrs, controllers, transcludeFn) {\r\n element = groupScan(element[0], attrStart, attrEnd);\r\n return linkFn(scope, element, attrs, controllers, transcludeFn);\r\n };\r\n }\r\n\r\n /**\r\n * Once the directives have been collected, their compile functions are executed. This method\r\n * is responsible for inlining directive templates as well as terminating the application\r\n * of the directives if the terminal directive has been reached.\r\n *\r\n * @param {Array} directives Array of collected directives to execute their compile function.\r\n * this needs to be pre-sorted by priority order.\r\n * @param {Node} compileNode The raw DOM node to apply the compile functions to\r\n * @param {Object} templateAttrs The shared attribute function\r\n * @param {function(angular.Scope, cloneAttachFn=)} transcludeFn A linking function, where the\r\n * scope argument is auto-generated to the new\r\n * child of the transcluded parent scope.\r\n * @param {JQLite} jqCollection If we are working on the root of the compile tree then this\r\n * argument has the root jqLite array so that we can replace nodes\r\n * on it.\r\n * @param {Object=} originalReplaceDirective An optional directive that will be ignored when\r\n * compiling the transclusion.\r\n * @param {Array.} preLinkFns\r\n * @param {Array.} postLinkFns\r\n * @param {Object} previousCompileContext Context used for previous compilation of the current\r\n * node\r\n * @returns {Function} linkFn\r\n */\r\n function applyDirectivesToNode(directives, compileNode, templateAttrs, transcludeFn,\r\n jqCollection, originalReplaceDirective, preLinkFns, postLinkFns,\r\n previousCompileContext) {\r\n previousCompileContext = previousCompileContext || {};\r\n\r\n var terminalPriority = -Number.MAX_VALUE,\r\n newScopeDirective,\r\n controllerDirectives = previousCompileContext.controllerDirectives,\r\n newIsolateScopeDirective = previousCompileContext.newIsolateScopeDirective,\r\n templateDirective = previousCompileContext.templateDirective,\r\n nonTlbTranscludeDirective = previousCompileContext.nonTlbTranscludeDirective,\r\n hasTranscludeDirective = false,\r\n hasTemplate = false,\r\n hasElementTranscludeDirective = previousCompileContext.hasElementTranscludeDirective,\r\n $compileNode = templateAttrs.$$element = jqLite(compileNode),\r\n directive,\r\n directiveName,\r\n $template,\r\n replaceDirective = originalReplaceDirective,\r\n childTranscludeFn = transcludeFn,\r\n linkFn,\r\n directiveValue;\r\n\r\n // executes all directives on the current element\r\n for(var i = 0, ii = directives.length; i < ii; i++) {\r\n directive = directives[i];\r\n var attrStart = directive.$$start;\r\n var attrEnd = directive.$$end;\r\n\r\n // collect multiblock sections\r\n if (attrStart) {\r\n $compileNode = groupScan(compileNode, attrStart, attrEnd);\r\n }\r\n $template = undefined;\r\n\r\n if (terminalPriority > directive.priority) {\r\n break; // prevent further processing of directives\r\n }\r\n\r\n if (directiveValue = directive.scope) {\r\n newScopeDirective = newScopeDirective || directive;\r\n\r\n // skip the check for directives with async templates, we'll check the derived sync\r\n // directive when the template arrives\r\n if (!directive.templateUrl) {\r\n assertNoDuplicate('new/isolated scope', newIsolateScopeDirective, directive,\r\n $compileNode);\r\n if (isObject(directiveValue)) {\r\n newIsolateScopeDirective = directive;\r\n }\r\n }\r\n }\r\n\r\n directiveName = directive.name;\r\n\r\n if (!directive.templateUrl && directive.controller) {\r\n directiveValue = directive.controller;\r\n controllerDirectives = controllerDirectives || {};\r\n assertNoDuplicate(\"'\" + directiveName + \"' controller\",\r\n controllerDirectives[directiveName], directive, $compileNode);\r\n controllerDirectives[directiveName] = directive;\r\n }\r\n\r\n if (directiveValue = directive.transclude) {\r\n hasTranscludeDirective = true;\r\n\r\n // Special case ngIf and ngRepeat so that we don't complain about duplicate transclusion.\r\n // This option should only be used by directives that know how to safely handle element transclusion,\r\n // where the transcluded nodes are added or replaced after linking.\r\n if (!directive.$$tlb) {\r\n assertNoDuplicate('transclusion', nonTlbTranscludeDirective, directive, $compileNode);\r\n nonTlbTranscludeDirective = directive;\r\n }\r\n\r\n if (directiveValue == 'element') {\r\n hasElementTranscludeDirective = true;\r\n terminalPriority = directive.priority;\r\n $template = $compileNode;\r\n $compileNode = templateAttrs.$$element =\r\n jqLite(document.createComment(' ' + directiveName + ': ' +\r\n templateAttrs[directiveName] + ' '));\r\n compileNode = $compileNode[0];\r\n replaceWith(jqCollection, sliceArgs($template), compileNode);\r\n\r\n childTranscludeFn = compile($template, transcludeFn, terminalPriority,\r\n replaceDirective && replaceDirective.name, {\r\n // Don't pass in:\r\n // - controllerDirectives - otherwise we'll create duplicates controllers\r\n // - newIsolateScopeDirective or templateDirective - combining templates with\r\n // element transclusion doesn't make sense.\r\n //\r\n // We need only nonTlbTranscludeDirective so that we prevent putting transclusion\r\n // on the same element more than once.\r\n nonTlbTranscludeDirective: nonTlbTranscludeDirective\r\n });\r\n } else {\r\n $template = jqLite(jqLiteClone(compileNode)).contents();\r\n $compileNode.empty(); // clear contents\r\n childTranscludeFn = compile($template, transcludeFn);\r\n }\r\n }\r\n\r\n if (directive.template) {\r\n hasTemplate = true;\r\n assertNoDuplicate('template', templateDirective, directive, $compileNode);\r\n templateDirective = directive;\r\n\r\n directiveValue = (isFunction(directive.template))\r\n ? directive.template($compileNode, templateAttrs)\r\n : directive.template;\r\n\r\n directiveValue = denormalizeTemplate(directiveValue);\r\n\r\n if (directive.replace) {\r\n replaceDirective = directive;\r\n if (jqLiteIsTextNode(directiveValue)) {\r\n $template = [];\r\n } else {\r\n $template = jqLite(trim(directiveValue));\r\n }\r\n compileNode = $template[0];\r\n\r\n if ($template.length != 1 || compileNode.nodeType !== 1) {\r\n throw $compileMinErr('tplrt',\r\n \"Template for directive '{0}' must have exactly one root element. {1}\",\r\n directiveName, '');\r\n }\r\n\r\n replaceWith(jqCollection, $compileNode, compileNode);\r\n\r\n var newTemplateAttrs = {$attr: {}};\r\n\r\n // combine directives from the original node and from the template:\r\n // - take the array of directives for this element\r\n // - split it into two parts, those that already applied (processed) and those that weren't (unprocessed)\r\n // - collect directives from the template and sort them by priority\r\n // - combine directives as: processed + template + unprocessed\r\n var templateDirectives = collectDirectives(compileNode, [], newTemplateAttrs);\r\n var unprocessedDirectives = directives.splice(i + 1, directives.length - (i + 1));\r\n\r\n if (newIsolateScopeDirective) {\r\n markDirectivesAsIsolate(templateDirectives);\r\n }\r\n directives = directives.concat(templateDirectives).concat(unprocessedDirectives);\r\n mergeTemplateAttributes(templateAttrs, newTemplateAttrs);\r\n\r\n ii = directives.length;\r\n } else {\r\n $compileNode.html(directiveValue);\r\n }\r\n }\r\n\r\n if (directive.templateUrl) {\r\n hasTemplate = true;\r\n assertNoDuplicate('template', templateDirective, directive, $compileNode);\r\n templateDirective = directive;\r\n\r\n if (directive.replace) {\r\n replaceDirective = directive;\r\n }\r\n\r\n nodeLinkFn = compileTemplateUrl(directives.splice(i, directives.length - i), $compileNode,\r\n templateAttrs, jqCollection, hasTranscludeDirective && childTranscludeFn, preLinkFns, postLinkFns, {\r\n controllerDirectives: controllerDirectives,\r\n newIsolateScopeDirective: newIsolateScopeDirective,\r\n templateDirective: templateDirective,\r\n nonTlbTranscludeDirective: nonTlbTranscludeDirective\r\n });\r\n ii = directives.length;\r\n } else if (directive.compile) {\r\n try {\r\n linkFn = directive.compile($compileNode, templateAttrs, childTranscludeFn);\r\n if (isFunction(linkFn)) {\r\n addLinkFns(null, linkFn, attrStart, attrEnd);\r\n } else if (linkFn) {\r\n addLinkFns(linkFn.pre, linkFn.post, attrStart, attrEnd);\r\n }\r\n } catch (e) {\r\n $exceptionHandler(e, startingTag($compileNode));\r\n }\r\n }\r\n\r\n if (directive.terminal) {\r\n nodeLinkFn.terminal = true;\r\n terminalPriority = Math.max(terminalPriority, directive.priority);\r\n }\r\n\r\n }\r\n\r\n nodeLinkFn.scope = newScopeDirective && newScopeDirective.scope === true;\r\n nodeLinkFn.transcludeOnThisElement = hasTranscludeDirective;\r\n nodeLinkFn.templateOnThisElement = hasTemplate;\r\n nodeLinkFn.transclude = childTranscludeFn;\r\n\r\n previousCompileContext.hasElementTranscludeDirective = hasElementTranscludeDirective;\r\n\r\n // might be normal or delayed nodeLinkFn depending on if templateUrl is present\r\n return nodeLinkFn;\r\n\r\n ////////////////////\r\n\r\n function addLinkFns(pre, post, attrStart, attrEnd) {\r\n if (pre) {\r\n if (attrStart) pre = groupElementsLinkFnWrapper(pre, attrStart, attrEnd);\r\n pre.require = directive.require;\r\n pre.directiveName = directiveName;\r\n if (newIsolateScopeDirective === directive || directive.$$isolateScope) {\r\n pre = cloneAndAnnotateFn(pre, {isolateScope: true});\r\n }\r\n preLinkFns.push(pre);\r\n }\r\n if (post) {\r\n if (attrStart) post = groupElementsLinkFnWrapper(post, attrStart, attrEnd);\r\n post.require = directive.require;\r\n post.directiveName = directiveName;\r\n if (newIsolateScopeDirective === directive || directive.$$isolateScope) {\r\n post = cloneAndAnnotateFn(post, {isolateScope: true});\r\n }\r\n postLinkFns.push(post);\r\n }\r\n }\r\n\r\n\r\n function getControllers(directiveName, require, $element, elementControllers) {\r\n var value, retrievalMethod = 'data', optional = false;\r\n if (isString(require)) {\r\n while((value = require.charAt(0)) == '^' || value == '?') {\r\n require = require.substr(1);\r\n if (value == '^') {\r\n retrievalMethod = 'inheritedData';\r\n }\r\n optional = optional || value == '?';\r\n }\r\n value = null;\r\n\r\n if (elementControllers && retrievalMethod === 'data') {\r\n value = elementControllers[require];\r\n }\r\n value = value || $element[retrievalMethod]('$' + require + 'Controller');\r\n\r\n if (!value && !optional) {\r\n throw $compileMinErr('ctreq',\r\n \"Controller '{0}', required by directive '{1}', can't be found!\",\r\n require, directiveName);\r\n }\r\n return value;\r\n } else if (isArray(require)) {\r\n value = [];\r\n forEach(require, function(require) {\r\n value.push(getControllers(directiveName, require, $element, elementControllers));\r\n });\r\n }\r\n return value;\r\n }\r\n\r\n\r\n function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn) {\r\n var attrs, $element, i, ii, linkFn, controller, isolateScope, elementControllers = {}, transcludeFn;\r\n\r\n attrs = (compileNode === linkNode)\r\n ? templateAttrs\r\n : shallowCopy(templateAttrs, new Attributes(jqLite(linkNode), templateAttrs.$attr));\r\n $element = attrs.$$element;\r\n\r\n if (newIsolateScopeDirective) {\r\n var LOCAL_REGEXP = /^\\s*([@=&])(\\??)\\s*(\\w*)\\s*$/;\r\n\r\n isolateScope = scope.$new(true);\r\n\r\n if (templateDirective && (templateDirective === newIsolateScopeDirective ||\r\n templateDirective === newIsolateScopeDirective.$$originalDirective)) {\r\n $element.data('$isolateScope', isolateScope);\r\n } else {\r\n $element.data('$isolateScopeNoTemplate', isolateScope);\r\n }\r\n\r\n\r\n\r\n safeAddClass($element, 'ng-isolate-scope');\r\n\r\n forEach(newIsolateScopeDirective.scope, function(definition, scopeName) {\r\n var match = definition.match(LOCAL_REGEXP) || [],\r\n attrName = match[3] || scopeName,\r\n optional = (match[2] == '?'),\r\n mode = match[1], // @, =, or &\r\n lastValue,\r\n parentGet, parentSet, compare;\r\n\r\n isolateScope.$$isolateBindings[scopeName] = mode + attrName;\r\n\r\n switch (mode) {\r\n\r\n case '@':\r\n attrs.$observe(attrName, function(value) {\r\n isolateScope[scopeName] = value;\r\n });\r\n attrs.$$observers[attrName].$$scope = scope;\r\n if( attrs[attrName] ) {\r\n // If the attribute has been provided then we trigger an interpolation to ensure\r\n // the value is there for use in the link fn\r\n isolateScope[scopeName] = $interpolate(attrs[attrName])(scope);\r\n }\r\n break;\r\n\r\n case '=':\r\n if (optional && !attrs[attrName]) {\r\n return;\r\n }\r\n parentGet = $parse(attrs[attrName]);\r\n if (parentGet.literal) {\r\n compare = equals;\r\n } else {\r\n compare = function(a,b) { return a === b || (a !== a && b !== b); };\r\n }\r\n parentSet = parentGet.assign || function() {\r\n // reset the change, or we will throw this exception on every $digest\r\n lastValue = isolateScope[scopeName] = parentGet(scope);\r\n throw $compileMinErr('nonassign',\r\n \"Expression '{0}' used with directive '{1}' is non-assignable!\",\r\n attrs[attrName], newIsolateScopeDirective.name);\r\n };\r\n lastValue = isolateScope[scopeName] = parentGet(scope);\r\n isolateScope.$watch(function parentValueWatch() {\r\n var parentValue = parentGet(scope);\r\n if (!compare(parentValue, isolateScope[scopeName])) {\r\n // we are out of sync and need to copy\r\n if (!compare(parentValue, lastValue)) {\r\n // parent changed and it has precedence\r\n isolateScope[scopeName] = parentValue;\r\n } else {\r\n // if the parent can be assigned then do so\r\n parentSet(scope, parentValue = isolateScope[scopeName]);\r\n }\r\n }\r\n return lastValue = parentValue;\r\n }, null, parentGet.literal);\r\n break;\r\n\r\n case '&':\r\n parentGet = $parse(attrs[attrName]);\r\n isolateScope[scopeName] = function(locals) {\r\n return parentGet(scope, locals);\r\n };\r\n break;\r\n\r\n default:\r\n throw $compileMinErr('iscp',\r\n \"Invalid isolate scope definition for directive '{0}'.\" +\r\n \" Definition: {... {1}: '{2}' ...}\",\r\n newIsolateScopeDirective.name, scopeName, definition);\r\n }\r\n });\r\n }\r\n transcludeFn = boundTranscludeFn && controllersBoundTransclude;\r\n if (controllerDirectives) {\r\n forEach(controllerDirectives, function(directive) {\r\n var locals = {\r\n $scope: directive === newIsolateScopeDirective || directive.$$isolateScope ? isolateScope : scope,\r\n $element: $element,\r\n $attrs: attrs,\r\n $transclude: transcludeFn\r\n }, controllerInstance;\r\n\r\n controller = directive.controller;\r\n if (controller == '@') {\r\n controller = attrs[directive.name];\r\n }\r\n\r\n controllerInstance = $controller(controller, locals);\r\n // For directives with element transclusion the element is a comment,\r\n // but jQuery .data doesn't support attaching data to comment nodes as it's hard to\r\n // clean up (http://bugs.jquery.com/ticket/8335).\r\n // Instead, we save the controllers for the element in a local hash and attach to .data\r\n // later, once we have the actual element.\r\n elementControllers[directive.name] = controllerInstance;\r\n if (!hasElementTranscludeDirective) {\r\n $element.data('$' + directive.name + 'Controller', controllerInstance);\r\n }\r\n\r\n if (directive.controllerAs) {\r\n locals.$scope[directive.controllerAs] = controllerInstance;\r\n }\r\n });\r\n }\r\n\r\n // PRELINKING\r\n for(i = 0, ii = preLinkFns.length; i < ii; i++) {\r\n try {\r\n linkFn = preLinkFns[i];\r\n linkFn(linkFn.isolateScope ? isolateScope : scope, $element, attrs,\r\n linkFn.require && getControllers(linkFn.directiveName, linkFn.require, $element, elementControllers), transcludeFn);\r\n } catch (e) {\r\n $exceptionHandler(e, startingTag($element));\r\n }\r\n }\r\n\r\n // RECURSION\r\n // We only pass the isolate scope, if the isolate directive has a template,\r\n // otherwise the child elements do not belong to the isolate directive.\r\n var scopeToChild = scope;\r\n if (newIsolateScopeDirective && (newIsolateScopeDirective.template || newIsolateScopeDirective.templateUrl === null)) {\r\n scopeToChild = isolateScope;\r\n }\r\n childLinkFn && childLinkFn(scopeToChild, linkNode.childNodes, undefined, boundTranscludeFn);\r\n\r\n // POSTLINKING\r\n for(i = postLinkFns.length - 1; i >= 0; i--) {\r\n try {\r\n linkFn = postLinkFns[i];\r\n linkFn(linkFn.isolateScope ? isolateScope : scope, $element, attrs,\r\n linkFn.require && getControllers(linkFn.directiveName, linkFn.require, $element, elementControllers), transcludeFn);\r\n } catch (e) {\r\n $exceptionHandler(e, startingTag($element));\r\n }\r\n }\r\n\r\n // This is the function that is injected as `$transclude`.\r\n function controllersBoundTransclude(scope, cloneAttachFn) {\r\n var transcludeControllers;\r\n\r\n // no scope passed\r\n if (arguments.length < 2) {\r\n cloneAttachFn = scope;\r\n scope = undefined;\r\n }\r\n\r\n if (hasElementTranscludeDirective) {\r\n transcludeControllers = elementControllers;\r\n }\r\n\r\n return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers);\r\n }\r\n }\r\n }\r\n\r\n function markDirectivesAsIsolate(directives) {\r\n // mark all directives as needing isolate scope.\r\n for (var j = 0, jj = directives.length; j < jj; j++) {\r\n directives[j] = inherit(directives[j], {$$isolateScope: true});\r\n }\r\n }\r\n\r\n /**\r\n * looks up the directive and decorates it with exception handling and proper parameters. We\r\n * call this the boundDirective.\r\n *\r\n * @param {string} name name of the directive to look up.\r\n * @param {string} location The directive must be found in specific format.\r\n * String containing any of theses characters:\r\n *\r\n * * `E`: element name\r\n * * `A': attribute\r\n * * `C`: class\r\n * * `M`: comment\r\n * @returns {boolean} true if directive was added.\r\n */\r\n function addDirective(tDirectives, name, location, maxPriority, ignoreDirective, startAttrName,\r\n endAttrName) {\r\n if (name === ignoreDirective) return null;\r\n var match = null;\r\n if (hasDirectives.hasOwnProperty(name)) {\r\n for(var directive, directives = $injector.get(name + Suffix),\r\n i = 0, ii = directives.length; i directive.priority) &&\r\n directive.restrict.indexOf(location) != -1) {\r\n if (startAttrName) {\r\n directive = inherit(directive, {$$start: startAttrName, $$end: endAttrName});\r\n }\r\n tDirectives.push(directive);\r\n match = directive;\r\n }\r\n } catch(e) { $exceptionHandler(e); }\r\n }\r\n }\r\n return match;\r\n }\r\n\r\n\r\n /**\r\n * When the element is replaced with HTML template then the new attributes\r\n * on the template need to be merged with the existing attributes in the DOM.\r\n * The desired effect is to have both of the attributes present.\r\n *\r\n * @param {object} dst destination attributes (original DOM)\r\n * @param {object} src source attributes (from the directive template)\r\n */\r\n function mergeTemplateAttributes(dst, src) {\r\n var srcAttr = src.$attr,\r\n dstAttr = dst.$attr,\r\n $element = dst.$$element;\r\n\r\n // reapply the old attributes to the new element\r\n forEach(dst, function(value, key) {\r\n if (key.charAt(0) != '$') {\r\n if (src[key] && src[key] !== value) {\r\n value += (key === 'style' ? ';' : ' ') + src[key];\r\n }\r\n dst.$set(key, value, true, srcAttr[key]);\r\n }\r\n });\r\n\r\n // copy the new attributes on the old attrs object\r\n forEach(src, function(value, key) {\r\n if (key == 'class') {\r\n safeAddClass($element, value);\r\n dst['class'] = (dst['class'] ? dst['class'] + ' ' : '') + value;\r\n } else if (key == 'style') {\r\n $element.attr('style', $element.attr('style') + ';' + value);\r\n dst['style'] = (dst['style'] ? dst['style'] + ';' : '') + value;\r\n // `dst` will never contain hasOwnProperty as DOM parser won't let it.\r\n // You will get an \"InvalidCharacterError: DOM Exception 5\" error if you\r\n // have an attribute like \"has-own-property\" or \"data-has-own-property\", etc.\r\n } else if (key.charAt(0) != '$' && !dst.hasOwnProperty(key)) {\r\n dst[key] = value;\r\n dstAttr[key] = srcAttr[key];\r\n }\r\n });\r\n }\r\n\r\n\r\n function compileTemplateUrl(directives, $compileNode, tAttrs,\r\n $rootElement, childTranscludeFn, preLinkFns, postLinkFns, previousCompileContext) {\r\n var linkQueue = [],\r\n afterTemplateNodeLinkFn,\r\n afterTemplateChildLinkFn,\r\n beforeTemplateCompileNode = $compileNode[0],\r\n origAsyncDirective = directives.shift(),\r\n // The fact that we have to copy and patch the directive seems wrong!\r\n derivedSyncDirective = extend({}, origAsyncDirective, {\r\n templateUrl: null, transclude: null, replace: null, $$originalDirective: origAsyncDirective\r\n }),\r\n templateUrl = (isFunction(origAsyncDirective.templateUrl))\r\n ? origAsyncDirective.templateUrl($compileNode, tAttrs)\r\n : origAsyncDirective.templateUrl;\r\n\r\n $compileNode.empty();\r\n\r\n $http.get($sce.getTrustedResourceUrl(templateUrl), {cache: $templateCache}).\r\n success(function(content) {\r\n var compileNode, tempTemplateAttrs, $template, childBoundTranscludeFn;\r\n\r\n content = denormalizeTemplate(content);\r\n\r\n if (origAsyncDirective.replace) {\r\n if (jqLiteIsTextNode(content)) {\r\n $template = [];\r\n } else {\r\n $template = jqLite(trim(content));\r\n }\r\n compileNode = $template[0];\r\n\r\n if ($template.length != 1 || compileNode.nodeType !== 1) {\r\n throw $compileMinErr('tplrt',\r\n \"Template for directive '{0}' must have exactly one root element. {1}\",\r\n origAsyncDirective.name, templateUrl);\r\n }\r\n\r\n tempTemplateAttrs = {$attr: {}};\r\n replaceWith($rootElement, $compileNode, compileNode);\r\n var templateDirectives = collectDirectives(compileNode, [], tempTemplateAttrs);\r\n\r\n if (isObject(origAsyncDirective.scope)) {\r\n markDirectivesAsIsolate(templateDirectives);\r\n }\r\n directives = templateDirectives.concat(directives);\r\n mergeTemplateAttributes(tAttrs, tempTemplateAttrs);\r\n } else {\r\n compileNode = beforeTemplateCompileNode;\r\n $compileNode.html(content);\r\n }\r\n\r\n directives.unshift(derivedSyncDirective);\r\n\r\n afterTemplateNodeLinkFn = applyDirectivesToNode(directives, compileNode, tAttrs,\r\n childTranscludeFn, $compileNode, origAsyncDirective, preLinkFns, postLinkFns,\r\n previousCompileContext);\r\n forEach($rootElement, function(node, i) {\r\n if (node == compileNode) {\r\n $rootElement[i] = $compileNode[0];\r\n }\r\n });\r\n afterTemplateChildLinkFn = compileNodes($compileNode[0].childNodes, childTranscludeFn);\r\n\r\n while(linkQueue.length) {\r\n var scope = linkQueue.shift(),\r\n beforeTemplateLinkNode = linkQueue.shift(),\r\n linkRootElement = linkQueue.shift(),\r\n boundTranscludeFn = linkQueue.shift(),\r\n linkNode = $compileNode[0];\r\n\r\n if (beforeTemplateLinkNode !== beforeTemplateCompileNode) {\r\n var oldClasses = beforeTemplateLinkNode.className;\r\n\r\n if (!(previousCompileContext.hasElementTranscludeDirective &&\r\n origAsyncDirective.replace)) {\r\n // it was cloned therefore we have to clone as well.\r\n linkNode = jqLiteClone(compileNode);\r\n }\r\n\r\n replaceWith(linkRootElement, jqLite(beforeTemplateLinkNode), linkNode);\r\n\r\n // Copy in CSS classes from original node\r\n safeAddClass(jqLite(linkNode), oldClasses);\r\n }\r\n if (afterTemplateNodeLinkFn.transcludeOnThisElement) {\r\n childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn);\r\n } else {\r\n childBoundTranscludeFn = boundTranscludeFn;\r\n }\r\n afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, linkNode, $rootElement,\r\n childBoundTranscludeFn);\r\n }\r\n linkQueue = null;\r\n }).\r\n error(function(response, code, headers, config) {\r\n throw $compileMinErr('tpload', 'Failed to load template: {0}', config.url);\r\n });\r\n\r\n return function delayedNodeLinkFn(ignoreChildLinkFn, scope, node, rootElement, boundTranscludeFn) {\r\n var childBoundTranscludeFn = boundTranscludeFn;\r\n if (linkQueue) {\r\n linkQueue.push(scope);\r\n linkQueue.push(node);\r\n linkQueue.push(rootElement);\r\n linkQueue.push(childBoundTranscludeFn);\r\n } else {\r\n if (afterTemplateNodeLinkFn.transcludeOnThisElement) {\r\n childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn);\r\n }\r\n afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, childBoundTranscludeFn);\r\n }\r\n };\r\n }\r\n\r\n\r\n /**\r\n * Sorting function for bound directives.\r\n */\r\n function byPriority(a, b) {\r\n var diff = b.priority - a.priority;\r\n if (diff !== 0) return diff;\r\n if (a.name !== b.name) return (a.name < b.name) ? -1 : 1;\r\n return a.index - b.index;\r\n }\r\n\r\n\r\n function assertNoDuplicate(what, previousDirective, directive, element) {\r\n if (previousDirective) {\r\n throw $compileMinErr('multidir', 'Multiple directives [{0}, {1}] asking for {2} on: {3}',\r\n previousDirective.name, directive.name, what, startingTag(element));\r\n }\r\n }\r\n\r\n\r\n function addTextInterpolateDirective(directives, text) {\r\n var interpolateFn = $interpolate(text, true);\r\n if (interpolateFn) {\r\n directives.push({\r\n priority: 0,\r\n compile: function textInterpolateCompileFn(templateNode) {\r\n // when transcluding a template that has bindings in the root\r\n // then we don't have a parent and should do this in the linkFn\r\n var parent = templateNode.parent(), hasCompileParent = parent.length;\r\n if (hasCompileParent) safeAddClass(templateNode.parent(), 'ng-binding');\r\n\r\n return function textInterpolateLinkFn(scope, node) {\r\n var parent = node.parent(),\r\n bindings = parent.data('$binding') || [];\r\n bindings.push(interpolateFn);\r\n parent.data('$binding', bindings);\r\n if (!hasCompileParent) safeAddClass(parent, 'ng-binding');\r\n scope.$watch(interpolateFn, function interpolateFnWatchAction(value) {\r\n node[0].nodeValue = value;\r\n });\r\n };\r\n }\r\n });\r\n }\r\n }\r\n\r\n\r\n function getTrustedContext(node, attrNormalizedName) {\r\n if (attrNormalizedName == \"srcdoc\") {\r\n return $sce.HTML;\r\n }\r\n var tag = nodeName_(node);\r\n // maction[xlink:href] can source SVG. It's not limited to .\r\n if (attrNormalizedName == \"xlinkHref\" ||\r\n (tag == \"FORM\" && attrNormalizedName == \"action\") ||\r\n (tag != \"IMG\" && (attrNormalizedName == \"src\" ||\r\n attrNormalizedName == \"ngSrc\"))) {\r\n return $sce.RESOURCE_URL;\r\n }\r\n }\r\n\r\n\r\n function addAttrInterpolateDirective(node, directives, value, name) {\r\n var interpolateFn = $interpolate(value, true);\r\n\r\n // no interpolation found -> ignore\r\n if (!interpolateFn) return;\r\n\r\n\r\n if (name === \"multiple\" && nodeName_(node) === \"SELECT\") {\r\n throw $compileMinErr(\"selmulti\",\r\n \"Binding to the 'multiple' attribute is not supported. Element: {0}\",\r\n startingTag(node));\r\n }\r\n\r\n directives.push({\r\n priority: 100,\r\n compile: function() {\r\n return {\r\n pre: function attrInterpolatePreLinkFn(scope, element, attr) {\r\n var $$observers = (attr.$$observers || (attr.$$observers = {}));\r\n\r\n if (EVENT_HANDLER_ATTR_REGEXP.test(name)) {\r\n throw $compileMinErr('nodomevents',\r\n \"Interpolations for HTML DOM event attributes are disallowed. Please use the \" +\r\n \"ng- versions (such as ng-click instead of onclick) instead.\");\r\n }\r\n\r\n // we need to interpolate again, in case the attribute value has been updated\r\n // (e.g. by another directive's compile function)\r\n interpolateFn = $interpolate(attr[name], true, getTrustedContext(node, name));\r\n\r\n // if attribute was updated so that there is no interpolation going on we don't want to\r\n // register any observers\r\n if (!interpolateFn) return;\r\n\r\n // TODO(i): this should likely be attr.$set(name, iterpolateFn(scope) so that we reset the\r\n // actual attr value\r\n attr[name] = interpolateFn(scope);\r\n ($$observers[name] || ($$observers[name] = [])).$$inter = true;\r\n (attr.$$observers && attr.$$observers[name].$$scope || scope).\r\n $watch(interpolateFn, function interpolateFnWatchAction(newValue, oldValue) {\r\n //special case for class attribute addition + removal\r\n //so that class changes can tap into the animation\r\n //hooks provided by the $animate service. Be sure to\r\n //skip animations when the first digest occurs (when\r\n //both the new and the old values are the same) since\r\n //the CSS classes are the non-interpolated values\r\n if(name === 'class' && newValue != oldValue) {\r\n attr.$updateClass(newValue, oldValue);\r\n } else {\r\n attr.$set(name, newValue);\r\n }\r\n });\r\n }\r\n };\r\n }\r\n });\r\n }\r\n\r\n\r\n /**\r\n * This is a special jqLite.replaceWith, which can replace items which\r\n * have no parents, provided that the containing jqLite collection is provided.\r\n *\r\n * @param {JqLite=} $rootElement The root of the compile tree. Used so that we can replace nodes\r\n * in the root of the tree.\r\n * @param {JqLite} elementsToRemove The jqLite element which we are going to replace. We keep\r\n * the shell, but replace its DOM node reference.\r\n * @param {Node} newNode The new DOM node.\r\n */\r\n function replaceWith($rootElement, elementsToRemove, newNode) {\r\n var firstElementToRemove = elementsToRemove[0],\r\n removeCount = elementsToRemove.length,\r\n parent = firstElementToRemove.parentNode,\r\n i, ii;\r\n\r\n if ($rootElement) {\r\n for(i = 0, ii = $rootElement.length; i < ii; i++) {\r\n if ($rootElement[i] == firstElementToRemove) {\r\n $rootElement[i++] = newNode;\r\n for (var j = i, j2 = j + removeCount - 1,\r\n jj = $rootElement.length;\r\n j < jj; j++, j2++) {\r\n if (j2 < jj) {\r\n $rootElement[j] = $rootElement[j2];\r\n } else {\r\n delete $rootElement[j];\r\n }\r\n }\r\n $rootElement.length -= removeCount - 1;\r\n break;\r\n }\r\n }\r\n }\r\n\r\n if (parent) {\r\n parent.replaceChild(newNode, firstElementToRemove);\r\n }\r\n var fragment = document.createDocumentFragment();\r\n fragment.appendChild(firstElementToRemove);\r\n newNode[jqLite.expando] = firstElementToRemove[jqLite.expando];\r\n for (var k = 1, kk = elementsToRemove.length; k < kk; k++) {\r\n var element = elementsToRemove[k];\r\n jqLite(element).remove(); // must do this way to clean up expando\r\n fragment.appendChild(element);\r\n delete elementsToRemove[k];\r\n }\r\n\r\n elementsToRemove[0] = newNode;\r\n elementsToRemove.length = 1;\r\n }\r\n\r\n\r\n function cloneAndAnnotateFn(fn, annotation) {\r\n return extend(function() { return fn.apply(null, arguments); }, fn, annotation);\r\n }\r\n }];\r\n}\r\n\r\nvar PREFIX_REGEXP = /^(x[\\:\\-_]|data[\\:\\-_])/i;\r\n/**\r\n * Converts all accepted directives format into proper directive name.\r\n * All of these will become 'myDirective':\r\n * my:Directive\r\n * my-directive\r\n * x-my-directive\r\n * data-my:directive\r\n *\r\n * Also there is special case for Moz prefix starting with upper case letter.\r\n * @param name Name to normalize\r\n */\r\nfunction directiveNormalize(name) {\r\n return camelCase(name.replace(PREFIX_REGEXP, ''));\r\n}\r\n\r\n/**\r\n * @ngdoc type\r\n * @name $compile.directive.Attributes\r\n *\r\n * @description\r\n * A shared object between directive compile / linking functions which contains normalized DOM\r\n * element attributes. The values reflect current binding state `{{ }}`. The normalization is\r\n * needed since all of these are treated as equivalent in Angular:\r\n *\r\n * ```\r\n * \r\n * ```\r\n */\r\n\r\n/**\r\n * @ngdoc property\r\n * @name $compile.directive.Attributes#$attr\r\n *\r\n * @description\r\n * A map of DOM element attribute names to the normalized name. This is\r\n * needed to do reverse lookup from normalized name back to actual name.\r\n */\r\n\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $compile.directive.Attributes#$set\r\n * @kind function\r\n *\r\n * @description\r\n * Set DOM element attribute value.\r\n *\r\n *\r\n * @param {string} name Normalized element attribute name of the property to modify. The name is\r\n * reverse-translated using the {@link ng.$compile.directive.Attributes#$attr $attr}\r\n * property to the original name.\r\n * @param {string} value Value to set the attribute to. The value can be an interpolated string.\r\n */\r\n\r\n\r\n\r\n/**\r\n * Closure compiler type information\r\n */\r\n\r\nfunction nodesetLinkingFn(\r\n /* angular.Scope */ scope,\r\n /* NodeList */ nodeList,\r\n /* Element */ rootElement,\r\n /* function(Function) */ boundTranscludeFn\r\n){}\r\n\r\nfunction directiveLinkingFn(\r\n /* nodesetLinkingFn */ nodesetLinkingFn,\r\n /* angular.Scope */ scope,\r\n /* Node */ node,\r\n /* Element */ rootElement,\r\n /* function(Function) */ boundTranscludeFn\r\n){}\r\n\r\nfunction tokenDifference(str1, str2) {\r\n var values = '',\r\n tokens1 = str1.split(/\\s+/),\r\n tokens2 = str2.split(/\\s+/);\r\n\r\n outer:\r\n for(var i = 0; i < tokens1.length; i++) {\r\n var token = tokens1[i];\r\n for(var j = 0; j < tokens2.length; j++) {\r\n if(token == tokens2[j]) continue outer;\r\n }\r\n values += (values.length > 0 ? ' ' : '') + token;\r\n }\r\n return values;\r\n}\r\n\r\n/**\r\n * @ngdoc provider\r\n * @name $controllerProvider\r\n * @description\r\n * The {@link ng.$controller $controller service} is used by Angular to create new\r\n * controllers.\r\n *\r\n * This provider allows controller registration via the\r\n * {@link ng.$controllerProvider#register register} method.\r\n */\r\nfunction $ControllerProvider() {\r\n var controllers = {},\r\n CNTRL_REG = /^(\\S+)(\\s+as\\s+(\\w+))?$/;\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $controllerProvider#register\r\n * @param {string|Object} name Controller name, or an object map of controllers where the keys are\r\n * the names and the values are the constructors.\r\n * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI\r\n * annotations in the array notation).\r\n */\r\n this.register = function(name, constructor) {\r\n assertNotHasOwnProperty(name, 'controller');\r\n if (isObject(name)) {\r\n extend(controllers, name);\r\n } else {\r\n controllers[name] = constructor;\r\n }\r\n };\r\n\r\n\r\n this.$get = ['$injector', '$window', function($injector, $window) {\r\n\r\n /**\r\n * @ngdoc service\r\n * @name $controller\r\n * @requires $injector\r\n *\r\n * @param {Function|string} constructor If called with a function then it's considered to be the\r\n * controller constructor function. Otherwise it's considered to be a string which is used\r\n * to retrieve the controller constructor using the following steps:\r\n *\r\n * * check if a controller with given name is registered via `$controllerProvider`\r\n * * check if evaluating the string on the current scope returns a constructor\r\n * * check `window[constructor]` on the global `window` object\r\n *\r\n * @param {Object} locals Injection locals for Controller.\r\n * @return {Object} Instance of given controller.\r\n *\r\n * @description\r\n * `$controller` service is responsible for instantiating controllers.\r\n *\r\n * It's just a simple call to {@link auto.$injector $injector}, but extracted into\r\n * a service, so that one can override this service with [BC version](https://gist.github.com/1649788).\r\n */\r\n return function(expression, locals) {\r\n var instance, match, constructor, identifier;\r\n\r\n if(isString(expression)) {\r\n match = expression.match(CNTRL_REG),\r\n constructor = match[1],\r\n identifier = match[3];\r\n expression = controllers.hasOwnProperty(constructor)\r\n ? controllers[constructor]\r\n : getter(locals.$scope, constructor, true) || getter($window, constructor, true);\r\n\r\n assertArgFn(expression, constructor, true);\r\n }\r\n\r\n instance = $injector.instantiate(expression, locals);\r\n\r\n if (identifier) {\r\n if (!(locals && typeof locals.$scope === 'object')) {\r\n throw minErr('$controller')('noscp',\r\n \"Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.\",\r\n constructor || expression.name, identifier);\r\n }\r\n\r\n locals.$scope[identifier] = instance;\r\n }\r\n\r\n return instance;\r\n };\r\n }];\r\n}\r\n\r\n/**\r\n * @ngdoc service\r\n * @name $document\r\n * @requires $window\r\n *\r\n * @description\r\n * A {@link angular.element jQuery or jqLite} wrapper for the browser's `window.document` object.\r\n *\r\n * @example\r\n \r\n \r\n \r\n \r\n angular.module('documentExample', [])\r\n .controller('ExampleController', ['$scope', '$document', function($scope, $document) {\r\n $scope.title = $document[0].title;\r\n $scope.windowTitle = angular.element(window.document)[0].title;\r\n }]);\r\n \r\n \r\n */\r\nfunction $DocumentProvider(){\r\n this.$get = ['$window', function(window){\r\n return jqLite(window.document);\r\n }];\r\n}\r\n\r\n/**\r\n * @ngdoc service\r\n * @name $exceptionHandler\r\n * @requires ng.$log\r\n *\r\n * @description\r\n * Any uncaught exception in angular expressions is delegated to this service.\r\n * The default implementation simply delegates to `$log.error` which logs it into\r\n * the browser console.\r\n *\r\n * In unit tests, if `angular-mocks.js` is loaded, this service is overridden by\r\n * {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing.\r\n *\r\n * ## Example:\r\n *\r\n * ```js\r\n * angular.module('exceptionOverride', []).factory('$exceptionHandler', function () {\r\n * return function (exception, cause) {\r\n * exception.message += ' (caused by \"' + cause + '\")';\r\n * throw exception;\r\n * };\r\n * });\r\n * ```\r\n *\r\n * This example will override the normal action of `$exceptionHandler`, to make angular\r\n * exceptions fail hard when they happen, instead of just logging to the console.\r\n *\r\n * @param {Error} exception Exception associated with the error.\r\n * @param {string=} cause optional information about the context in which\r\n * the error was thrown.\r\n *\r\n */\r\nfunction $ExceptionHandlerProvider() {\r\n this.$get = ['$log', function($log) {\r\n return function(exception, cause) {\r\n $log.error.apply($log, arguments);\r\n };\r\n }];\r\n}\r\n\r\n/**\r\n * Parse headers into key value object\r\n *\r\n * @param {string} headers Raw headers as a string\r\n * @returns {Object} Parsed headers as key value object\r\n */\r\nfunction parseHeaders(headers) {\r\n var parsed = {}, key, val, i;\r\n\r\n if (!headers) return parsed;\r\n\r\n forEach(headers.split('\\n'), function(line) {\r\n i = line.indexOf(':');\r\n key = lowercase(trim(line.substr(0, i)));\r\n val = trim(line.substr(i + 1));\r\n\r\n if (key) {\r\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\r\n }\r\n });\r\n\r\n return parsed;\r\n}\r\n\r\n\r\n/**\r\n * Returns a function that provides access to parsed headers.\r\n *\r\n * Headers are lazy parsed when first requested.\r\n * @see parseHeaders\r\n *\r\n * @param {(string|Object)} headers Headers to provide access to.\r\n * @returns {function(string=)} Returns a getter function which if called with:\r\n *\r\n * - if called with single an argument returns a single header value or null\r\n * - if called with no arguments returns an object containing all headers.\r\n */\r\nfunction headersGetter(headers) {\r\n var headersObj = isObject(headers) ? headers : undefined;\r\n\r\n return function(name) {\r\n if (!headersObj) headersObj = parseHeaders(headers);\r\n\r\n if (name) {\r\n return headersObj[lowercase(name)] || null;\r\n }\r\n\r\n return headersObj;\r\n };\r\n}\r\n\r\n\r\n/**\r\n * Chain all given functions\r\n *\r\n * This function is used for both request and response transforming\r\n *\r\n * @param {*} data Data to transform.\r\n * @param {function(string=)} headers Http headers getter fn.\r\n * @param {(Function|Array.)} fns Function or an array of functions.\r\n * @returns {*} Transformed data.\r\n */\r\nfunction transformData(data, headers, fns) {\r\n if (isFunction(fns))\r\n return fns(data, headers);\r\n\r\n forEach(fns, function(fn) {\r\n data = fn(data, headers);\r\n });\r\n\r\n return data;\r\n}\r\n\r\n\r\nfunction isSuccess(status) {\r\n return 200 <= status && status < 300;\r\n}\r\n\r\n\r\n/**\r\n * @ngdoc provider\r\n * @name $httpProvider\r\n * @description\r\n * Use `$httpProvider` to change the default behavior of the {@link ng.$http $http} service.\r\n * */\r\nfunction $HttpProvider() {\r\n var JSON_START = /^\\s*(\\[|\\{[^\\{])/,\r\n JSON_END = /[\\}\\]]\\s*$/,\r\n PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/,\r\n CONTENT_TYPE_APPLICATION_JSON = {'Content-Type': 'application/json;charset=utf-8'};\r\n\r\n /**\r\n * @ngdoc property\r\n * @name $httpProvider#defaults\r\n * @description\r\n *\r\n * Object containing default values for all {@link ng.$http $http} requests.\r\n *\r\n * - **`defaults.xsrfCookieName`** - {string} - Name of cookie containing the XSRF token.\r\n * Defaults value is `'XSRF-TOKEN'`.\r\n *\r\n * - **`defaults.xsrfHeaderName`** - {string} - Name of HTTP header to populate with the\r\n * XSRF token. Defaults value is `'X-XSRF-TOKEN'`.\r\n *\r\n * - **`defaults.headers`** - {Object} - Default headers for all $http requests.\r\n * Refer to {@link ng.$http#setting-http-headers $http} for documentation on\r\n * setting default headers.\r\n * - **`defaults.headers.common`**\r\n * - **`defaults.headers.post`**\r\n * - **`defaults.headers.put`**\r\n * - **`defaults.headers.patch`**\r\n **/\r\n var defaults = this.defaults = {\r\n // transform incoming response data\r\n transformResponse: [function(data) {\r\n if (isString(data)) {\r\n // strip json vulnerability protection prefix\r\n data = data.replace(PROTECTION_PREFIX, '');\r\n if (JSON_START.test(data) && JSON_END.test(data))\r\n data = fromJson(data);\r\n }\r\n return data;\r\n }],\r\n\r\n // transform outgoing request data\r\n transformRequest: [function(d) {\r\n return isObject(d) && !isFile(d) && !isBlob(d) ? toJson(d) : d;\r\n }],\r\n\r\n // default headers\r\n headers: {\r\n common: {\r\n 'Accept': 'application/json, text/plain, */*'\r\n },\r\n post: shallowCopy(CONTENT_TYPE_APPLICATION_JSON),\r\n put: shallowCopy(CONTENT_TYPE_APPLICATION_JSON),\r\n patch: shallowCopy(CONTENT_TYPE_APPLICATION_JSON)\r\n },\r\n\r\n xsrfCookieName: 'XSRF-TOKEN',\r\n xsrfHeaderName: 'X-XSRF-TOKEN'\r\n };\r\n\r\n /**\r\n * @ngdoc property\r\n * @name $httpProvider#interceptors\r\n * @description\r\n *\r\n * Array containing service factories for all synchronous or asynchronous {@link ng.$http $http}\r\n * pre-processing of request or postprocessing of responses.\r\n *\r\n * These service factories are ordered by request, i.e. they are applied in the same order as the\r\n * array, on request, but reverse order, on response.\r\n *\r\n * {@link ng.$http#interceptors Interceptors detailed info}\r\n **/\r\n var interceptorFactories = this.interceptors = [];\r\n\r\n /**\r\n * For historical reasons, response interceptors are ordered by the order in which\r\n * they are applied to the response. (This is the opposite of interceptorFactories)\r\n */\r\n var responseInterceptorFactories = this.responseInterceptors = [];\r\n\r\n this.$get = ['$httpBackend', '$browser', '$cacheFactory', '$rootScope', '$q', '$injector',\r\n function($httpBackend, $browser, $cacheFactory, $rootScope, $q, $injector) {\r\n\r\n var defaultCache = $cacheFactory('$http');\r\n\r\n /**\r\n * Interceptors stored in reverse order. Inner interceptors before outer interceptors.\r\n * The reversal is needed so that we can build up the interception chain around the\r\n * server request.\r\n */\r\n var reversedInterceptors = [];\r\n\r\n forEach(interceptorFactories, function(interceptorFactory) {\r\n reversedInterceptors.unshift(isString(interceptorFactory)\r\n ? $injector.get(interceptorFactory) : $injector.invoke(interceptorFactory));\r\n });\r\n\r\n forEach(responseInterceptorFactories, function(interceptorFactory, index) {\r\n var responseFn = isString(interceptorFactory)\r\n ? $injector.get(interceptorFactory)\r\n : $injector.invoke(interceptorFactory);\r\n\r\n /**\r\n * Response interceptors go before \"around\" interceptors (no real reason, just\r\n * had to pick one.) But they are already reversed, so we can't use unshift, hence\r\n * the splice.\r\n */\r\n reversedInterceptors.splice(index, 0, {\r\n response: function(response) {\r\n return responseFn($q.when(response));\r\n },\r\n responseError: function(response) {\r\n return responseFn($q.reject(response));\r\n }\r\n });\r\n });\r\n\r\n\r\n /**\r\n * @ngdoc service\r\n * @kind function\r\n * @name $http\r\n * @requires ng.$httpBackend\r\n * @requires $cacheFactory\r\n * @requires $rootScope\r\n * @requires $q\r\n * @requires $injector\r\n *\r\n * @description\r\n * The `$http` service is a core Angular service that facilitates communication with the remote\r\n * HTTP servers via the browser's [XMLHttpRequest](https://developer.mozilla.org/en/xmlhttprequest)\r\n * object or via [JSONP](http://en.wikipedia.org/wiki/JSONP).\r\n *\r\n * For unit testing applications that use `$http` service, see\r\n * {@link ngMock.$httpBackend $httpBackend mock}.\r\n *\r\n * For a higher level of abstraction, please check out the {@link ngResource.$resource\r\n * $resource} service.\r\n *\r\n * The $http API is based on the {@link ng.$q deferred/promise APIs} exposed by\r\n * the $q service. While for simple usage patterns this doesn't matter much, for advanced usage\r\n * it is important to familiarize yourself with these APIs and the guarantees they provide.\r\n *\r\n *\r\n * # General usage\r\n * The `$http` service is a function which takes a single argument — a configuration object —\r\n * that is used to generate an HTTP request and returns a {@link ng.$q promise}\r\n * with two $http specific methods: `success` and `error`.\r\n *\r\n * ```js\r\n * $http({method: 'GET', url: '/someUrl'}).\r\n * success(function(data, status, headers, config) {\r\n * // this callback will be called asynchronously\r\n * // when the response is available\r\n * }).\r\n * error(function(data, status, headers, config) {\r\n * // called asynchronously if an error occurs\r\n * // or server returns response with an error status.\r\n * });\r\n * ```\r\n *\r\n * Since the returned value of calling the $http function is a `promise`, you can also use\r\n * the `then` method to register callbacks, and these callbacks will receive a single argument –\r\n * an object representing the response. See the API signature and type info below for more\r\n * details.\r\n *\r\n * A response status code between 200 and 299 is considered a success status and\r\n * will result in the success callback being called. Note that if the response is a redirect,\r\n * XMLHttpRequest will transparently follow it, meaning that the error callback will not be\r\n * called for such responses.\r\n *\r\n * # Writing Unit Tests that use $http\r\n * When unit testing (using {@link ngMock ngMock}), it is necessary to call\r\n * {@link ngMock.$httpBackend#flush $httpBackend.flush()} to flush each pending\r\n * request using trained responses.\r\n *\r\n * ```\r\n * $httpBackend.expectGET(...);\r\n * $http.get(...);\r\n * $httpBackend.flush();\r\n * ```\r\n *\r\n * # Shortcut methods\r\n *\r\n * Shortcut methods are also available. All shortcut methods require passing in the URL, and\r\n * request data must be passed in for POST/PUT requests.\r\n *\r\n * ```js\r\n * $http.get('/someUrl').success(successCallback);\r\n * $http.post('/someUrl', data).success(successCallback);\r\n * ```\r\n *\r\n * Complete list of shortcut methods:\r\n *\r\n * - {@link ng.$http#get $http.get}\r\n * - {@link ng.$http#head $http.head}\r\n * - {@link ng.$http#post $http.post}\r\n * - {@link ng.$http#put $http.put}\r\n * - {@link ng.$http#delete $http.delete}\r\n * - {@link ng.$http#jsonp $http.jsonp}\r\n * - {@link ng.$http#patch $http.patch}\r\n *\r\n *\r\n * # Setting HTTP Headers\r\n *\r\n * The $http service will automatically add certain HTTP headers to all requests. These defaults\r\n * can be fully configured by accessing the `$httpProvider.defaults.headers` configuration\r\n * object, which currently contains this default configuration:\r\n *\r\n * - `$httpProvider.defaults.headers.common` (headers that are common for all requests):\r\n * - `Accept: application/json, text/plain, * / *`\r\n * - `$httpProvider.defaults.headers.post`: (header defaults for POST requests)\r\n * - `Content-Type: application/json`\r\n * - `$httpProvider.defaults.headers.put` (header defaults for PUT requests)\r\n * - `Content-Type: application/json`\r\n *\r\n * To add or overwrite these defaults, simply add or remove a property from these configuration\r\n * objects. To add headers for an HTTP method other than POST or PUT, simply add a new object\r\n * with the lowercased HTTP method name as the key, e.g.\r\n * `$httpProvider.defaults.headers.get = { 'My-Header' : 'value' }.\r\n *\r\n * The defaults can also be set at runtime via the `$http.defaults` object in the same\r\n * fashion. For example:\r\n *\r\n * ```\r\n * module.run(function($http) {\r\n * $http.defaults.headers.common.Authorization = 'Basic YmVlcDpib29w'\r\n * });\r\n * ```\r\n *\r\n * In addition, you can supply a `headers` property in the config object passed when\r\n * calling `$http(config)`, which overrides the defaults without changing them globally.\r\n *\r\n *\r\n * # Transforming Requests and Responses\r\n *\r\n * Both requests and responses can be transformed using transform functions. By default, Angular\r\n * applies these transformations:\r\n *\r\n * Request transformations:\r\n *\r\n * - If the `data` property of the request configuration object contains an object, serialize it\r\n * into JSON format.\r\n *\r\n * Response transformations:\r\n *\r\n * - If XSRF prefix is detected, strip it (see Security Considerations section below).\r\n * - If JSON response is detected, deserialize it using a JSON parser.\r\n *\r\n * To globally augment or override the default transforms, modify the\r\n * `$httpProvider.defaults.transformRequest` and `$httpProvider.defaults.transformResponse`\r\n * properties. These properties are by default an array of transform functions, which allows you\r\n * to `push` or `unshift` a new transformation function into the transformation chain. You can\r\n * also decide to completely override any default transformations by assigning your\r\n * transformation functions to these properties directly without the array wrapper. These defaults\r\n * are again available on the $http factory at run-time, which may be useful if you have run-time\r\n * services you wish to be involved in your transformations.\r\n *\r\n * Similarly, to locally override the request/response transforms, augment the\r\n * `transformRequest` and/or `transformResponse` properties of the configuration object passed\r\n * into `$http`.\r\n *\r\n *\r\n * # Caching\r\n *\r\n * To enable caching, set the request configuration `cache` property to `true` (to use default\r\n * cache) or to a custom cache object (built with {@link ng.$cacheFactory `$cacheFactory`}).\r\n * When the cache is enabled, `$http` stores the response from the server in the specified\r\n * cache. The next time the same request is made, the response is served from the cache without\r\n * sending a request to the server.\r\n *\r\n * Note that even if the response is served from cache, delivery of the data is asynchronous in\r\n * the same way that real requests are.\r\n *\r\n * If there are multiple GET requests for the same URL that should be cached using the same\r\n * cache, but the cache is not populated yet, only one request to the server will be made and\r\n * the remaining requests will be fulfilled using the response from the first request.\r\n *\r\n * You can change the default cache to a new object (built with\r\n * {@link ng.$cacheFactory `$cacheFactory`}) by updating the\r\n * {@link ng.$http#properties_defaults `$http.defaults.cache`} property. All requests who set\r\n * their `cache` property to `true` will now use this cache object.\r\n *\r\n * If you set the default cache to `false` then only requests that specify their own custom\r\n * cache object will be cached.\r\n *\r\n * # Interceptors\r\n *\r\n * Before you start creating interceptors, be sure to understand the\r\n * {@link ng.$q $q and deferred/promise APIs}.\r\n *\r\n * For purposes of global error handling, authentication, or any kind of synchronous or\r\n * asynchronous pre-processing of request or postprocessing of responses, it is desirable to be\r\n * able to intercept requests before they are handed to the server and\r\n * responses before they are handed over to the application code that\r\n * initiated these requests. The interceptors leverage the {@link ng.$q\r\n * promise APIs} to fulfill this need for both synchronous and asynchronous pre-processing.\r\n *\r\n * The interceptors are service factories that are registered with the `$httpProvider` by\r\n * adding them to the `$httpProvider.interceptors` array. The factory is called and\r\n * injected with dependencies (if specified) and returns the interceptor.\r\n *\r\n * There are two kinds of interceptors (and two kinds of rejection interceptors):\r\n *\r\n * * `request`: interceptors get called with a http `config` object. The function is free to\r\n * modify the `config` object or create a new one. The function needs to return the `config`\r\n * object directly, or a promise containing the `config` or a new `config` object.\r\n * * `requestError`: interceptor gets called when a previous interceptor threw an error or\r\n * resolved with a rejection.\r\n * * `response`: interceptors get called with http `response` object. The function is free to\r\n * modify the `response` object or create a new one. The function needs to return the `response`\r\n * object directly, or as a promise containing the `response` or a new `response` object.\r\n * * `responseError`: interceptor gets called when a previous interceptor threw an error or\r\n * resolved with a rejection.\r\n *\r\n *\r\n * ```js\r\n * // register the interceptor as a service\r\n * $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {\r\n * return {\r\n * // optional method\r\n * 'request': function(config) {\r\n * // do something on success\r\n * return config;\r\n * },\r\n *\r\n * // optional method\r\n * 'requestError': function(rejection) {\r\n * // do something on error\r\n * if (canRecover(rejection)) {\r\n * return responseOrNewPromise\r\n * }\r\n * return $q.reject(rejection);\r\n * },\r\n *\r\n *\r\n *\r\n * // optional method\r\n * 'response': function(response) {\r\n * // do something on success\r\n * return response;\r\n * },\r\n *\r\n * // optional method\r\n * 'responseError': function(rejection) {\r\n * // do something on error\r\n * if (canRecover(rejection)) {\r\n * return responseOrNewPromise\r\n * }\r\n * return $q.reject(rejection);\r\n * }\r\n * };\r\n * });\r\n *\r\n * $httpProvider.interceptors.push('myHttpInterceptor');\r\n *\r\n *\r\n * // alternatively, register the interceptor via an anonymous factory\r\n * $httpProvider.interceptors.push(function($q, dependency1, dependency2) {\r\n * return {\r\n * 'request': function(config) {\r\n * // same as above\r\n * },\r\n *\r\n * 'response': function(response) {\r\n * // same as above\r\n * }\r\n * };\r\n * });\r\n * ```\r\n *\r\n * # Response interceptors (DEPRECATED)\r\n *\r\n * Before you start creating interceptors, be sure to understand the\r\n * {@link ng.$q $q and deferred/promise APIs}.\r\n *\r\n * For purposes of global error handling, authentication or any kind of synchronous or\r\n * asynchronous preprocessing of received responses, it is desirable to be able to intercept\r\n * responses for http requests before they are handed over to the application code that\r\n * initiated these requests. The response interceptors leverage the {@link ng.$q\r\n * promise apis} to fulfil this need for both synchronous and asynchronous preprocessing.\r\n *\r\n * The interceptors are service factories that are registered with the $httpProvider by\r\n * adding them to the `$httpProvider.responseInterceptors` array. The factory is called and\r\n * injected with dependencies (if specified) and returns the interceptor — a function that\r\n * takes a {@link ng.$q promise} and returns the original or a new promise.\r\n *\r\n * ```js\r\n * // register the interceptor as a service\r\n * $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {\r\n * return function(promise) {\r\n * return promise.then(function(response) {\r\n * // do something on success\r\n * return response;\r\n * }, function(response) {\r\n * // do something on error\r\n * if (canRecover(response)) {\r\n * return responseOrNewPromise\r\n * }\r\n * return $q.reject(response);\r\n * });\r\n * }\r\n * });\r\n *\r\n * $httpProvider.responseInterceptors.push('myHttpInterceptor');\r\n *\r\n *\r\n * // register the interceptor via an anonymous factory\r\n * $httpProvider.responseInterceptors.push(function($q, dependency1, dependency2) {\r\n * return function(promise) {\r\n * // same as above\r\n * }\r\n * });\r\n * ```\r\n *\r\n *\r\n * # Security Considerations\r\n *\r\n * When designing web applications, consider security threats from:\r\n *\r\n * - [JSON vulnerability](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx)\r\n * - [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery)\r\n *\r\n * Both server and the client must cooperate in order to eliminate these threats. Angular comes\r\n * pre-configured with strategies that address these issues, but for this to work backend server\r\n * cooperation is required.\r\n *\r\n * ## JSON Vulnerability Protection\r\n *\r\n * A [JSON vulnerability](http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx)\r\n * allows third party website to turn your JSON resource URL into\r\n * [JSONP](http://en.wikipedia.org/wiki/JSONP) request under some conditions. To\r\n * counter this your server can prefix all JSON requests with following string `\")]}',\\n\"`.\r\n * Angular will automatically strip the prefix before processing it as JSON.\r\n *\r\n * For example if your server needs to return:\r\n * ```js\r\n * ['one','two']\r\n * ```\r\n *\r\n * which is vulnerable to attack, your server can return:\r\n * ```js\r\n * )]}',\r\n * ['one','two']\r\n * ```\r\n *\r\n * Angular will strip the prefix, before processing the JSON.\r\n *\r\n *\r\n * ## Cross Site Request Forgery (XSRF) Protection\r\n *\r\n * [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery) is a technique by which\r\n * an unauthorized site can gain your user's private data. Angular provides a mechanism\r\n * to counter XSRF. When performing XHR requests, the $http service reads a token from a cookie\r\n * (by default, `XSRF-TOKEN`) and sets it as an HTTP header (`X-XSRF-TOKEN`). Since only\r\n * JavaScript that runs on your domain could read the cookie, your server can be assured that\r\n * the XHR came from JavaScript running on your domain. The header will not be set for\r\n * cross-domain requests.\r\n *\r\n * To take advantage of this, your server needs to set a token in a JavaScript readable session\r\n * cookie called `XSRF-TOKEN` on the first HTTP GET request. On subsequent XHR requests the\r\n * server can verify that the cookie matches `X-XSRF-TOKEN` HTTP header, and therefore be sure\r\n * that only JavaScript running on your domain could have sent the request. The token must be\r\n * unique for each user and must be verifiable by the server (to prevent the JavaScript from\r\n * making up its own tokens). We recommend that the token is a digest of your site's\r\n * authentication cookie with a [salt](https://en.wikipedia.org/wiki/Salt_(cryptography))\r\n * for added security.\r\n *\r\n * The name of the headers can be specified using the xsrfHeaderName and xsrfCookieName\r\n * properties of either $httpProvider.defaults at config-time, $http.defaults at run-time,\r\n * or the per-request config object.\r\n *\r\n *\r\n * @param {object} config Object describing the request to be made and how it should be\r\n * processed. The object has following properties:\r\n *\r\n * - **method** – `{string}` – HTTP method (e.g. 'GET', 'POST', etc)\r\n * - **url** – `{string}` – Absolute or relative URL of the resource that is being requested.\r\n * - **params** – `{Object.}` – Map of strings or objects which will be turned\r\n * to `?key1=value1&key2=value2` after the url. If the value is not a string, it will be\r\n * JSONified.\r\n * - **data** – `{string|Object}` – Data to be sent as the request message data.\r\n * - **headers** – `{Object}` – Map of strings or functions which return strings representing\r\n * HTTP headers to send to the server. If the return value of a function is null, the\r\n * header will not be sent.\r\n * - **xsrfHeaderName** – `{string}` – Name of HTTP header to populate with the XSRF token.\r\n * - **xsrfCookieName** – `{string}` – Name of cookie containing the XSRF token.\r\n * - **transformRequest** –\r\n * `{function(data, headersGetter)|Array.}` –\r\n * transform function or an array of such functions. The transform function takes the http\r\n * request body and headers and returns its transformed (typically serialized) version.\r\n * - **transformResponse** –\r\n * `{function(data, headersGetter)|Array.}` –\r\n * transform function or an array of such functions. The transform function takes the http\r\n * response body and headers and returns its transformed (typically deserialized) version.\r\n * - **cache** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the\r\n * GET request, otherwise if a cache instance built with\r\n * {@link ng.$cacheFactory $cacheFactory}, this cache will be used for\r\n * caching.\r\n * - **timeout** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise}\r\n * that should abort the request when resolved.\r\n * - **withCredentials** - `{boolean}` - whether to set the `withCredentials` flag on the\r\n * XHR object. See [requests with credentials](https://developer.mozilla.org/docs/Web/HTTP/Access_control_CORS#Requests_with_credentials)\r\n * for more information.\r\n * - **responseType** - `{string}` - see\r\n * [requestType](https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType).\r\n *\r\n * @returns {HttpPromise} Returns a {@link ng.$q promise} object with the\r\n * standard `then` method and two http specific methods: `success` and `error`. The `then`\r\n * method takes two arguments a success and an error callback which will be called with a\r\n * response object. The `success` and `error` methods take a single argument - a function that\r\n * will be called when the request succeeds or fails respectively. The arguments passed into\r\n * these functions are destructured representation of the response object passed into the\r\n * `then` method. The response object has these properties:\r\n *\r\n * - **data** – `{string|Object}` – The response body transformed with the transform\r\n * functions.\r\n * - **status** – `{number}` – HTTP status code of the response.\r\n * - **headers** – `{function([headerName])}` – Header getter function.\r\n * - **config** – `{Object}` – The configuration object that was used to generate the request.\r\n * - **statusText** – `{string}` – HTTP status text of the response.\r\n *\r\n * @property {Array.
\r\n *\r\n * @param {function()} fn A function that should be called repeatedly.\r\n * @param {number} delay Number of milliseconds between each function call.\r\n * @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat\r\n * indefinitely.\r\n * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise\r\n * will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.\r\n * @returns {promise} A promise which will be notified on each iteration.\r\n *\r\n * @example\r\n * \r\n I can add: {{a}} + {{b}} = {{ a+b }}\r\n
\r\n \r\n * \r\n *
\r\n *
\r\n * | {{heading}} | \r\n *
|---|
| {{fill}} | \r\n *
jqLite is a tiny, API-compatible subset of jQuery that allows\r\n * Angular to manipulate the DOM in a cross-browser compatible way. **jqLite** implements only the most\r\n * commonly needed functionality with the goal of having a very small footprint.
\r\n *\r\n * To use jQuery, simply load it before `DOMContentLoaded` event fired.\r\n *\r\n * **Note:** all element references in Angular are always wrapped with jQuery or\r\n * jqLite; they are never raw DOM references.
\r\n *\r\n * ## Angular's jqLite\r\n * jqLite provides only the following jQuery methods:\r\n *\r\n * - [`addClass()`](http://api.jquery.com/addClass/)\r\n * - [`after()`](http://api.jquery.com/after/)\r\n * - [`append()`](http://api.jquery.com/append/)\r\n * - [`attr()`](http://api.jquery.com/attr/)\r\n * - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData\r\n * - [`children()`](http://api.jquery.com/children/) - Does not support selectors\r\n * - [`clone()`](http://api.jquery.com/clone/)\r\n * - [`contents()`](http://api.jquery.com/contents/)\r\n * - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyles()`\r\n * - [`data()`](http://api.jquery.com/data/)\r\n * - [`empty()`](http://api.jquery.com/empty/)\r\n * - [`eq()`](http://api.jquery.com/eq/)\r\n * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name\r\n * - [`hasClass()`](http://api.jquery.com/hasClass/)\r\n * - [`html()`](http://api.jquery.com/html/)\r\n * - [`next()`](http://api.jquery.com/next/) - Does not support selectors\r\n * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData\r\n * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces or selectors\r\n * - [`one()`](http://api.jquery.com/one/) - Does not support namespaces or selectors\r\n * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors\r\n * - [`prepend()`](http://api.jquery.com/prepend/)\r\n * - [`prop()`](http://api.jquery.com/prop/)\r\n * - [`ready()`](http://api.jquery.com/ready/)\r\n * - [`remove()`](http://api.jquery.com/remove/)\r\n * - [`removeAttr()`](http://api.jquery.com/removeAttr/)\r\n * - [`removeClass()`](http://api.jquery.com/removeClass/)\r\n * - [`removeData()`](http://api.jquery.com/removeData/)\r\n * - [`replaceWith()`](http://api.jquery.com/replaceWith/)\r\n * - [`text()`](http://api.jquery.com/text/)\r\n * - [`toggleClass()`](http://api.jquery.com/toggleClass/)\r\n * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.\r\n * - [`unbind()`](http://api.jquery.com/unbind/) - Does not support namespaces\r\n * - [`val()`](http://api.jquery.com/val/)\r\n * - [`wrap()`](http://api.jquery.com/wrap/)\r\n *\r\n * ## jQuery/jqLite Extras\r\n * Angular also provides the following additional methods and events to both jQuery and jqLite:\r\n *\r\n * ### Events\r\n * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event\r\n * on all DOM nodes being removed. This can be used to clean up any 3rd party bindings to the DOM\r\n * element before it is removed.\r\n *\r\n * ### Methods\r\n * - `controller(name)` - retrieves the controller of the current element or its parent. By default\r\n * retrieves controller associated with the `ngController` directive. If `name` is provided as\r\n * camelCase directive name, then the controller for this directive will be retrieved (e.g.\r\n * `'ngModel'`).\r\n * - `injector()` - retrieves the injector of the current element or its parent.\r\n * - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current\r\n * element or its parent.\r\n * - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the\r\n * current element. This getter should be used only on elements that contain a directive which starts a new isolate\r\n * scope. Calling `scope()` on this element always returns the original non-isolate scope.\r\n * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top\r\n * parent element is reached.\r\n *\r\n * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.\r\n * @returns {Object} jQuery object.\r\n */\r\n\r\nJQLite.expando = 'ng339';\r\n\r\nvar jqCache = JQLite.cache = {},\r\n jqId = 1,\r\n addEventListenerFn = (window.document.addEventListener\r\n ? function(element, type, fn) {element.addEventListener(type, fn, false);}\r\n : function(element, type, fn) {element.attachEvent('on' + type, fn);}),\r\n removeEventListenerFn = (window.document.removeEventListener\r\n ? function(element, type, fn) {element.removeEventListener(type, fn, false); }\r\n : function(element, type, fn) {element.detachEvent('on' + type, fn); });\r\n\r\n/*\r\n * !!! This is an undocumented \"private\" function !!!\r\n */\r\nvar jqData = JQLite._data = function(node) {\r\n //jQuery always returns an object on cache miss\r\n return this.cache[node[this.expando]] || {};\r\n};\r\n\r\nfunction jqNextId() { return ++jqId; }\r\n\r\n\r\nvar SPECIAL_CHARS_REGEXP = /([\\:\\-\\_]+(.))/g;\r\nvar MOZ_HACK_REGEXP = /^moz([A-Z])/;\r\nvar jqLiteMinErr = minErr('jqLite');\r\n\r\n/**\r\n * Converts snake_case to camelCase.\r\n * Also there is special case for Moz prefix starting with upper case letter.\r\n * @param name Name to normalize\r\n */\r\nfunction camelCase(name) {\r\n return name.\r\n replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {\r\n return offset ? letter.toUpperCase() : letter;\r\n }).\r\n replace(MOZ_HACK_REGEXP, 'Moz$1');\r\n}\r\n\r\n/////////////////////////////////////////////\r\n// jQuery mutation patch\r\n//\r\n// In conjunction with bindJQuery intercepts all jQuery's DOM destruction apis and fires a\r\n// $destroy event on all DOM nodes being removed.\r\n//\r\n/////////////////////////////////////////////\r\n\r\nfunction jqLitePatchJQueryRemove(name, dispatchThis, filterElems, getterIfNoArguments) {\r\n var originalJqFn = jQuery.fn[name];\r\n originalJqFn = originalJqFn.$original || originalJqFn;\r\n removePatch.$original = originalJqFn;\r\n jQuery.fn[name] = removePatch;\r\n\r\n function removePatch(param) {\r\n // jshint -W040\r\n var list = filterElems && param ? [this.filter(param)] : [this],\r\n fireEvent = dispatchThis,\r\n set, setIndex, setLength,\r\n element, childIndex, childLength, children;\r\n\r\n if (!getterIfNoArguments || param != null) {\r\n while(list.length) {\r\n set = list.shift();\r\n for(setIndex = 0, setLength = set.length; setIndex < setLength; setIndex++) {\r\n element = jqLite(set[setIndex]);\r\n if (fireEvent) {\r\n element.triggerHandler('$destroy');\r\n } else {\r\n fireEvent = !fireEvent;\r\n }\r\n for(childIndex = 0, childLength = (children = element.children()).length;\r\n childIndex < childLength;\r\n childIndex++) {\r\n list.push(jQuery(children[childIndex]));\r\n }\r\n }\r\n }\r\n }\r\n return originalJqFn.apply(this, arguments);\r\n }\r\n}\r\n\r\nvar SINGLE_TAG_REGEXP = /^<(\\w+)\\s*\\/?>(?:<\\/\\1>|)$/;\r\nvar HTML_REGEXP = /<|&#?\\w+;/;\r\nvar TAG_NAME_REGEXP = /<([\\w:]+)/;\r\nvar XHTML_TAG_REGEXP = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\\w:]+)[^>]*)\\/>/gi;\r\n\r\nvar wrapMap = {\r\n 'option': [1, ''],\r\n\r\n 'thead': [1, '{{content.label}}
');\r\n * $(document.body).append($div);\r\n *\r\n * angular.element(document).injector().invoke(function($compile) {\r\n * var scope = angular.element($div).scope();\r\n * $compile($div)(scope);\r\n * });\r\n * ```\r\n */\r\n\r\n\r\n/**\r\n * @ngdoc module\r\n * @name auto\r\n * @description\r\n *\r\n * Implicit module which gets automatically added to each {@link auto.$injector $injector}.\r\n */\r\n\r\nvar FN_ARGS = /^function\\s*[^\\(]*\\(\\s*([^\\)]*)\\)/m;\r\nvar FN_ARG_SPLIT = /,/;\r\nvar FN_ARG = /^\\s*(_?)(\\S+?)\\1\\s*$/;\r\nvar STRIP_COMMENTS = /((\\/\\/.*$)|(\\/\\*[\\s\\S]*?\\*\\/))/mg;\r\nvar $injectorMinErr = minErr('$injector');\r\nfunction annotate(fn) {\r\n var $inject,\r\n fnText,\r\n argDecl,\r\n last;\r\n\r\n if (typeof fn === 'function') {\r\n if (!($inject = fn.$inject)) {\r\n $inject = [];\r\n if (fn.length) {\r\n fnText = fn.toString().replace(STRIP_COMMENTS, '');\r\n argDecl = fnText.match(FN_ARGS);\r\n forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg){\r\n arg.replace(FN_ARG, function(all, underscore, name){\r\n $inject.push(name);\r\n });\r\n });\r\n }\r\n fn.$inject = $inject;\r\n }\r\n } else if (isArray(fn)) {\r\n last = fn.length - 1;\r\n assertArgFn(fn[last], 'fn');\r\n $inject = fn.slice(0, last);\r\n } else {\r\n assertArgFn(fn, 'fn', true);\r\n }\r\n return $inject;\r\n}\r\n\r\n///////////////////////////////////////\r\n\r\n/**\r\n * @ngdoc service\r\n * @name $injector\r\n *\r\n * @description\r\n *\r\n * `$injector` is used to retrieve object instances as defined by\r\n * {@link auto.$provide provider}, instantiate types, invoke methods,\r\n * and load modules.\r\n *\r\n * The following always holds true:\r\n *\r\n * ```js\r\n * var $injector = angular.injector();\r\n * expect($injector.get('$injector')).toBe($injector);\r\n * expect($injector.invoke(function($injector){\r\n * return $injector;\r\n * })).toBe($injector);\r\n * ```\r\n *\r\n * # Injection Function Annotation\r\n *\r\n * JavaScript does not have annotations, and annotations are needed for dependency injection. The\r\n * following are all valid ways of annotating function with injection arguments and are equivalent.\r\n *\r\n * ```js\r\n * // inferred (only works if code not minified/obfuscated)\r\n * $injector.invoke(function(serviceA){});\r\n *\r\n * // annotated\r\n * function explicit(serviceA) {};\r\n * explicit.$inject = ['serviceA'];\r\n * $injector.invoke(explicit);\r\n *\r\n * // inline\r\n * $injector.invoke(['serviceA', function(serviceA){}]);\r\n * ```\r\n *\r\n * ## Inference\r\n *\r\n * In JavaScript calling `toString()` on a function returns the function definition. The definition\r\n * can then be parsed and the function arguments can be extracted. *NOTE:* This does not work with\r\n * minification, and obfuscation tools since these tools change the argument names.\r\n *\r\n * ## `$inject` Annotation\r\n * By adding an `$inject` property onto a function the injection parameters can be specified.\r\n *\r\n * ## Inline\r\n * As an array of injection names, where the last item in the array is the function to call.\r\n */\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $injector#get\r\n *\r\n * @description\r\n * Return an instance of the service.\r\n *\r\n * @param {string} name The name of the instance to retrieve.\r\n * @return {*} The instance.\r\n */\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $injector#invoke\r\n *\r\n * @description\r\n * Invoke the method and supply the method arguments from the `$injector`.\r\n *\r\n * @param {!Function} fn The function to invoke. Function parameters are injected according to the\r\n * {@link guide/di $inject Annotation} rules.\r\n * @param {Object=} self The `this` for the invoked method.\r\n * @param {Object=} locals Optional object. If preset then any argument names are read from this\r\n * object first, before the `$injector` is consulted.\r\n * @returns {*} the value returned by the invoked `fn` function.\r\n */\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $injector#has\r\n *\r\n * @description\r\n * Allows the user to query if the particular service exists.\r\n *\r\n * @param {string} name Name of the service to query.\r\n * @returns {boolean} `true` if injector has given service.\r\n */\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $injector#instantiate\r\n * @description\r\n * Create a new instance of JS type. The method takes a constructor function, invokes the new\r\n * operator, and supplies all of the arguments to the constructor function as specified by the\r\n * constructor annotation.\r\n *\r\n * @param {Function} Type Annotated constructor function.\r\n * @param {Object=} locals Optional object. If preset then any argument names are read from this\r\n * object first, before the `$injector` is consulted.\r\n * @returns {Object} new instance of `Type`.\r\n */\r\n\r\n/**\r\n * @ngdoc method\r\n * @name $injector#annotate\r\n *\r\n * @description\r\n * Returns an array of service names which the function is requesting for injection. This API is\r\n * used by the injector to determine which services need to be injected into the function when the\r\n * function is invoked. There are three ways in which the function can be annotated with the needed\r\n * dependencies.\r\n *\r\n * # Argument names\r\n *\r\n * The simplest form is to extract the dependencies from the arguments of the function. This is done\r\n * by converting the function into a string using `toString()` method and extracting the argument\r\n * names.\r\n * ```js\r\n * // Given\r\n * function MyController($scope, $route) {\r\n * // ...\r\n * }\r\n *\r\n * // Then\r\n * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);\r\n * ```\r\n *\r\n * This method does not work with code minification / obfuscation. For this reason the following\r\n * annotation strategies are supported.\r\n *\r\n * # The `$inject` property\r\n *\r\n * If a function has an `$inject` property and its value is an array of strings, then the strings\r\n * represent names of services to be injected into the function.\r\n * ```js\r\n * // Given\r\n * var MyController = function(obfuscatedScope, obfuscatedRoute) {\r\n * // ...\r\n * }\r\n * // Define function dependencies\r\n * MyController['$inject'] = ['$scope', '$route'];\r\n *\r\n * // Then\r\n * expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);\r\n * ```\r\n *\r\n * # The array notation\r\n *\r\n * It is often desirable to inline Injected functions and that's when setting the `$inject` property\r\n * is very inconvenient. In these situations using the array notation to specify the dependencies in\r\n * a way that survives minification is a better choice:\r\n *\r\n * ```js\r\n * // We wish to write this (not minification / obfuscation safe)\r\n * injector.invoke(function($compile, $rootScope) {\r\n * // ...\r\n * });\r\n *\r\n * // We are forced to write break inlining\r\n * var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {\r\n * // ...\r\n * };\r\n * tmpFn.$inject = ['$compile', '$rootScope'];\r\n * injector.invoke(tmpFn);\r\n *\r\n * // To better support inline function the inline annotation is supported\r\n * injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {\r\n * // ...\r\n * }]);\r\n *\r\n * // Therefore\r\n * expect(injector.annotate(\r\n * ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])\r\n * ).toEqual(['$compile', '$rootScope']);\r\n * ```\r\n *\r\n * @param {Function|Array.\r\n Go to bottom\r\n You're at the bottom!\r\n
\r\n \r\n * Use this method to disable automatic scrolling.\r\n *\r\n * If automatic scrolling is disabled, one must explicitly call\r\n * {@link ng.$anchorScroll $anchorScroll()} in order to scroll to the element related to the\r\n * current hash.\r\n */\r\n this.disableAutoScrolling = function() {\r\n autoScrollingEnabled = false;\r\n };\r\n\r\n this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) {\r\n var document = $window.document;\r\n\r\n // helper function to get first anchor from a NodeList\r\n // can't use filter.filter, as it accepts only instances of Array\r\n // and IE can't convert NodeList to an array using [].slice\r\n // TODO(vojta): use filter if we change it to accept lists as well\r\n function getFirstAnchor(list) {\r\n var result = null;\r\n forEach(list, function(element) {\r\n if (!result && lowercase(element.nodeName) === 'a') result = element;\r\n });\r\n return result;\r\n }\r\n\r\n function scroll() {\r\n var hash = $location.hash(), elm;\r\n\r\n // empty hash, scroll to the top of the page\r\n if (!hash) $window.scrollTo(0, 0);\r\n\r\n // element with given id\r\n else if ((elm = document.getElementById(hash))) elm.scrollIntoView();\r\n\r\n // first anchor with given name :-D\r\n else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) elm.scrollIntoView();\r\n\r\n // no element and hash == 'top', scroll to the top of the page\r\n else if (hash === 'top') $window.scrollTo(0, 0);\r\n }\r\n\r\n // does not scroll when user clicks on anchor link that is currently on\r\n // (no url change, no $location.hash() change), browser native does scroll\r\n if (autoScrollingEnabled) {\r\n $rootScope.$watch(function autoScrollWatch() {return $location.hash();},\r\n function autoScrollWatchAction() {\r\n $rootScope.$evalAsync(scroll);\r\n });\r\n }\r\n\r\n return scroll;\r\n }];\r\n}\r\n\r\nvar $animateMinErr = minErr('$animate');\r\n\r\n/**\r\n * @ngdoc provider\r\n * @name $animateProvider\r\n *\r\n * @description\r\n * Default implementation of $animate that doesn't perform any animations, instead just\r\n * synchronously performs DOM\r\n * updates and calls done() callbacks.\r\n *\r\n * In order to enable animations the ngAnimate module has to be loaded.\r\n *\r\n * To see the functional implementation check out src/ngAnimate/animate.js\r\n */\r\nvar $AnimateProvider = ['$provide', function($provide) {\r\n\r\n\r\n this.$$selectors = {};\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $animateProvider#register\r\n *\r\n * @description\r\n * Registers a new injectable animation factory function. The factory function produces the\r\n * animation object which contains callback functions for each event that is expected to be\r\n * animated.\r\n *\r\n * * `eventFn`: `function(Element, doneFunction)` The element to animate, the `doneFunction`\r\n * must be called once the element animation is complete. If a function is returned then the\r\n * animation service will use this function to cancel the animation whenever a cancel event is\r\n * triggered.\r\n *\r\n *\r\n * ```js\r\n * return {\r\n * eventFn : function(element, done) {\r\n * //code to run the animation\r\n * //once complete, then run done()\r\n * return function cancellationFunction() {\r\n * //code to cancel the animation\r\n * }\r\n * }\r\n * }\r\n * ```\r\n *\r\n * @param {string} name The name of the animation.\r\n * @param {Function} factory The factory function that will be executed to return the animation\r\n * object.\r\n */\r\n this.register = function(name, factory) {\r\n var key = name + '-animation';\r\n if (name && name.charAt(0) != '.') throw $animateMinErr('notcsel',\r\n \"Expecting class selector starting with '.' got '{0}'.\", name);\r\n this.$$selectors[name.substr(1)] = key;\r\n $provide.factory(key, factory);\r\n };\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $animateProvider#classNameFilter\r\n *\r\n * @description\r\n * Sets and/or returns the CSS class regular expression that is checked when performing\r\n * an animation. Upon bootstrap the classNameFilter value is not set at all and will\r\n * therefore enable $animate to attempt to perform an animation on any element.\r\n * When setting the classNameFilter value, animations will only be performed on elements\r\n * that successfully match the filter expression. This in turn can boost performance\r\n * for low-powered devices as well as applications containing a lot of structural operations.\r\n * @param {RegExp=} expression The className expression which will be checked against all animations\r\n * @return {RegExp} The current CSS className expression value. If null then there is no expression value\r\n */\r\n this.classNameFilter = function(expression) {\r\n if(arguments.length === 1) {\r\n this.$$classNameFilter = (expression instanceof RegExp) ? expression : null;\r\n }\r\n return this.$$classNameFilter;\r\n };\r\n\r\n this.$get = ['$timeout', '$$asyncCallback', function($timeout, $$asyncCallback) {\r\n\r\n function async(fn) {\r\n fn && $$asyncCallback(fn);\r\n }\r\n\r\n /**\r\n *\r\n * @ngdoc service\r\n * @name $animate\r\n * @description The $animate service provides rudimentary DOM manipulation functions to\r\n * insert, remove and move elements within the DOM, as well as adding and removing classes.\r\n * This service is the core service used by the ngAnimate $animator service which provides\r\n * high-level animation hooks for CSS and JavaScript.\r\n *\r\n * $animate is available in the AngularJS core, however, the ngAnimate module must be included\r\n * to enable full out animation support. Otherwise, $animate will only perform simple DOM\r\n * manipulation operations.\r\n *\r\n * To learn more about enabling animation support, click here to visit the {@link ngAnimate\r\n * ngAnimate module page} as well as the {@link ngAnimate.$animate ngAnimate $animate service\r\n * page}.\r\n */\r\n return {\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#enter\r\n * @kind function\r\n * @description Inserts the element into the DOM either after the `after` element or within\r\n * the `parent` element. Once complete, the done() callback will be fired (if provided).\r\n * @param {DOMElement} element the element which will be inserted into the DOM\r\n * @param {DOMElement} parent the parent element which will append the element as\r\n * a child (if the after element is not present)\r\n * @param {DOMElement} after the sibling element which will append the element\r\n * after itself\r\n * @param {Function=} done callback function that will be called after the element has been\r\n * inserted into the DOM\r\n */\r\n enter : function(element, parent, after, done) {\r\n if (after) {\r\n after.after(element);\r\n } else {\r\n if (!parent || !parent[0]) {\r\n parent = after.parent();\r\n }\r\n parent.append(element);\r\n }\r\n async(done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#leave\r\n * @kind function\r\n * @description Removes the element from the DOM. Once complete, the done() callback will be\r\n * fired (if provided).\r\n * @param {DOMElement} element the element which will be removed from the DOM\r\n * @param {Function=} done callback function that will be called after the element has been\r\n * removed from the DOM\r\n */\r\n leave : function(element, done) {\r\n element.remove();\r\n async(done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#move\r\n * @kind function\r\n * @description Moves the position of the provided element within the DOM to be placed\r\n * either after the `after` element or inside of the `parent` element. Once complete, the\r\n * done() callback will be fired (if provided).\r\n *\r\n * @param {DOMElement} element the element which will be moved around within the\r\n * DOM\r\n * @param {DOMElement} parent the parent element where the element will be\r\n * inserted into (if the after element is not present)\r\n * @param {DOMElement} after the sibling element where the element will be\r\n * positioned next to\r\n * @param {Function=} done the callback function (if provided) that will be fired after the\r\n * element has been moved to its new position\r\n */\r\n move : function(element, parent, after, done) {\r\n // Do not remove element before insert. Removing will cause data associated with the\r\n // element to be dropped. Insert will implicitly do the remove.\r\n this.enter(element, parent, after, done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#addClass\r\n * @kind function\r\n * @description Adds the provided className CSS class value to the provided element. Once\r\n * complete, the done() callback will be fired (if provided).\r\n * @param {DOMElement} element the element which will have the className value\r\n * added to it\r\n * @param {string} className the CSS class which will be added to the element\r\n * @param {Function=} done the callback function (if provided) that will be fired after the\r\n * className value has been added to the element\r\n */\r\n addClass : function(element, className, done) {\r\n className = isString(className) ?\r\n className :\r\n isArray(className) ? className.join(' ') : '';\r\n forEach(element, function (element) {\r\n jqLiteAddClass(element, className);\r\n });\r\n async(done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#removeClass\r\n * @kind function\r\n * @description Removes the provided className CSS class value from the provided element.\r\n * Once complete, the done() callback will be fired (if provided).\r\n * @param {DOMElement} element the element which will have the className value\r\n * removed from it\r\n * @param {string} className the CSS class which will be removed from the element\r\n * @param {Function=} done the callback function (if provided) that will be fired after the\r\n * className value has been removed from the element\r\n */\r\n removeClass : function(element, className, done) {\r\n className = isString(className) ?\r\n className :\r\n isArray(className) ? className.join(' ') : '';\r\n forEach(element, function (element) {\r\n jqLiteRemoveClass(element, className);\r\n });\r\n async(done);\r\n },\r\n\r\n /**\r\n *\r\n * @ngdoc method\r\n * @name $animate#setClass\r\n * @kind function\r\n * @description Adds and/or removes the given CSS classes to and from the element.\r\n * Once complete, the done() callback will be fired (if provided).\r\n * @param {DOMElement} element the element which will have its CSS classes changed\r\n * removed from it\r\n * @param {string} add the CSS classes which will be added to the element\r\n * @param {string} remove the CSS class which will be removed from the element\r\n * @param {Function=} done the callback function (if provided) that will be fired after the\r\n * CSS classes have been set on the element\r\n */\r\n setClass : function(element, add, remove, done) {\r\n forEach(element, function (element) {\r\n jqLiteAddClass(element, add);\r\n jqLiteRemoveClass(element, remove);\r\n });\r\n async(done);\r\n },\r\n\r\n enabled : noop\r\n };\r\n }];\r\n}];\r\n\r\nfunction $$AsyncCallbackProvider(){\r\n this.$get = ['$$rAF', '$timeout', function($$rAF, $timeout) {\r\n return $$rAF.supported\r\n ? function(fn) { return $$rAF(fn); }\r\n : function(fn) {\r\n return $timeout(fn, 0, false);\r\n };\r\n }];\r\n}\r\n\r\n/* global stripHash: true */\r\n\r\n/**\r\n * ! This is a private undocumented service !\r\n *\r\n * @name $browser\r\n * @requires $log\r\n * @description\r\n * This object has two goals:\r\n *\r\n * - hide all the global state in the browser caused by the window object\r\n * - abstract away all the browser specific features and inconsistencies\r\n *\r\n * For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`\r\n * service, which can be used for convenient testing of the application without the interaction with\r\n * the real browser apis.\r\n */\r\n/**\r\n * @param {object} window The global window object.\r\n * @param {object} document jQuery wrapped document.\r\n * @param {function()} XHR XMLHttpRequest constructor.\r\n * @param {object} $log console.log or an object with the same interface.\r\n * @param {object} $sniffer $sniffer service\r\n */\r\nfunction Browser(window, document, $log, $sniffer) {\r\n var self = this,\r\n rawDocument = document[0],\r\n location = window.location,\r\n history = window.history,\r\n setTimeout = window.setTimeout,\r\n clearTimeout = window.clearTimeout,\r\n pendingDeferIds = {};\r\n\r\n self.isMock = false;\r\n\r\n var outstandingRequestCount = 0;\r\n var outstandingRequestCallbacks = [];\r\n\r\n // TODO(vojta): remove this temporary api\r\n self.$$completeOutstandingRequest = completeOutstandingRequest;\r\n self.$$incOutstandingRequestCount = function() { outstandingRequestCount++; };\r\n\r\n /**\r\n * Executes the `fn` function(supports currying) and decrements the `outstandingRequestCallbacks`\r\n * counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.\r\n */\r\n function completeOutstandingRequest(fn) {\r\n try {\r\n fn.apply(null, sliceArgs(arguments, 1));\r\n } finally {\r\n outstandingRequestCount--;\r\n if (outstandingRequestCount === 0) {\r\n while(outstandingRequestCallbacks.length) {\r\n try {\r\n outstandingRequestCallbacks.pop()();\r\n } catch (e) {\r\n $log.error(e);\r\n }\r\n }\r\n }\r\n }\r\n }\r\n\r\n /**\r\n * @private\r\n * Note: this method is used only by scenario runner\r\n * TODO(vojta): prefix this method with $$ ?\r\n * @param {function()} callback Function that will be called when no outstanding request\r\n */\r\n self.notifyWhenNoOutstandingRequests = function(callback) {\r\n // force browser to execute all pollFns - this is needed so that cookies and other pollers fire\r\n // at some deterministic time in respect to the test runner's actions. Leaving things up to the\r\n // regular poller would result in flaky tests.\r\n forEach(pollFns, function(pollFn){ pollFn(); });\r\n\r\n if (outstandingRequestCount === 0) {\r\n callback();\r\n } else {\r\n outstandingRequestCallbacks.push(callback);\r\n }\r\n };\r\n\r\n //////////////////////////////////////////////////////////////\r\n // Poll Watcher API\r\n //////////////////////////////////////////////////////////////\r\n var pollFns = [],\r\n pollTimeout;\r\n\r\n /**\r\n * @name $browser#addPollFn\r\n *\r\n * @param {function()} fn Poll function to add\r\n *\r\n * @description\r\n * Adds a function to the list of functions that poller periodically executes,\r\n * and starts polling if not started yet.\r\n *\r\n * @returns {function()} the added function\r\n */\r\n self.addPollFn = function(fn) {\r\n if (isUndefined(pollTimeout)) startPoller(100, setTimeout);\r\n pollFns.push(fn);\r\n return fn;\r\n };\r\n\r\n /**\r\n * @param {number} interval How often should browser call poll functions (ms)\r\n * @param {function()} setTimeout Reference to a real or fake `setTimeout` function.\r\n *\r\n * @description\r\n * Configures the poller to run in the specified intervals, using the specified\r\n * setTimeout fn and kicks it off.\r\n */\r\n function startPoller(interval, setTimeout) {\r\n (function check() {\r\n forEach(pollFns, function(pollFn){ pollFn(); });\r\n pollTimeout = setTimeout(check, interval);\r\n })();\r\n }\r\n\r\n //////////////////////////////////////////////////////////////\r\n // URL API\r\n //////////////////////////////////////////////////////////////\r\n\r\n var lastBrowserUrl = location.href,\r\n baseElement = document.find('base'),\r\n reloadLocation = null;\r\n\r\n /**\r\n * @name $browser#url\r\n *\r\n * @description\r\n * GETTER:\r\n * Without any argument, this method just returns current value of location.href.\r\n *\r\n * SETTER:\r\n * With at least one argument, this method sets url to new value.\r\n * If html5 history api supported, pushState/replaceState is used, otherwise\r\n * location.href/location.replace is used.\r\n * Returns its own instance to allow chaining\r\n *\r\n * NOTE: this api is intended for use only by the $location service. Please use the\r\n * {@link ng.$location $location service} to change url.\r\n *\r\n * @param {string} url New url (when used as setter)\r\n * @param {boolean=} replace Should new url replace current history record ?\r\n */\r\n self.url = function(url, replace) {\r\n // Android Browser BFCache causes location, history reference to become stale.\r\n if (location !== window.location) location = window.location;\r\n if (history !== window.history) history = window.history;\r\n\r\n // setter\r\n if (url) {\r\n if (lastBrowserUrl == url) return;\r\n var sameBase = lastBrowserUrl && stripHash(lastBrowserUrl) === stripHash(url);\r\n lastBrowserUrl = url;\r\n // Don't use history API if only the hash changed\r\n // due to a bug in IE10/IE11 which leads\r\n // to not firing a `hashchange` nor `popstate` event\r\n // in some cases (see #9143).\r\n if (!sameBase && $sniffer.history) {\r\n if (replace) history.replaceState(null, '', url);\r\n else {\r\n history.pushState(null, '', url);\r\n // Crazy Opera Bug: http://my.opera.com/community/forums/topic.dml?id=1185462\r\n baseElement.attr('href', baseElement.attr('href'));\r\n }\r\n } else {\r\n if (!sameBase) {\r\n reloadLocation = url;\r\n }\r\n if (replace) {\r\n location.replace(url);\r\n } else {\r\n location.href = url;\r\n }\r\n }\r\n return self;\r\n // getter\r\n } else {\r\n // - reloadLocation is needed as browsers don't allow to read out\r\n // the new location.href if a reload happened.\r\n // - the replacement is a workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=407172\r\n return reloadLocation || location.href.replace(/%27/g,\"'\");\r\n }\r\n };\r\n\r\n var urlChangeListeners = [],\r\n urlChangeInit = false;\r\n\r\n function fireUrlChange() {\r\n if (lastBrowserUrl == self.url()) return;\r\n\r\n lastBrowserUrl = self.url();\r\n forEach(urlChangeListeners, function(listener) {\r\n listener(self.url());\r\n });\r\n }\r\n\r\n /**\r\n * @name $browser#onUrlChange\r\n *\r\n * @description\r\n * Register callback function that will be called, when url changes.\r\n *\r\n * It's only called when the url is changed from outside of angular:\r\n * - user types different url into address bar\r\n * - user clicks on history (forward/back) button\r\n * - user clicks on a link\r\n *\r\n * It's not called when url is changed by $browser.url() method\r\n *\r\n * The listener gets called with new url as parameter.\r\n *\r\n * NOTE: this api is intended for use only by the $location service. Please use the\r\n * {@link ng.$location $location service} to monitor url changes in angular apps.\r\n *\r\n * @param {function(string)} listener Listener function to be called when url changes.\r\n * @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.\r\n */\r\n self.onUrlChange = function(callback) {\r\n // TODO(vojta): refactor to use node's syntax for events\r\n if (!urlChangeInit) {\r\n // We listen on both (hashchange/popstate) when available, as some browsers (e.g. Opera)\r\n // don't fire popstate when user change the address bar and don't fire hashchange when url\r\n // changed by push/replaceState\r\n\r\n // html5 history api - popstate event\r\n if ($sniffer.history) jqLite(window).on('popstate', fireUrlChange);\r\n // hashchange event\r\n if ($sniffer.hashchange) jqLite(window).on('hashchange', fireUrlChange);\r\n // polling\r\n else self.addPollFn(fireUrlChange);\r\n\r\n urlChangeInit = true;\r\n }\r\n\r\n urlChangeListeners.push(callback);\r\n return callback;\r\n };\r\n\r\n /**\r\n * Checks whether the url has changed outside of Angular.\r\n * Needs to be exported to be able to check for changes that have been done in sync,\r\n * as hashchange/popstate events fire in async.\r\n */\r\n self.$$checkUrlChange = fireUrlChange;\r\n\r\n //////////////////////////////////////////////////////////////\r\n // Misc API\r\n //////////////////////////////////////////////////////////////\r\n\r\n /**\r\n * @name $browser#baseHref\r\n *\r\n * @description\r\n * Returns current
\r\n \r\n \r\n \r\n\r\n
\r\n Cached Values
\r\n\r\n \r\n : \r\n \r\n
\r\n\r\n Cache Info
\r\n\r\n \r\n : \r\n \r\n
\r\n - \r\n *
- **id**: the id of the cache instance \r\n *
- **size**: the number of entries kept in the cache instance \r\n *
- **...**: any additional properties from the options object when creating the\r\n * cache. \r\n *
\r\n * **Note:** This document is an in-depth reference of all directive options.\r\n * For a gentle introduction to directives with examples of common use cases,\r\n * see the {@link guide/directive directive guide}.\r\n *
\r\n *\r\n * ## Comprehensive Directive API\r\n *\r\n * There are many different options for a directive.\r\n *\r\n * The difference resides in the return value of the factory function.\r\n * You can either return a \"Directive Definition Object\" (see below) that defines the directive properties,\r\n * or just the `postLink` function (all other properties will have the default values).\r\n *\r\n * \r\n * **Best Practice:** It's recommended to use the \"directive definition object\" form.\r\n *
\r\n *\r\n * Here's an example directive declared with a Directive Definition Object:\r\n *\r\n * ```js\r\n * var myModule = angular.module(...);\r\n *\r\n * myModule.directive('directiveName', function factory(injectables) {\r\n * var directiveDefinitionObject = {\r\n * priority: 0,\r\n * template: '', // or // function(tElement, tAttrs) { ... },\r\n * // or\r\n * // templateUrl: 'directive.html', // or // function(tElement, tAttrs) { ... },\r\n * transclude: false,\r\n * restrict: 'A',\r\n * scope: false,\r\n * controller: function($scope, $element, $attrs, $transclude, otherInjectables) { ... },\r\n * controllerAs: 'stringAlias',\r\n * require: 'siblingDirectiveName', // or // ['^parentDirectiveName', '?optionalDirectiveName', '?^optionalParent'],\r\n * compile: function compile(tElement, tAttrs, transclude) {\r\n * return {\r\n * pre: function preLink(scope, iElement, iAttrs, controller) { ... },\r\n * post: function postLink(scope, iElement, iAttrs, controller) { ... }\r\n * }\r\n * // or\r\n * // return function postLink( ... ) { ... }\r\n * },\r\n * // or\r\n * // link: {\r\n * // pre: function preLink(scope, iElement, iAttrs, controller) { ... },\r\n * // post: function postLink(scope, iElement, iAttrs, controller) { ... }\r\n * // }\r\n * // or\r\n * // link: function postLink( ... ) { ... }\r\n * };\r\n * return directiveDefinitionObject;\r\n * });\r\n * ```\r\n *\r\n * \r\n * **Note:** Any unspecified options will use the default value. You can see the default values below.\r\n *
\r\n *\r\n * Therefore the above can be simplified as:\r\n *\r\n * ```js\r\n * var myModule = angular.module(...);\r\n *\r\n * myModule.directive('directiveName', function factory(injectables) {\r\n * var directiveDefinitionObject = {\r\n * link: function postLink(scope, iElement, iAttrs) { ... }\r\n * };\r\n * return directiveDefinitionObject;\r\n * // or\r\n * // return function postLink(scope, iElement, iAttrs) { ... }\r\n * });\r\n * ```\r\n *\r\n *\r\n *\r\n * ### Directive Definition Object\r\n *\r\n * The directive definition object provides instructions to the {@link ng.$compile\r\n * compiler}. The attributes are:\r\n *\r\n * #### `priority`\r\n * When there are multiple directives defined on a single DOM element, sometimes it\r\n * is necessary to specify the order in which the directives are applied. The `priority` is used\r\n * to sort the directives before their `compile` functions get called. Priority is defined as a\r\n * number. Directives with greater numerical `priority` are compiled first. Pre-link functions\r\n * are also run in priority order, but post-link functions are run in reverse order. The order\r\n * of directives with the same priority is undefined. The default priority is `0`.\r\n *\r\n * #### `terminal`\r\n * If set to true then the current `priority` will be the last set of directives\r\n * which will execute (any directives at the current priority will still execute\r\n * as the order of execution on same `priority` is undefined).\r\n *\r\n * #### `scope`\r\n * **If set to `true`,** then a new scope will be created for this directive. If multiple directives on the\r\n * same element request a new scope, only one new scope is created. The new scope rule does not\r\n * apply for the root of the template since the root of the template always gets a new scope.\r\n *\r\n * **If set to `{}` (object hash),** then a new \"isolate\" scope is created. The 'isolate' scope differs from\r\n * normal scope in that it does not prototypically inherit from the parent scope. This is useful\r\n * when creating reusable components, which should not accidentally read or modify data in the\r\n * parent scope.\r\n *\r\n * The 'isolate' scope takes an object hash which defines a set of local scope properties\r\n * derived from the parent scope. These local properties are useful for aliasing values for\r\n * templates. Locals definition is a hash of local scope property to its source:\r\n *\r\n * * `@` or `@attr` - bind a local scope property to the value of DOM attribute. The result is\r\n * always a string since DOM attributes are strings. If no `attr` name is specified then the\r\n * attribute name is assumed to be the same as the local name.\r\n * Given `{{delete_str}}
`.\r\n * * A function which takes two arguments `tElement` and `tAttrs` (described in the `compile`\r\n * function api below) and returns a string value.\r\n *\r\n *\r\n * #### `templateUrl`\r\n * Same as `template` but the template is loaded from the specified URL. Because\r\n * the template loading is asynchronous the compilation/linking is suspended until the template\r\n * is loaded.\r\n *\r\n * You can specify `templateUrl` as a string representing the URL or as a function which takes two\r\n * arguments `tElement` and `tAttrs` (described in the `compile` function api below) and returns\r\n * a string value representing the url. In either case, the template URL is passed through {@link\r\n * api/ng.$sce#getTrustedResourceUrl $sce.getTrustedResourceUrl}.\r\n *\r\n *\r\n * #### `replace` ([*DEPRECATED*!], will be removed in next major release)\r\n * specify what the template should replace. Defaults to `false`.\r\n *\r\n * * `true` - the template will replace the directive's element.\r\n * * `false` - the template will replace the contents of the directive's element.\r\n *\r\n * The replacement process migrates all of the attributes / classes from the old element to the new\r\n * one. See the {@link guide/directive#creating-custom-directives_creating-directives_template-expanding-directive\r\n * Directives Guide} for an example.\r\n *\r\n * #### `transclude`\r\n * compile the content of the element and make it available to the directive.\r\n * Typically used with {@link ng.directive:ngTransclude\r\n * ngTransclude}. The advantage of transclusion is that the linking function receives a\r\n * transclusion function which is pre-bound to the correct scope. In a typical setup the widget\r\n * creates an `isolate` scope, but the transclusion is not a child, but a sibling of the `isolate`\r\n * scope. This makes it possible for the widget to have private state, and the transclusion to\r\n * be bound to the parent (pre-`isolate`) scope.\r\n *\r\n * There are two kinds of transclusion depending upon whether you want to transclude just the contents of the\r\n * directive's element or the entire element:\r\n *\r\n * * `true` - transclude the content (i.e. the child nodes) of the directive's element.\r\n * * `'element'` - transclude the whole of the directive's element including any directives on this\r\n * element that defined at a lower priority than this directive. When used, the `template`\r\n * property is ignored.\r\n *\r\n * \r\n * **Note:** When testing an element transclude directive you must not place the directive at the root of the\r\n * DOM fragment that is being compiled. See {@link guide/unit-testing#testing-transclusion-directives\r\n * Testing Transclusion Directives}.\r\n *
\r\n *\r\n * #### `compile`\r\n *\r\n * ```js\r\n * function compile(tElement, tAttrs, transclude) { ... }\r\n * ```\r\n *\r\n * The compile function deals with transforming the template DOM. Since most directives do not do\r\n * template transformation, it is not used often. The compile function takes the following arguments:\r\n *\r\n * * `tElement` - template element - The element where the directive has been declared. It is\r\n * safe to do template transformation on the element and child elements only.\r\n *\r\n * * `tAttrs` - template attributes - Normalized list of attributes declared on this element shared\r\n * between all directive compile functions.\r\n *\r\n * * `transclude` - [*DEPRECATED*!] A transclude linking function: `function(scope, cloneLinkingFn)`\r\n *\r\n * \r\n * **Note:** The template instance and the link instance may be different objects if the template has\r\n * been cloned. For this reason it is **not** safe to do anything other than DOM transformations that\r\n * apply to all cloned DOM nodes within the compile function. Specifically, DOM listener registration\r\n * should be done in a linking function rather than in a compile function.\r\n *
\r\n\r\n * \r\n * **Note:** The compile function cannot handle directives that recursively use themselves in their\r\n * own templates or compile functions. Compiling these directives results in an infinite loop and a\r\n * stack overflow errors.\r\n *\r\n * This can be avoided by manually using $compile in the postLink function to imperatively compile\r\n * a directive's template instead of relying on automatic template compilation via `template` or\r\n * `templateUrl` declaration or manual compilation inside the compile function.\r\n *
\r\n *\r\n * \r\n * **Note:** The `transclude` function that is passed to the compile function is deprecated, as it\r\n * e.g. does not know about the right outer scope. Please use the transclude function that is passed\r\n * to the link function instead.\r\n *
\r\n\r\n * A compile function can have a return value which can be either a function or an object.\r\n *\r\n * * returning a (post-link) function - is equivalent to registering the linking function via the\r\n * `link` property of the config object when the compile function is empty.\r\n *\r\n * * returning an object with function(s) registered via `pre` and `post` properties - allows you to\r\n * control when a linking function should be called during the linking phase. See info about\r\n * pre-linking and post-linking functions below.\r\n *\r\n *\r\n * #### `link`\r\n * This property is used only if the `compile` property is not defined.\r\n *\r\n * ```js\r\n * function link(scope, iElement, iAttrs, controller, transcludeFn) { ... }\r\n * ```\r\n *\r\n * The link function is responsible for registering DOM listeners as well as updating the DOM. It is\r\n * executed after the template has been cloned. This is where most of the directive logic will be\r\n * put.\r\n *\r\n * * `scope` - {@link ng.$rootScope.Scope Scope} - The scope to be used by the\r\n * directive for registering {@link ng.$rootScope.Scope#$watch watches}.\r\n *\r\n * * `iElement` - instance element - The element where the directive is to be used. It is safe to\r\n * manipulate the children of the element only in `postLink` function since the children have\r\n * already been linked.\r\n *\r\n * * `iAttrs` - instance attributes - Normalized list of attributes declared on this element shared\r\n * between all directive linking functions.\r\n *\r\n * * `controller` - a controller instance - A controller instance if at least one directive on the\r\n * element defines a controller. The controller is shared among all the directives, which allows\r\n * the directives to use the controllers as a communication channel.\r\n *\r\n * * `transcludeFn` - A transclude linking function pre-bound to the correct transclusion scope.\r\n * The scope can be overridden by an optional first argument. This is the same as the `$transclude`\r\n * parameter of directive controllers.\r\n * `function([scope], cloneLinkingFn)`.\r\n *\r\n *\r\n * #### Pre-linking function\r\n *\r\n * Executed before the child elements are linked. Not safe to do DOM transformation since the\r\n * compiler linking function will fail to locate the correct elements for linking.\r\n *\r\n * #### Post-linking function\r\n *\r\n * Executed after the child elements are linked. It is safe to do DOM transformation in the post-linking function.\r\n *\r\n * \r\n * ### Attributes\r\n *\r\n * The {@link ng.$compile.directive.Attributes Attributes} object - passed as a parameter in the\r\n * `link()` or `compile()` functions. It has a variety of uses.\r\n *\r\n * accessing *Normalized attribute names:*\r\n * Directives like 'ngBind' can be expressed in many ways: 'ng:bind', `data-ng-bind`, or 'x-ng-bind'.\r\n * the attributes object allows for normalized access to\r\n * the attributes.\r\n *\r\n * * *Directive inter-communication:* All directives share the same instance of the attributes\r\n * object which allows the directives to use the attributes object as inter directive\r\n * communication.\r\n *\r\n * * *Supports interpolation:* Interpolation attributes are assigned to the attribute object\r\n * allowing other directives to read the interpolated value.\r\n *\r\n * * *Observing interpolated attributes:* Use `$observe` to observe the value changes of attributes\r\n * that contain interpolation (e.g. `src=\"{{bar}}\"`). Not only is this very efficient but it's also\r\n * the only way to easily get the actual value because during the linking phase the interpolation\r\n * hasn't been evaluated yet and so the value is at this time set to `undefined`.\r\n *\r\n * ```js\r\n * function linkingFn(scope, elm, attrs, ctrl) {\r\n * // get the attribute value\r\n * console.log(attrs.ngModel);\r\n *\r\n * // change the attribute\r\n * attrs.$set('ngModel', 'new value');\r\n *\r\n * // observe changes to interpolated attribute\r\n * attrs.$observe('ngModel', function(value) {\r\n * console.log('ngModel has changed value to ' + value);\r\n * });\r\n * }\r\n * ```\r\n *\r\n * ## Example\r\n *\r\n * \r\n * **Note**: Typically directives are registered with `module.directive`. The example below is\r\n * to illustrate how `$compile` works.\r\n *
\r\n *\r\n \r\n
\r\n
\r\n \r\n
\r\n \r\n
\r\n \r\n
`cloneAttachFn(clonedElement, scope)` where:\r\n *\r\n * * `clonedElement` - is a clone of the original `element` passed into the compiler.\r\n * * `scope` - is the current scope with which the linking function is working with.\r\n *\r\n * Calling the linking function returns the element of the template. It is either the original\r\n * element passed in, or the clone of the element if the `cloneAttachFn` is provided.\r\n *\r\n * After linking the view is not updated until after a call to $digest which typically is done by\r\n * Angular automatically.\r\n *\r\n * If you need access to the bound view, there are two ways to do it:\r\n *\r\n * - If you are not asking the linking function to clone the template, create the DOM element(s)\r\n * before you send them to the compiler and keep this reference around.\r\n * ```js\r\n * var element = $compile('
{{total}}
')(scope);\r\n * ```\r\n *\r\n * - if on the other hand, you need the element to be cloned, the view reference from the original\r\n * example would not point to the clone, but rather to the original template that was cloned. In\r\n * this case, you can access the clone via the cloneAttachFn:\r\n * ```js\r\n * var templateElement = angular.element('{{total}}
'),\r\n * scope = ....;\r\n *\r\n * var clonedElement = $compile(templateElement)(scope, function(clonedElement, scope) {\r\n * //attach the clone to DOM document at the right place\r\n * });\r\n *\r\n * //now we have reference to the cloned DOM via `clonedElement`\r\n * ```\r\n *\r\n *\r\n * For information on how the compiler works, see the\r\n * {@link guide/compiler Angular HTML Compiler} section of the Developer Guide.\r\n */\r\n\r\nvar $compileMinErr = minErr('$compile');\r\n\r\n/**\r\n * @ngdoc provider\r\n * @name $compileProvider\r\n * @kind function\r\n *\r\n * @description\r\n */\r\n$CompileProvider.$inject = ['$provide', '$$sanitizeUriProvider'];\r\nfunction $CompileProvider($provide, $$sanitizeUriProvider) {\r\n var hasDirectives = {},\r\n Suffix = 'Directive',\r\n COMMENT_DIRECTIVE_REGEXP = /^\\s*directive\\:\\s*([\\d\\w_\\-]+)\\s+(.*)$/,\r\n CLASS_DIRECTIVE_REGEXP = /(([\\d\\w_\\-]+)(?:\\:([^;]+))?;?)/;\r\n\r\n // Ref: http://developers.whatwg.org/webappapis.html#event-handler-idl-attributes\r\n // The assumption is that future DOM event attribute names will begin with\r\n // 'on' and be composed of only English letters.\r\n var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $compileProvider#directive\r\n * @kind function\r\n *\r\n * @description\r\n * Register a new directive with the compiler.\r\n *\r\n * @param {string|Object} name Name of the directive in camel-case (i.e.ngBind which\r\n * will match as ng-bind), or an object map of directives where the keys are the\r\n * names and the values are the factories.\r\n * @param {Function|Array} directiveFactory An injectable directive factory function. See\r\n * {@link guide/directive} for more info.\r\n * @returns {ng.$compileProvider} Self for chaining.\r\n */\r\n this.directive = function registerDirective(name, directiveFactory) {\r\n assertNotHasOwnProperty(name, 'directive');\r\n if (isString(name)) {\r\n assertArg(directiveFactory, 'directiveFactory');\r\n if (!hasDirectives.hasOwnProperty(name)) {\r\n hasDirectives[name] = [];\r\n $provide.factory(name + Suffix, ['$injector', '$exceptionHandler',\r\n function($injector, $exceptionHandler) {\r\n var directives = [];\r\n forEach(hasDirectives[name], function(directiveFactory, index) {\r\n try {\r\n var directive = $injector.invoke(directiveFactory);\r\n if (isFunction(directive)) {\r\n directive = { compile: valueFn(directive) };\r\n } else if (!directive.compile && directive.link) {\r\n directive.compile = valueFn(directive.link);\r\n }\r\n directive.priority = directive.priority || 0;\r\n directive.index = index;\r\n directive.name = directive.name || name;\r\n directive.require = directive.require || (directive.controller && directive.name);\r\n directive.restrict = directive.restrict || 'A';\r\n directives.push(directive);\r\n } catch (e) {\r\n $exceptionHandler(e);\r\n }\r\n });\r\n return directives;\r\n }]);\r\n }\r\n hasDirectives[name].push(directiveFactory);\r\n } else {\r\n forEach(name, reverseParams(registerDirective));\r\n }\r\n return this;\r\n };\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $compileProvider#aHrefSanitizationWhitelist\r\n * @kind function\r\n *\r\n * @description\r\n * Retrieves or overrides the default regular expression that is used for whitelisting of safe\r\n * urls during a[href] sanitization.\r\n *\r\n * The sanitization is a security measure aimed at prevent XSS attacks via html links.\r\n *\r\n * Any url about to be assigned to a[href] via data-binding is first normalized and turned into\r\n * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist`\r\n * regular expression. If a match is found, the original url is written into the dom. Otherwise,\r\n * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.\r\n *\r\n * @param {RegExp=} regexp New regexp to whitelist urls with.\r\n * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for\r\n * chaining otherwise.\r\n */\r\n this.aHrefSanitizationWhitelist = function(regexp) {\r\n if (isDefined(regexp)) {\r\n $$sanitizeUriProvider.aHrefSanitizationWhitelist(regexp);\r\n return this;\r\n } else {\r\n return $$sanitizeUriProvider.aHrefSanitizationWhitelist();\r\n }\r\n };\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $compileProvider#imgSrcSanitizationWhitelist\r\n * @kind function\r\n *\r\n * @description\r\n * Retrieves or overrides the default regular expression that is used for whitelisting of safe\r\n * urls during img[src] sanitization.\r\n *\r\n * The sanitization is a security measure aimed at prevent XSS attacks via html links.\r\n *\r\n * Any url about to be assigned to img[src] via data-binding is first normalized and turned into\r\n * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist`\r\n * regular expression. If a match is found, the original url is written into the dom. Otherwise,\r\n * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.\r\n *\r\n * @param {RegExp=} regexp New regexp to whitelist urls with.\r\n * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for\r\n * chaining otherwise.\r\n */\r\n this.imgSrcSanitizationWhitelist = function(regexp) {\r\n if (isDefined(regexp)) {\r\n $$sanitizeUriProvider.imgSrcSanitizationWhitelist(regexp);\r\n return this;\r\n } else {\r\n return $$sanitizeUriProvider.imgSrcSanitizationWhitelist();\r\n }\r\n };\r\n\r\n this.$get = [\r\n '$injector', '$interpolate', '$exceptionHandler', '$http', '$templateCache', '$parse',\r\n '$controller', '$rootScope', '$document', '$sce', '$animate', '$$sanitizeUri',\r\n function($injector, $interpolate, $exceptionHandler, $http, $templateCache, $parse,\r\n $controller, $rootScope, $document, $sce, $animate, $$sanitizeUri) {\r\n\r\n var Attributes = function(element, attr) {\r\n this.$$element = element;\r\n this.$attr = attr || {};\r\n };\r\n\r\n Attributes.prototype = {\r\n $normalize: directiveNormalize,\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $compile.directive.Attributes#$addClass\r\n * @kind function\r\n *\r\n * @description\r\n * Adds the CSS class value specified by the classVal parameter to the element. If animations\r\n * are enabled then an animation will be triggered for the class addition.\r\n *\r\n * @param {string} classVal The className value that will be added to the element\r\n */\r\n $addClass : function(classVal) {\r\n if(classVal && classVal.length > 0) {\r\n $animate.addClass(this.$$element, classVal);\r\n }\r\n },\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $compile.directive.Attributes#$removeClass\r\n * @kind function\r\n *\r\n * @description\r\n * Removes the CSS class value specified by the classVal parameter from the element. If\r\n * animations are enabled then an animation will be triggered for the class removal.\r\n *\r\n * @param {string} classVal The className value that will be removed from the element\r\n */\r\n $removeClass : function(classVal) {\r\n if(classVal && classVal.length > 0) {\r\n $animate.removeClass(this.$$element, classVal);\r\n }\r\n },\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $compile.directive.Attributes#$updateClass\r\n * @kind function\r\n *\r\n * @description\r\n * Adds and removes the appropriate CSS class values to the element based on the difference\r\n * between the new and old CSS class values (specified as newClasses and oldClasses).\r\n *\r\n * @param {string} newClasses The current CSS className value\r\n * @param {string} oldClasses The former CSS className value\r\n */\r\n $updateClass : function(newClasses, oldClasses) {\r\n var toAdd = tokenDifference(newClasses, oldClasses);\r\n var toRemove = tokenDifference(oldClasses, newClasses);\r\n\r\n if(toAdd.length === 0) {\r\n $animate.removeClass(this.$$element, toRemove);\r\n } else if(toRemove.length === 0) {\r\n $animate.addClass(this.$$element, toAdd);\r\n } else {\r\n $animate.setClass(this.$$element, toAdd, toRemove);\r\n }\r\n },\r\n\r\n /**\r\n * Set a normalized attribute on the element in a way such that all directives\r\n * can share the attribute. This function properly handles boolean attributes.\r\n * @param {string} key Normalized key. (ie ngAttribute)\r\n * @param {string|boolean} value The value to set. If `null` attribute will be deleted.\r\n * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.\r\n * Defaults to true.\r\n * @param {string=} attrName Optional none normalized name. Defaults to key.\r\n */\r\n $set: function(key, value, writeAttr, attrName) {\r\n // TODO: decide whether or not to throw an error if \"class\"\r\n //is set through this function since it may cause $updateClass to\r\n //become unstable.\r\n\r\n var booleanKey = getBooleanAttrName(this.$$element[0], key),\r\n normalizedVal,\r\n nodeName;\r\n\r\n if (booleanKey) {\r\n this.$$element.prop(key, value);\r\n attrName = booleanKey;\r\n }\r\n\r\n this[key] = value;\r\n\r\n // translate normalized key to actual key\r\n if (attrName) {\r\n this.$attr[key] = attrName;\r\n } else {\r\n attrName = this.$attr[key];\r\n if (!attrName) {\r\n this.$attr[key] = attrName = snake_case(key, '-');\r\n }\r\n }\r\n\r\n nodeName = nodeName_(this.$$element);\r\n\r\n // sanitize a[href] and img[src] values\r\n if ((nodeName === 'A' && key === 'href') ||\r\n (nodeName === 'IMG' && key === 'src')) {\r\n this[key] = value = $$sanitizeUri(value, key === 'src');\r\n }\r\n\r\n if (writeAttr !== false) {\r\n if (value === null || value === undefined) {\r\n this.$$element.removeAttr(attrName);\r\n } else {\r\n this.$$element.attr(attrName, value);\r\n }\r\n }\r\n\r\n // fire observers\r\n var $$observers = this.$$observers;\r\n $$observers && forEach($$observers[key], function(fn) {\r\n try {\r\n fn(value);\r\n } catch (e) {\r\n $exceptionHandler(e);\r\n }\r\n });\r\n },\r\n\r\n\r\n /**\r\n * @ngdoc method\r\n * @name $compile.directive.Attributes#$observe\r\n * @kind function\r\n *\r\n * @description\r\n * Observes an interpolated attribute.\r\n *\r\n * The observer function will be invoked once during the next `$digest` following\r\n * compilation. The observer is then invoked whenever the interpolated value\r\n * changes.\r\n *\r\n * @param {string} key Normalized key. (ie ngAttribute) .\r\n * @param {function(interpolatedValue)} fn Function that will be called whenever\r\n the interpolated value of the attribute changes.\r\n * See the {@link guide/directive#Attributes Directives} guide for more info.\r\n * @returns {function()} the `fn` parameter.\r\n */\r\n $observe: function(key, fn) {\r\n var attrs = this,\r\n $$observers = (attrs.$$observers || (attrs.$$observers = {})),\r\n listeners = ($$observers[key] || ($$observers[key] = []));\r\n\r\n listeners.push(fn);\r\n $rootScope.$evalAsync(function() {\r\n if (!listeners.$$inter) {\r\n // no one registered attribute interpolation function, so lets call it manually\r\n fn(attrs[key]);\r\n }\r\n });\r\n return fn;\r\n }\r\n };\r\n\r\n var startSymbol = $interpolate.startSymbol(),\r\n endSymbol = $interpolate.endSymbol(),\r\n denormalizeTemplate = (startSymbol == '{{' || endSymbol == '}}')\r\n ? identity\r\n : function denormalizeTemplate(template) {\r\n return template.replace(/\\{\\{/g, startSymbol).replace(/}}/g, endSymbol);\r\n },\r\n NG_ATTR_BINDING = /^ngAttr[A-Z]/;\r\n\r\n\r\n return compile;\r\n\r\n //================================\r\n\r\n function compile($compileNodes, transcludeFn, maxPriority, ignoreDirective,\r\n previousCompileContext) {\r\n if (!($compileNodes instanceof jqLite)) {\r\n // jquery always rewraps, whereas we need to preserve the original selector so that we can\r\n // modify it.\r\n $compileNodes = jqLite($compileNodes);\r\n }\r\n // We can not compile top level text elements since text nodes can be merged and we will\r\n // not be able to attach scope data to them, so we will wrap them in \r\n forEach($compileNodes, function(node, index){\r\n if (node.nodeType == 3 /* text node */ && node.nodeValue.match(/\\S+/) /* non-empty */ ) {\r\n $compileNodes[index] = node = jqLite(node).wrap('').parent()[0];\r\n }\r\n });\r\n var compositeLinkFn =\r\n compileNodes($compileNodes, transcludeFn, $compileNodes,\r\n maxPriority, ignoreDirective, previousCompileContext);\r\n safeAddClass($compileNodes, 'ng-scope');\r\n return function publicLinkFn(scope, cloneConnectFn, transcludeControllers, parentBoundTranscludeFn){\r\n assertArg(scope, 'scope');\r\n // important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart\r\n // and sometimes changes the structure of the DOM.\r\n var $linkNode = cloneConnectFn\r\n ? JQLitePrototype.clone.call($compileNodes) // IMPORTANT!!!\r\n : $compileNodes;\r\n\r\n forEach(transcludeControllers, function(instance, name) {\r\n $linkNode.data('$' + name + 'Controller', instance);\r\n });\r\n\r\n // Attach scope only to non-text nodes.\r\n for(var i = 0, ii = $linkNode.length; i\r\n
\r\n $document title:
\r\nwindow.document title:
\r\n\r\n *
\r\n *\r\n * \r\n * Date format:
\r\n * Current time is: \r\n *
\r\n * Blood 1 : {{blood_1}}\r\n * Blood 2 : {{blood_2}}\r\n * \r\n * \r\n * \r\n *
\r\n * \r\n * Current time is: \r\n *
\r\n * Blood 1 : {{blood_1}}\r\n * Blood 2 : {{blood_2}}\r\n * \r\n * \r\n * \r\n *
\r\n
\r\n Reload this page with open console, enter text and hit the log button...
\r\n Message:\r\n \r\n \r\n \r\n \r\n \r\nimplicitly trusted'\">
`) just works.\r\n *\r\n * Additionally, `a[href]` and `img[src]` automatically sanitize their URLs and do not pass them\r\n * through {@link ng.$sce#getTrusted $sce.getTrusted}. SCE doesn't play a role here.\r\n *\r\n * The included {@link ng.$sceDelegate $sceDelegate} comes with sane defaults to allow you to load\r\n * templates in `ng-include` from your application's domain without having to even know about SCE.\r\n * It blocks loading templates from other domains or loading templates over http from an https\r\n * served document. You can change these by setting your own custom {@link\r\n * ng.$sceDelegateProvider#resourceUrlWhitelist whitelists} and {@link\r\n * ng.$sceDelegateProvider#resourceUrlBlacklist blacklists} for matching such URLs.\r\n *\r\n * This significantly reduces the overhead. It is far easier to pay the small overhead and have an\r\n * application that's secure and can be audited to verify that with much more ease than bolting\r\n * security onto an application later.\r\n *\r\n * \r\n * ## What trusted context types are supported?\r\n *\r\n * | Context | Notes |\r\n * |---------------------|----------------|\r\n * | `$sce.HTML` | For HTML that's safe to source into the application. The {@link ng.directive:ngBindHtml ngBindHtml} directive uses this context for bindings. If an unsafe value is encountered and the {@link ngSanitize $sanitize} module is present this will sanitize the value instead of throwing an error. |\r\n * | `$sce.CSS` | For CSS that's safe to source into the application. Currently unused. Feel free to use it in your own directives. |\r\n * | `$sce.URL` | For URLs that are safe to follow as links. Currently unused (`Note that `$sce.RESOURCE_URL` makes a stronger statement about the URL than `$sce.URL` does and therefore contexts requiring values trusted for `$sce.RESOURCE_URL` can be used anywhere that values trusted for `$sce.URL` are required. |\r\n * | `$sce.JS` | For JavaScript that is safe to execute in your application's context. Currently unused. Feel free to use it in your own directives. |\r\n *\r\n * ## Format of items in {@link ng.$sceDelegateProvider#resourceUrlWhitelist resourceUrlWhitelist}/{@link ng.$sceDelegateProvider#resourceUrlBlacklist Blacklist} \r\n *\r\n * Each element in these arrays must be one of the following:\r\n *\r\n * - **'self'**\r\n * - The special **string**, `'self'`, can be used to match against all URLs of the **same\r\n * domain** as the application document using the **same protocol**.\r\n * - **String** (except the special value `'self'`)\r\n * - The string is matched against the full *normalized / absolute URL* of the resource\r\n * being tested (substring matches are not good enough.)\r\n * - There are exactly **two wildcard sequences** - `*` and `**`. All other characters\r\n * match themselves.\r\n * - `*`: matches zero or more occurrences of any character other than one of the following 6\r\n * characters: '`:`', '`/`', '`.`', '`?`', '`&`' and ';'. It's a useful wildcard for use\r\n * in a whitelist.\r\n * - `**`: matches zero or more occurrences of *any* character. As such, it's not\r\n * not appropriate to use in for a scheme, domain, etc. as it would match too much. (e.g.\r\n * http://**.example.com/ would match http://evil.com/?ignore=.example.com/ and that might\r\n * not have been the intention.) Its usage at the very end of the path is ok. (e.g.\r\n * http://foo.example.com/templates/**).\r\n * - **RegExp** (*see caveat below*)\r\n * - *Caveat*: While regular expressions are powerful and offer great flexibility, their syntax\r\n * (and all the inevitable escaping) makes them *harder to maintain*. It's easy to\r\n * accidentally introduce a bug when one updates a complex expression (imho, all regexes should\r\n * have good test coverage.). For instance, the use of `.` in the regex is correct only in a\r\n * small number of cases. A `.` character in the regex used when matching the scheme or a\r\n * subdomain could be matched against a `:` or literal `.` that was likely not intended. It\r\n * is highly recommended to use the string patterns and only fall back to regular expressions\r\n * if they as a last resort.\r\n * - The regular expression must be an instance of RegExp (i.e. not a string.) It is\r\n * matched against the **entire** *normalized / absolute URL* of the resource being tested\r\n * (even when the RegExp did not have the `^` and `$` codes.) In addition, any flags\r\n * present on the RegExp (such as multiline, global, ignoreCase) are ignored.\r\n * - If you are generating your JavaScript from some other templating engine (not\r\n * recommended, e.g. in issue [#4006](https://github.com/angular/angular.js/issues/4006)),\r\n * remember to escape your regular expression (and be aware that you might need more than\r\n * one level of escaping depending on your templating engine and the way you interpolated\r\n * the value.) Do make use of your platform's escaping mechanism as it might be good\r\n * enough before coding your own. e.g. Ruby has\r\n * [Regexp.escape(str)](http://www.ruby-doc.org/core-2.0.0/Regexp.html#method-c-escape)\r\n * and Python has [re.escape](http://docs.python.org/library/re.html#re.escape).\r\n * Javascript lacks a similar built in function for escaping. Take a look at Google\r\n * Closure library's [goog.string.regExpEscape(s)](\r\n * http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962).\r\n *\r\n * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} for an example.\r\n *\r\n * ## Show me an example using SCE.\r\n *\r\n *
\r\n *
\r\n * User comments
\r\n * By default, HTML that isn't explicitly trusted (e.g. Alice's comment) is sanitized when\r\n * $sanitize is available. If $sanitize isn't available, this results in an error instead of an\r\n * exploit.\r\n *
\r\n * \r\n * User comments
\r\n * By default, HTML that isn't explicitly trusted (e.g. Alice's comment) is sanitized when\r\n * $sanitize is available. If $sanitize isn't available, this results in an error instead of an\r\n * exploit.\r\n *
\r\n *
\r\n * \r\n * {{userComment.name}}:\r\n * \r\n *
\r\n *
\r\n * \r\n *
\r\n \r\n \r\n
\r\n \r\n
\r\n {{ originalText }}
\r\n{{ filteredText }}
\r\n| Name | Phone |
|---|---|
| {{friend.name}} | \r\n{{friend.phone}} | \r\n
\r\n Any:
\r\n Name only
\r\n Phone only
\r\n Equality
\r\n
| Name | Phone |
|---|---|
| {{friendObj.name}} | \r\n{{friendObj.phone}} | \r\n
\r\n
\r\n default currency symbol ($): {{amount | currency}}
\r\n custom currency identifier (USD$): {{amount | currency:\"USD$\"}}\r\n
\r\n \r\n default currency symbol ($): {{amount | currency}}
\r\n custom currency identifier (USD$): {{amount | currency:\"USD$\"}}\r\n
\r\n Enter number:
\r\n Default formatting: {{val | number}}
\r\n No fractions: {{val | number:0}}
\r\n Negative number: {{-val | number:4}}\r\n
\r\n \r\n Default formatting: {{val | number}}
\r\n No fractions: {{val | number:0}}
\r\n Negative number: {{-val | number:4}}\r\n
\r\n {{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}:\r\n {{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}
\r\n {{1288323623006 | date:'MM/dd/yyyy @ h:mma'}}:\r\n {{'1288323623006' | date:'MM/dd/yyyy @ h:mma'}}
\r\n {{1288323623006 | date:\"MM/dd/yyyy 'at' h:mma\"}}:\r\n {{'1288323623006' | date:\"MM/dd/yyyy 'at' h:mma\"}}
\r\n
{{ {'name':'value'} | json }}\r\n \r\n Limit {{numbers}} to: \r\n
\r\n Output numbers: {{ numbers | limitTo:numLimit }}
\r\n Limit {{letters}} to: \r\nOutput letters: {{ letters | limitTo:letterLimit }}
\r\n\r\n
\r\n [ unsorted ]\r\n\r\n
\r\n
\r\n Sorting predicate = {{predicate}}; reverse = {{reverse}}\r\n \r\n [ unsorted ]\r\n
| Name\r\n (^) | \r\nPhone Number | \r\nAge | \r\n
|---|---|---|
| {{friend.name}} | \r\n{{friend.phone}} | \r\n{{friend.age}} | \r\n
\r\n \r\n
\r\n
\r\n | Name\r\n (^) | \r\nPhone Number | \r\nAge | \r\n
|---|---|---|
| {{friend.name}} | \r\n{{friend.phone}} | \r\n{{friend.age}} | \r\n
\r\n link 1 (link, don't reload)
\r\n link 2 (link, don't reload)
\r\n link 3 (link, reload!)
\r\n anchor (link, don't reload)
\r\n anchor (no link)
\r\n link (link, change location)\r\n
![](\"http://www.gravatar.com/avatar/{{hash}}\"/)
\r\n * ```\r\n *\r\n * The correct way to write it:\r\n * ```html\r\n * ![](\"http://www.gravatar.com/avatar/{{hash}})
\r\n * ```\r\n *\r\n * The correct way to write it:\r\n * ```html\r\n * \r\n * \r\n *
\r\n * ```\r\n *\r\n * The HTML specification does not require browsers to preserve the values of boolean attributes\r\n * such as disabled. (Their presence means true and their absence means false.)\r\n * If we put an Angular interpolation expression into such an attribute then the\r\n * binding information would be lost when the browser removes the attribute.\r\n * The `ngDisabled` directive solves this problem for the `disabled` attribute.\r\n * This complementary directive is not removed by the browser and so provides\r\n * a permanent reliable place to store the binding information.\r\n *\r\n * @example\r\n \r\n \r\n
\r\n \r\n
\r\n \r\n
\r\n \r\n
\r\n
\r\n
\r\n