').append($compileNodes).html())\r\n );\r\n } else if (cloneConnectFn) {\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 $linkNode = JQLitePrototype.clone.call($compileNodes);\r\n } else {\r\n $linkNode = $compileNodes;\r\n }\r\n\r\n if (transcludeControllers) {\r\n for (var controllerName in transcludeControllers) {\r\n $linkNode.data('$' + controllerName + 'Controller', transcludeControllers[controllerName].instance);\r\n }\r\n }\r\n\r\n compile.$$addScopeInfo($linkNode, scope);\r\n\r\n if (cloneConnectFn) cloneConnectFn($linkNode, scope);\r\n if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode, parentBoundTranscludeFn);\r\n return $linkNode;\r\n };\r\n }\r\n\r\n function detectNamespaceForChildElements(parentElement) {\r\n // TODO: Make this detect MathML as well...\r\n var node = parentElement && parentElement[0];\r\n if (!node) {\r\n return 'html';\r\n } else {\r\n return nodeName_(node) !== 'foreignobject' && node.toString().match(/SVG/) ? 'svg' : 'html';\r\n }\r\n }\r\n\r\n /**\r\n * Compile function matches each node in nodeList against the directives. Once all directives\r\n * for a particular node are collected their compile functions are executed. The compile\r\n * functions return values - the linking functions - are combined into a composite linking\r\n * function, which is the a linking function for the node.\r\n *\r\n * @param {NodeList} nodeList an array of nodes or NodeList to compile\r\n * @param {function(angular.Scope, cloneAttachFn=)} transcludeFn A linking function, where the\r\n * scope argument is auto-generated to the new child of the transcluded parent scope.\r\n * @param {DOMElement=} $rootElement If the nodeList is the root of the compilation tree then\r\n * the rootElement must be set the jqLite collection of the compile root. This is\r\n * needed so that the jqLite collection items can be replaced with widgets.\r\n * @param {number=} maxPriority Max directive priority.\r\n * @returns {Function} A composite linking function of all of the matched directives or null.\r\n */\r\n function compileNodes(nodeList, transcludeFn, $rootElement, maxPriority, ignoreDirective,\r\n previousCompileContext) {\r\n var linkFns = [],\r\n attrs, directives, nodeLinkFn, childNodes, childLinkFn, linkFnFound, nodeLinkFnFound;\r\n\r\n for (var i = 0; i < nodeList.length; i++) {\r\n attrs = new Attributes();\r\n\r\n // we must always refer to nodeList[i] since the nodes can be replaced underneath us.\r\n directives = collectDirectives(nodeList[i], [], attrs, i === 0 ? maxPriority : undefined,\r\n ignoreDirective);\r\n\r\n nodeLinkFn = (directives.length)\r\n ? applyDirectivesToNode(directives, nodeList[i], attrs, transcludeFn, $rootElement,\r\n null, [], [], previousCompileContext)\r\n : null;\r\n\r\n if (nodeLinkFn && nodeLinkFn.scope) {\r\n compile.$$addScopeClass(attrs.$$element);\r\n }\r\n\r\n childLinkFn = (nodeLinkFn && nodeLinkFn.terminal ||\r\n !(childNodes = nodeList[i].childNodes) ||\r\n !childNodes.length)\r\n ? null\r\n : compileNodes(childNodes,\r\n nodeLinkFn ? (\r\n (nodeLinkFn.transcludeOnThisElement || !nodeLinkFn.templateOnThisElement)\r\n && nodeLinkFn.transclude) : transcludeFn);\r\n\r\n if (nodeLinkFn || childLinkFn) {\r\n linkFns.push(i, nodeLinkFn, childLinkFn);\r\n linkFnFound = true;\r\n nodeLinkFnFound = nodeLinkFnFound || nodeLinkFn;\r\n }\r\n\r\n //use the previous context only for the first element in the virtual group\r\n previousCompileContext = null;\r\n }\r\n\r\n // return a linking function if we have found anything, null otherwise\r\n return linkFnFound ? compositeLinkFn : null;\r\n\r\n function compositeLinkFn(scope, nodeList, $rootElement, parentBoundTranscludeFn) {\r\n var nodeLinkFn, childLinkFn, node, childScope, i, ii, idx, childBoundTranscludeFn;\r\n var stableNodeList;\r\n\r\n\r\n if (nodeLinkFnFound) {\r\n // copy nodeList so that if a nodeLinkFn removes or adds an element at this DOM level our\r\n // offsets don't get screwed up\r\n var nodeListLength = nodeList.length;\r\n stableNodeList = new Array(nodeListLength);\r\n\r\n // create a sparse array by only copying the elements which have a linkFn\r\n for (i = 0; i < linkFns.length; i+=3) {\r\n idx = linkFns[i];\r\n stableNodeList[idx] = nodeList[idx];\r\n }\r\n } else {\r\n stableNodeList = nodeList;\r\n }\r\n\r\n for (i = 0, ii = linkFns.length; i < ii;) {\r\n node = stableNodeList[linkFns[i++]];\r\n nodeLinkFn = linkFns[i++];\r\n childLinkFn = linkFns[i++];\r\n\r\n if (nodeLinkFn) {\r\n if (nodeLinkFn.scope) {\r\n childScope = scope.$new();\r\n compile.$$addScopeInfo(jqLite(node), childScope);\r\n var destroyBindings = nodeLinkFn.$$destroyBindings;\r\n if (destroyBindings) {\r\n nodeLinkFn.$$destroyBindings = null;\r\n childScope.$on('$destroyed', destroyBindings);\r\n }\r\n } else {\r\n childScope = scope;\r\n }\r\n\r\n if (nodeLinkFn.transcludeOnThisElement) {\r\n childBoundTranscludeFn = createBoundTranscludeFn(\r\n scope, nodeLinkFn.transclude, parentBoundTranscludeFn);\r\n\r\n } else if (!nodeLinkFn.templateOnThisElement && parentBoundTranscludeFn) {\r\n childBoundTranscludeFn = parentBoundTranscludeFn;\r\n\r\n } else if (!parentBoundTranscludeFn && transcludeFn) {\r\n childBoundTranscludeFn = createBoundTranscludeFn(scope, transcludeFn);\r\n\r\n } else {\r\n childBoundTranscludeFn = null;\r\n }\r\n\r\n nodeLinkFn(childLinkFn, childScope, node, $rootElement, childBoundTranscludeFn,\r\n nodeLinkFn);\r\n\r\n } else if (childLinkFn) {\r\n childLinkFn(scope, node.childNodes, undefined, parentBoundTranscludeFn);\r\n }\r\n }\r\n }\r\n }\r\n\r\n function createBoundTranscludeFn(scope, transcludeFn, previousBoundTranscludeFn) {\r\n\r\n var boundTranscludeFn = function(transcludedScope, cloneFn, controllers, futureParentElement, containingScope) {\r\n\r\n if (!transcludedScope) {\r\n transcludedScope = scope.$new(false, containingScope);\r\n transcludedScope.$$transcluded = true;\r\n }\r\n\r\n return transcludeFn(transcludedScope, cloneFn, {\r\n parentBoundTranscludeFn: previousBoundTranscludeFn,\r\n transcludeControllers: controllers,\r\n futureParentElement: futureParentElement\r\n });\r\n };\r\n\r\n return boundTranscludeFn;\r\n }\r\n\r\n /**\r\n * Looks for directives on the given node and adds them to the directive collection which is\r\n * sorted.\r\n *\r\n * @param node Node to search.\r\n * @param directives An array to which the directives are added to. This array is sorted before\r\n * the function returns.\r\n * @param attrs The shared attrs object which is used to populate the normalized attributes.\r\n * @param {number=} maxPriority Max directive priority.\r\n */\r\n function collectDirectives(node, directives, attrs, maxPriority, ignoreDirective) {\r\n var nodeType = node.nodeType,\r\n attrsMap = attrs.$attr,\r\n match,\r\n className;\r\n\r\n switch (nodeType) {\r\n case NODE_TYPE_ELEMENT: /* Element */\r\n // use the node name:
\r\n addDirective(directives,\r\n directiveNormalize(nodeName_(node)), '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 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 = name.replace(PREFIX_REGEXP, '')\r\n .substr(8).replace(/_(.)/g, function(match, letter) {\r\n return letter.toUpperCase();\r\n });\r\n }\r\n\r\n var directiveNName = ngAttrName.replace(/(Start|End)$/, '');\r\n if (directiveIsMultiElement(directiveNName)) {\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\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, isNgAttr);\r\n addDirective(directives, nName, 'A', maxPriority, ignoreDirective, attrStartName,\r\n attrEndName);\r\n }\r\n\r\n // use class as directive\r\n className = node.className;\r\n if (isObject(className)) {\r\n // Maybe SVGAnimatedString\r\n className = className.animVal;\r\n }\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 NODE_TYPE_TEXT: /* Text Node */\r\n if (msie === 11) {\r\n // Workaround for #11781\r\n while (node.parentNode && node.nextSibling && node.nextSibling.nodeType === NODE_TYPE_TEXT) {\r\n node.nodeValue = node.nodeValue + node.nextSibling.nodeValue;\r\n node.parentNode.removeChild(node.nextSibling);\r\n }\r\n }\r\n addTextInterpolateDirective(directives, node.nodeValue);\r\n break;\r\n case NODE_TYPE_COMMENT: /* 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 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 == NODE_TYPE_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 = previousCompileContext.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\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 if (isObject(directiveValue)) {\r\n // This directive is trying to add an isolated scope.\r\n // Check that there is no scope of any kind already\r\n assertNoDuplicate('new/isolated scope', newIsolateScopeDirective || newScopeDirective,\r\n directive, $compileNode);\r\n newIsolateScopeDirective = directive;\r\n } else {\r\n // This directive is trying to add a child scope.\r\n // Check that there is no isolated scope already\r\n assertNoDuplicate('new/isolated scope', newIsolateScopeDirective, directive,\r\n $compileNode);\r\n }\r\n }\r\n\r\n newScopeDirective = newScopeDirective || directive;\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 || createMap();\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 = removeComments(wrapTemplate(directive.templateNamespace, trim(directiveValue)));\r\n }\r\n compileNode = $template[0];\r\n\r\n if ($template.length != 1 || compileNode.nodeType !== NODE_TYPE_ELEMENT) {\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 newScopeDirective: (newScopeDirective !== directive) && newScopeDirective,\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;\r\n\r\n if (isString(require)) {\r\n var match = require.match(REQUIRE_PREFIX_REGEXP);\r\n var name = require.substring(match[0].length);\r\n var inheritType = match[1] || match[3];\r\n var optional = match[2] === '?';\r\n\r\n //If only parents then start at the parent element\r\n if (inheritType === '^^') {\r\n $element = $element.parent();\r\n //Otherwise attempt getting the controller from elementControllers in case\r\n //the element is transcluded (and has no data) and to avoid .data if possible\r\n } else {\r\n value = elementControllers && elementControllers[name];\r\n value = value && value.instance;\r\n }\r\n\r\n if (!value) {\r\n var dataName = '$' + name + 'Controller';\r\n value = inheritType ? $element.inheritedData(dataName) : $element.data(dataName);\r\n }\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 name, directiveName);\r\n }\r\n } else if (isArray(require)) {\r\n value = [];\r\n for (var i = 0, ii = require.length; i < ii; i++) {\r\n value[i] = getControllers(directiveName, require[i], $element, elementControllers);\r\n }\r\n }\r\n\r\n return value || null;\r\n }\r\n\r\n function setupControllers($element, attrs, transcludeFn, controllerDirectives, isolateScope, scope) {\r\n var elementControllers = createMap();\r\n for (var controllerKey in controllerDirectives) {\r\n var directive = controllerDirectives[controllerKey];\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 };\r\n\r\n var controller = directive.controller;\r\n if (controller == '@') {\r\n controller = attrs[directive.name];\r\n }\r\n\r\n var controllerInstance = $controller(controller, locals, true, directive.controllerAs);\r\n\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.instance);\r\n }\r\n }\r\n return elementControllers;\r\n }\r\n\r\n function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn,\r\n thisLinkFn) {\r\n var i, ii, linkFn, controller, isolateScope, elementControllers, transcludeFn, $element,\r\n attrs;\r\n\r\n if (compileNode === linkNode) {\r\n attrs = templateAttrs;\r\n $element = templateAttrs.$$element;\r\n } else {\r\n $element = jqLite(linkNode);\r\n attrs = new Attributes($element, templateAttrs);\r\n }\r\n\r\n if (newIsolateScopeDirective) {\r\n isolateScope = scope.$new(true);\r\n }\r\n\r\n if (boundTranscludeFn) {\r\n // track `boundTranscludeFn` so it can be unwrapped if `transcludeFn`\r\n // is later passed as `parentBoundTranscludeFn` to `publicLinkFn`\r\n transcludeFn = controllersBoundTransclude;\r\n transcludeFn.$$boundTransclude = boundTranscludeFn;\r\n }\r\n\r\n if (controllerDirectives) {\r\n elementControllers = setupControllers($element, attrs, transcludeFn, controllerDirectives, isolateScope, scope);\r\n }\r\n\r\n if (newIsolateScopeDirective) {\r\n // Initialize isolate scope bindings for new isolate scope directive.\r\n compile.$$addScopeInfo($element, isolateScope, true, !(templateDirective && (templateDirective === newIsolateScopeDirective ||\r\n templateDirective === newIsolateScopeDirective.$$originalDirective)));\r\n compile.$$addScopeClass($element, true);\r\n isolateScope.$$isolateBindings =\r\n newIsolateScopeDirective.$$isolateBindings;\r\n initializeDirectiveBindings(scope, attrs, isolateScope,\r\n isolateScope.$$isolateBindings,\r\n newIsolateScopeDirective, isolateScope);\r\n }\r\n if (elementControllers) {\r\n // Initialize bindToController bindings for new/isolate scopes\r\n var scopeDirective = newIsolateScopeDirective || newScopeDirective;\r\n var bindings;\r\n var controllerForBindings;\r\n if (scopeDirective && elementControllers[scopeDirective.name]) {\r\n bindings = scopeDirective.$$bindings.bindToController;\r\n controller = elementControllers[scopeDirective.name];\r\n\r\n if (controller && controller.identifier && bindings) {\r\n controllerForBindings = controller;\r\n thisLinkFn.$$destroyBindings =\r\n initializeDirectiveBindings(scope, attrs, controller.instance,\r\n bindings, scopeDirective);\r\n }\r\n }\r\n for (i in elementControllers) {\r\n controller = elementControllers[i];\r\n var controllerResult = controller();\r\n\r\n if (controllerResult !== controller.instance) {\r\n // If the controller constructor has a return value, overwrite the instance\r\n // from setupControllers and update the element data\r\n controller.instance = controllerResult;\r\n $element.data('$' + i + 'Controller', controllerResult);\r\n if (controller === controllerForBindings) {\r\n // Remove and re-install bindToController bindings\r\n thisLinkFn.$$destroyBindings();\r\n thisLinkFn.$$destroyBindings =\r\n initializeDirectiveBindings(scope, attrs, controllerResult, bindings, scopeDirective);\r\n }\r\n }\r\n }\r\n }\r\n\r\n // PRELINKING\r\n for (i = 0, ii = preLinkFns.length; i < ii; i++) {\r\n linkFn = preLinkFns[i];\r\n invokeLinkFn(linkFn,\r\n linkFn.isolateScope ? isolateScope : scope,\r\n $element,\r\n attrs,\r\n linkFn.require && getControllers(linkFn.directiveName, linkFn.require, $element, elementControllers),\r\n transcludeFn\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 linkFn = postLinkFns[i];\r\n invokeLinkFn(linkFn,\r\n linkFn.isolateScope ? isolateScope : scope,\r\n $element,\r\n attrs,\r\n linkFn.require && getControllers(linkFn.directiveName, linkFn.require, $element, elementControllers),\r\n transcludeFn\r\n );\r\n }\r\n\r\n // This is the function that is injected as `$transclude`.\r\n // Note: all arguments are optional!\r\n function controllersBoundTransclude(scope, cloneAttachFn, futureParentElement) {\r\n var transcludeControllers;\r\n\r\n // No scope passed in:\r\n if (!isScope(scope)) {\r\n futureParentElement = cloneAttachFn;\r\n cloneAttachFn = scope;\r\n scope = undefined;\r\n }\r\n\r\n if (hasElementTranscludeDirective) {\r\n transcludeControllers = elementControllers;\r\n }\r\n if (!futureParentElement) {\r\n futureParentElement = hasElementTranscludeDirective ? $element.parent() : $element;\r\n }\r\n return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers, futureParentElement, scopeToChild);\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 < ii; i++) {\r\n try {\r\n directive = directives[i];\r\n if ((isUndefined(maxPriority) || maxPriority > 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 * looks up the directive and returns true if it is a multi-element directive,\r\n * and therefore requires DOM nodes between -start and -end markers to be grouped\r\n * together.\r\n *\r\n * @param {string} name name of the directive to look up.\r\n * @returns true if directive was registered as multi-element.\r\n */\r\n function directiveIsMultiElement(name) {\r\n if (hasDirectives.hasOwnProperty(name)) {\r\n for (var directive, directives = $injector.get(name + Suffix),\r\n i = 0, ii = directives.length; i < ii; i++) {\r\n directive = directives[i];\r\n if (directive.multiElement) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\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 derivedSyncDirective = inherit(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 templateNamespace = origAsyncDirective.templateNamespace;\r\n\r\n $compileNode.empty();\r\n\r\n $templateRequest(templateUrl)\r\n .then(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 = removeComments(wrapTemplate(templateNamespace, trim(content)));\r\n }\r\n compileNode = $template[0];\r\n\r\n if ($template.length != 1 || compileNode.nodeType !== NODE_TYPE_ELEMENT) {\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 (scope.$$destroyed) continue;\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 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, afterTemplateNodeLinkFn);\r\n }\r\n linkQueue = null;\r\n });\r\n\r\n return function delayedNodeLinkFn(ignoreChildLinkFn, scope, node, rootElement, boundTranscludeFn) {\r\n var childBoundTranscludeFn = boundTranscludeFn;\r\n if (scope.$$destroyed) return;\r\n if (linkQueue) {\r\n linkQueue.push(scope,\r\n node,\r\n rootElement,\r\n 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 afterTemplateNodeLinkFn);\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 function assertNoDuplicate(what, previousDirective, directive, element) {\r\n\r\n function wrapModuleNameIfDefined(moduleName) {\r\n return moduleName ?\r\n (' (module: ' + moduleName + ')') :\r\n '';\r\n }\r\n\r\n if (previousDirective) {\r\n throw $compileMinErr('multidir', 'Multiple directives [{0}{1}, {2}{3}] asking for {4} on: {5}',\r\n previousDirective.name, wrapModuleNameIfDefined(previousDirective.$$moduleName),\r\n directive.name, wrapModuleNameIfDefined(directive.$$moduleName), 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 var templateNodeParent = templateNode.parent(),\r\n hasCompileParent = !!templateNodeParent.length;\r\n\r\n // When transcluding a template that has bindings in the root\r\n // we don't have a parent and thus need to add the class during linking fn.\r\n if (hasCompileParent) compile.$$addBindingClass(templateNodeParent);\r\n\r\n return function textInterpolateLinkFn(scope, node) {\r\n var parent = node.parent();\r\n if (!hasCompileParent) compile.$$addBindingClass(parent);\r\n compile.$$addBindingInfo(parent, interpolateFn.expressions);\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 wrapTemplate(type, template) {\r\n type = lowercase(type || 'html');\r\n switch (type) {\r\n case 'svg':\r\n case 'math':\r\n var wrapper = document.createElement('div');\r\n wrapper.innerHTML = '<' + type + '>' + template + '';\r\n return wrapper.childNodes[0].childNodes;\r\n default:\r\n return template;\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, allOrNothing) {\r\n var trustedContext = getTrustedContext(node, name);\r\n allOrNothing = ALL_OR_NOTHING_ATTRS[name] || allOrNothing;\r\n\r\n var interpolateFn = $interpolate(value, true, trustedContext, allOrNothing);\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 // If the attribute has changed since last $interpolate()ed\r\n var newValue = attr[name];\r\n if (newValue !== value) {\r\n // we need to interpolate again since the attribute value has been updated\r\n // (e.g. by another directive's compile function)\r\n // ensure unset/empty values make interpolateFn falsy\r\n interpolateFn = newValue && $interpolate(newValue, true, trustedContext, allOrNothing);\r\n value = newValue;\r\n }\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 // initialize attr object so that it's ready in case we need the value for isolate\r\n // scope initialization, otherwise the value would not be available from isolate\r\n // directive's linking fn during linking phase\r\n attr[name] = interpolateFn(scope);\r\n\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\r\n // If the replaced element is also the jQuery .context then replace it\r\n // .context is a deprecated jQuery api, so we should set it only when jQuery set it\r\n // http://api.jquery.com/context/\r\n if ($rootElement.context === firstElementToRemove) {\r\n $rootElement.context = newNode;\r\n }\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\r\n // TODO(perf): what's this document fragment for? is it needed? can we at least reuse it?\r\n var fragment = document.createDocumentFragment();\r\n fragment.appendChild(firstElementToRemove);\r\n\r\n if (jqLite.hasData(firstElementToRemove)) {\r\n // Copy over user data (that includes Angular's $scope etc.). Don't copy private\r\n // data here because there's no public interface in jQuery to do that and copying over\r\n // event listeners (which is the main use of private data) wouldn't work anyway.\r\n jqLite(newNode).data(jqLite(firstElementToRemove).data());\r\n\r\n // Remove data of the replaced element. We cannot just call .remove()\r\n // on the element it since that would deallocate scope that is needed\r\n // for the new node. Instead, remove the data \"manually\".\r\n if (!jQuery) {\r\n delete jqLite.cache[firstElementToRemove[jqLite.expando]];\r\n } else {\r\n // jQuery 2.x doesn't expose the data storage. Use jQuery.cleanData to clean up after\r\n // the replaced element. The cleanData version monkey-patched by Angular would cause\r\n // the scope to be trashed and we do need the very same scope to work with the new\r\n // element. However, we cannot just cache the non-patched version and use it here as\r\n // that would break if another library patches the method after Angular does (one\r\n // example is jQuery UI). Instead, set a flag indicating scope destroying should be\r\n // skipped this one time.\r\n skipDestroyOnNextJQueryCleanData = true;\r\n jQuery.cleanData([firstElementToRemove]);\r\n }\r\n }\r\n\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 function invokeLinkFn(linkFn, scope, $element, attrs, controllers, transcludeFn) {\r\n try {\r\n linkFn(scope, $element, attrs, controllers, transcludeFn);\r\n } catch (e) {\r\n $exceptionHandler(e, startingTag($element));\r\n }\r\n }\r\n\r\n\r\n // Set up $watches for isolate scope and controller bindings. This process\r\n // only occurs for isolate scopes and new scopes with controllerAs.\r\n function initializeDirectiveBindings(scope, attrs, destination, bindings,\r\n directive, newScope) {\r\n var onNewScopeDestroyed;\r\n forEach(bindings, function(definition, scopeName) {\r\n var attrName = definition.attrName,\r\n optional = definition.optional,\r\n mode = definition.mode, // @, =, or &\r\n lastValue,\r\n parentGet, parentSet, compare;\r\n\r\n switch (mode) {\r\n\r\n case '@':\r\n if (!optional && !hasOwnProperty.call(attrs, attrName)) {\r\n destination[scopeName] = attrs[attrName] = void 0;\r\n }\r\n attrs.$observe(attrName, function(value) {\r\n if (isString(value)) {\r\n destination[scopeName] = value;\r\n }\r\n });\r\n attrs.$$observers[attrName].$$scope = scope;\r\n if (isString(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 destination[scopeName] = $interpolate(attrs[attrName])(scope);\r\n }\r\n break;\r\n\r\n case '=':\r\n if (!hasOwnProperty.call(attrs, attrName)) {\r\n if (optional) break;\r\n attrs[attrName] = void 0;\r\n }\r\n if (optional && !attrs[attrName]) break;\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 = destination[scopeName] = parentGet(scope);\r\n throw $compileMinErr('nonassign',\r\n \"Expression '{0}' used with directive '{1}' is non-assignable!\",\r\n attrs[attrName], directive.name);\r\n };\r\n lastValue = destination[scopeName] = parentGet(scope);\r\n var parentValueWatch = function parentValueWatch(parentValue) {\r\n if (!compare(parentValue, destination[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 destination[scopeName] = parentValue;\r\n } else {\r\n // if the parent can be assigned then do so\r\n parentSet(scope, parentValue = destination[scopeName]);\r\n }\r\n }\r\n return lastValue = parentValue;\r\n };\r\n parentValueWatch.$stateful = true;\r\n var unwatch;\r\n if (definition.collection) {\r\n unwatch = scope.$watchCollection(attrs[attrName], parentValueWatch);\r\n } else {\r\n unwatch = scope.$watch($parse(attrs[attrName], parentValueWatch), null, parentGet.literal);\r\n }\r\n onNewScopeDestroyed = (onNewScopeDestroyed || []);\r\n onNewScopeDestroyed.push(unwatch);\r\n break;\r\n\r\n case '&':\r\n // Don't assign Object.prototype method to scope\r\n parentGet = attrs.hasOwnProperty(attrName) ? $parse(attrs[attrName]) : noop;\r\n\r\n // Don't assign noop to destination if expression is not valid\r\n if (parentGet === noop && optional) break;\r\n\r\n destination[scopeName] = function(locals) {\r\n return parentGet(scope, locals);\r\n };\r\n break;\r\n }\r\n });\r\n var destroyBindings = onNewScopeDestroyed ? function destroyBindings() {\r\n for (var i = 0, ii = onNewScopeDestroyed.length; i < ii; ++i) {\r\n onNewScopeDestroyed[i]();\r\n }\r\n } : noop;\r\n if (newScope && destroyBindings !== noop) {\r\n newScope.$on('$destroy', destroyBindings);\r\n return noop;\r\n }\r\n return destroyBindings;\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 * @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\nfunction removeComments(jqNodes) {\r\n jqNodes = jqLite(jqNodes);\r\n var i = jqNodes.length;\r\n\r\n if (i <= 1) {\r\n return jqNodes;\r\n }\r\n\r\n while (i--) {\r\n var node = jqNodes[i];\r\n if (node.nodeType === NODE_TYPE_COMMENT) {\r\n splice.call(jqNodes, i, 1);\r\n }\r\n }\r\n return jqNodes;\r\n}\r\n\r\nvar $controllerMinErr = minErr('$controller');\r\n\r\n\r\nvar CNTRL_REG = /^(\\S+)(\\s+as\\s+(\\w+))?$/;\r\nfunction identifierForController(controller, ident) {\r\n if (ident && isString(ident)) return ident;\r\n if (isString(controller)) {\r\n var match = CNTRL_REG.exec(controller);\r\n if (match) return match[3];\r\n }\r\n}\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 globals = false;\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 * @ngdoc method\r\n * @name $controllerProvider#allowGlobals\r\n * @description If called, allows `$controller` to find controller constructors on `window`\r\n */\r\n this.allowGlobals = function() {\r\n globals = true;\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 * * if $controllerProvider#allowGlobals, check `window[constructor]` on the global\r\n * `window` object (not recommended)\r\n *\r\n * The string can use the `controller as property` syntax, where the controller instance is published\r\n * as the specified property on the `scope`; the `scope` must be injected into `locals` param for this\r\n * to work correctly.\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, later, ident) {\r\n // PRIVATE API:\r\n // param `later` --- indicates that the controller's constructor is invoked at a later time.\r\n // If true, $controller will allocate the object with the correct\r\n // prototype chain, but will not invoke the controller until a returned\r\n // callback is invoked.\r\n // param `ident` --- An optional label which overrides the label parsed from the controller\r\n // expression, if any.\r\n var instance, match, constructor, identifier;\r\n later = later === true;\r\n if (ident && isString(ident)) {\r\n identifier = ident;\r\n }\r\n\r\n if (isString(expression)) {\r\n match = expression.match(CNTRL_REG);\r\n if (!match) {\r\n throw $controllerMinErr('ctrlfmt',\r\n \"Badly formed controller string '{0}'. \" +\r\n \"Must match `__name__ as __id__` or `__name__`.\", expression);\r\n }\r\n constructor = match[1],\r\n identifier = identifier || match[3];\r\n expression = controllers.hasOwnProperty(constructor)\r\n ? controllers[constructor]\r\n : getter(locals.$scope, constructor, true) ||\r\n (globals ? getter($window, constructor, true) : undefined);\r\n\r\n assertArgFn(expression, constructor, true);\r\n }\r\n\r\n if (later) {\r\n // Instantiate controller later:\r\n // This machinery is used to create an instance of the object before calling the\r\n // controller's constructor itself.\r\n //\r\n // This allows properties to be added to the controller before the constructor is\r\n // invoked. Primarily, this is used for isolate scope bindings in $compile.\r\n //\r\n // This feature is not intended for use by applications, and is thus not documented\r\n // publicly.\r\n // Object creation: http://jsperf.com/create-constructor/2\r\n var controllerPrototype = (isArray(expression) ?\r\n expression[expression.length - 1] : expression).prototype;\r\n instance = Object.create(controllerPrototype || null);\r\n\r\n if (identifier) {\r\n addIdentifier(locals, identifier, instance, constructor || expression.name);\r\n }\r\n\r\n var instantiate;\r\n return instantiate = extend(function() {\r\n var result = $injector.invoke(expression, instance, locals, constructor);\r\n if (result !== instance && (isObject(result) || isFunction(result))) {\r\n instance = result;\r\n if (identifier) {\r\n // If result changed, re-assign controllerAs value to scope.\r\n addIdentifier(locals, identifier, instance, constructor || expression.name);\r\n }\r\n }\r\n return instance;\r\n }, {\r\n instance: instance,\r\n identifier: identifier\r\n });\r\n }\r\n\r\n instance = $injector.instantiate(expression, locals, constructor);\r\n\r\n if (identifier) {\r\n addIdentifier(locals, identifier, instance, constructor || expression.name);\r\n }\r\n\r\n return instance;\r\n };\r\n\r\n function addIdentifier(locals, identifier, instance, name) {\r\n if (!(locals && isObject(locals.$scope))) {\r\n throw minErr('$controller')('noscp',\r\n \"Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.\",\r\n name, identifier);\r\n }\r\n\r\n locals.$scope[identifier] = 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
$document title:
\r\n
window.document title:
\r\n
\r\n * Note, that code executed in event-listeners (even those registered using jqLite's `on`/`bind`\r\n * methods) does not delegate exceptions to the {@link ng.$exceptionHandler $exceptionHandler}\r\n * (unless executed during a digest).\r\n *\r\n * If you wish, you can manually delegate exceptions, e.g.\r\n * `try { ... } catch(e) { $exceptionHandler(e); }`\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\nvar $$ForceReflowProvider = function() {\r\n this.$get = ['$document', function($document) {\r\n return function(domNode) {\r\n //the line below will force the browser to perform a repaint so\r\n //that all the animated elements within the animation frame will\r\n //be properly updated and drawn on screen. This is required to\r\n //ensure that the preparation animation is properly flushed so that\r\n //the active state picks up from there. DO NOT REMOVE THIS LINE.\r\n //DO NOT OPTIMIZE THIS LINE. THE MINIFIER WILL REMOVE IT OTHERWISE WHICH\r\n //WILL RESULT IN AN UNPREDICTABLE BUG THAT IS VERY HARD TO TRACK DOWN AND\r\n //WILL TAKE YEARS AWAY FROM YOUR LIFE.\r\n if (domNode) {\r\n if (!domNode.nodeType && domNode instanceof jqLite) {\r\n domNode = domNode[0];\r\n }\r\n } else {\r\n domNode = $document[0].body;\r\n }\r\n return domNode.offsetWidth + 1;\r\n };\r\n }];\r\n};\r\n\r\nvar APPLICATION_JSON = 'application/json';\r\nvar CONTENT_TYPE_APPLICATION_JSON = {'Content-Type': APPLICATION_JSON + ';charset=utf-8'};\r\nvar JSON_START = /^\\[|^\\{(?!\\{)/;\r\nvar JSON_ENDS = {\r\n '[': /]$/,\r\n '{': /}$/\r\n};\r\nvar JSON_PROTECTION_PREFIX = /^\\)\\]\\}',?\\n/;\r\nvar $httpMinErr = minErr('$http');\r\nvar $httpMinErrLegacyFn = function(method) {\r\n return function() {\r\n throw $httpMinErr('legacy', 'The method `{0}` on the promise returned from `$http` has been disabled.', method);\r\n };\r\n};\r\n\r\nfunction serializeValue(v) {\r\n if (isObject(v)) {\r\n return isDate(v) ? v.toISOString() : toJson(v);\r\n }\r\n return v;\r\n}\r\n\r\n\r\nfunction $HttpParamSerializerProvider() {\r\n /**\r\n * @ngdoc service\r\n * @name $httpParamSerializer\r\n * @description\r\n *\r\n * Default {@link $http `$http`} params serializer that converts objects to strings\r\n * according to the following rules:\r\n *\r\n * * `{'foo': 'bar'}` results in `foo=bar`\r\n * * `{'foo': Date.now()}` results in `foo=2015-04-01T09%3A50%3A49.262Z` (`toISOString()` and encoded representation of a Date object)\r\n * * `{'foo': ['bar', 'baz']}` results in `foo=bar&foo=baz` (repeated key for each array element)\r\n * * `{'foo': {'bar':'baz'}}` results in `foo=%7B%22bar%22%3A%22baz%22%7D\"` (stringified and encoded representation of an object)\r\n *\r\n * Note that serializer will sort the request parameters alphabetically.\r\n * */\r\n\r\n this.$get = function() {\r\n return function ngParamSerializer(params) {\r\n if (!params) return '';\r\n var parts = [];\r\n forEachSorted(params, function(value, key) {\r\n if (value === null || isUndefined(value)) return;\r\n if (isArray(value)) {\r\n forEach(value, function(v, k) {\r\n parts.push(encodeUriQuery(key) + '=' + encodeUriQuery(serializeValue(v)));\r\n });\r\n } else {\r\n parts.push(encodeUriQuery(key) + '=' + encodeUriQuery(serializeValue(value)));\r\n }\r\n });\r\n\r\n return parts.join('&');\r\n };\r\n };\r\n}\r\n\r\nfunction $HttpParamSerializerJQLikeProvider() {\r\n /**\r\n * @ngdoc service\r\n * @name $httpParamSerializerJQLike\r\n * @description\r\n *\r\n * Alternative {@link $http `$http`} params serializer that follows\r\n * jQuery's [`param()`](http://api.jquery.com/jquery.param/) method logic.\r\n * The serializer will also sort the params alphabetically.\r\n *\r\n * To use it for serializing `$http` request parameters, set it as the `paramSerializer` property:\r\n *\r\n * ```js\r\n * $http({\r\n * url: myUrl,\r\n * method: 'GET',\r\n * params: myParams,\r\n * paramSerializer: '$httpParamSerializerJQLike'\r\n * });\r\n * ```\r\n *\r\n * It is also possible to set it as the default `paramSerializer` in the\r\n * {@link $httpProvider#defaults `$httpProvider`}.\r\n *\r\n * Additionally, you can inject the serializer and use it explicitly, for example to serialize\r\n * form data for submission:\r\n *\r\n * ```js\r\n * .controller(function($http, $httpParamSerializerJQLike) {\r\n * //...\r\n *\r\n * $http({\r\n * url: myUrl,\r\n * method: 'POST',\r\n * data: $httpParamSerializerJQLike(myData),\r\n * headers: {\r\n * 'Content-Type': 'application/x-www-form-urlencoded'\r\n * }\r\n * });\r\n *\r\n * });\r\n * ```\r\n *\r\n * */\r\n this.$get = function() {\r\n return function jQueryLikeParamSerializer(params) {\r\n if (!params) return '';\r\n var parts = [];\r\n serialize(params, '', true);\r\n return parts.join('&');\r\n\r\n function serialize(toSerialize, prefix, topLevel) {\r\n if (toSerialize === null || isUndefined(toSerialize)) return;\r\n if (isArray(toSerialize)) {\r\n forEach(toSerialize, function(value, index) {\r\n serialize(value, prefix + '[' + (isObject(value) ? index : '') + ']');\r\n });\r\n } else if (isObject(toSerialize) && !isDate(toSerialize)) {\r\n forEachSorted(toSerialize, function(value, key) {\r\n serialize(value, prefix +\r\n (topLevel ? '' : '[') +\r\n key +\r\n (topLevel ? '' : ']'));\r\n });\r\n } else {\r\n parts.push(encodeUriQuery(prefix) + '=' + encodeUriQuery(serializeValue(toSerialize)));\r\n }\r\n }\r\n };\r\n };\r\n}\r\n\r\nfunction defaultHttpResponseTransform(data, headers) {\r\n if (isString(data)) {\r\n // Strip json vulnerability protection prefix and trim whitespace\r\n var tempData = data.replace(JSON_PROTECTION_PREFIX, '').trim();\r\n\r\n if (tempData) {\r\n var contentType = headers('Content-Type');\r\n if ((contentType && (contentType.indexOf(APPLICATION_JSON) === 0)) || isJsonLike(tempData)) {\r\n data = fromJson(tempData);\r\n }\r\n }\r\n }\r\n\r\n return data;\r\n}\r\n\r\nfunction isJsonLike(str) {\r\n var jsonStart = str.match(JSON_START);\r\n return jsonStart && JSON_ENDS[jsonStart[0]].test(str);\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 = createMap(), i;\r\n\r\n function fillInParsed(key, val) {\r\n if (key) {\r\n parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;\r\n }\r\n }\r\n\r\n if (isString(headers)) {\r\n forEach(headers.split('\\n'), function(line) {\r\n i = line.indexOf(':');\r\n fillInParsed(lowercase(trim(line.substr(0, i))), trim(line.substr(i + 1)));\r\n });\r\n } else if (isObject(headers)) {\r\n forEach(headers, function(headerVal, headerKey) {\r\n fillInParsed(lowercase(headerKey), trim(headerVal));\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;\r\n\r\n return function(name) {\r\n if (!headersObj) headersObj = parseHeaders(headers);\r\n\r\n if (name) {\r\n var value = headersObj[lowercase(name)];\r\n if (value === void 0) {\r\n value = null;\r\n }\r\n return value;\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 {number} status HTTP status code of the response.\r\n * @param {(Function|Array.)} fns Function or an array of functions.\r\n * @returns {*} Transformed data.\r\n */\r\nfunction transformData(data, headers, status, fns) {\r\n if (isFunction(fns)) {\r\n return fns(data, headers, status);\r\n }\r\n\r\n forEach(fns, function(fn) {\r\n data = fn(data, headers, status);\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 /**\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.cache`** - {Object} - an object built with {@link ng.$cacheFactory `$cacheFactory`}\r\n * that will provide the cache for all requests who set their `cache` property to `true`.\r\n * If you set the `defaults.cache = false` then only requests that specify their own custom\r\n * cache object will be cached. See {@link $http#caching $http Caching} for more information.\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 *\r\n * - **`defaults.paramSerializer`** - `{string|function(Object):string}` - A function\r\n * used to the prepare string representation of request parameters (specified as an object).\r\n * If specified as string, it is interpreted as a function registered with the {@link auto.$injector $injector}.\r\n * Defaults to {@link ng.$httpParamSerializer $httpParamSerializer}.\r\n *\r\n **/\r\n var defaults = this.defaults = {\r\n // transform incoming response data\r\n transformResponse: [defaultHttpResponseTransform],\r\n\r\n // transform outgoing request data\r\n transformRequest: [function(d) {\r\n return isObject(d) && !isFile(d) && !isBlob(d) && !isFormData(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 paramSerializer: '$httpParamSerializer'\r\n };\r\n\r\n var useApplyAsync = false;\r\n /**\r\n * @ngdoc method\r\n * @name $httpProvider#useApplyAsync\r\n * @description\r\n *\r\n * Configure $http service to combine processing of multiple http responses received at around\r\n * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in\r\n * significant performance improvement for bigger applications that make many HTTP requests\r\n * concurrently (common during application bootstrap).\r\n *\r\n * Defaults to false. If no value is specified, returns the current configured value.\r\n *\r\n * @param {boolean=} value If true, when requests are loaded, they will schedule a deferred\r\n * \"apply\" on the next tick, giving time for subsequent requests in a roughly ~10ms window\r\n * to load and share the same digest cycle.\r\n *\r\n * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining.\r\n * otherwise, returns the current configured value.\r\n **/\r\n this.useApplyAsync = function(value) {\r\n if (isDefined(value)) {\r\n useApplyAsync = !!value;\r\n return this;\r\n }\r\n return useApplyAsync;\r\n };\r\n\r\n var useLegacyPromise = true;\r\n /**\r\n * @ngdoc method\r\n * @name $httpProvider#useLegacyPromiseExtensions\r\n * @description\r\n *\r\n * Configure `$http` service to return promises without the shorthand methods `success` and `error`.\r\n * This should be used to make sure that applications work without these methods.\r\n *\r\n * Defaults to false. If no value is specified, returns the current configured value.\r\n *\r\n * @param {boolean=} value If true, `$http` will return a normal promise without the `success` and `error` methods.\r\n *\r\n * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining.\r\n * otherwise, returns the current configured value.\r\n **/\r\n this.useLegacyPromiseExtensions = function(value) {\r\n if (isDefined(value)) {\r\n useLegacyPromise = !!value;\r\n return this;\r\n }\r\n return useLegacyPromise;\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 this.$get = ['$httpBackend', '$$cookieReader', '$cacheFactory', '$rootScope', '$q', '$injector',\r\n function($httpBackend, $$cookieReader, $cacheFactory, $rootScope, $q, $injector) {\r\n\r\n var defaultCache = $cacheFactory('$http');\r\n\r\n /**\r\n * Make sure that default param serializer is exposed as a function\r\n */\r\n defaults.paramSerializer = isString(defaults.paramSerializer) ?\r\n $injector.get(defaults.paramSerializer) : defaults.paramSerializer;\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 /**\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 *\r\n * ```js\r\n * // Simple GET request example :\r\n * $http.get('/someUrl').\r\n * then(function(response) {\r\n * // this callback will be called asynchronously\r\n * // when the response is available\r\n * }, function(response) {\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 * ```js\r\n * // Simple POST request example (passing data) :\r\n * $http.post('/someUrl', {msg:'hello word!'}).\r\n * then(function(response) {\r\n * // this callback will be called asynchronously\r\n * // when the response is available\r\n * }, function(response) {\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 * 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 * 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').then(successCallback);\r\n * $http.post('/someUrl', data).then(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 * ## Deprecation Notice\r\n * \r\n * The `$http` legacy promise methods `success` and `error` have been deprecated.\r\n * Use the standard `then` method instead.\r\n * If {@link $httpProvider#useLegacyPromiseExtensions `$httpProvider.useLegacyPromiseExtensions`} is set to\r\n * `false` then these methods will throw {@link $http:legacy `$http/legacy`} error.\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 * To explicitly remove a header automatically added via $httpProvider.defaults.headers on a per request basis,\r\n * Use the `headers` property, setting the desired header to `undefined`. For example:\r\n *\r\n * ```js\r\n * var req = {\r\n * method: 'POST',\r\n * url: 'http://example.com',\r\n * headers: {\r\n * 'Content-Type': undefined\r\n * },\r\n * data: { test: 'test' }\r\n * }\r\n *\r\n * $http(req).then(function(){...}, function(){...});\r\n * ```\r\n *\r\n * ## Transforming Requests and Responses\r\n *\r\n * Both requests and responses can be transformed using transformation functions: `transformRequest`\r\n * and `transformResponse`. These properties can be a single function that returns\r\n * the transformed value (`function(data, headersGetter, status)`) or an array of such transformation functions,\r\n * which allows you to `push` or `unshift` a new transformation function into the transformation chain.\r\n *\r\n * ### Default Transformations\r\n *\r\n * The `$httpProvider` provider and `$http` service expose `defaults.transformRequest` and\r\n * `defaults.transformResponse` properties. If a request does not provide its own transformations\r\n * then these will be applied.\r\n *\r\n * You can augment or replace the default transformations by modifying these properties by adding to or\r\n * replacing the array.\r\n *\r\n * Angular provides the following default transformations:\r\n *\r\n * Request transformations (`$httpProvider.defaults.transformRequest` and `$http.defaults.transformRequest`):\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 (`$httpProvider.defaults.transformResponse` and `$http.defaults.transformResponse`):\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 *\r\n * ### Overriding the Default Transformations Per Request\r\n *\r\n * If you wish override the request/response transformations only for a single request then provide\r\n * `transformRequest` and/or `transformResponse` properties on the configuration object passed\r\n * into `$http`.\r\n *\r\n * Note that if you provide these properties on the config object the default transformations will be\r\n * overwritten. If you wish to augment the default transformations then you must include them in your\r\n * local transformation array.\r\n *\r\n * The following code demonstrates adding a new response transformation to be run after the default response\r\n * transformations have been run.\r\n *\r\n * ```js\r\n * function appendTransform(defaults, transform) {\r\n *\r\n * // We can't guarantee that the default transformation is an array\r\n * defaults = angular.isArray(defaults) ? defaults : [defaults];\r\n *\r\n * // Append the new transformation to the defaults\r\n * return defaults.concat(transform);\r\n * }\r\n *\r\n * $http({\r\n * url: '...',\r\n * method: 'GET',\r\n * transformResponse: appendTransform($http.defaults.transformResponse, function(value) {\r\n * return doTransform(value);\r\n * })\r\n * });\r\n * ```\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#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 * ## 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 * In order to prevent collisions in environments where multiple Angular apps share the\r\n * same domain or subdomain, we recommend that each application uses unique cookie name.\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 serialized\r\n * with the `paramSerializer` and appended as GET parameters.\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. Functions accept a config object as an argument.\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 * See {@link ng.$http#overriding-the-default-transformations-per-request\r\n * Overriding the Default Transformations}\r\n * - **transformResponse** –\r\n * `{function(data, headersGetter, status)|Array.}` –\r\n * transform function or an array of such functions. The transform function takes the http\r\n * response body, headers and status and returns its transformed (typically deserialized) version.\r\n * See {@link ng.$http#overriding-the-default-transformations-per-request\r\n * Overriding the Default TransformationjqLiks}\r\n * - **paramSerializer** - `{string|function(Object):string}` - A function used to\r\n * prepare the string representation of request parameters (specified as an object).\r\n * If specified as string, it is interpreted as function registered with the\r\n * {@link $injector $injector}, which means you can create your own serializer\r\n * by registering it as a {@link auto.$provide#service service}.\r\n * The default serializer is the {@link $httpParamSerializer $httpParamSerializer};\r\n * alternatively, you can use the {@link $httpParamSerializerJQLike $httpParamSerializerJQLike}\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 * [XMLHttpRequest.responseType](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest#xmlhttprequest-responsetype).\r\n *\r\n * @returns {HttpPromise} Returns a {@link ng.$q `Promise}` that will be resolved to a response object\r\n * when the request succeeds or fails.\r\n *\r\n *\r\n * @property {Array.