terser, angular

beutified.js

/**
 * @license AngularJS v1.2.5
 * (c) 2010-2014 Google, Inc. http://angularjs.org
 * License: MIT
 */
(function (window, document, undefined) {
    "use strict";

    function minErr(module) {
        return function () {
            var code = arguments[0],
                prefix = "[" + (module ? module + ":" : "") + code + "] ",
                template = arguments[1],
                templateArgs = arguments,
                stringify = function (obj) {
                    if (typeof obj === "function") {
                        return obj.toString().replace(/ \{[\s\S]*$/, "")
                    } else if (typeof obj === "undefined") {
                        return "undefined"
                    } else if (typeof obj !== "string") {
                        return JSON.stringify(obj)
                    }
                    return obj
                },
                message, i;
            message = prefix + template.replace(/\{\d+\}/g, (function (match) {
                var index = +match.slice(1, -1),
                    arg;
                if (index + 2 < templateArgs.length) {
                    arg = templateArgs[index + 2];
                    if (typeof arg === "function") {
                        return arg.toString().replace(/ ?\{[\s\S]*$/, "")
                    } else if (typeof arg === "undefined") {
                        return "undefined"
                    } else if (typeof arg !== "string") {
                        return toJson(arg)
                    }
                    return arg
                }
                return match
            }));
            message = message + "\nhttp://errors.angularjs.org/1.2.5/" + (module ? module + "/" : "") + code;
            for (i = 2; i < arguments.length; i++) {
                message = message + (i == 2 ? "?" : "&") + "p" + (i - 2) + "=" + encodeURIComponent(stringify(arguments[i]))
            }
            return new Error(message)
        }
    }
    var lowercase = function (string) {
        return isString(string) ? string.toLowerCase() : string
    };
    var uppercase = function (string) {
        return isString(string) ? string.toUpperCase() : string
    };
    var manualLowercase = function (s) {
        return isString(s) ? s.replace(/[A-Z]/g, (function (ch) {
            return String.fromCharCode(ch.charCodeAt(0) | 32)
        })) : s
    };
    var manualUppercase = function (s) {
        return isString(s) ? s.replace(/[a-z]/g, (function (ch) {
            return String.fromCharCode(ch.charCodeAt(0) & ~32)
        })) : s
    };
    if ("i" !== "I".toLowerCase()) {
        lowercase = manualLowercase;
        uppercase = manualUppercase
    }
    var msie, jqLite, jQuery, slice = [].slice,
        push = [].push,
        toString = Object.prototype.toString,
        ngMinErr = minErr("ng"),
        _angular = window.angular,
        angular = window.angular || (window.angular = {}),
        angularModule, nodeName_, uid = ["0", "0", "0"];
    msie = int((/msie (\d+)/.exec(lowercase(navigator.userAgent)) || [])[1]);
    if (isNaN(msie)) {
        msie = int((/trident\/.*; rv:(\d+)/.exec(lowercase(navigator.userAgent)) || [])[1])
    }

    function isArrayLike(obj) {
        if (obj == null || isWindow(obj)) {
            return false
        }
        var length = obj.length;
        if (obj.nodeType === 1 && length) {
            return true
        }
        return isString(obj) || isArray(obj) || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj
    }

    function forEach(obj, iterator, context) {
        var key;
        if (obj) {
            if (isFunction(obj)) {
                for (key in obj) {
                    if (key != "prototype" && key != "length" && key != "name" && obj.hasOwnProperty(key)) {
                        iterator.call(context, obj[key], key)
                    }
                }
            } else if (obj.forEach && obj.forEach !== forEach) {
                obj.forEach(iterator, context)
            } else if (isArrayLike(obj)) {
                for (key = 0; key < obj.length; key++) iterator.call(context, obj[key], key)
            } else {
                for (key in obj) {
                    if (obj.hasOwnProperty(key)) {
                        iterator.call(context, obj[key], key)
                    }
                }
            }
        }
        return obj
    }

    function sortedKeys(obj) {
        var keys = [];
        for (var key in obj) {
            if (obj.hasOwnProperty(key)) {
                keys.push(key)
            }
        }
        return keys.sort()
    }

    function forEachSorted(obj, iterator, context) {
        var keys = sortedKeys(obj);
        for (var i = 0; i < keys.length; i++) {
            iterator.call(context, obj[keys[i]], keys[i])
        }
        return keys
    }

    function reverseParams(iteratorFn) {
        return function (value, key) {
            iteratorFn(key, value)
        }
    }

    function nextUid() {
        var index = uid.length;
        var digit;
        while (index) {
            index--;
            digit = uid[index].charCodeAt(0);
            if (digit == 57) {
                uid[index] = "A";
                return uid.join("")
            }
            if (digit == 90) {
                uid[index] = "0"
            } else {
                uid[index] = String.fromCharCode(digit + 1);
                return uid.join("")
            }
        }
        uid.unshift("0");
        return uid.join("")
    }

    function setHashKey(obj, h) {
        if (h) {
            obj.$$hashKey = h
        } else {
            delete obj.$$hashKey
        }
    }

    function extend(dst) {
        var h = dst.$$hashKey;
        forEach(arguments, (function (obj) {
            if (obj !== dst) {
                forEach(obj, (function (value, key) {
                    dst[key] = value
                }))
            }
        }));
        setHashKey(dst, h);
        return dst
    }

    function int(str) {
        return parseInt(str, 10)
    }

    function inherit(parent, extra) {
        return extend(new (extend((function () { }), {
            prototype: parent
        })), extra)
    }

    function noop() { }
    noop.$inject = [];

    function identity($) {
        return $
    }
    identity.$inject = [];

    function valueFn(value) {
        return function () {
            return value
        }
    }

    function isUndefined(value) {
        return typeof value === "undefined"
    }

    function isDefined(value) {
        return typeof value !== "undefined"
    }
    var isObject = globalThis.isObject;

    function isString(value) {
        return typeof value === "string"
    }

    function isNumber(value) {
        return typeof value === "number"
    }

    function isDate(value) {
        return toString.call(value) === "[object Date]"
    }

    function isArray(value) {
        return toString.call(value) === "[object Array]"
    }

    function isFunction(value) {
        return typeof value === "function"
    }

    function isRegExp(value) {
        return toString.call(value) === "[object RegExp]"
    }

    function isWindow(obj) {
        return obj && obj.document && obj.location && obj.alert && obj.setInterval
    }

    function isScope(obj) {
        return obj && obj.$evalAsync && obj.$watch
    }

    function isFile(obj) {
        return toString.call(obj) === "[object File]"
    }

    function isBoolean(value) {
        return typeof value === "boolean"
    }
    var trim = function () {
        if (!String.prototype.trim) {
            return function (value) {
                return isString(value) ? value.replace(/^\s\s*/, "").replace(/\s\s*$/, "") : value
            }
        }
        return function (value) {
            return isString(value) ? value.trim() : value
        }
    }();

    function isElement(node) {
        return !!(node && (node.nodeName || node.on && node.find))
    }

    function makeMap(str) {
        var obj = {},
            items = str.split(","),
            i;
        for (i = 0; i < items.length; i++) obj[items[i]] = true;
        return obj
    }
    if (msie < 9) {
        nodeName_ = function (element) {
            element = element.nodeName ? element : element[0];
            return element.scopeName && element.scopeName != "HTML" ? uppercase(element.scopeName + ":" + element.nodeName) : element.nodeName
        }
    } else {
        nodeName_ = function (element) {
            return element.nodeName ? element.nodeName : element[0].nodeName
        }
    }

    function map(obj, iterator, context) {
        var results = [];
        forEach(obj, (function (value, index, list) {
            results.push(iterator.call(context, value, index, list))
        }));
        return results
    }

    function size(obj, ownPropsOnly) {
        var count = 0,
            key;
        if (isArray(obj) || isString(obj)) {
            return obj.length
        } else if (isObject(obj)) {
            for (key in obj)
                if (!ownPropsOnly || obj.hasOwnProperty(key)) count++
        }
        return count
    }

    function includes(array, obj) {
        return indexOf(array, obj) != -1
    }

    function indexOf(array, obj) {
        if (array.indexOf) return array.indexOf(obj);
        for (var i = 0; i < array.length; i++) {
            if (obj === array[i]) return i
        }
        return -1
    }

    function arrayRemove(array, value) {
        var index = indexOf(array, value);
        if (index >= 0) array.splice(index, 1);
        return value
    }

    function isLeafNode(node) {
        if (node) {
            switch (node.nodeName) {
                case "OPTION":
                case "PRE":
                case "TITLE":
                    return true
            }
        }
        return false
    }

    function copy(source, destination) {
        if (isWindow(source) || isScope(source)) {
            throw ngMinErr("cpws", "Can't copy! Making copies of Window or Scope instances is not supported.")
        }
        if (!destination) {
            destination = source;
            if (source) {
                if (isArray(source)) {
                    destination = copy(source, [])
                } else if (isDate(source)) {
                    destination = new Date(source.getTime())
                } else if (isRegExp(source)) {
                    destination = new RegExp(source.source)
                } else if (isObject(source)) {
                    destination = copy(source, {})
                }
            }
        } else {
            if (source === destination) throw ngMinErr("cpi", "Can't copy! Source and destination are identical.");
            if (isArray(source)) {
                destination.length = 0;
                for (var i = 0; i < source.length; i++) {
                    destination.push(copy(source[i]))
                }
            } else {
                var h = destination.$$hashKey;
                forEach(destination, (function (value, key) {
                    delete destination[key]
                }));
                for (var key in source) {
                    destination[key] = copy(source[key])
                }
                setHashKey(destination, h)
            }
        }
        return destination
    }

    function shallowCopy(src, dst) {
        dst = dst || {};
        for (var key in src) {
            if (src.hasOwnProperty(key) && key.substr(0, 2) !== "$$") {
                dst[key] = src[key]
            }
        }
        return dst
    }

    function equals(o1, o2) {
        if (o1 === o2) return true;
        if (o1 === null || o2 === null) return false;
        if (o1 !== o1 && o2 !== o2) return true;
        var t1 = typeof o1,
            t2 = typeof o2,
            length, key, keySet;
        if (t1 == t2) {
            if (t1 == "object") {
                if (isArray(o1)) {
                    if (!isArray(o2)) return false;
                    if ((length = o1.length) == o2.length) {
                        for (key = 0; key < length; key++) {
                            if (!equals(o1[key], o2[key])) return false
                        }
                        return true
                    }
                } else if (isDate(o1)) {
                    return isDate(o2) && o1.getTime() == o2.getTime()
                } else if (isRegExp(o1) && isRegExp(o2)) {
                    return o1.toString() == o2.toString()
                } else {
                    if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) || isArray(o2)) return false;
                    keySet = {};
                    for (key in o1) {
                        if (key.charAt(0) === "$" || isFunction(o1[key])) continue;
                        if (!equals(o1[key], o2[key])) return false;
                        keySet[key] = true
                    }
                    for (key in o2) {
                        if (!keySet.hasOwnProperty(key) && key.charAt(0) !== "$" && o2[key] !== undefined && !isFunction(o2[key])) return false
                    }
                    return true
                }
            }
        }
        return false
    }

    function csp() {
        return document.securityPolicy && document.securityPolicy.isActive || document.querySelector && !!(document.querySelector("[ng-csp]") || document.querySelector("[data-ng-csp]"))
    }

    function concat(array1, array2, index) {
        return array1.concat(slice.call(array2, index))
    }

    function sliceArgs(args, startIndex) {
        return slice.call(args, startIndex || 0)
    }

    function bind(self, fn) {
        var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
        if (isFunction(fn) && !(fn instanceof RegExp)) {
            return curryArgs.length ? function () {
                return arguments.length ? fn.apply(self, curryArgs.concat(slice.call(arguments, 0))) : fn.apply(self, curryArgs)
            } : function () {
                return arguments.length ? fn.apply(self, arguments) : fn.call(self)
            }
        } else {
            return fn
        }
    }

    function toJsonReplacer(key, value) {
        var val = value;
        if (typeof key === "string" && key.charAt(0) === "$") {
            val = undefined
        } else if (isWindow(value)) {
            val = "$WINDOW"
        } else if (value && document === value) {
            val = "$DOCUMENT"
        } else if (isScope(value)) {
            val = "$SCOPE"
        }
        return val
    }

    function toJson(obj, pretty) {
        if (typeof obj === "undefined") return undefined;
        return JSON.stringify(obj, toJsonReplacer, pretty ? "  " : null)
    }

    function fromJson(json) {
        return isString(json) ? JSON.parse(json) : json
    }

    function toBoolean(value) {
        if (value && value.length !== 0) {
            var v = lowercase("" + value);
            value = !(v == "f" || v == "0" || v == "false" || v == "no" || v == "n" || v == "[]")
        } else {
            value = false
        }
        return value
    }

    function startingTag(element) {
        element = jqLite(element).clone();
        try {
            element.empty()
        } catch (e) { }
        var TEXT_NODE = 3;
        var elemHtml = jqLite("<div>").append(element).html();
        try {
            return element[0].nodeType === TEXT_NODE ? lowercase(elemHtml) : elemHtml.match(/^(<[^>]+>)/)[1].replace(/^<([\w\-]+)/, (function (match, nodeName) {
                return "<" + lowercase(nodeName)
            }))
        } catch (e) {
            return lowercase(elemHtml)
        }
    }

    function tryDecodeURIComponent(value) {
        try {
            return decodeURIComponent(value)
        } catch (e) { }
    }

    function parseKeyValue(keyValue) {
        var obj = {},
            key_value, key;
        forEach((keyValue || "").split("&"), (function (keyValue) {
            if (keyValue) {
                key_value = keyValue.split("=");
                key = tryDecodeURIComponent(key_value[0]);
                if (isDefined(key)) {
                    var val = isDefined(key_value[1]) ? tryDecodeURIComponent(key_value[1]) : true;
                    if (!obj[key]) {
                        obj[key] = val
                    } else if (isArray(obj[key])) {
                        obj[key].push(val)
                    } else {
                        obj[key] = [obj[key], val]
                    }
                }
            }
        }));
        return obj
    }

    function toKeyValue(obj) {
        var parts = [];
        forEach(obj, (function (value, key) {
            if (isArray(value)) {
                forEach(value, (function (arrayValue) {
                    parts.push(encodeUriQuery(key, true) + (arrayValue === true ? "" : "=" + encodeUriQuery(arrayValue, true)))
                }))
            } else {
                parts.push(encodeUriQuery(key, true) + (value === true ? "" : "=" + encodeUriQuery(value, true)))
            }
        }));
        return parts.length ? parts.join("&") : ""
    }

    function encodeUriSegment(val) {
        return encodeUriQuery(val, true).replace(/%26/gi, "&").replace(/%3D/gi, "=").replace(/%2B/gi, "+")
    }

    function encodeUriQuery(val, pctEncodeSpaces) {
        return encodeURIComponent(val).replace(/%40/gi, "@").replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, pctEncodeSpaces ? "%20" : "+")
    }

    function angularInit(element, bootstrap) {
        var elements = [element],
            appElement, module, names = ["ng:app", "ng-app", "x-ng-app", "data-ng-app"],
            NG_APP_CLASS_REGEXP = /\sng[:\-]app(:\s*([\w\d_]+);?)?\s/;

        function append(element) {
            element && elements.push(element)
        }
        forEach(names, (function (name) {
            names[name] = true;
            append(document.getElementById(name));
            name = name.replace(":", "\\:");
            if (element.querySelectorAll) {
                forEach(element.querySelectorAll("." + name), append);
                forEach(element.querySelectorAll("." + name + "\\:"), append);
                forEach(element.querySelectorAll("[" + name + "]"), append)
            }
        }));
        forEach(elements, (function (element) {
            if (!appElement) {
                var className = " " + element.className + " ";
                var match = NG_APP_CLASS_REGEXP.exec(className);
                if (match) {
                    appElement = element;
                    module = (match[2] || "").replace(/\s+/g, ",")
                } else {
                    forEach(element.attributes, (function (attr) {
                        if (!appElement && names[attr.name]) {
                            appElement = element;
                            module = attr.value
                        }
                    }))
                }
            }
        }));
        if (appElement) {
            bootstrap(appElement, module ? [module] : [])
        }
    }

    function bootstrap(element, modules) {
        var doBootstrap = function () {
            element = jqLite(element);
            if (element.injector()) {
                var tag = element[0] === document ? "document" : startingTag(element);
                throw ngMinErr("btstrpd", "App Already Bootstrapped with this Element '{0}'", tag)
            }
            modules = modules || [];
            modules.unshift(["$provide", function ($provide) {
                $provide.value("$rootElement", element)
            }]);
            modules.unshift("ng");
            var injector = createInjector(modules);
            injector.invoke(["$rootScope", "$rootElement", "$compile", "$injector", "$animate", function (scope, element, compile, injector, animate) {
                scope.$apply((function () {
                    element.data("$injector", injector);
                    compile(element)(scope)
                }))
            }]);
            return injector
        };
        var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;
        if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
            return doBootstrap()
        }
        window.name = window.name.replace(NG_DEFER_BOOTSTRAP, "");
        angular.resumeBootstrap = function (extraModules) {
            forEach(extraModules, (function (module) {
                modules.push(module)
            }));
            doBootstrap()
        }
    }
    var SNAKE_CASE_REGEXP = /[A-Z]/g;

    function snake_case(name, separator) {
        separator = separator || "_";
        return name.replace(SNAKE_CASE_REGEXP, (function (letter, pos) {
            return (pos ? separator : "") + letter.toLowerCase()
        }))
    }

    function bindJQuery() {
        jQuery = window.jQuery;
        if (jQuery) {
            jqLite = jQuery;
            extend(jQuery.fn, {
                scope: JQLitePrototype.scope,
                isolateScope: JQLitePrototype.isolateScope,
                controller: JQLitePrototype.controller,
                injector: JQLitePrototype.injector,
                inheritedData: JQLitePrototype.inheritedData
            });
            jqLitePatchJQueryRemove("remove", true, true, false);
            jqLitePatchJQueryRemove("empty", false, false, false);
            jqLitePatchJQueryRemove("html", false, false, true)
        } else {
            jqLite = JQLite
        }
        angular.element = jqLite
    }

    function assertArg(arg, name, reason) {
        if (!arg) {
            throw ngMinErr("areq", "Argument '{0}' is {1}", name || "?", reason || "required")
        }
        return arg
    }

    function assertArgFn(arg, name, acceptArrayAnnotation) {
        if (acceptArrayAnnotation && isArray(arg)) {
            arg = arg[arg.length - 1]
        }
        assertArg(isFunction(arg), name, "not a function, got " + (arg && typeof arg == "object" ? arg.constructor.name || "Object" : typeof arg));
        return arg
    }

    function assertNotHasOwnProperty(name, context) {
        if (name === "hasOwnProperty") {
            throw ngMinErr("badname", "hasOwnProperty is not a valid {0} name", context)
        }
    }

    function getter(obj, path, bindFnToScope) {
        if (!path) return obj;
        var keys = path.split(".");
        var key;
        var lastInstance = obj;
        var len = keys.length;
        for (var i = 0; i < len; i++) {
            key = keys[i];
            if (obj) {
                obj = (lastInstance = obj)[key]
            }
        }
        if (!bindFnToScope && isFunction(obj)) {
            return bind(lastInstance, obj)
        }
        return obj
    }

    function getBlockElements(nodes) {
        var startNode = nodes[0],
            endNode = nodes[nodes.length - 1];
        if (startNode === endNode) {
            return jqLite(startNode)
        }
        var element = startNode;
        var elements = [element];
        do {
            element = element.nextSibling;
            if (!element) break;
            elements.push(element)
        } while (element !== endNode);
        return jqLite(elements)
    }

    function setupModuleLoader(window) {
        var $injectorMinErr = minErr("$injector");
        var ngMinErr = minErr("ng");

        function ensure(obj, name, factory) {
            return obj[name] || (obj[name] = factory())
        }
        var angular = ensure(window, "angular", Object);
        angular.$$minErr = angular.$$minErr || minErr;
        return ensure(angular, "module", (function () {
            var modules = {};
            return function module(name, requires, configFn) {
                var assertNotHasOwnProperty = function (name, context) {
                    if (name === "hasOwnProperty") {
                        throw ngMinErr("badname", "hasOwnProperty is not a valid {0} name", context)
                    }
                };
                assertNotHasOwnProperty(name, "module");
                if (requires && modules.hasOwnProperty(name)) {
                    modules[name] = null
                }
                return ensure(modules, name, (function () {
                    if (!requires) {
                        throw $injectorMinErr("nomod", "Module '{0}' is not available! You either misspelled " + "the module name or forgot to load it. If registering a module ensure that you " + "specify the dependencies as the second argument.", name)
                    }
                    var invokeQueue = [];
                    var runBlocks = [];
                    var config = invokeLater("$injector", "invoke");
                    var moduleInstance = {
                        _invokeQueue: invokeQueue,
                        _runBlocks: runBlocks,
                        requires: requires,
                        name: name,
                        provider: invokeLater("$provide", "provider"),
                        factory: invokeLater("$provide", "factory"),
                        service: invokeLater("$provide", "service"),
                        value: invokeLater("$provide", "value"),
                        constant: invokeLater("$provide", "constant", "unshift"),
                        animation: invokeLater("$animateProvider", "register"),
                        filter: invokeLater("$filterProvider", "register"),
                        controller: invokeLater("$controllerProvider", "register"),
                        directive: invokeLater("$compileProvider", "directive"),
                        config: config,
                        run: function (block) {
                            runBlocks.push(block);
                            return this
                        }
                    };
                    if (configFn) {
                        config(configFn)
                    }
                    return moduleInstance;

                    function invokeLater(provider, method, insertMethod) {
                        return function () {
                            invokeQueue[insertMethod || "push"]([provider, method, arguments]);
                            return moduleInstance
                        }
                    }
                }))
            }
        }))
    }
    var version = {
        full: "1.2.5",
        major: 1,
        minor: 2,
        dot: 5,
        codeName: "singularity-expansion"
    };

    function publishExternalAPI(angular) {
        extend(angular, {
            bootstrap: bootstrap,
            copy: copy,
            extend: extend,
            equals: equals,
            element: jqLite,
            forEach: forEach,
            injector: createInjector,
            noop: noop,
            bind: bind,
            toJson: toJson,
            fromJson: fromJson,
            identity: identity,
            isUndefined: isUndefined,
            isDefined: isDefined,
            isString: isString,
            isFunction: isFunction,
            isObject: isObject,
            isNumber: isNumber,
            isElement: isElement,
            isArray: isArray,
            version: version,
            isDate: isDate,
            lowercase: lowercase,
            uppercase: uppercase,
            callbacks: {
                counter: 0
            },
            $$minErr: minErr,
            $$csp: csp
        });
        angularModule = setupModuleLoader(window);
        try {
            angularModule("ngLocale")
        } catch (e) {
            angularModule("ngLocale", []).provider("$locale", $LocaleProvider)
        }
        angularModule("ng", ["ngLocale"], ["$provide", function ngModule($provide) {
            $provide.provider({
                $$sanitizeUri: $$SanitizeUriProvider
            });
            $provide.provider("$compile", $CompileProvider).directive({
                a: htmlAnchorDirective,
                input: inputDirective,
                textarea: inputDirective,
                form: formDirective,
                script: scriptDirective,
                select: selectDirective,
                style: styleDirective,
                option: optionDirective,
                ngBind: ngBindDirective,
                ngBindHtml: ngBindHtmlDirective,
                ngBindTemplate: ngBindTemplateDirective,
                ngClass: ngClassDirective,
                ngClassEven: ngClassEvenDirective,
                ngClassOdd: ngClassOddDirective,
                ngCloak: ngCloakDirective,
                ngController: ngControllerDirective,
                ngForm: ngFormDirective,
                ngHide: ngHideDirective,
                ngIf: ngIfDirective,
                ngInclude: ngIncludeDirective,
                ngInit: ngInitDirective,
                ngNonBindable: ngNonBindableDirective,
                ngPluralize: ngPluralizeDirective,
                ngRepeat: ngRepeatDirective,
                ngShow: ngShowDirective,
                ngStyle: ngStyleDirective,
                ngSwitch: ngSwitchDirective,
                ngSwitchWhen: ngSwitchWhenDirective,
                ngSwitchDefault: ngSwitchDefaultDirective,
                ngOptions: ngOptionsDirective,
                ngTransclude: ngTranscludeDirective,
                ngModel: ngModelDirective,
                ngList: ngListDirective,
                ngChange: ngChangeDirective,
                required: requiredDirective,
                ngRequired: requiredDirective,
                ngValue: ngValueDirective
            }).directive({
                ngInclude: ngIncludeFillContentDirective
            }).directive(ngAttributeAliasDirectives).directive(ngEventDirectives);
            $provide.provider({
                $anchorScroll: $AnchorScrollProvider,
                $animate: $AnimateProvider,
                $browser: $BrowserProvider,
                $cacheFactory: $CacheFactoryProvider,
                $controller: $ControllerProvider,
                $document: $DocumentProvider,
                $exceptionHandler: $ExceptionHandlerProvider,
                $filter: $FilterProvider,
                $interpolate: $InterpolateProvider,
                $interval: $IntervalProvider,
                $http: $HttpProvider,
                $httpBackend: $HttpBackendProvider,
                $location: $LocationProvider,
                $log: $LogProvider,
                $parse: $ParseProvider,
                $rootScope: $RootScopeProvider,
                $q: $QProvider,
                $sce: $SceProvider,
                $sceDelegate: $SceDelegateProvider,
                $sniffer: $SnifferProvider,
                $templateCache: $TemplateCacheProvider,
                $timeout: $TimeoutProvider,
                $window: $WindowProvider
            })
        }])
    }
    var jqCache = JQLite.cache = {},
        jqName = JQLite.expando = "ng-" + (new Date).getTime(),
        jqId = 1,
        addEventListenerFn = window.document.addEventListener ? function (element, type, fn) {
            element.addEventListener(type, fn, false)
        } : function (element, type, fn) {
            element.attachEvent("on" + type, fn)
        },
        removeEventListenerFn = window.document.removeEventListener ? function (element, type, fn) {
            element.removeEventListener(type, fn, false)
        } : function (element, type, fn) {
            element.detachEvent("on" + type, fn)
        };

    function jqNextId() {
        return ++jqId
    }
    var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
    var MOZ_HACK_REGEXP = /^moz([A-Z])/;
    var jqLiteMinErr = minErr("jqLite");

    function camelCase(name) {
        return name.replace(SPECIAL_CHARS_REGEXP, (function (_, separator, letter, offset) {
            return offset ? letter.toUpperCase() : letter
        })).replace(MOZ_HACK_REGEXP, "Moz$1")
    }

    function jqLitePatchJQueryRemove(name, dispatchThis, filterElems, getterIfNoArguments) {
        var originalJqFn = jQuery.fn[name];
        originalJqFn = originalJqFn.$original || originalJqFn;
        removePatch.$original = originalJqFn;
        jQuery.fn[name] = removePatch;

        function removePatch(param) {
            var list = filterElems && param ? [this.filter(param)] : [this],
                fireEvent = dispatchThis,
                set, setIndex, setLength, element, childIndex, childLength, children;
            if (!getterIfNoArguments || param != null) {
                while (list.length) {
                    set = list.shift();
                    for (setIndex = 0, setLength = set.length; setIndex < setLength; setIndex++) {
                        element = jqLite(set[setIndex]);
                        if (fireEvent) {
                            element.triggerHandler("$destroy")
                        } else {
                            fireEvent = !fireEvent
                        }
                        for (childIndex = 0, childLength = (children = element.children()).length; childIndex < childLength; childIndex++) {
                            list.push(jQuery(children[childIndex]))
                        }
                    }
                }
            }
            return originalJqFn.apply(this, arguments)
        }
    }

    function JQLite(element) {
        if (element instanceof JQLite) {
            return element
        }
        if (!(this instanceof JQLite)) {
            if (isString(element) && element.charAt(0) != "<") {
                throw jqLiteMinErr("nosel", "Looking up elements via selectors is not supported by jqLite! See: http://docs.angularjs.org/api/angular.element")
            }
            return new JQLite(element)
        }
        if (isString(element)) {
            var div = document.createElement("div");
            div.innerHTML = "<div>&#160;</div>" + element;
            div.removeChild(div.firstChild);
            jqLiteAddNodes(this, div.childNodes);
            var fragment = jqLite(document.createDocumentFragment());
            fragment.append(this)
        } else {
            jqLiteAddNodes(this, element)
        }
    }

    function jqLiteClone(element) {
        return element.cloneNode(true)
    }

    function jqLiteDealoc(element) {
        jqLiteRemoveData(element);
        for (var i = 0, children = element.childNodes || []; i < children.length; i++) {
            jqLiteDealoc(children[i])
        }
    }

    function jqLiteOff(element, type, fn, unsupported) {
        if (isDefined(unsupported)) throw jqLiteMinErr("offargs", "jqLite#off() does not support the `selector` argument");
        var events = jqLiteExpandoStore(element, "events"),
            handle = jqLiteExpandoStore(element, "handle");
        if (!handle) return;
        if (isUndefined(type)) {
            forEach(events, (function (eventHandler, type) {
                removeEventListenerFn(element, type, eventHandler);
                delete events[type]
            }))
        } else {
            forEach(type.split(" "), (function (type) {
                if (isUndefined(fn)) {
                    removeEventListenerFn(element, type, events[type]);
                    delete events[type]
                } else {
                    arrayRemove(events[type] || [], fn)
                }
            }))
        }
    }

    function jqLiteRemoveData(element, name) {
        var expandoId = element[jqName],
            expandoStore = jqCache[expandoId];
        if (expandoStore) {
            if (name) {
                delete jqCache[expandoId].data[name];
                return
            }
            if (expandoStore.handle) {
                expandoStore.events.$destroy && expandoStore.handle({}, "$destroy");
                jqLiteOff(element)
            }
            delete jqCache[expandoId];
            element[jqName] = undefined
        }
    }

    function jqLiteExpandoStore(element, key, value) {
        var expandoId = element[jqName],
            expandoStore = jqCache[expandoId || -1];
        if (isDefined(value)) {
            if (!expandoStore) {
                element[jqName] = expandoId = jqNextId();
                expandoStore = jqCache[expandoId] = {}
            }
            expandoStore[key] = value
        } else {
            return expandoStore && expandoStore[key]
        }
    }

    function jqLiteData(element, key, value) {
        var data = jqLiteExpandoStore(element, "data"),
            isSetter = isDefined(value),
            keyDefined = !isSetter && isDefined(key),
            isSimpleGetter = keyDefined && !isObject(key);
        if (!data && !isSimpleGetter) {
            jqLiteExpandoStore(element, "data", data = {})
        }
        if (isSetter) {
            data[key] = value
        } else {
            if (keyDefined) {
                if (isSimpleGetter) {
                    return data && data[key]
                } else {
                    extend(data, key)
                }
            } else {
                return data
            }
        }
    }

    function jqLiteHasClass(element, selector) {
        if (!element.getAttribute) return false;
        return (" " + (element.getAttribute("class") || "") + " ").replace(/[\n\t]/g, " ").indexOf(" " + selector + " ") > -1
    }

    function jqLiteRemoveClass(element, cssClasses) {
        if (cssClasses && element.setAttribute) {
            forEach(cssClasses.split(" "), (function (cssClass) {
                element.setAttribute("class", trim((" " + (element.getAttribute("class") || "") + " ").replace(/[\n\t]/g, " ").replace(" " + trim(cssClass) + " ", " ")))
            }))
        }
    }

    function jqLiteAddClass(element, cssClasses) {
        if (cssClasses && element.setAttribute) {
            var existingClasses = (" " + (element.getAttribute("class") || "") + " ").replace(/[\n\t]/g, " ");
            forEach(cssClasses.split(" "), (function (cssClass) {
                cssClass = trim(cssClass);
                if (existingClasses.indexOf(" " + cssClass + " ") === -1) {
                    existingClasses += cssClass + " "
                }
            }));
            element.setAttribute("class", trim(existingClasses))
        }
    }

    function jqLiteAddNodes(root, elements) {
        if (elements) {
            elements = !elements.nodeName && isDefined(elements.length) && !isWindow(elements) ? elements : [elements];
            for (var i = 0; i < elements.length; i++) {
                root.push(elements[i])
            }
        }
    }

    function jqLiteController(element, name) {
        return jqLiteInheritedData(element, "$" + (name || "ngController") + "Controller")
    }

    function jqLiteInheritedData(element, name, value) {
        element = jqLite(element);
        if (element[0].nodeType == 9) {
            element = element.find("html")
        }
        var names = isArray(name) ? name : [name];
        while (element.length) {
            for (var i = 0, ii = names.length; i < ii; i++) {
                if ((value = element.data(names[i])) !== undefined) return value
            }
            element = element.parent()
        }
    }

    function jqLiteEmpty(element) {
        for (var i = 0, childNodes = element.childNodes; i < childNodes.length; i++) {
            jqLiteDealoc(childNodes[i])
        }
        while (element.firstChild) {
            element.removeChild(element.firstChild)
        }
    }
    var JQLitePrototype = JQLite.prototype = {
        ready: function (fn) {
            var fired = false;

            function trigger() {
                if (fired) return;
                fired = true;
                fn()
            }
            if (document.readyState === "complete") {
                setTimeout(trigger)
            } else {
                this.on("DOMContentLoaded", trigger);
                JQLite(window).on("load", trigger)
            }
        },
        toString: function () {
            var value = [];
            forEach(this, (function (e) {
                value.push("" + e)
            }));
            return "[" + value.join(", ") + "]"
        },
        eq: function (index) {
            return index >= 0 ? jqLite(this[index]) : jqLite(this[this.length + index])
        },
        length: 0,
        push: push,
        sort: [].sort,
        splice: [].splice
    };
    var BOOLEAN_ATTR = {};
    forEach("multiple,selected,checked,disabled,readOnly,required,open".split(","), (function (value) {
        BOOLEAN_ATTR[lowercase(value)] = value
    }));
    var BOOLEAN_ELEMENTS = {};
    forEach("input,select,option,textarea,button,form,details".split(","), (function (value) {
        BOOLEAN_ELEMENTS[uppercase(value)] = true
    }));

    function getBooleanAttrName(element, name) {
        var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
        return booleanAttr && BOOLEAN_ELEMENTS[element.nodeName] && booleanAttr
    }
    forEach({
        data: jqLiteData,
        inheritedData: jqLiteInheritedData,
        scope: function (element) {
            return jqLite(element).data("$scope") || jqLiteInheritedData(element.parentNode || element, ["$isolateScope", "$scope"])
        },
        isolateScope: function (element) {
            return jqLite(element).data("$isolateScope") || jqLite(element).data("$isolateScopeNoTemplate")
        },
        controller: jqLiteController,
        injector: function (element) {
            return jqLiteInheritedData(element, "$injector")
        },
        removeAttr: function (element, name) {
            element.removeAttribute(name)
        },
        hasClass: jqLiteHasClass,
        css: function (element, name, value) {
            name = camelCase(name);
            if (isDefined(value)) {
                element.style[name] = value
            } else {
                var val;
                if (msie <= 8) {
                    val = element.currentStyle && element.currentStyle[name];
                    if (val === "") val = "auto"
                }
                val = val || element.style[name];
                if (msie <= 8) {
                    val = val === "" ? undefined : val
                }
                return val
            }
        },
        attr: function (element, name, value) {
            var lowercasedName = lowercase(name);
            if (BOOLEAN_ATTR[lowercasedName]) {
                if (isDefined(value)) {
                    if (!!value) {
                        element[name] = true;
                        element.setAttribute(name, lowercasedName)
                    } else {
                        element[name] = false;
                        element.removeAttribute(lowercasedName)
                    }
                } else {
                    return element[name] || (element.attributes.getNamedItem(name) || noop).specified ? lowercasedName : undefined
                }
            } else if (isDefined(value)) {
                element.setAttribute(name, value)
            } else if (element.getAttribute) {
                var ret = element.getAttribute(name, 2);
                return ret === null ? undefined : ret
            }
        },
        prop: function (element, name, value) {
            if (isDefined(value)) {
                element[name] = value
            } else {
                return element[name]
            }
        },
        text: function () {
            var NODE_TYPE_TEXT_PROPERTY = [];
            if (msie < 9) {
                NODE_TYPE_TEXT_PROPERTY[1] = "innerText";
                NODE_TYPE_TEXT_PROPERTY[3] = "nodeValue"
            } else {
                NODE_TYPE_TEXT_PROPERTY[1] = NODE_TYPE_TEXT_PROPERTY[3] = "textContent"
            }
            getText.$dv = "";
            return getText;

            function getText(element, value) {
                var textProp = NODE_TYPE_TEXT_PROPERTY[element.nodeType];
                if (isUndefined(value)) {
                    return textProp ? element[textProp] : ""
                }
                element[textProp] = value
            }
        }(),
        val: function (element, value) {
            if (isUndefined(value)) {
                if (nodeName_(element) === "SELECT" && element.multiple) {
                    var result = [];
                    forEach(element.options, (function (option) {
                        if (option.selected) {
                            result.push(option.value || option.text)
                        }
                    }));
                    return result.length === 0 ? null : result
                }
                return element.value
            }
            element.value = value
        },
        html: function (element, value) {
            if (isUndefined(value)) {
                return element.innerHTML
            }
            for (var i = 0, childNodes = element.childNodes; i < childNodes.length; i++) {
                jqLiteDealoc(childNodes[i])
            }
            element.innerHTML = value
        },
        empty: jqLiteEmpty
    }, (function (fn, name) {
        JQLite.prototype[name] = function (arg1, arg2) {
            var i, key;
            if (fn !== jqLiteEmpty && (fn.length == 2 && fn !== jqLiteHasClass && fn !== jqLiteController ? arg1 : arg2) === undefined) {
                if (isObject(arg1)) {
                    for (i = 0; i < this.length; i++) {
                        if (fn === jqLiteData) {
                            fn(this[i], arg1)
                        } else {
                            for (key in arg1) {
                                fn(this[i], key, arg1[key])
                            }
                        }
                    }
                    return this
                } else {
                    var value = fn.$dv;
                    var jj = value === undefined ? Math.min(this.length, 1) : this.length;
                    for (var j = 0; j < jj; j++) {
                        var nodeValue = fn(this[j], arg1, arg2);
                        value = value ? value + nodeValue : nodeValue
                    }
                    return value
                }
            } else {
                for (i = 0; i < this.length; i++) {
                    fn(this[i], arg1, arg2)
                }
                return this
            }
        }
    }));

    function createEventHandler(element, events) {
        var eventHandler = function (event, type) {
            if (!event.preventDefault) {
                event.preventDefault = function () {
                    event.returnValue = false
                }
            }
            if (!event.stopPropagation) {
                event.stopPropagation = function () {
                    event.cancelBubble = true
                }
            }
            if (!event.target) {
                event.target = event.srcElement || document
            }
            if (isUndefined(event.defaultPrevented)) {
                var prevent = event.preventDefault;
                event.preventDefault = function () {
                    event.defaultPrevented = true;
                    prevent.call(event)
                };
                event.defaultPrevented = false
            }
            event.isDefaultPrevented = function () {
                return event.defaultPrevented || event.returnValue === false
            };
            forEach(events[type || event.type], (function (fn) {
                fn.call(element, event)
            }));
            if (msie <= 8) {
                event.preventDefault = null;
                event.stopPropagation = null;
                event.isDefaultPrevented = null
            } else {
                delete event.preventDefault;
                delete event.stopPropagation;
                delete event.isDefaultPrevented
            }
        };
        eventHandler.elem = element;
        return eventHandler
    }
    forEach({
        removeData: jqLiteRemoveData,
        dealoc: jqLiteDealoc,
        on: function onFn(element, type, fn, unsupported) {
            if (isDefined(unsupported)) throw jqLiteMinErr("onargs", "jqLite#on() does not support the `selector` or `eventData` parameters");
            var events = jqLiteExpandoStore(element, "events"),
                handle = jqLiteExpandoStore(element, "handle");
            if (!events) jqLiteExpandoStore(element, "events", events = {});
            if (!handle) jqLiteExpandoStore(element, "handle", handle = createEventHandler(element, events));
            forEach(type.split(" "), (function (type) {
                var eventFns = events[type];
                if (!eventFns) {
                    if (type == "mouseenter" || type == "mouseleave") {
                        var contains = document.body.contains || document.body.compareDocumentPosition ? function (a, b) {
                            var adown = a.nodeType === 9 ? a.documentElement : a,
                                bup = b && b.parentNode;
                            return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16))
                        } : function (a, b) {
                            if (b) {
                                while (b = b.parentNode) {
                                    if (b === a) {
                                        return true
                                    }
                                }
                            }
                            return false
                        };
                        events[type] = [];
                        var eventmap = {
                            mouseleave: "mouseout",
                            mouseenter: "mouseover"
                        };
                        onFn(element, eventmap[type], (function (event) {
                            var target = this,
                                related = event.relatedTarget;
                            if (!related || related !== target && !contains(target, related)) {
                                handle(event, type)
                            }
                        }))
                    } else {
                        addEventListenerFn(element, type, handle);
                        events[type] = []
                    }
                    eventFns = events[type]
                }
                eventFns.push(fn)
            }))
        },
        off: jqLiteOff,
        replaceWith: function (element, replaceNode) {
            var index, parent = element.parentNode;
            jqLiteDealoc(element);
            forEach(new JQLite(replaceNode), (function (node) {
                if (index) {
                    parent.insertBefore(node, index.nextSibling)
                } else {
                    parent.replaceChild(node, element)
                }
                index = node
            }))
        },
        children: function (element) {
            var children = [];
            forEach(element.childNodes, (function (element) {
                if (element.nodeType === 1) children.push(element)
            }));
            return children
        },
        contents: function (element) {
            return element.childNodes || []
        },
        append: function (element, node) {
            forEach(new JQLite(node), (function (child) {
                if (element.nodeType === 1 || element.nodeType === 11) {
                    element.appendChild(child)
                }
            }))
        },
        prepend: function (element, node) {
            if (element.nodeType === 1) {
                var index = element.firstChild;
                forEach(new JQLite(node), (function (child) {
                    element.insertBefore(child, index)
                }))
            }
        },
        wrap: function (element, wrapNode) {
            wrapNode = jqLite(wrapNode)[0];
            var parent = element.parentNode;
            if (parent) {
                parent.replaceChild(wrapNode, element)
            }
            wrapNode.appendChild(element)
        },
        remove: function (element) {
            jqLiteDealoc(element);
            var parent = element.parentNode;
            if (parent) parent.removeChild(element)
        },
        after: function (element, newElement) {
            var index = element,
                parent = element.parentNode;
            forEach(new JQLite(newElement), (function (node) {
                parent.insertBefore(node, index.nextSibling);
                index = node
            }))
        },
        addClass: jqLiteAddClass,
        removeClass: jqLiteRemoveClass,
        toggleClass: function (element, selector, condition) {
            if (isUndefined(condition)) {
                condition = !jqLiteHasClass(element, selector)
            } (condition ? jqLiteAddClass : jqLiteRemoveClass)(element, selector)
        },
        parent: function (element) {
            var parent = element.parentNode;
            return parent && parent.nodeType !== 11 ? parent : null
        },
        next: function (element) {
            if (element.nextElementSibling) {
                return element.nextElementSibling
            }
            var elm = element.nextSibling;
            while (elm != null && elm.nodeType !== 1) {
                elm = elm.nextSibling
            }
            return elm
        },
        find: function (element, selector) {
            if (element.getElementsByTagName) {
                return element.getElementsByTagName(selector)
            } else {
                return []
            }
        },
        clone: jqLiteClone,
        triggerHandler: function (element, eventName, eventData) {
            var eventFns = (jqLiteExpandoStore(element, "events") || {})[eventName];
            eventData = eventData || [];
            var event = [{
                preventDefault: noop,
                stopPropagation: noop
            }];
            forEach(eventFns, (function (fn) {
                fn.apply(element, event.concat(eventData))
            }))
        }
    }, (function (fn, name) {
        JQLite.prototype[name] = function (arg1, arg2, arg3) {
            var value;
            for (var i = 0; i < this.length; i++) {
                if (isUndefined(value)) {
                    value = fn(this[i], arg1, arg2, arg3);
                    if (isDefined(value)) {
                        value = jqLite(value)
                    }
                } else {
                    jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3))
                }
            }
            return isDefined(value) ? value : this
        };
        JQLite.prototype.bind = JQLite.prototype.on;
        JQLite.prototype.unbind = JQLite.prototype.off
    }));

    function hashKey(obj) {
        var objType = typeof obj,
            key;
        if (objType == "object" && obj !== null) {
            if (typeof (key = obj.$$hashKey) == "function") {
                key = obj.$$hashKey()
            } else if (key === undefined) {
                key = obj.$$hashKey = nextUid()
            }
        } else {
            key = obj
        }
        return objType + ":" + key
    }

    function HashMap(array) {
        forEach(array, this.put, this)
    }
    HashMap.prototype = {
        put: function (key, value) {
            this[hashKey(key)] = value
        },
        get: function (key) {
            return this[hashKey(key)]
        },
        remove: function (key) {
            var value = this[key = hashKey(key)];
            delete this[key];
            return value
        }
    };
    var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
    var FN_ARG_SPLIT = /,/;
    var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
    var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
    var $injectorMinErr = minErr("$injector");

    function annotate(fn) {
        var $inject, fnText, argDecl, last;
        if (typeof fn == "function") {
            if (!($inject = fn.$inject)) {
                $inject = [];
                if (fn.length) {
                    fnText = fn.toString().replace(STRIP_COMMENTS, "");
                    argDecl = fnText.match(FN_ARGS);
                    forEach(argDecl[1].split(FN_ARG_SPLIT), (function (arg) {
                        arg.replace(FN_ARG, (function (all, underscore, name) {
                            $inject.push(name)
                        }))
                    }))
                }
                fn.$inject = $inject
            }
        } else if (isArray(fn)) {
            last = fn.length - 1;
            assertArgFn(fn[last], "fn");
            $inject = fn.slice(0, last)
        } else {
            assertArgFn(fn, "fn", true)
        }
        return $inject
    }

    function createInjector(modulesToLoad) {
        var INSTANTIATING = {},
            providerSuffix = "Provider",
            path = [],
            loadedModules = new HashMap,
            providerCache = {
                $provide: {
                    provider: supportObject(provider),
                    factory: supportObject(factory),
                    service: supportObject(service),
                    value: supportObject(value),
                    constant: supportObject(constant),
                    decorator: decorator
                }
            },
            providerInjector = providerCache.$injector = createInternalInjector(providerCache, (function () {
                throw $injectorMinErr("unpr", "Unknown provider: {0}", path.join(" <- "))
            })),
            instanceCache = {},
            instanceInjector = instanceCache.$injector = createInternalInjector(instanceCache, (function (servicename) {
                var provider = providerInjector.get(servicename + providerSuffix);
                return instanceInjector.invoke(provider.$get, provider)
            }));
        forEach(loadModules(modulesToLoad), (function (fn) {
            instanceInjector.invoke(fn || noop)
        }));
        return instanceInjector;

        function supportObject(delegate) {
            return function (key, value) {
                if (isObject(key)) {
                    forEach(key, reverseParams(delegate))
                } else {
                    return delegate(key, value)
                }
            }
        }

        function provider(name, provider_) {
            assertNotHasOwnProperty(name, "service");
            if (isFunction(provider_) || isArray(provider_)) {
                provider_ = providerInjector.instantiate(provider_)
            }
            if (!provider_.$get) {
                throw $injectorMinErr("pget", "Provider '{0}' must define $get factory method.", name)
            }
            return providerCache[name + providerSuffix] = provider_
        }

        function factory(name, factoryFn) {
            return provider(name, {
                $get: factoryFn
            })
        }

        function service(name, constructor) {
            return factory(name, ["$injector", function ($injector) {
                return $injector.instantiate(constructor)
            }])
        }

        function value(name, val) {
            return factory(name, valueFn(val))
        }

        function constant(name, value) {
            assertNotHasOwnProperty(name, "constant");
            providerCache[name] = value;
            instanceCache[name] = value
        }

        function decorator(serviceName, decorFn) {
            var origProvider = providerInjector.get(serviceName + providerSuffix),
                orig$get = origProvider.$get;
            origProvider.$get = function () {
                var origInstance = instanceInjector.invoke(orig$get, origProvider);
                return instanceInjector.invoke(decorFn, null, {
                    $delegate: origInstance
                })
            }
        }

        function loadModules(modulesToLoad) {
            var runBlocks = [],
                moduleFn, invokeQueue, i, ii;
            forEach(modulesToLoad, (function (module) {
                if (loadedModules.get(module)) return;
                loadedModules.put(module, true);
                try {
                    if (isString(module)) {
                        moduleFn = angularModule(module);
                        runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);
                        for (invokeQueue = moduleFn._invokeQueue, i = 0, ii = invokeQueue.length; i < ii; i++) {
                            var invokeArgs = invokeQueue[i],
                                provider = providerInjector.get(invokeArgs[0]);
                            provider[invokeArgs[1]].apply(provider, invokeArgs[2])
                        }
                    } else if (isFunction(module)) {
                        runBlocks.push(providerInjector.invoke(module))
                    } else if (isArray(module)) {
                        runBlocks.push(providerInjector.invoke(module))
                    } else {
                        assertArgFn(module, "module")
                    }
                } catch (e) {
                    if (isArray(module)) {
                        module = module[module.length - 1]
                    }
                    if (e.message && e.stack && e.stack.indexOf(e.message) == -1) {
                        e = e.message + "\n" + e.stack
                    }
                    throw $injectorMinErr("modulerr", "Failed to instantiate module {0} due to:\n{1}", module, e.stack || e.message || e)
                }
            }));
            return runBlocks
        }

        function createInternalInjector(cache, factory) {
            function getService(serviceName) {
                if (cache.hasOwnProperty(serviceName)) {
                    if (cache[serviceName] === INSTANTIATING) {
                        throw $injectorMinErr("cdep", "Circular dependency found: {0}", path.join(" <- "))
                    }
                    return cache[serviceName]
                } else {
                    try {
                        path.unshift(serviceName);
                        cache[serviceName] = INSTANTIATING;
                        return cache[serviceName] = factory(serviceName)
                    } finally {
                        path.shift()
                    }
                }
            }

            function invoke(fn, self, locals) {
                var args = [],
                    $inject = annotate(fn),
                    length, i, key;
                for (i = 0, length = $inject.length; i < length; i++) {
                    key = $inject[i];
                    if (typeof key !== "string") {
                        throw $injectorMinErr("itkn", "Incorrect injection token! Expected service name as string, got {0}", key)
                    }
                    args.push(locals && locals.hasOwnProperty(key) ? locals[key] : getService(key))
                }
                if (!fn.$inject) {
                    fn = fn[length]
                }
                return fn.apply(self, args)
            }

            function instantiate(Type, locals) {
                var Constructor = function () { },
                    instance, returnedValue;
                Constructor.prototype = (isArray(Type) ? Type[Type.length - 1] : Type).prototype;
                instance = new Constructor;
                returnedValue = invoke(Type, instance, locals);
                return isObject(returnedValue) || isFunction(returnedValue) ? returnedValue : instance
            }
            return {
                invoke: invoke,
                instantiate: instantiate,
                get: getService,
                annotate: annotate,
                has: function (name) {
                    return providerCache.hasOwnProperty(name + providerSuffix) || cache.hasOwnProperty(name)
                }
            }
        }
    }

    function $AnchorScrollProvider() {
        var autoScrollingEnabled = true;
        this.disableAutoScrolling = function () {
            autoScrollingEnabled = false
        };
        this.$get = ["$window", "$location", "$rootScope", function ($window, $location, $rootScope) {
            var document = $window.document;

            function getFirstAnchor(list) {
                var result = null;
                forEach(list, (function (element) {
                    if (!result && lowercase(element.nodeName) === "a") result = element
                }));
                return result
            }

            function scroll() {
                var hash = $location.hash(),
                    elm;
                if (!hash) $window.scrollTo(0, 0);
                else if (elm = document.getElementById(hash)) elm.scrollIntoView();
                else if (elm = getFirstAnchor(document.getElementsByName(hash))) elm.scrollIntoView();
                else if (hash === "top") $window.scrollTo(0, 0)
            }
            if (autoScrollingEnabled) {
                $rootScope.$watch((function autoScrollWatch() {
                    return $location.hash()
                }), (function autoScrollWatchAction() {
                    $rootScope.$evalAsync(scroll)
                }))
            }
            return scroll
        }]
    }
    var $animateMinErr = minErr("$animate");
    var $AnimateProvider = ["$provide", function ($provide) {
        this.$$selectors = {};
        this.register = function (name, factory) {
            var key = name + "-animation";
            if (name && name.charAt(0) != ".") throw $animateMinErr("notcsel", "Expecting class selector starting with '.' got '{0}'.", name);
            this.$$selectors[name.substr(1)] = key;
            $provide.factory(key, factory)
        };
        this.$get = ["$timeout", function ($timeout) {
            return {
                enter: function (element, parent, after, done) {
                    if (after) {
                        after.after(element)
                    } else {
                        if (!parent || !parent[0]) {
                            parent = after.parent()
                        }
                        parent.append(element)
                    }
                    done && $timeout(done, 0, false)
                },
                leave: function (element, done) {
                    element.remove();
                    done && $timeout(done, 0, false)
                },
                move: function (element, parent, after, done) {
                    this.enter(element, parent, after, done)
                },
                addClass: function (element, className, done) {
                    className = isString(className) ? className : isArray(className) ? className.join(" ") : "";
                    forEach(element, (function (element) {
                        jqLiteAddClass(element, className)
                    }));
                    done && $timeout(done, 0, false)
                },
                removeClass: function (element, className, done) {
                    className = isString(className) ? className : isArray(className) ? className.join(" ") : "";
                    forEach(element, (function (element) {
                        jqLiteRemoveClass(element, className)
                    }));
                    done && $timeout(done, 0, false)
                },
                enabled: noop
            }
        }]
    }];

    function Browser(window, document, $log, $sniffer) {
        var self = this,
            rawDocument = document[0],
            location = window.location,
            history = window.history,
            setTimeout = window.setTimeout,
            clearTimeout = window.clearTimeout,
            pendingDeferIds = {};
        self.isMock = false;
        var outstandingRequestCount = 0;
        var outstandingRequestCallbacks = [];
        self.$$completeOutstandingRequest = completeOutstandingRequest;
        self.$$incOutstandingRequestCount = function () {
            outstandingRequestCount++
        };

        function completeOutstandingRequest(fn) {
            try {
                fn.apply(null, sliceArgs(arguments, 1))
            } finally {
                outstandingRequestCount--;
                if (outstandingRequestCount === 0) {
                    while (outstandingRequestCallbacks.length) {
                        try {
                            outstandingRequestCallbacks.pop()()
                        } catch (e) {
                            $log.error(e)
                        }
                    }
                }
            }
        }
        self.notifyWhenNoOutstandingRequests = function (callback) {
            forEach(pollFns, (function (pollFn) {
                pollFn()
            }));
            if (outstandingRequestCount === 0) {
                callback()
            } else {
                outstandingRequestCallbacks.push(callback)
            }
        };
        var pollFns = [],
            pollTimeout;
        self.addPollFn = function (fn) {
            if (isUndefined(pollTimeout)) startPoller(100, setTimeout);
            pollFns.push(fn);
            return fn
        };

        function startPoller(interval, setTimeout) {
            (function check() {
                forEach(pollFns, (function (pollFn) {
                    pollFn()
                }));
                pollTimeout = setTimeout(check, interval)
            })()
        }
        var lastBrowserUrl = location.href,
            baseElement = document.find("base"),
            newLocation = null;
        self.url = function (url, replace) {
            if (location !== window.location) location = window.location;
            if (url) {
                if (lastBrowserUrl == url) return;
                lastBrowserUrl = url;
                if ($sniffer.history) {
                    if (replace) history.replaceState(null, "", url);
                    else {
                        history.pushState(null, "", url);
                        baseElement.attr("href", baseElement.attr("href"))
                    }
                } else {
                    newLocation = url;
                    if (replace) {
                        location.replace(url)
                    } else {
                        location.href = url
                    }
                }
                return self
            } else {
                return newLocation || location.href.replace(/%27/g, "'")
            }
        };
        var urlChangeListeners = [],
            urlChangeInit = false;

        function fireUrlChange() {
            newLocation = null;
            if (lastBrowserUrl == self.url()) return;
            lastBrowserUrl = self.url();
            forEach(urlChangeListeners, (function (listener) {
                listener(self.url())
            }))
        }
        self.onUrlChange = function (callback) {
            if (!urlChangeInit) {
                if ($sniffer.history) jqLite(window).on("popstate", fireUrlChange);
                if ($sniffer.hashchange) jqLite(window).on("hashchange", fireUrlChange);
                else self.addPollFn(fireUrlChange);
                urlChangeInit = true
            }
            urlChangeListeners.push(callback);
            return callback
        };
        self.baseHref = function () {
            var href = baseElement.attr("href");
            return href ? href.replace(/^https?\:\/\/[^\/]*/, "") : ""
        };
        var lastCookies = {};
        var lastCookieString = "";
        var cookiePath = self.baseHref();
        self.cookies = function (name, value) {
            var cookieLength, cookieArray, cookie, i, index;
            if (name) {
                if (value === undefined) {
                    rawDocument.cookie = escape(name) + "=;path=" + cookiePath + ";expires=Thu, 01 Jan 1970 00:00:00 GMT"
                } else {
                    if (isString(value)) {
                        cookieLength = (rawDocument.cookie = escape(name) + "=" + escape(value) + ";path=" + cookiePath).length + 1;
                        if (cookieLength > 4096) {
                            $log.warn("Cookie '" + name + "' possibly not set or overflowed because it was too large (" + cookieLength + " > 4096 bytes)!")
                        }
                    }
                }
            } else {
                if (rawDocument.cookie !== lastCookieString) {
                    lastCookieString = rawDocument.cookie;
                    cookieArray = lastCookieString.split("; ");
                    lastCookies = {};
                    for (i = 0; i < cookieArray.length; i++) {
                        cookie = cookieArray[i];
                        index = cookie.indexOf("=");
                        if (index > 0) {
                            name = unescape(cookie.substring(0, index));
                            if (lastCookies[name] === undefined) {
                                lastCookies[name] = unescape(cookie.substring(index + 1))
                            }
                        }
                    }
                }
                return lastCookies
            }
        };
        self.defer = function (fn, delay) {
            var timeoutId;
            outstandingRequestCount++;
            timeoutId = setTimeout((function () {
                delete pendingDeferIds[timeoutId];
                completeOutstandingRequest(fn)
            }), delay || 0);
            pendingDeferIds[timeoutId] = true;
            return timeoutId
        };
        self.defer.cancel = function (deferId) {
            if (pendingDeferIds[deferId]) {
                delete pendingDeferIds[deferId];
                clearTimeout(deferId);
                completeOutstandingRequest(noop);
                return true
            }
            return false
        }
    }

    function $BrowserProvider() {
        this.$get = ["$window", "$log", "$sniffer", "$document", function ($window, $log, $sniffer, $document) {
            return new Browser($window, $document, $log, $sniffer)
        }]
    }

    function $CacheFactoryProvider() {
        this.$get = function () {
            var caches = {};

            function cacheFactory(cacheId, options) {
                if (cacheId in caches) {
                    throw minErr("$cacheFactory")("iid", "CacheId '{0}' is already taken!", cacheId)
                }
                var size = 0,
                    stats = extend({}, options, {
                        id: cacheId
                    }),
                    data = {},
                    capacity = options && options.capacity || Number.MAX_VALUE,
                    lruHash = {},
                    freshEnd = null,
                    staleEnd = null;
                return caches[cacheId] = {
                    put: function (key, value) {
                        var lruEntry = lruHash[key] || (lruHash[key] = {
                            key: key
                        });
                        refresh(lruEntry);
                        if (isUndefined(value)) return;
                        if (!(key in data)) size++;
                        data[key] = value;
                        if (size > capacity) {
                            this.remove(staleEnd.key)
                        }
                        return value
                    },
                    get: function (key) {
                        var lruEntry = lruHash[key];
                        if (!lruEntry) return;
                        refresh(lruEntry);
                        return data[key]
                    },
                    remove: function (key) {
                        var lruEntry = lruHash[key];
                        if (!lruEntry) return;
                        if (lruEntry == freshEnd) freshEnd = lruEntry.p;
                        if (lruEntry == staleEnd) staleEnd = lruEntry.n;
                        link(lruEntry.n, lruEntry.p);
                        delete lruHash[key];
                        delete data[key];
                        size--
                    },
                    removeAll: function () {
                        data = {};
                        size = 0;
                        lruHash = {};
                        freshEnd = staleEnd = null
                    },
                    destroy: function () {
                        data = null;
                        stats = null;
                        lruHash = null;
                        delete caches[cacheId]
                    },
                    info: function () {
                        return extend({}, stats, {
                            size: size
                        })
                    }
                };

                function refresh(entry) {
                    if (entry != freshEnd) {
                        if (!staleEnd) {
                            staleEnd = entry
                        } else if (staleEnd == entry) {
                            staleEnd = entry.n
                        }
                        link(entry.n, entry.p);
                        link(entry, freshEnd);
                        freshEnd = entry;
                        freshEnd.n = null
                    }
                }

                function link(nextEntry, prevEntry) {
                    if (nextEntry != prevEntry) {
                        if (nextEntry) nextEntry.p = prevEntry;
                        if (prevEntry) prevEntry.n = nextEntry
                    }
                }
            }
            cacheFactory.info = function () {
                var info = {};
                forEach(caches, (function (cache, cacheId) {
                    info[cacheId] = cache.info()
                }));
                return info
            };
            cacheFactory.get = function (cacheId) {
                return caches[cacheId]
            };
            return cacheFactory
        }
    }

    function $TemplateCacheProvider() {
        this.$get = ["$cacheFactory", function ($cacheFactory) {
            return $cacheFactory("templates")
        }]
    }
    var $compileMinErr = minErr("$compile");
    $CompileProvider.$inject = ["$provide", "$$sanitizeUriProvider"];

    function $CompileProvider($provide, $$sanitizeUriProvider) {
        var hasDirectives = {},
            Suffix = "Directive",
            COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\d\w\-_]+)\s+(.*)$/,
            CLASS_DIRECTIVE_REGEXP = /(([\d\w\-_]+)(?:\:([^;]+))?;?)/;
        var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;
        this.directive = function registerDirective(name, directiveFactory) {
            assertNotHasOwnProperty(name, "directive");
            if (isString(name)) {
                assertArg(directiveFactory, "directiveFactory");
                if (!hasDirectives.hasOwnProperty(name)) {
                    hasDirectives[name] = [];
                    $provide.factory(name + Suffix, ["$injector", "$exceptionHandler", function ($injector, $exceptionHandler) {
                        var directives = [];
                        forEach(hasDirectives[name], (function (directiveFactory, index) {
                            try {
                                var directive = $injector.invoke(directiveFactory);
                                if (isFunction(directive)) {
                                    directive = {
                                        compile: valueFn(directive)
                                    }
                                } else if (!directive.compile && directive.link) {
                                    directive.compile = valueFn(directive.link)
                                }
                                directive.priority = directive.priority || 0;
                                directive.index = index;
                                directive.name = directive.name || name;
                                directive.require = directive.require || directive.controller && directive.name;
                                directive.restrict = directive.restrict || "A";
                                directives.push(directive)
                            } catch (e) {
                                $exceptionHandler(e)
                            }
                        }));
                        return directives
                    }])
                }
                hasDirectives[name].push(directiveFactory)
            } else {
                forEach(name, reverseParams(registerDirective))
            }
            return this
        };
        this.aHrefSanitizationWhitelist = function (regexp) {
            if (isDefined(regexp)) {
                $$sanitizeUriProvider.aHrefSanitizationWhitelist(regexp);
                return this
            } else {
                return $$sanitizeUriProvider.aHrefSanitizationWhitelist()
            }
        };
        this.imgSrcSanitizationWhitelist = function (regexp) {
            if (isDefined(regexp)) {
                $$sanitizeUriProvider.imgSrcSanitizationWhitelist(regexp);
                return this
            } else {
                return $$sanitizeUriProvider.imgSrcSanitizationWhitelist()
            }
        };
        this.$get = ["$injector", "$interpolate", "$exceptionHandler", "$http", "$templateCache", "$parse", "$controller", "$rootScope", "$document", "$sce", "$animate", "$$sanitizeUri", function ($injector, $interpolate, $exceptionHandler, $http, $templateCache, $parse, $controller, $rootScope, $document, $sce, $animate, $$sanitizeUri) {
            var Attributes = function (element, attr) {
                this.$$element = element;
                this.$attr = attr || {}
            };
            Attributes.prototype = {
                $normalize: directiveNormalize,
                $addClass: function (classVal) {
                    if (classVal && classVal.length > 0) {
                        $animate.addClass(this.$$element, classVal)
                    }
                },
                $removeClass: function (classVal) {
                    if (classVal && classVal.length > 0) {
                        $animate.removeClass(this.$$element, classVal)
                    }
                },
                $updateClass: function (newClasses, oldClasses) {
                    this.$removeClass(tokenDifference(oldClasses, newClasses));
                    this.$addClass(tokenDifference(newClasses, oldClasses))
                },
                $set: function (key, value, writeAttr, attrName) {
                    var booleanKey = getBooleanAttrName(this.$$element[0], key),
                        normalizedVal, nodeName;
                    if (booleanKey) {
                        this.$$element.prop(key, value);
                        attrName = booleanKey
                    }
                    this[key] = value;
                    if (attrName) {
                        this.$attr[key] = attrName
                    } else {
                        attrName = this.$attr[key];
                        if (!attrName) {
                            this.$attr[key] = attrName = snake_case(key, "-")
                        }
                    }
                    nodeName = nodeName_(this.$$element);
                    if (nodeName === "A" && key === "href" || nodeName === "IMG" && key === "src") {
                        this[key] = value = $$sanitizeUri(value, key === "src")
                    }
                    if (writeAttr !== false) {
                        if (value === null || value === undefined) {
                            this.$$element.removeAttr(attrName)
                        } else {
                            this.$$element.attr(attrName, value)
                        }
                    }
                    var $$observers = this.$$observers;
                    $$observers && forEach($$observers[key], (function (fn) {
                        try {
                            fn(value)
                        } catch (e) {
                            $exceptionHandler(e)
                        }
                    }))
                },
                $observe: function (key, fn) {
                    var attrs = this,
                        $$observers = attrs.$$observers || (attrs.$$observers = {}),
                        listeners = $$observers[key] || ($$observers[key] = []);
                    listeners.push(fn);
                    $rootScope.$evalAsync((function () {
                        if (!listeners.$$inter) {
                            fn(attrs[key])
                        }
                    }));
                    return fn
                }
            };
            var startSymbol = $interpolate.startSymbol(),
                endSymbol = $interpolate.endSymbol(),
                denormalizeTemplate = startSymbol == "{{" || endSymbol == "}}" ? identity : function denormalizeTemplate(template) {
                    return template.replace(/\{\{/g, startSymbol).replace(/}}/g, endSymbol)
                },
                NG_ATTR_BINDING = /^ngAttr[A-Z]/;
            return compile;

            function compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext) {
                if (!($compileNodes instanceof jqLite)) {
                    $compileNodes = jqLite($compileNodes)
                }
                forEach($compileNodes, (function (node, index) {
                    if (node.nodeType == 3 && node.nodeValue.match(/\S+/)) {
                        $compileNodes[index] = node = jqLite(node).wrap("<span></span>").parent()[0]
                    }
                }));
                var compositeLinkFn = compileNodes($compileNodes, transcludeFn, $compileNodes, maxPriority, ignoreDirective, previousCompileContext);
                return function publicLinkFn(scope, cloneConnectFn, transcludeControllers) {
                    assertArg(scope, "scope");
                    var $linkNode = cloneConnectFn ? JQLitePrototype.clone.call($compileNodes) : $compileNodes;
                    forEach(transcludeControllers, (function (instance, name) {
                        $linkNode.data("$" + name + "Controller", instance)
                    }));
                    for (var i = 0, ii = $linkNode.length; i < ii; i++) {
                        var node = $linkNode[i];
                        if (node.nodeType == 1 || node.nodeType == 9) {
                            $linkNode.eq(i).data("$scope", scope)
                        }
                    }
                    safeAddClass($linkNode, "ng-scope");
                    if (cloneConnectFn) cloneConnectFn($linkNode, scope);
                    if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode);
                    return $linkNode
                }
            }

            function safeAddClass($element, className) {
                try {
                    $element.addClass(className)
                } catch (e) { }
            }

            function compileNodes(nodeList, transcludeFn, $rootElement, maxPriority, ignoreDirective, previousCompileContext) {
                var linkFns = [],
                    nodeLinkFn, childLinkFn, directives, attrs, linkFnFound;
                for (var i = 0; i < nodeList.length; i++) {
                    attrs = new Attributes;
                    directives = collectDirectives(nodeList[i], [], attrs, i === 0 ? maxPriority : undefined, ignoreDirective);
                    nodeLinkFn = directives.length ? applyDirectivesToNode(directives, nodeList[i], attrs, transcludeFn, $rootElement, null, [], [], previousCompileContext) : null;
                    childLinkFn = nodeLinkFn && nodeLinkFn.terminal || !nodeList[i].childNodes || !nodeList[i].childNodes.length ? null : compileNodes(nodeList[i].childNodes, nodeLinkFn ? nodeLinkFn.transclude : transcludeFn);
                    linkFns.push(nodeLinkFn);
                    linkFns.push(childLinkFn);
                    linkFnFound = linkFnFound || nodeLinkFn || childLinkFn;
                    previousCompileContext = null
                }
                return linkFnFound ? compositeLinkFn : null;

                function compositeLinkFn(scope, nodeList, $rootElement, boundTranscludeFn) {
                    var nodeLinkFn, childLinkFn, node, $node, childScope, childTranscludeFn, i, ii, n;
                    var stableNodeList = [];
                    for (i = 0, ii = nodeList.length; i < ii; i++) {
                        stableNodeList.push(nodeList[i])
                    }
                    for (i = 0, n = 0, ii = linkFns.length; i < ii; n++) {
                        node = stableNodeList[n];
                        nodeLinkFn = linkFns[i++];
                        childLinkFn = linkFns[i++];
                        $node = jqLite(node);
                        if (nodeLinkFn) {
                            if (nodeLinkFn.scope) {
                                childScope = scope.$new();
                                $node.data("$scope", childScope);
                                safeAddClass($node, "ng-scope")
                            } else {
                                childScope = scope
                            }
                            childTranscludeFn = nodeLinkFn.transclude;
                            if (childTranscludeFn || !boundTranscludeFn && transcludeFn) {
                                nodeLinkFn(childLinkFn, childScope, node, $rootElement, createBoundTranscludeFn(scope, childTranscludeFn || transcludeFn))
                            } else {
                                nodeLinkFn(childLinkFn, childScope, node, $rootElement, boundTranscludeFn)
                            }
                        } else if (childLinkFn) {
                            childLinkFn(scope, node.childNodes, undefined, boundTranscludeFn)
                        }
                    }
                }
            }

            function createBoundTranscludeFn(scope, transcludeFn) {
                return function boundTranscludeFn(transcludedScope, cloneFn, controllers) {
                    var scopeCreated = false;
                    if (!transcludedScope) {
                        transcludedScope = scope.$new();
                        transcludedScope.$$transcluded = true;
                        scopeCreated = true
                    }
                    var clone = transcludeFn(transcludedScope, cloneFn, controllers);
                    if (scopeCreated) {
                        clone.on("$destroy", bind(transcludedScope, transcludedScope.$destroy))
                    }
                    return clone
                }
            }

            function collectDirectives(node, directives, attrs, maxPriority, ignoreDirective) {
                var nodeType = node.nodeType,
                    attrsMap = attrs.$attr,
                    match, className;
                switch (nodeType) {
                    case 1:
                        addDirective(directives, directiveNormalize(nodeName_(node).toLowerCase()), "E", maxPriority, ignoreDirective);
                        for (var attr, name, nName, ngAttrName, value, nAttrs = node.attributes, j = 0, jj = nAttrs && nAttrs.length; j < jj; j++) {
                            var attrStartName = false;
                            var attrEndName = false;
                            attr = nAttrs[j];
                            if (!msie || msie >= 8 || attr.specified) {
                                name = attr.name;
                                ngAttrName = directiveNormalize(name);
                                if (NG_ATTR_BINDING.test(ngAttrName)) {
                                    name = snake_case(ngAttrName.substr(6), "-")
                                }
                                var directiveNName = ngAttrName.replace(/(Start|End)$/, "");
                                if (ngAttrName === directiveNName + "Start") {
                                    attrStartName = name;
                                    attrEndName = name.substr(0, name.length - 5) + "end";
                                    name = name.substr(0, name.length - 6)
                                }
                                nName = directiveNormalize(name.toLowerCase());
                                attrsMap[nName] = name;
                                attrs[nName] = value = trim(msie && name == "href" ? decodeURIComponent(node.getAttribute(name, 2)) : attr.value);
                                if (getBooleanAttrName(node, nName)) {
                                    attrs[nName] = true
                                }
                                addAttrInterpolateDirective(node, directives, value, nName);
                                addDirective(directives, nName, "A", maxPriority, ignoreDirective, attrStartName, attrEndName)
                            }
                        }
                        className = node.className;
                        if (isString(className) && className !== "") {
                            while (match = CLASS_DIRECTIVE_REGEXP.exec(className)) {
                                nName = directiveNormalize(match[2]);
                                if (addDirective(directives, nName, "C", maxPriority, ignoreDirective)) {
                                    attrs[nName] = trim(match[3])
                                }
                                className = className.substr(match.index + match[0].length)
                            }
                        }
                        break;
                    case 3:
                        addTextInterpolateDirective(directives, node.nodeValue);
                        break;
                    case 8:
                        try {
                            match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue);
                            if (match) {
                                nName = directiveNormalize(match[1]);
                                if (addDirective(directives, nName, "M", maxPriority, ignoreDirective)) {
                                    attrs[nName] = trim(match[2])
                                }
                            }
                        } catch (e) { }
                        break
                }
                directives.sort(byPriority);
                return directives
            }

            function groupScan(node, attrStart, attrEnd) {
                var nodes = [];
                var depth = 0;
                if (attrStart && node.hasAttribute && node.hasAttribute(attrStart)) {
                    var startNode = node;
                    do {
                        if (!node) {
                            throw $compileMinErr("uterdir", "Unterminated attribute, found '{0}' but no matching '{1}' found.", attrStart, attrEnd)
                        }
                        if (node.nodeType == 1) {
                            if (node.hasAttribute(attrStart)) depth++;
                            if (node.hasAttribute(attrEnd)) depth--
                        }
                        nodes.push(node);
                        node = node.nextSibling
                    } while (depth > 0)
                } else {
                    nodes.push(node)
                }
                return jqLite(nodes)
            }

            function groupElementsLinkFnWrapper(linkFn, attrStart, attrEnd) {
                return function (scope, element, attrs, controllers, transcludeFn) {
                    element = groupScan(element[0], attrStart, attrEnd);
                    return linkFn(scope, element, attrs, controllers, transcludeFn)
                }
            }

            function applyDirectivesToNode(directives, compileNode, templateAttrs, transcludeFn, jqCollection, originalReplaceDirective, preLinkFns, postLinkFns, previousCompileContext) {
                previousCompileContext = previousCompileContext || {};
                var terminalPriority = -Number.MAX_VALUE,
                    newScopeDirective, controllerDirectives = previousCompileContext.controllerDirectives,
                    newIsolateScopeDirective = previousCompileContext.newIsolateScopeDirective,
                    templateDirective = previousCompileContext.templateDirective,
                    nonTlbTranscludeDirective = previousCompileContext.nonTlbTranscludeDirective,
                    hasTranscludeDirective = false,
                    hasElementTranscludeDirective = false,
                    $compileNode = templateAttrs.$$element = jqLite(compileNode),
                    directive, directiveName, $template, replaceDirective = originalReplaceDirective,
                    childTranscludeFn = transcludeFn,
                    linkFn, directiveValue;
                for (var i = 0, ii = directives.length; i < ii; i++) {
                    directive = directives[i];
                    var attrStart = directive.$$start;
                    var attrEnd = directive.$$end;
                    if (attrStart) {
                        $compileNode = groupScan(compileNode, attrStart, attrEnd)
                    }
                    $template = undefined;
                    if (terminalPriority > directive.priority) {
                        break
                    }
                    if (directiveValue = directive.scope) {
                        newScopeDirective = newScopeDirective || directive;
                        if (!directive.templateUrl) {
                            assertNoDuplicate("new/isolated scope", newIsolateScopeDirective, directive, $compileNode);
                            if (isObject(directiveValue)) {
                                newIsolateScopeDirective = directive
                            }
                        }
                    }
                    directiveName = directive.name;
                    if (!directive.templateUrl && directive.controller) {
                        directiveValue = directive.controller;
                        controllerDirectives = controllerDirectives || {};
                        assertNoDuplicate("'" + directiveName + "' controller", controllerDirectives[directiveName], directive, $compileNode);
                        controllerDirectives[directiveName] = directive
                    }
                    if (directiveValue = directive.transclude) {
                        hasTranscludeDirective = true;
                        if (!directive.$$tlb) {
                            assertNoDuplicate("transclusion", nonTlbTranscludeDirective, directive, $compileNode);
                            nonTlbTranscludeDirective = directive
                        }
                        if (directiveValue == "element") {
                            hasElementTranscludeDirective = true;
                            terminalPriority = directive.priority;
                            $template = groupScan(compileNode, attrStart, attrEnd);
                            $compileNode = templateAttrs.$$element = jqLite(document.createComment(" " + directiveName + ": " + templateAttrs[directiveName] + " "));
                            compileNode = $compileNode[0];
                            replaceWith(jqCollection, jqLite(sliceArgs($template)), compileNode);
                            childTranscludeFn = compile($template, transcludeFn, terminalPriority, replaceDirective && replaceDirective.name, {
                                nonTlbTranscludeDirective: nonTlbTranscludeDirective
                            })
                        } else {
                            $template = jqLite(jqLiteClone(compileNode)).contents();
                            $compileNode.empty();
                            childTranscludeFn = compile($template, transcludeFn)
                        }
                    }
                    if (directive.template) {
                        assertNoDuplicate("template", templateDirective, directive, $compileNode);
                        templateDirective = directive;
                        directiveValue = isFunction(directive.template) ? directive.template($compileNode, templateAttrs) : directive.template;
                        directiveValue = denormalizeTemplate(directiveValue);
                        if (directive.replace) {
                            replaceDirective = directive;
                            $template = jqLite("<div>" + trim(directiveValue) + "</div>").contents();
                            compileNode = $template[0];
                            if ($template.length != 1 || compileNode.nodeType !== 1) {
                                throw $compileMinErr("tplrt", "Template for directive '{0}' must have exactly one root element. {1}", directiveName, "")
                            }
                            replaceWith(jqCollection, $compileNode, compileNode);
                            var newTemplateAttrs = {
                                $attr: {}
                            };
                            var templateDirectives = collectDirectives(compileNode, [], newTemplateAttrs);
                            var unprocessedDirectives = directives.splice(i + 1, directives.length - (i + 1));
                            if (newIsolateScopeDirective) {
                                markDirectivesAsIsolate(templateDirectives)
                            }
                            directives = directives.concat(templateDirectives).concat(unprocessedDirectives);
                            mergeTemplateAttributes(templateAttrs, newTemplateAttrs);
                            ii = directives.length
                        } else {
                            $compileNode.html(directiveValue)
                        }
                    }
                    if (directive.templateUrl) {
                        assertNoDuplicate("template", templateDirective, directive, $compileNode);
                        templateDirective = directive;
                        if (directive.replace) {
                            replaceDirective = directive
                        }
                        nodeLinkFn = compileTemplateUrl(directives.splice(i, directives.length - i), $compileNode, templateAttrs, jqCollection, childTranscludeFn, preLinkFns, postLinkFns, {
                            controllerDirectives: controllerDirectives,
                            newIsolateScopeDirective: newIsolateScopeDirective,
                            templateDirective: templateDirective,
                            nonTlbTranscludeDirective: nonTlbTranscludeDirective
                        });
                        ii = directives.length
                    } else if (directive.compile) {
                        try {
                            linkFn = directive.compile($compileNode, templateAttrs, childTranscludeFn);
                            if (isFunction(linkFn)) {
                                addLinkFns(null, linkFn, attrStart, attrEnd)
                            } else if (linkFn) {
                                addLinkFns(linkFn.pre, linkFn.post, attrStart, attrEnd)
                            }
                        } catch (e) {
                            $exceptionHandler(e, startingTag($compileNode))
                        }
                    }
                    if (directive.terminal) {
                        nodeLinkFn.terminal = true;
                        terminalPriority = Math.max(terminalPriority, directive.priority)
                    }
                }
                nodeLinkFn.scope = newScopeDirective && newScopeDirective.scope === true;
                nodeLinkFn.transclude = hasTranscludeDirective && childTranscludeFn;
                return nodeLinkFn;

                function addLinkFns(pre, post, attrStart, attrEnd) {
                    if (pre) {
                        if (attrStart) pre = groupElementsLinkFnWrapper(pre, attrStart, attrEnd);
                        pre.require = directive.require;
                        if (newIsolateScopeDirective === directive || directive.$$isolateScope) {
                            pre = cloneAndAnnotateFn(pre, {
                                isolateScope: true
                            })
                        }
                        preLinkFns.push(pre)
                    }
                    if (post) {
                        if (attrStart) post = groupElementsLinkFnWrapper(post, attrStart, attrEnd);
                        post.require = directive.require;
                        if (newIsolateScopeDirective === directive || directive.$$isolateScope) {
                            post = cloneAndAnnotateFn(post, {
                                isolateScope: true
                            })
                        }
                        postLinkFns.push(post)
                    }
                }

                function getControllers(require, $element, elementControllers) {
                    var value, retrievalMethod = "data",
                        optional = false;
                    if (isString(require)) {
                        while ((value = require.charAt(0)) == "^" || value == "?") {
                            require = require.substr(1);
                            if (value == "^") {
                                retrievalMethod = "inheritedData"
                            }
                            optional = optional || value == "?"
                        }
                        value = null;
                        if (elementControllers && retrievalMethod === "data") {
                            value = elementControllers[require]
                        }
                        value = value || $element[retrievalMethod]("$" + require + "Controller");
                        if (!value && !optional) {
                            throw $compileMinErr("ctreq", "Controller '{0}', required by directive '{1}', can't be found!", require, directiveName)
                        }
                        return value
                    } else if (isArray(require)) {
                        value = [];
                        forEach(require, (function (require) {
                            value.push(getControllers(require, $element, elementControllers))
                        }))
                    }
                    return value
                }

                function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn) {
                    var attrs, $element, i, ii, linkFn, controller, isolateScope, elementControllers = {},
                        transcludeFn;
                    if (compileNode === linkNode) {
                        attrs = templateAttrs
                    } else {
                        attrs = shallowCopy(templateAttrs, new Attributes(jqLite(linkNode), templateAttrs.$attr))
                    }
                    $element = attrs.$$element;
                    if (newIsolateScopeDirective) {
                        var LOCAL_REGEXP = /^\s*([@=&])(\??)\s*(\w*)\s*$/;
                        var $linkNode = jqLite(linkNode);
                        isolateScope = scope.$new(true);
                        if (templateDirective && templateDirective === newIsolateScopeDirective.$$originalDirective) {
                            $linkNode.data("$isolateScope", isolateScope)
                        } else {
                            $linkNode.data("$isolateScopeNoTemplate", isolateScope)
                        }
                        safeAddClass($linkNode, "ng-isolate-scope");
                        forEach(newIsolateScopeDirective.scope, (function (definition, scopeName) {
                            var match = definition.match(LOCAL_REGEXP) || [],
                                attrName = match[3] || scopeName,
                                optional = match[2] == "?",
                                mode = match[1],
                                lastValue, parentGet, parentSet, compare;
                            isolateScope.$$isolateBindings[scopeName] = mode + attrName;
                            switch (mode) {
                                case "@":
                                    attrs.$observe(attrName, (function (value) {
                                        isolateScope[scopeName] = value
                                    }));
                                    attrs.$$observers[attrName].$$scope = scope;
                                    if (attrs[attrName]) {
                                        isolateScope[scopeName] = $interpolate(attrs[attrName])(scope)
                                    }
                                    break;
                                case "=":
                                    if (optional && !attrs[attrName]) {
                                        return
                                    }
                                    parentGet = $parse(attrs[attrName]);
                                    if (parentGet.literal) {
                                        compare = equals
                                    } else {
                                        compare = function (a, b) {
                                            return a === b
                                        }
                                    }
                                    parentSet = parentGet.assign || function () {
                                        lastValue = isolateScope[scopeName] = parentGet(scope);
                                        throw $compileMinErr("nonassign", "Expression '{0}' used with directive '{1}' is non-assignable!", attrs[attrName], newIsolateScopeDirective.name)
                                    };
                                    lastValue = isolateScope[scopeName] = parentGet(scope);
                                    isolateScope.$watch((function parentValueWatch() {
                                        var parentValue = parentGet(scope);
                                        if (!compare(parentValue, isolateScope[scopeName])) {
                                            if (!compare(parentValue, lastValue)) {
                                                isolateScope[scopeName] = parentValue
                                            } else {
                                                parentSet(scope, parentValue = isolateScope[scopeName])
                                            }
                                        }
                                        return lastValue = parentValue
                                    }), null, parentGet.literal);
                                    break;
                                case "&":
                                    parentGet = $parse(attrs[attrName]);
                                    isolateScope[scopeName] = function (locals) {
                                        return parentGet(scope, locals)
                                    };
                                    break;
                                default:
                                    throw $compileMinErr("iscp", "Invalid isolate scope definition for directive '{0}'." + " Definition: {... {1}: '{2}' ...}", newIsolateScopeDirective.name, scopeName, definition)
                            }
                        }))
                    }
                    transcludeFn = boundTranscludeFn && controllersBoundTransclude;
                    if (controllerDirectives) {
                        forEach(controllerDirectives, (function (directive) {
                            var locals = {
                                $scope: directive === newIsolateScopeDirective || directive.$$isolateScope ? isolateScope : scope,
                                $element: $element,
                                $attrs: attrs,
                                $transclude: transcludeFn
                            },
                                controllerInstance;
                            controller = directive.controller;
                            if (controller == "@") {
                                controller = attrs[directive.name]
                            }
                            controllerInstance = $controller(controller, locals);
                            elementControllers[directive.name] = controllerInstance;
                            if (!hasElementTranscludeDirective) {
                                $element.data("$" + directive.name + "Controller", controllerInstance)
                            }
                            if (directive.controllerAs) {
                                locals.$scope[directive.controllerAs] = controllerInstance
                            }
                        }))
                    }
                    for (i = 0, ii = preLinkFns.length; i < ii; i++) {
                        try {
                            linkFn = preLinkFns[i];
                            linkFn(linkFn.isolateScope ? isolateScope : scope, $element, attrs, linkFn.require && getControllers(linkFn.require, $element, elementControllers), transcludeFn)
                        } catch (e) {
                            $exceptionHandler(e, startingTag($element))
                        }
                    }
                    var scopeToChild = scope;
                    if (newIsolateScopeDirective && (newIsolateScopeDirective.template || newIsolateScopeDirective.templateUrl === null)) {
                        scopeToChild = isolateScope
                    }
                    childLinkFn && childLinkFn(scopeToChild, linkNode.childNodes, undefined, boundTranscludeFn);
                    for (i = postLinkFns.length - 1; i >= 0; i--) {
                        try {
                            linkFn = postLinkFns[i];
                            linkFn(linkFn.isolateScope ? isolateScope : scope, $element, attrs, linkFn.require && getControllers(linkFn.require, $element, elementControllers), transcludeFn)
                        } catch (e) {
                            $exceptionHandler(e, startingTag($element))
                        }
                    }

                    function controllersBoundTransclude(scope, cloneAttachFn) {
                        var transcludeControllers;
                        if (arguments.length < 2) {
                            cloneAttachFn = scope;
                            scope = undefined
                        }
                        if (hasElementTranscludeDirective) {
                            transcludeControllers = elementControllers
                        }
                        return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers)
                    }
                }
            }

            function markDirectivesAsIsolate(directives) {
                for (var j = 0, jj = directives.length; j < jj; j++) {
                    directives[j] = inherit(directives[j], {
                        $$isolateScope: true
                    })
                }
            }

            function addDirective(tDirectives, name, location, maxPriority, ignoreDirective, startAttrName, endAttrName) {
                if (name === ignoreDirective) return null;
                var match = null;
                if (hasDirectives.hasOwnProperty(name)) {
                    for (var directive, directives = $injector.get(name + Suffix), i = 0, ii = directives.length; i < ii; i++) {
                        try {
                            directive = directives[i];
                            if ((maxPriority === undefined || maxPriority > directive.priority) && directive.restrict.indexOf(location) != -1) {
                                if (startAttrName) {
                                    directive = inherit(directive, {
                                        $$start: startAttrName,
                                        $$end: endAttrName
                                    })
                                }
                                tDirectives.push(directive);
                                match = directive
                            }
                        } catch (e) {
                            $exceptionHandler(e)
                        }
                    }
                }
                return match
            }

            function mergeTemplateAttributes(dst, src) {
                var srcAttr = src.$attr,
                    dstAttr = dst.$attr,
                    $element = dst.$$element;
                forEach(dst, (function (value, key) {
                    if (key.charAt(0) != "$") {
                        if (src[key]) {
                            value += (key === "style" ? ";" : " ") + src[key]
                        }
                        dst.$set(key, value, true, srcAttr[key])
                    }
                }));
                forEach(src, (function (value, key) {
                    if (key == "class") {
                        safeAddClass($element, value);
                        dst["class"] = (dst["class"] ? dst["class"] + " " : "") + value
                    } else if (key == "style") {
                        $element.attr("style", $element.attr("style") + ";" + value);
                        dst["style"] = (dst["style"] ? dst["style"] + ";" : "") + value
                    } else if (key.charAt(0) != "$" && !dst.hasOwnProperty(key)) {
                        dst[key] = value;
                        dstAttr[key] = srcAttr[key]
                    }
                }))
            }

            function compileTemplateUrl(directives, $compileNode, tAttrs, $rootElement, childTranscludeFn, preLinkFns, postLinkFns, previousCompileContext) {
                var linkQueue = [],
                    afterTemplateNodeLinkFn, afterTemplateChildLinkFn, beforeTemplateCompileNode = $compileNode[0],
                    origAsyncDirective = directives.shift(),
                    derivedSyncDirective = extend({}, origAsyncDirective, {
                        templateUrl: null,
                        transclude: null,
                        replace: null,
                        $$originalDirective: origAsyncDirective
                    }),
                    templateUrl = isFunction(origAsyncDirective.templateUrl) ? origAsyncDirective.templateUrl($compileNode, tAttrs) : origAsyncDirective.templateUrl;
                $compileNode.empty();
                $http.get($sce.getTrustedResourceUrl(templateUrl), {
                    cache: $templateCache
                }).success((function (content) {
                    var compileNode, tempTemplateAttrs, $template, childBoundTranscludeFn;
                    content = denormalizeTemplate(content);
                    if (origAsyncDirective.replace) {
                        $template = jqLite("<div>" + trim(content) + "</div>").contents();
                        compileNode = $template[0];
                        if ($template.length != 1 || compileNode.nodeType !== 1) {
                            throw $compileMinErr("tplrt", "Template for directive '{0}' must have exactly one root element. {1}", origAsyncDirective.name, templateUrl)
                        }
                        tempTemplateAttrs = {
                            $attr: {}
                        };
                        replaceWith($rootElement, $compileNode, compileNode);
                        var templateDirectives = collectDirectives(compileNode, [], tempTemplateAttrs);
                        if (isObject(origAsyncDirective.scope)) {
                            markDirectivesAsIsolate(templateDirectives)
                        }
                        directives = templateDirectives.concat(directives);
                        mergeTemplateAttributes(tAttrs, tempTemplateAttrs)
                    } else {
                        compileNode = beforeTemplateCompileNode;
                        $compileNode.html(content)
                    }
                    directives.unshift(derivedSyncDirective);
                    afterTemplateNodeLinkFn = applyDirectivesToNode(directives, compileNode, tAttrs, childTranscludeFn, $compileNode, origAsyncDirective, preLinkFns, postLinkFns, previousCompileContext);
                    forEach($rootElement, (function (node, i) {
                        if (node == compileNode) {
                            $rootElement[i] = $compileNode[0]
                        }
                    }));
                    afterTemplateChildLinkFn = compileNodes($compileNode[0].childNodes, childTranscludeFn);
                    while (linkQueue.length) {
                        var scope = linkQueue.shift(),
                            beforeTemplateLinkNode = linkQueue.shift(),
                            linkRootElement = linkQueue.shift(),
                            boundTranscludeFn = linkQueue.shift(),
                            linkNode = $compileNode[0];
                        if (beforeTemplateLinkNode !== beforeTemplateCompileNode) {
                            linkNode = jqLiteClone(compileNode);
                            replaceWith(linkRootElement, jqLite(beforeTemplateLinkNode), linkNode)
                        }
                        if (afterTemplateNodeLinkFn.transclude) {
                            childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude)
                        } else {
                            childBoundTranscludeFn = boundTranscludeFn
                        }
                        afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, linkNode, $rootElement, childBoundTranscludeFn)
                    }
                    linkQueue = null
                })).error((function (response, code, headers, config) {
                    throw $compileMinErr("tpload", "Failed to load template: {0}", config.url)
                }));
                return function delayedNodeLinkFn(ignoreChildLinkFn, scope, node, rootElement, boundTranscludeFn) {
                    if (linkQueue) {
                        linkQueue.push(scope);
                        linkQueue.push(node);
                        linkQueue.push(rootElement);
                        linkQueue.push(boundTranscludeFn)
                    } else {
                        afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, boundTranscludeFn)
                    }
                }
            }

            function byPriority(a, b) {
                var diff = b.priority - a.priority;
                if (diff !== 0) return diff;
                if (a.name !== b.name) return a.name < b.name ? -1 : 1;
                return a.index - b.index
            }

            function assertNoDuplicate(what, previousDirective, directive, element) {
                if (previousDirective) {
                    throw $compileMinErr("multidir", "Multiple directives [{0}, {1}] asking for {2} on: {3}", previousDirective.name, directive.name, what, startingTag(element))
                }
            }

            function addTextInterpolateDirective(directives, text) {
                var interpolateFn = $interpolate(text, true);
                if (interpolateFn) {
                    directives.push({
                        priority: 0,
                        compile: valueFn((function textInterpolateLinkFn(scope, node) {
                            var parent = node.parent(),
                                bindings = parent.data("$binding") || [];
                            bindings.push(interpolateFn);
                            safeAddClass(parent.data("$binding", bindings), "ng-binding");
                            scope.$watch(interpolateFn, (function interpolateFnWatchAction(value) {
                                node[0].nodeValue = value
                            }))
                        }))
                    })
                }
            }

            function getTrustedContext(node, attrNormalizedName) {
                if (attrNormalizedName == "srcdoc") {
                    return $sce.HTML
                }
                var tag = nodeName_(node);
                if (attrNormalizedName == "xlinkHref" || tag == "FORM" && attrNormalizedName == "action" || tag != "IMG" && (attrNormalizedName == "src" || attrNormalizedName == "ngSrc")) {
                    return $sce.RESOURCE_URL
                }
            }

            function addAttrInterpolateDirective(node, directives, value, name) {
                var interpolateFn = $interpolate(value, true);
                if (!interpolateFn) return;
                if (name === "multiple" && nodeName_(node) === "SELECT") {
                    throw $compileMinErr("selmulti", "Binding to the 'multiple' attribute is not supported. Element: {0}", startingTag(node))
                }
                directives.push({
                    priority: 100,
                    compile: function () {
                        return {
                            pre: function attrInterpolatePreLinkFn(scope, element, attr) {
                                var $$observers = attr.$$observers || (attr.$$observers = {});
                                if (EVENT_HANDLER_ATTR_REGEXP.test(name)) {
                                    throw $compileMinErr("nodomevents", "Interpolations for HTML DOM event attributes are disallowed.  Please use the " + "ng- versions (such as ng-click instead of onclick) instead.")
                                }
                                interpolateFn = $interpolate(attr[name], true, getTrustedContext(node, name));
                                if (!interpolateFn) return;
                                attr[name] = interpolateFn(scope);
                                ($$observers[name] || ($$observers[name] = [])).$$inter = true;
                                (attr.$$observers && attr.$$observers[name].$$scope || scope).$watch(interpolateFn, (function interpolateFnWatchAction(newValue, oldValue) {
                                    if (name === "class" && newValue != oldValue) {
                                        attr.$updateClass(newValue, oldValue)
                                    } else {
                                        attr.$set(name, newValue)
                                    }
                                }))
                            }
                        }
                    }
                })
            }

            function replaceWith($rootElement, elementsToRemove, newNode) {
                var firstElementToRemove = elementsToRemove[0],
                    removeCount = elementsToRemove.length,
                    parent = firstElementToRemove.parentNode,
                    i, ii;
                if ($rootElement) {
                    for (i = 0, ii = $rootElement.length; i < ii; i++) {
                        if ($rootElement[i] == firstElementToRemove) {
                            $rootElement[i++] = newNode;
                            for (var j = i, j2 = j + removeCount - 1, jj = $rootElement.length; j < jj; j++, j2++) {
                                if (j2 < jj) {
                                    $rootElement[j] = $rootElement[j2]
                                } else {
                                    delete $rootElement[j]
                                }
                            }
                            $rootElement.length -= removeCount - 1;
                            break
                        }
                    }
                }
                if (parent) {
                    parent.replaceChild(newNode, firstElementToRemove)
                }
                var fragment = document.createDocumentFragment();
                fragment.appendChild(firstElementToRemove);
                newNode[jqLite.expando] = firstElementToRemove[jqLite.expando];
                for (var k = 1, kk = elementsToRemove.length; k < kk; k++) {
                    var element = elementsToRemove[k];
                    jqLite(element).remove();
                    fragment.appendChild(element);
                    delete elementsToRemove[k]
                }
                elementsToRemove[0] = newNode;
                elementsToRemove.length = 1
            }

            function cloneAndAnnotateFn(fn, annotation) {
                return extend((function () {
                    return fn.apply(null, arguments)
                }), fn, annotation)
            }
        }]
    }
    var PREFIX_REGEXP = /^(x[\:\-_]|data[\:\-_])/i;

    function directiveNormalize(name) {
        return camelCase(name.replace(PREFIX_REGEXP, ""))
    }

    function nodesetLinkingFn(scope, nodeList, rootElement, boundTranscludeFn) { }

    function directiveLinkingFn(nodesetLinkingFn, scope, node, rootElement, boundTranscludeFn) { }

    function tokenDifference(str1, str2) {
        var values = "",
            tokens1 = str1.split(/\s+/),
            tokens2 = str2.split(/\s+/);
        outer: for (var i = 0; i < tokens1.length; i++) {
            var token = tokens1[i];
            for (var j = 0; j < tokens2.length; j++) {
                if (token == tokens2[j]) continue outer
            }
            values += (values.length > 0 ? " " : "") + token
        }
        return values
    }

    function $ControllerProvider() {
        var controllers = {},
            CNTRL_REG = /^(\S+)(\s+as\s+(\w+))?$/;
        this.register = function (name, constructor) {
            assertNotHasOwnProperty(name, "controller");
            if (isObject(name)) {
                extend(controllers, name)
            } else {
                controllers[name] = constructor
            }
        };
        this.$get = ["$injector", "$window", function ($injector, $window) {
            return function (expression, locals) {
                var instance, match, constructor, identifier;
                if (isString(expression)) {
                    match = expression.match(CNTRL_REG), constructor = match[1], identifier = match[3];
                    expression = controllers.hasOwnProperty(constructor) ? controllers[constructor] : getter(locals.$scope, constructor, true) || getter($window, constructor, true);
                    assertArgFn(expression, constructor, true)
                }
                instance = $injector.instantiate(expression, locals);
                if (identifier) {
                    if (!(locals && typeof locals.$scope == "object")) {
                        throw minErr("$controller")("noscp", "Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.", constructor || expression.name, identifier)
                    }
                    locals.$scope[identifier] = instance
                }
                return instance
            }
        }]
    }

    function $DocumentProvider() {
        this.$get = ["$window", function (window) {
            return jqLite(window.document)
        }]
    }

    function $ExceptionHandlerProvider() {
        this.$get = ["$log", function ($log) {
            return function (exception, cause) {
                $log.error.apply($log, arguments)
            }
        }]
    }

    function parseHeaders(headers) {
        var parsed = {},
            key, val, i;
        if (!headers) return parsed;
        forEach(headers.split("\n"), (function (line) {
            i = line.indexOf(":");
            key = lowercase(trim(line.substr(0, i)));
            val = trim(line.substr(i + 1));
            if (key) {
                if (parsed[key]) {
                    parsed[key] += ", " + val
                } else {
                    parsed[key] = val
                }
            }
        }));
        return parsed
    }

    function headersGetter(headers) {
        var headersObj = isObject(headers) ? headers : undefined;
        return function (name) {
            if (!headersObj) headersObj = parseHeaders(headers);
            if (name) {
                return headersObj[lowercase(name)] || null
            }
            return headersObj
        }
    }

    function transformData(data, headers, fns) {
        if (isFunction(fns)) return fns(data, headers);
        forEach(fns, (function (fn) {
            data = fn(data, headers)
        }));
        return data
    }

    function isSuccess(status) {
        return 200 <= status && status < 300
    }

    function $HttpProvider() {
        var JSON_START = /^\s*(\[|\{[^\{])/,
            JSON_END = /[\}\]]\s*$/,
            PROTECTION_PREFIX = /^\)\]\}',?\n/,
            CONTENT_TYPE_APPLICATION_JSON = {
                "Content-Type": "application/json;charset=utf-8"
            };
        var defaults = this.defaults = {
            transformResponse: [function (data) {
                if (isString(data)) {
                    data = data.replace(PROTECTION_PREFIX, "");
                    if (JSON_START.test(data) && JSON_END.test(data)) data = fromJson(data)
                }
                return data
            }],
            transformRequest: [function (d) {
                return isObject(d) && !isFile(d) ? toJson(d) : d
            }],
            headers: {
                common: {
                    Accept: "application/json, text/plain, */*"
                },
                post: CONTENT_TYPE_APPLICATION_JSON,
                put: CONTENT_TYPE_APPLICATION_JSON,
                patch: CONTENT_TYPE_APPLICATION_JSON
            },
            xsrfCookieName: "XSRF-TOKEN",
            xsrfHeaderName: "X-XSRF-TOKEN"
        };
        var interceptorFactories = this.interceptors = [];
        var responseInterceptorFactories = this.responseInterceptors = [];
        this.$get = ["$httpBackend", "$browser", "$cacheFactory", "$rootScope", "$q", "$injector", function ($httpBackend, $browser, $cacheFactory, $rootScope, $q, $injector) {
            var defaultCache = $cacheFactory("$http");
            var reversedInterceptors = [];
            forEach(interceptorFactories, (function (interceptorFactory) {
                reversedInterceptors.unshift(isString(interceptorFactory) ? $injector.get(interceptorFactory) : $injector.invoke(interceptorFactory))
            }));
            forEach(responseInterceptorFactories, (function (interceptorFactory, index) {
                var responseFn = isString(interceptorFactory) ? $injector.get(interceptorFactory) : $injector.invoke(interceptorFactory);
                reversedInterceptors.splice(index, 0, {
                    response: function (response) {
                        return responseFn($q.when(response))
                    },
                    responseError: function (response) {
                        return responseFn($q.reject(response))
                    }
                })
            }));

            function $http(requestConfig) {
                var config = {
                    transformRequest: defaults.transformRequest,
                    transformResponse: defaults.transformResponse
                };
                var headers = mergeHeaders(requestConfig);
                extend(config, requestConfig);
                config.headers = headers;
                config.method = uppercase(config.method);
                var xsrfValue = urlIsSameOrigin(config.url) ? $browser.cookies()[config.xsrfCookieName || defaults.xsrfCookieName] : undefined;
                if (xsrfValue) {
                    headers[config.xsrfHeaderName || defaults.xsrfHeaderName] = xsrfValue
                }
                var serverRequest = function (config) {
                    headers = config.headers;
                    var reqData = transformData(config.data, headersGetter(headers), config.transformRequest);
                    if (isUndefined(config.data)) {
                        forEach(headers, (function (value, header) {
                            if (lowercase(header) === "content-type") {
                                delete headers[header]
                            }
                        }))
                    }
                    if (isUndefined(config.withCredentials) && !isUndefined(defaults.withCredentials)) {
                        config.withCredentials = defaults.withCredentials
                    }
                    return sendReq(config, reqData, headers).then(transformResponse, transformResponse)
                };
                var chain = [serverRequest, undefined];
                var promise = $q.when(config);
                forEach(reversedInterceptors, (function (interceptor) {
                    if (interceptor.request || interceptor.requestError) {
                        chain.unshift(interceptor.request, interceptor.requestError)
                    }
                    if (interceptor.response || interceptor.responseError) {
                        chain.push(interceptor.response, interceptor.responseError)
                    }
                }));
                while (chain.length) {
                    var thenFn = chain.shift();
                    var rejectFn = chain.shift();
                    promise = promise.then(thenFn, rejectFn)
                }
                promise.success = function (fn) {
                    promise.then((function (response) {
                        fn(response.data, response.status, response.headers, config)
                    }));
                    return promise
                };
                promise.error = function (fn) {
                    promise.then(null, (function (response) {
                        fn(response.data, response.status, response.headers, config)
                    }));
                    return promise
                };
                return promise;

                function transformResponse(response) {
                    var resp = extend({}, response, {
                        data: transformData(response.data, response.headers, config.transformResponse)
                    });
                    return isSuccess(response.status) ? resp : $q.reject(resp)
                }

                function mergeHeaders(config) {
                    var defHeaders = defaults.headers,
                        reqHeaders = extend({}, config.headers),
                        defHeaderName, lowercaseDefHeaderName, reqHeaderName;
                    defHeaders = extend({}, defHeaders.common, defHeaders[lowercase(config.method)]);
                    execHeaders(defHeaders);
                    execHeaders(reqHeaders);
                    defaultHeadersIteration: for (defHeaderName in defHeaders) {
                        lowercaseDefHeaderName = lowercase(defHeaderName);
                        for (reqHeaderName in reqHeaders) {
                            if (lowercase(reqHeaderName) === lowercaseDefHeaderName) {
                                continue defaultHeadersIteration
                            }
                        }
                        reqHeaders[defHeaderName] = defHeaders[defHeaderName]
                    }
                    return reqHeaders;

                    function execHeaders(headers) {
                        var headerContent;
                        forEach(headers, (function (headerFn, header) {
                            if (isFunction(headerFn)) {
                                headerContent = headerFn();
                                if (headerContent != null) {
                                    headers[header] = headerContent
                                } else {
                                    delete headers[header]
                                }
                            }
                        }))
                    }
                }
            }
            $http.pendingRequests = [];
            createShortMethods("get", "delete", "head", "jsonp");
            createShortMethodsWithData("post", "put");
            $http.defaults = defaults;
            return $http;

            function createShortMethods(names) {
                forEach(arguments, (function (name) {
                    $http[name] = function (url, config) {
                        return $http(extend(config || {}, {
                            method: name,
                            url: url
                        }))
                    }
                }))
            }

            function createShortMethodsWithData(name) {
                forEach(arguments, (function (name) {
                    $http[name] = function (url, data, config) {
                        return $http(extend(config || {}, {
                            method: name,
                            url: url,
                            data: data
                        }))
                    }
                }))
            }

            function sendReq(config, reqData, reqHeaders) {
                var deferred = $q.defer(),
                    promise = deferred.promise,
                    cache, cachedResp, url = buildUrl(config.url, config.params);
                $http.pendingRequests.push(config);
                promise.then(removePendingReq, removePendingReq);
                if ((config.cache || defaults.cache) && config.cache !== false && config.method == "GET") {
                    cache = isObject(config.cache) ? config.cache : isObject(defaults.cache) ? defaults.cache : defaultCache
                }
                if (cache) {
                    cachedResp = cache.get(url);
                    if (isDefined(cachedResp)) {
                        if (cachedResp.then) {
                            cachedResp.then(removePendingReq, removePendingReq);
                            return cachedResp
                        } else {
                            if (isArray(cachedResp)) {
                                resolvePromise(cachedResp[1], cachedResp[0], copy(cachedResp[2]))
                            } else {
                                resolvePromise(cachedResp, 200, {})
                            }
                        }
                    } else {
                        cache.put(url, promise)
                    }
                }
                if (isUndefined(cachedResp)) {
                    $httpBackend(config.method, url, reqData, done, reqHeaders, config.timeout, config.withCredentials, config.responseType)
                }
                return promise;

                function done(status, response, headersString) {
                    if (cache) {
                        if (isSuccess(status)) {
                            cache.put(url, [status, response, parseHeaders(headersString)])
                        } else {
                            cache.remove(url)
                        }
                    }
                    resolvePromise(response, status, headersString);
                    if (!$rootScope.$$phase) $rootScope.$apply()
                }

                function resolvePromise(response, status, headers) {
                    status = Math.max(status, 0);
                    (isSuccess(status) ? deferred.resolve : deferred.reject)({
                        data: response,
                        status: status,
                        headers: headersGetter(headers),
                        config: config
                    })
                }

                function removePendingReq() {
                    var idx = indexOf($http.pendingRequests, config);
                    if (idx !== -1) $http.pendingRequests.splice(idx, 1)
                }
            }

            function buildUrl(url, params) {
                if (!params) return url;
                var parts = [];
                forEachSorted(params, (function (value, key) {
                    if (value === null || isUndefined(value)) return;
                    if (!isArray(value)) value = [value];
                    forEach(value, (function (v) {
                        if (isObject(v)) {
                            v = toJson(v)
                        }
                        parts.push(encodeUriQuery(key) + "=" + encodeUriQuery(v))
                    }))
                }));
                return url + (url.indexOf("?") == -1 ? "?" : "&") + parts.join("&")
            }
        }]
    }
    var XHR = window.XMLHttpRequest || function () {
        try {
            return new ActiveXObject("Msxml2.XMLHTTP.6.0")
        } catch (e1) { }
        try {
            return new ActiveXObject("Msxml2.XMLHTTP.3.0")
        } catch (e2) { }
        try {
            return new ActiveXObject("Msxml2.XMLHTTP")
        } catch (e3) { }
        throw minErr("$httpBackend")("noxhr", "This browser does not support XMLHttpRequest.")
    };

    function $HttpBackendProvider() {
        this.$get = ["$browser", "$window", "$document", function ($browser, $window, $document) {
            return createHttpBackend($browser, XHR, $browser.defer, $window.angular.callbacks, $document[0])
        }]
    }

    function createHttpBackend($browser, XHR, $browserDefer, callbacks, rawDocument) {
        var ABORTED = -1;
        return function (method, url, post, callback, headers, timeout, withCredentials, responseType) {
            var status;
            $browser.$$incOutstandingRequestCount();
            url = url || $browser.url();
            if (lowercase(method) == "jsonp") {
                var callbackId = "_" + (callbacks.counter++).toString(36);
                callbacks[callbackId] = function (data) {
                    callbacks[callbackId].data = data
                };
                var jsonpDone = jsonpReq(url.replace("JSON_CALLBACK", "angular.callbacks." + callbackId), (function () {
                    if (callbacks[callbackId].data) {
                        completeRequest(callback, 200, callbacks[callbackId].data)
                    } else {
                        completeRequest(callback, status || -2)
                    }
                    delete callbacks[callbackId]
                }))
            } else {
                var xhr = new XHR;
                xhr.open(method, url, true);
                forEach(headers, (function (value, key) {
                    if (isDefined(value)) {
                        xhr.setRequestHeader(key, value)
                    }
                }));
                xhr.onreadystatechange = function () {
                    if (xhr.readyState == 4) {
                        var responseHeaders = null,
                            response = null;
                        if (status !== ABORTED) {
                            responseHeaders = xhr.getAllResponseHeaders();
                            response = xhr.responseType ? xhr.response : xhr.responseText
                        }
                        completeRequest(callback, status || xhr.status, response, responseHeaders)
                    }
                };
                if (withCredentials) {
                    xhr.withCredentials = true
                }
                if (responseType) {
                    xhr.responseType = responseType
                }
                xhr.send(post || null)
            }
            if (timeout > 0) {
                var timeoutId = $browserDefer(timeoutRequest, timeout)
            } else if (timeout && timeout.then) {
                timeout.then(timeoutRequest)
            }

            function timeoutRequest() {
                status = ABORTED;
                jsonpDone && jsonpDone();
                xhr && xhr.abort()
            }

            function completeRequest(callback, status, response, headersString) {
                var protocol = urlResolve(url).protocol;
                timeoutId && $browserDefer.cancel(timeoutId);
                jsonpDone = xhr = null;
                status = protocol == "file" && status === 0 ? response ? 200 : 404 : status;
                status = status == 1223 ? 204 : status;
                callback(status, response, headersString);
                $browser.$$completeOutstandingRequest(noop)
            }
        };

        function jsonpReq(url, done) {
            var script = rawDocument.createElement("script"),
                doneWrapper = function () {
                    script.onreadystatechange = script.onload = script.onerror = null;
                    rawDocument.body.removeChild(script);
                    if (done) done()
                };
            script.type = "text/javascript";
            script.src = url;
            if (msie && msie <= 8) {
                script.onreadystatechange = function () {
                    if (/loaded|complete/.test(script.readyState)) {
                        doneWrapper()
                    }
                }
            } else {
                script.onload = script.onerror = function () {
                    doneWrapper()
                }
            }
            rawDocument.body.appendChild(script);
            return doneWrapper
        }
    }
    var $interpolateMinErr = minErr("$interpolate");

    function $InterpolateProvider() {
        var startSymbol = "{{";
        var endSymbol = "}}";
        this.startSymbol = function (value) {
            if (value) {
                startSymbol = value;
                return this
            } else {
                return startSymbol
            }
        };
        this.endSymbol = function (value) {
            if (value) {
                endSymbol = value;
                return this
            } else {
                return endSymbol
            }
        };
        this.$get = ["$parse", "$exceptionHandler", "$sce", function ($parse, $exceptionHandler, $sce) {
            var startSymbolLength = startSymbol.length,
                endSymbolLength = endSymbol.length;

            function $interpolate(text, mustHaveExpression, trustedContext) {
                var startIndex, endIndex, index = 0,
                    parts = [],
                    length = text.length,
                    hasInterpolation = false,
                    fn, exp, concat = [];
                while (index < length) {
                    if ((startIndex = text.indexOf(startSymbol, index)) != -1 && (endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1) {
                        index != startIndex && parts.push(text.substring(index, startIndex));
                        parts.push(fn = $parse(exp = text.substring(startIndex + startSymbolLength, endIndex)));
                        fn.exp = exp;
                        index = endIndex + endSymbolLength;
                        hasInterpolation = true
                    } else {
                        index != length && parts.push(text.substring(index));
                        index = length
                    }
                }
                if (!(length = parts.length)) {
                    parts.push("");
                    length = 1
                }
                if (trustedContext && parts.length > 1) {
                    throw $interpolateMinErr("noconcat", "Error while interpolating: {0}\nStrict Contextual Escaping disallows " + "interpolations that concatenate multiple expressions when a trusted value is " + "required.  See http://docs.angularjs.org/api/ng.$sce", text)
                }
                if (!mustHaveExpression || hasInterpolation) {
                    concat.length = length;
                    fn = function (context) {
                        try {
                            for (var i = 0, ii = length, part; i < ii; i++) {
                                if (typeof (part = parts[i]) == "function") {
                                    part = part(context);
                                    if (trustedContext) {
                                        part = $sce.getTrusted(trustedContext, part)
                                    } else {
                                        part = $sce.valueOf(part)
                                    }
                                    if (part === null || isUndefined(part)) {
                                        part = ""
                                    } else if (typeof part != "string") {
                                        part = toJson(part)
                                    }
                                }
                                concat[i] = part
                            }
                            return concat.join("")
                        } catch (err) {
                            var newErr = $interpolateMinErr("interr", "Can't interpolate: {0}\n{1}", text, err.toString());
                            $exceptionHandler(newErr)
                        }
                    };
                    fn.exp = text;
                    fn.parts = parts;
                    return fn
                }
            }
            $interpolate.startSymbol = function () {
                return startSymbol
            };
            $interpolate.endSymbol = function () {
                return endSymbol
            };
            return $interpolate
        }]
    }

    function $IntervalProvider() {
        this.$get = ["$rootScope", "$window", "$q", function ($rootScope, $window, $q) {
            var intervals = {};

            function interval(fn, delay, count, invokeApply) {
                var setInterval = $window.setInterval,
                    clearInterval = $window.clearInterval,
                    deferred = $q.defer(),
                    promise = deferred.promise,
                    iteration = 0,
                    skipApply = isDefined(invokeApply) && !invokeApply;
                count = isDefined(count) ? count : 0, promise.then(null, null, fn);
                promise.$$intervalId = setInterval((function tick() {
                    deferred.notify(iteration++);
                    if (count > 0 && iteration >= count) {
                        deferred.resolve(iteration);
                        clearInterval(promise.$$intervalId);
                        delete intervals[promise.$$intervalId]
                    }
                    if (!skipApply) $rootScope.$apply()
                }), delay);
                intervals[promise.$$intervalId] = deferred;
                return promise
            }
            interval.cancel = function (promise) {
                if (promise && promise.$$intervalId in intervals) {
                    intervals[promise.$$intervalId].reject("canceled");
                    clearInterval(promise.$$intervalId);
                    delete intervals[promise.$$intervalId];
                    return true
                }
                return false
            };
            return interval
        }]
    }

    function $LocaleProvider() {
        this.$get = function () {
            return {
                id: "en-us",
                NUMBER_FORMATS: {
                    DECIMAL_SEP: ".",
                    GROUP_SEP: ",",
                    PATTERNS: [{
                        minInt: 1,
                        minFrac: 0,
                        maxFrac: 3,
                        posPre: "",
                        posSuf: "",
                        negPre: "-",
                        negSuf: "",
                        gSize: 3,
                        lgSize: 3
                    }, {
                        minInt: 1,
                        minFrac: 2,
                        maxFrac: 2,
                        posPre: "¤",
                        posSuf: "",
                        negPre: "(¤",
                        negSuf: ")",
                        gSize: 3,
                        lgSize: 3
                    }],
                    CURRENCY_SYM: "$"
                },
                DATETIME_FORMATS: {
                    MONTH: "January,February,March,April,May,June,July,August,September,October,November,December".split(","),
                    SHORTMONTH: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec".split(","),
                    DAY: "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(","),
                    SHORTDAY: "Sun,Mon,Tue,Wed,Thu,Fri,Sat".split(","),
                    AMPMS: ["AM", "PM"],
                    medium: "MMM d, y h:mm:ss a",
                    short: "M/d/yy h:mm a",
                    fullDate: "EEEE, MMMM d, y",
                    longDate: "MMMM d, y",
                    mediumDate: "MMM d, y",
                    shortDate: "M/d/yy",
                    mediumTime: "h:mm:ss a",
                    shortTime: "h:mm a"
                },
                pluralCat: function (num) {
                    if (num === 1) {
                        return "one"
                    }
                    return "other"
                }
            }
        }
    }
    var PATH_MATCH = /^([^\?#]*)(\?([^#]*))?(#(.*))?$/,
        DEFAULT_PORTS = {
            http: 80,
            https: 443,
            ftp: 21
        };
    var $locationMinErr = minErr("$location");

    function encodePath(path) {
        var segments = path.split("/"),
            i = segments.length;
        while (i--) {
            segments[i] = encodeUriSegment(segments[i])
        }
        return segments.join("/")
    }

    function parseAbsoluteUrl(absoluteUrl, locationObj, appBase) {
        var parsedUrl = urlResolve(absoluteUrl, appBase);
        locationObj.$$protocol = parsedUrl.protocol;
        locationObj.$$host = parsedUrl.hostname;
        locationObj.$$port = int(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null
    }

    function parseAppUrl(relativeUrl, locationObj, appBase) {
        var prefixed = relativeUrl.charAt(0) !== "/";
        if (prefixed) {
            relativeUrl = "/" + relativeUrl
        }
        var match = urlResolve(relativeUrl, appBase);
        locationObj.$$path = decodeURIComponent(prefixed && match.pathname.charAt(0) === "/" ? match.pathname.substring(1) : match.pathname);
        locationObj.$$search = parseKeyValue(match.search);
        locationObj.$$hash = decodeURIComponent(match.hash);
        if (locationObj.$$path && locationObj.$$path.charAt(0) != "/") {
            locationObj.$$path = "/" + locationObj.$$path
        }
    }

    function beginsWith(begin, whole) {
        if (whole.indexOf(begin) === 0) {
            return whole.substr(begin.length)
        }
    }

    function stripHash(url) {
        var index = url.indexOf("#");
        return index == -1 ? url : url.substr(0, index)
    }

    function stripFile(url) {
        return url.substr(0, stripHash(url).lastIndexOf("/") + 1)
    }

    function serverBase(url) {
        return url.substring(0, url.indexOf("/", url.indexOf("//") + 2))
    }

    function LocationHtml5Url(appBase, basePrefix) {
        this.$$html5 = true;
        basePrefix = basePrefix || "";
        var appBaseNoFile = stripFile(appBase);
        parseAbsoluteUrl(appBase, this, appBase);
        this.$$parse = function (url) {
            var pathUrl = beginsWith(appBaseNoFile, url);
            if (!isString(pathUrl)) {
                throw $locationMinErr("ipthprfx", 'Invalid url "{0}", missing path prefix "{1}".', url, appBaseNoFile)
            }
            parseAppUrl(pathUrl, this, appBase);
            if (!this.$$path) {
                this.$$path = "/"
            }
            this.$$compose()
        };
        this.$$compose = function () {
            var search = toKeyValue(this.$$search),
                hash = this.$$hash ? "#" + encodeUriSegment(this.$$hash) : "";
            this.$$url = encodePath(this.$$path) + (search ? "?" + search : "") + hash;
            this.$$absUrl = appBaseNoFile + this.$$url.substr(1)
        };
        this.$$rewrite = function (url) {
            var appUrl, prevAppUrl;
            if ((appUrl = beginsWith(appBase, url)) !== undefined) {
                prevAppUrl = appUrl;
                if ((appUrl = beginsWith(basePrefix, appUrl)) !== undefined) {
                    return appBaseNoFile + (beginsWith("/", appUrl) || appUrl)
                } else {
                    return appBase + prevAppUrl
                }
            } else if ((appUrl = beginsWith(appBaseNoFile, url)) !== undefined) {
                return appBaseNoFile + appUrl
            } else if (appBaseNoFile == url + "/") {
                return appBaseNoFile
            }
        }
    }

    function LocationHashbangUrl(appBase, hashPrefix) {
        var appBaseNoFile = stripFile(appBase);
        parseAbsoluteUrl(appBase, this, appBase);
        this.$$parse = function (url) {
            var withoutBaseUrl = beginsWith(appBase, url) || beginsWith(appBaseNoFile, url);
            var withoutHashUrl = withoutBaseUrl.charAt(0) == "#" ? beginsWith(hashPrefix, withoutBaseUrl) : this.$$html5 ? withoutBaseUrl : "";
            if (!isString(withoutHashUrl)) {
                throw $locationMinErr("ihshprfx", 'Invalid url "{0}", missing hash prefix "{1}".', url, hashPrefix)
            }
            parseAppUrl(withoutHashUrl, this, appBase);
            this.$$path = removeWindowsDriveName(this.$$path, withoutHashUrl, appBase);
            this.$$compose();

            function removeWindowsDriveName(path, url, base) {
                var windowsFilePathExp = /^\/?.*?:(\/.*)/;
                var firstPathSegmentMatch;
                if (url.indexOf(base) === 0) {
                    url = url.replace(base, "")
                }
                if (windowsFilePathExp.exec(url)) {
                    return path
                }
                firstPathSegmentMatch = windowsFilePathExp.exec(path);
                return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path
            }
        };
        this.$$compose = function () {
            var search = toKeyValue(this.$$search),
                hash = this.$$hash ? "#" + encodeUriSegment(this.$$hash) : "";
            this.$$url = encodePath(this.$$path) + (search ? "?" + search : "") + hash;
            this.$$absUrl = appBase + (this.$$url ? hashPrefix + this.$$url : "")
        };
        this.$$rewrite = function (url) {
            if (stripHash(appBase) == stripHash(url)) {
                return url
            }
        }
    }

    function LocationHashbangInHtml5Url(appBase, hashPrefix) {
        this.$$html5 = true;
        LocationHashbangUrl.apply(this, arguments);
        var appBaseNoFile = stripFile(appBase);
        this.$$rewrite = function (url) {
            var appUrl;
            if (appBase == stripHash(url)) {
                return url
            } else if (appUrl = beginsWith(appBaseNoFile, url)) {
                return appBase + hashPrefix + appUrl
            } else if (appBaseNoFile === url + "/") {
                return appBaseNoFile
            }
        }
    }
    LocationHashbangInHtml5Url.prototype = LocationHashbangUrl.prototype = LocationHtml5Url.prototype = {
        $$html5: false,
        $$replace: false,
        absUrl: locationGetter("$$absUrl"),
        url: function (url, replace) {
            if (isUndefined(url)) return this.$$url;
            var match = PATH_MATCH.exec(url);
            if (match[1]) this.path(decodeURIComponent(match[1]));
            if (match[2] || match[1]) this.search(match[3] || "");
            this.hash(match[5] || "", replace);
            return this
        },
        protocol: locationGetter("$$protocol"),
        host: locationGetter("$$host"),
        port: locationGetter("$$port"),
        path: locationGetterSetter("$$path", (function (path) {
            return path.charAt(0) == "/" ? path : "/" + path
        })),
        search: function (search, paramValue) {
            switch (arguments.length) {
                case 0:
                    return this.$$search;
                case 1:
                    if (isString(search)) {
                        this.$$search = parseKeyValue(search)
                    } else if (isObject(search)) {
                        this.$$search = search
                    } else {
                        throw $locationMinErr("isrcharg", "The first argument of the `$location#search()` call must be a string or an object.")
                    }
                    break;
                default:
                    if (isUndefined(paramValue) || paramValue === null) {
                        delete this.$$search[search]
                    } else {
                        this.$$search[search] = paramValue
                    }
            }
            this.$$compose();
            return this
        },
        hash: locationGetterSetter("$$hash", identity),
        replace: function () {
            this.$$replace = true;
            return this
        }
    };

    function locationGetter(property) {
        return function () {
            return this[property]
        }
    }

    function locationGetterSetter(property, preprocess) {
        return function (value) {
            if (isUndefined(value)) return this[property];
            this[property] = preprocess(value);
            this.$$compose();
            return this
        }
    }

    function $LocationProvider() {
        var hashPrefix = "",
            html5Mode = false;
        this.hashPrefix = function (prefix) {
            if (isDefined(prefix)) {
                hashPrefix = prefix;
                return this
            } else {
                return hashPrefix
            }
        };
        this.html5Mode = function (mode) {
            if (isDefined(mode)) {
                html5Mode = mode;
                return this
            } else {
                return html5Mode
            }
        };
        this.$get = ["$rootScope", "$browser", "$sniffer", "$rootElement", function ($rootScope, $browser, $sniffer, $rootElement) {
            var $location, LocationMode, baseHref = $browser.baseHref(),
                initialUrl = $browser.url(),
                appBase;
            if (html5Mode) {
                appBase = serverBase(initialUrl) + (baseHref || "/");
                LocationMode = $sniffer.history ? LocationHtml5Url : LocationHashbangInHtml5Url
            } else {
                appBase = stripHash(initialUrl);
                LocationMode = LocationHashbangUrl
            }
            $location = new LocationMode(appBase, "#" + hashPrefix);
            $location.$$parse($location.$$rewrite(initialUrl));
            $rootElement.on("click", (function (event) {
                if (event.ctrlKey || event.metaKey || event.which == 2) return;
                var elm = jqLite(event.target);
                while (lowercase(elm[0].nodeName) !== "a") {
                    if (elm[0] === $rootElement[0] || !(elm = elm.parent())[0]) return
                }
                var absHref = elm.prop("href");
                var rewrittenUrl = $location.$$rewrite(absHref);
                if (absHref && !elm.attr("target") && rewrittenUrl && !event.isDefaultPrevented()) {
                    event.preventDefault();
                    if (rewrittenUrl != $browser.url()) {
                        $location.$$parse(rewrittenUrl);
                        $rootScope.$apply();
                        window.angular["ff-684208-preventDefault"] = true
                    }
                }
            }));
            if ($location.absUrl() != initialUrl) {
                $browser.url($location.absUrl(), true)
            }
            $browser.onUrlChange((function (newUrl) {
                if ($location.absUrl() != newUrl) {
                    if ($rootScope.$broadcast("$locationChangeStart", newUrl, $location.absUrl()).defaultPrevented) {
                        $browser.url($location.absUrl());
                        return
                    }
                    $rootScope.$evalAsync((function () {
                        var oldUrl = $location.absUrl();
                        $location.$$parse(newUrl);
                        afterLocationChange(oldUrl)
                    }));
                    if (!$rootScope.$$phase) $rootScope.$digest()
                }
            }));
            var changeCounter = 0;
            $rootScope.$watch((function $locationWatch() {
                var oldUrl = $browser.url();
                var currentReplace = $location.$$replace;
                if (!changeCounter || oldUrl != $location.absUrl()) {
                    changeCounter++;
                    $rootScope.$evalAsync((function () {
                        if ($rootScope.$broadcast("$locationChangeStart", $location.absUrl(), oldUrl).defaultPrevented) {
                            $location.$$parse(oldUrl)
                        } else {
                            $browser.url($location.absUrl(), currentReplace);
                            afterLocationChange(oldUrl)
                        }
                    }))
                }
                $location.$$replace = false;
                return changeCounter
            }));
            return $location;

            function afterLocationChange(oldUrl) {
                $rootScope.$broadcast("$locationChangeSuccess", $location.absUrl(), oldUrl)
            }
        }]
    }

    function $LogProvider() {
        var debug = true,
            self = this;
        this.debugEnabled = function (flag) {
            if (isDefined(flag)) {
                debug = flag;
                return this
            } else {
                return debug
            }
        };
        this.$get = ["$window", function ($window) {
            return {
                log: consoleLog("log"),
                info: consoleLog("info"),
                warn: consoleLog("warn"),
                error: consoleLog("error"),
                debug: function () {
                    var fn = consoleLog("debug");
                    return function () {
                        if (debug) {
                            fn.apply(self, arguments)
                        }
                    }
                }()
            };

            function formatError(arg) {
                if (arg instanceof Error) {
                    if (arg.stack) {
                        arg = arg.message && arg.stack.indexOf(arg.message) === -1 ? "Error: " + arg.message + "\n" + arg.stack : arg.stack
                    } else if (arg.sourceURL) {
                        arg = arg.message + "\n" + arg.sourceURL + ":" + arg.line
                    }
                }
                return arg
            }

            function consoleLog(type) {
                var console = $window.console || {},
                    logFn = console[type] || console.log || noop;
                if (logFn.apply) {
                    return function () {
                        var args = [];
                        forEach(arguments, (function (arg) {
                            args.push(formatError(arg))
                        }));
                        return logFn.apply(console, args)
                    }
                }
                return function (arg1, arg2) {
                    logFn(arg1, arg2 == null ? "" : arg2)
                }
            }
        }]
    }
    var $parseMinErr = minErr("$parse");
    var promiseWarningCache = {};
    var promiseWarning;

    function ensureSafeMemberName(name, fullExpression) {
        if (name === "constructor") {
            throw $parseMinErr("isecfld", 'Referencing "constructor" field in Angular expressions is disallowed! Expression: {0}', fullExpression)
        }
        return name
    }

    function ensureSafeObject(obj, fullExpression) {
        if (obj) {
            if (obj.constructor === obj) {
                throw $parseMinErr("isecfn", "Referencing Function in Angular expressions is disallowed! Expression: {0}", fullExpression)
            } else if (obj.document && obj.location && obj.alert && obj.setInterval) {
                throw $parseMinErr("isecwindow", "Referencing the Window in Angular expressions is disallowed! Expression: {0}", fullExpression)
            } else if (obj.children && (obj.nodeName || obj.on && obj.find)) {
                throw $parseMinErr("isecdom", "Referencing DOM nodes in Angular expressions is disallowed! Expression: {0}", fullExpression)
            }
        }
        return obj
    }
    var OPERATORS = {
        null: function () {
            return null
        },
        true: function () {
            return true
        },
        false: function () {
            return false
        },
        undefined: noop,
        "+": function (self, locals, a, b) {
            a = a(self, locals);
            b = b(self, locals);
            if (isDefined(a)) {
                if (isDefined(b)) {
                    return a + b
                }
                return a
            }
            return isDefined(b) ? b : undefined
        },
        "-": function (self, locals, a, b) {
            a = a(self, locals);
            b = b(self, locals);
            return (isDefined(a) ? a : 0) - (isDefined(b) ? b : 0)
        },
        "*": function (self, locals, a, b) {
            return a(self, locals) * b(self, locals)
        },
        "/": function (self, locals, a, b) {
            return a(self, locals) / b(self, locals)
        },
        "%": function (self, locals, a, b) {
            return a(self, locals) % b(self, locals)
        },
        "^": function (self, locals, a, b) {
            return a(self, locals) ^ b(self, locals)
        },
        "=": noop,
        "===": function (self, locals, a, b) {
            return a(self, locals) === b(self, locals)
        },
        "!==": function (self, locals, a, b) {
            return a(self, locals) !== b(self, locals)
        },
        "==": function (self, locals, a, b) {
            return a(self, locals) == b(self, locals)
        },
        "!=": function (self, locals, a, b) {
            return a(self, locals) != b(self, locals)
        },
        "<": function (self, locals, a, b) {
            return a(self, locals) < b(self, locals)
        },
        ">": function (self, locals, a, b) {
            return a(self, locals) > b(self, locals)
        },
        "<=": function (self, locals, a, b) {
            return a(self, locals) <= b(self, locals)
        },
        ">=": function (self, locals, a, b) {
            return a(self, locals) >= b(self, locals)
        },
        "&&": function (self, locals, a, b) {
            return a(self, locals) && b(self, locals)
        },
        "||": function (self, locals, a, b) {
            return a(self, locals) || b(self, locals)
        },
        "&": function (self, locals, a, b) {
            return a(self, locals) & b(self, locals)
        },
        "|": function (self, locals, a, b) {
            return b(self, locals)(self, locals, a(self, locals))
        },
        "!": function (self, locals, a) {
            return !a(self, locals)
        }
    };
    var ESCAPE = {
        n: "\n",
        f: "\f",
        r: "\r",
        t: "\t",
        v: "\v",
        "'": "'",
        '"': '"'
    };
    var Lexer = function (options) {
        this.options = options
    };
    Lexer.prototype = {
        constructor: Lexer,
        lex: function (text) {
            this.text = text;
            this.index = 0;
            this.ch = undefined;
            this.lastCh = ":";
            this.tokens = [];
            var token;
            var json = [];
            while (this.index < this.text.length) {
                this.ch = this.text.charAt(this.index);
                if (this.is("\"'")) {
                    this.readString(this.ch)
                } else if (this.isNumber(this.ch) || this.is(".") && this.isNumber(this.peek())) {
                    this.readNumber()
                } else if (this.isIdent(this.ch)) {
                    this.readIdent();
                    if (this.was("{,") && json[0] === "{" && (token = this.tokens[this.tokens.length - 1])) {
                        token.json = token.text.indexOf(".") === -1
                    }
                } else if (this.is("(){}[].,;:?")) {
                    this.tokens.push({
                        index: this.index,
                        text: this.ch,
                        json: this.was(":[,") && this.is("{[") || this.is("}]:,")
                    });
                    if (this.is("{[")) json.unshift(this.ch);
                    if (this.is("}]")) json.shift();
                    this.index++
                } else if (this.isWhitespace(this.ch)) {
                    this.index++;
                    continue
                } else {
                    var ch2 = this.ch + this.peek();
                    var ch3 = ch2 + this.peek(2);
                    var fn = OPERATORS[this.ch];
                    var fn2 = OPERATORS[ch2];
                    var fn3 = OPERATORS[ch3];
                    if (fn3) {
                        this.tokens.push({
                            index: this.index,
                            text: ch3,
                            fn: fn3
                        });
                        this.index += 3
                    } else if (fn2) {
                        this.tokens.push({
                            index: this.index,
                            text: ch2,
                            fn: fn2
                        });
                        this.index += 2
                    } else if (fn) {
                        this.tokens.push({
                            index: this.index,
                            text: this.ch,
                            fn: fn,
                            json: this.was("[,:") && this.is("+-")
                        });
                        this.index += 1
                    } else {
                        this.throwError("Unexpected next character ", this.index, this.index + 1)
                    }
                }
                this.lastCh = this.ch
            }
            return this.tokens
        },
        is: function (chars) {
            return chars.indexOf(this.ch) !== -1
        },
        was: function (chars) {
            return chars.indexOf(this.lastCh) !== -1
        },
        peek: function (i) {
            var num = i || 1;
            return this.index + num < this.text.length ? this.text.charAt(this.index + num) : false
        },
        isNumber: function (ch) {
            return "0" <= ch && ch <= "9"
        },
        isWhitespace: function (ch) {
            return ch === " " || ch === "\r" || ch === "\t" || ch === "\n" || ch === "\v" || ch === " "
        },
        isIdent: function (ch) {
            return "a" <= ch && ch <= "z" || "A" <= ch && ch <= "Z" || "_" === ch || ch === "$"
        },
        isExpOperator: function (ch) {
            return ch === "-" || ch === "+" || this.isNumber(ch)
        },
        throwError: function (error, start, end) {
            end = end || this.index;
            var colStr = isDefined(start) ? "s " + start + "-" + this.index + " [" + this.text.substring(start, end) + "]" : " " + end;
            throw $parseMinErr("lexerr", "Lexer Error: {0} at column{1} in expression [{2}].", error, colStr, this.text)
        },
        readNumber: function () {
            var number = "";
            var start = this.index;
            while (this.index < this.text.length) {
                var ch = lowercase(this.text.charAt(this.index));
                if (ch == "." || this.isNumber(ch)) {
                    number += ch
                } else {
                    var peekCh = this.peek();
                    if (ch == "e" && this.isExpOperator(peekCh)) {
                        number += ch
                    } else if (this.isExpOperator(ch) && peekCh && this.isNumber(peekCh) && number.charAt(number.length - 1) == "e") {
                        number += ch
                    } else if (this.isExpOperator(ch) && (!peekCh || !this.isNumber(peekCh)) && number.charAt(number.length - 1) == "e") {
                        this.throwError("Invalid exponent")
                    } else {
                        break
                    }
                }
                this.index++
            }
            number = 1 * number;
            this.tokens.push({
                index: start,
                text: number,
                json: true,
                fn: function () {
                    return number
                }
            })
        },
        readIdent: function () {
            var parser = this;
            var ident = "";
            var start = this.index;
            var lastDot, peekIndex, methodName, ch;
            while (this.index < this.text.length) {
                ch = this.text.charAt(this.index);
                if (ch === "." || this.isIdent(ch) || this.isNumber(ch)) {
                    if (ch === ".") lastDot = this.index;
                    ident += ch
                } else {
                    break
                }
                this.index++
            }
            if (lastDot) {
                peekIndex = this.index;
                while (peekIndex < this.text.length) {
                    ch = this.text.charAt(peekIndex);
                    if (ch === "(") {
                        methodName = ident.substr(lastDot - start + 1);
                        ident = ident.substr(0, lastDot - start);
                        this.index = peekIndex;
                        break
                    }
                    if (this.isWhitespace(ch)) {
                        peekIndex++
                    } else {
                        break
                    }
                }
            }
            var token = {
                index: start,
                text: ident
            };
            if (OPERATORS.hasOwnProperty(ident)) {
                token.fn = OPERATORS[ident];
                token.json = OPERATORS[ident]
            } else {
                var getter = getterFn(ident, this.options, this.text);
                token.fn = extend((function (self, locals) {
                    return getter(self, locals)
                }), {
                    assign: function (self, value) {
                        return setter(self, ident, value, parser.text, parser.options)
                    }
                })
            }
            this.tokens.push(token);
            if (methodName) {
                this.tokens.push({
                    index: lastDot,
                    text: ".",
                    json: false
                });
                this.tokens.push({
                    index: lastDot + 1,
                    text: methodName,
                    json: false
                })
            }
        },
        readString: function (quote) {
            var start = this.index;
            this.index++;
            var string = "";
            var rawString = quote;
            var escape = false;
            while (this.index < this.text.length) {
                var ch = this.text.charAt(this.index);
                rawString += ch;
                if (escape) {
                    if (ch === "u") {
                        var hex = this.text.substring(this.index + 1, this.index + 5);
                        if (!hex.match(/[\da-f]{4}/i)) this.throwError("Invalid unicode escape [\\u" + hex + "]");
                        this.index += 4;
                        string += String.fromCharCode(parseInt(hex, 16))
                    } else {
                        var rep = ESCAPE[ch];
                        if (rep) {
                            string += rep
                        } else {
                            string += ch
                        }
                    }
                    escape = false
                } else if (ch === "\\") {
                    escape = true
                } else if (ch === quote) {
                    this.index++;
                    this.tokens.push({
                        index: start,
                        text: rawString,
                        string: string,
                        json: true,
                        fn: function () {
                            return string
                        }
                    });
                    return
                } else {
                    string += ch
                }
                this.index++
            }
            this.throwError("Unterminated quote", start)
        }
    };
    var Parser = function (lexer, $filter, options) {
        this.lexer = lexer;
        this.$filter = $filter;
        this.options = options
    };
    Parser.ZERO = function () {
        return 0
    };
    Parser.prototype = {
        constructor: Parser,
        parse: function (text, json) {
            this.text = text;
            this.json = json;
            this.tokens = this.lexer.lex(text);
            if (json) {
                this.assignment = this.logicalOR;
                this.functionCall = this.fieldAccess = this.objectIndex = this.filterChain = function () {
                    this.throwError("is not valid json", {
                        text: text,
                        index: 0
                    })
                }
            }
            var value = json ? this.primary() : this.statements();
            if (this.tokens.length !== 0) {
                this.throwError("is an unexpected token", this.tokens[0])
            }
            value.literal = !!value.literal;
            value.constant = !!value.constant;
            return value
        },
        primary: function () {
            var primary;
            if (this.expect("(")) {
                primary = this.filterChain();
                this.consume(")")
            } else if (this.expect("[")) {
                primary = this.arrayDeclaration()
            } else if (this.expect("{")) {
                primary = this.object()
            } else {
                var token = this.expect();
                primary = token.fn;
                if (!primary) {
                    this.throwError("not a primary expression", token)
                }
                if (token.json) {
                    primary.constant = true;
                    primary.literal = true
                }
            }
            var next, context;
            while (next = this.expect("(", "[", ".")) {
                if (next.text === "(") {
                    primary = this.functionCall(primary, context);
                    context = null
                } else if (next.text === "[") {
                    context = primary;
                    primary = this.objectIndex(primary)
                } else if (next.text === ".") {
                    context = primary;
                    primary = this.fieldAccess(primary)
                } else {
                    this.throwError("IMPOSSIBLE")
                }
            }
            return primary
        },
        throwError: function (msg, token) {
            throw $parseMinErr("syntax", "Syntax Error: Token '{0}' {1} at column {2} of the expression [{3}] starting at [{4}].", token.text, msg, token.index + 1, this.text, this.text.substring(token.index))
        },
        peekToken: function () {
            if (this.tokens.length === 0) throw $parseMinErr("ueoe", "Unexpected end of expression: {0}", this.text);
            return this.tokens[0]
        },
        peek: function (e1, e2, e3, e4) {
            if (this.tokens.length > 0) {
                var token = this.tokens[0];
                var t = token.text;
                if (t === e1 || t === e2 || t === e3 || t === e4 || !e1 && !e2 && !e3 && !e4) {
                    return token
                }
            }
            return false
        },
        expect: function (e1, e2, e3, e4) {
            var token = this.peek(e1, e2, e3, e4);
            if (token) {
                if (this.json && !token.json) {
                    this.throwError("is not valid json", token)
                }
                this.tokens.shift();
                return token
            }
            return false
        },
        consume: function (e1) {
            if (!this.expect(e1)) {
                this.throwError("is unexpected, expecting [" + e1 + "]", this.peek())
            }
        },
        unaryFn: function (fn, right) {
            return extend((function (self, locals) {
                return fn(self, locals, right)
            }), {
                constant: right.constant
            })
        },
        ternaryFn: function (left, middle, right) {
            return extend((function (self, locals) {
                return left(self, locals) ? middle(self, locals) : right(self, locals)
            }), {
                constant: left.constant && middle.constant && right.constant
            })
        },
        binaryFn: function (left, fn, right) {
            return extend((function (self, locals) {
                return fn(self, locals, left, right)
            }), {
                constant: left.constant && right.constant
            })
        },
        statements: function () {
            var statements = [];
            while (true) {
                if (this.tokens.length > 0 && !this.peek("}", ")", ";", "]")) statements.push(this.filterChain());
                if (!this.expect(";")) {
                    return statements.length === 1 ? statements[0] : function (self, locals) {
                        var value;
                        for (var i = 0; i < statements.length; i++) {
                            var statement = statements[i];
                            if (statement) {
                                value = statement(self, locals)
                            }
                        }
                        return value
                    }
                }
            }
        },
        filterChain: function () {
            var left = this.expression();
            var token;
            while (true) {
                if (token = this.expect("|")) {
                    left = this.binaryFn(left, token.fn, this.filter())
                } else {
                    return left
                }
            }
        },
        filter: function () {
            var token = this.expect();
            var fn = this.$filter(token.text);
            var argsFn = [];
            while (true) {
                if (token = this.expect(":")) {
                    argsFn.push(this.expression())
                } else {
                    var fnInvoke = function (self, locals, input) {
                        var args = [input];
                        for (var i = 0; i < argsFn.length; i++) {
                            args.push(argsFn[i](self, locals))
                        }
                        return fn.apply(self, args)
                    };
                    return function () {
                        return fnInvoke
                    }
                }
            }
        },
        expression: function () {
            return this.assignment()
        },
        assignment: function () {
            var left = this.ternary();
            var right;
            var token;
            if (token = this.expect("=")) {
                if (!left.assign) {
                    this.throwError("implies assignment but [" + this.text.substring(0, token.index) + "] can not be assigned to", token)
                }
                right = this.ternary();
                return function (scope, locals) {
                    return left.assign(scope, right(scope, locals), locals)
                }
            }
            return left
        },
        ternary: function () {
            var left = this.logicalOR();
            var middle;
            var token;
            if (token = this.expect("?")) {
                middle = this.ternary();
                if (token = this.expect(":")) {
                    return this.ternaryFn(left, middle, this.ternary())
                } else {
                    this.throwError("expected :", token)
                }
            } else {
                return left
            }
        },
        logicalOR: function () {
            var left = this.logicalAND();
            var token;
            while (true) {
                if (token = this.expect("||")) {
                    left = this.binaryFn(left, token.fn, this.logicalAND())
                } else {
                    return left
                }
            }
        },
        logicalAND: function () {
            var left = this.equality();
            var token;
            if (token = this.expect("&&")) {
                left = this.binaryFn(left, token.fn, this.logicalAND())
            }
            return left
        },
        equality: function () {
            var left = this.relational();
            var token;
            if (token = this.expect("==", "!=", "===", "!==")) {
                left = this.binaryFn(left, token.fn, this.equality())
            }
            return left
        },
        relational: function () {
            var left = this.additive();
            var token;
            if (token = this.expect("<", ">", "<=", ">=")) {
                left = this.binaryFn(left, token.fn, this.relational())
            }
            return left
        },
        additive: function () {
            var left = this.multiplicative();
            var token;
            while (token = this.expect("+", "-")) {
                left = this.binaryFn(left, token.fn, this.multiplicative())
            }
            return left
        },
        multiplicative: function () {
            var left = this.unary();
            var token;
            while (token = this.expect("*", "/", "%")) {
                left = this.binaryFn(left, token.fn, this.unary())
            }
            return left
        },
        unary: function () {
            var token;
            if (this.expect("+")) {
                return this.primary()
            } else if (token = this.expect("-")) {
                return this.binaryFn(Parser.ZERO, token.fn, this.unary())
            } else if (token = this.expect("!")) {
                return this.unaryFn(token.fn, this.unary())
            } else {
                return this.primary()
            }
        },
        fieldAccess: function (object) {
            var parser = this;
            var field = this.expect().text;
            var getter = getterFn(field, this.options, this.text);
            return extend((function (scope, locals, self) {
                return getter(self || object(scope, locals), locals)
            }), {
                assign: function (scope, value, locals) {
                    return setter(object(scope, locals), field, value, parser.text, parser.options)
                }
            })
        },
        objectIndex: function (obj) {
            var parser = this;
            var indexFn = this.expression();
            this.consume("]");
            return extend((function (self, locals) {
                var o = obj(self, locals),
                    i = indexFn(self, locals),
                    v, p;
                if (!o) return undefined;
                v = ensureSafeObject(o[i], parser.text);
                if (v && v.then && parser.options.unwrapPromises) {
                    p = v;
                    if (!("$$v" in v)) {
                        p.$$v = undefined;
                        p.then((function (val) {
                            p.$$v = val
                        }))
                    }
                    v = v.$$v
                }
                return v
            }), {
                assign: function (self, value, locals) {
                    var key = indexFn(self, locals);
                    var safe = ensureSafeObject(obj(self, locals), parser.text);
                    return safe[key] = value
                }
            })
        },
        functionCall: function (fn, contextGetter) {
            var argsFn = [];
            if (this.peekToken().text !== ")") {
                do {
                    argsFn.push(this.expression())
                } while (this.expect(","))
            }
            this.consume(")");
            var parser = this;
            return function (scope, locals) {
                var args = [];
                var context = contextGetter ? contextGetter(scope, locals) : scope;
                for (var i = 0; i < argsFn.length; i++) {
                    args.push(argsFn[i](scope, locals))
                }
                var fnPtr = fn(scope, locals, context) || noop;
                ensureSafeObject(context, parser.text);
                ensureSafeObject(fnPtr, parser.text);
                var v = fnPtr.apply ? fnPtr.apply(context, args) : fnPtr(args[0], args[1], args[2], args[3], args[4]);
                return ensureSafeObject(v, parser.text)
            }
        },
        arrayDeclaration: function () {
            var elementFns = [];
            var allConstant = true;
            if (this.peekToken().text !== "]") {
                do {
                    var elementFn = this.expression();
                    elementFns.push(elementFn);
                    if (!elementFn.constant) {
                        allConstant = false
                    }
                } while (this.expect(","))
            }
            this.consume("]");
            return extend((function (self, locals) {
                var array = [];
                for (var i = 0; i < elementFns.length; i++) {
                    array.push(elementFns[i](self, locals))
                }
                return array
            }), {
                literal: true,
                constant: allConstant
            })
        },
        object: function () {
            var keyValues = [];
            var allConstant = true;
            if (this.peekToken().text !== "}") {
                do {
                    var token = this.expect(),
                        key = token.string || token.text;
                    this.consume(":");
                    var value = this.expression();
                    keyValues.push({
                        key: key,
                        value: value
                    });
                    if (!value.constant) {
                        allConstant = false
                    }
                } while (this.expect(","))
            }
            this.consume("}");
            return extend((function (self, locals) {
                var object = {};
                for (var i = 0; i < keyValues.length; i++) {
                    var keyValue = keyValues[i];
                    object[keyValue.key] = keyValue.value(self, locals)
                }
                return object
            }), {
                literal: true,
                constant: allConstant
            })
        }
    };

    function setter(obj, path, setValue, fullExp, options) {
        options = options || {};
        var element = path.split("."),
            key;
        for (var i = 0; element.length > 1; i++) {
            key = ensureSafeMemberName(element.shift(), fullExp);
            var propertyObj = obj[key];
            if (!propertyObj) {
                propertyObj = {};
                obj[key] = propertyObj
            }
            obj = propertyObj;
            if (obj.then && options.unwrapPromises) {
                promiseWarning(fullExp);
                if (!("$$v" in obj)) {
                    (function (promise) {
                        promise.then((function (val) {
                            promise.$$v = val
                        }))
                    })(obj)
                }
                if (obj.$$v === undefined) {
                    obj.$$v = {}
                }
                obj = obj.$$v
            }
        }
        key = ensureSafeMemberName(element.shift(), fullExp);
        obj[key] = setValue;
        return setValue
    }
    var getterFnCache = {};

    function cspSafeGetterFn(key0, key1, key2, key3, key4, fullExp, options) {
        ensureSafeMemberName(key0, fullExp);
        ensureSafeMemberName(key1, fullExp);
        ensureSafeMemberName(key2, fullExp);
        ensureSafeMemberName(key3, fullExp);
        ensureSafeMemberName(key4, fullExp);
        return !options.unwrapPromises ? function cspSafeGetter(scope, locals) {
            var pathVal = locals && locals.hasOwnProperty(key0) ? locals : scope;
            if (pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key0];
            if (!key1 || pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key1];
            if (!key2 || pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key2];
            if (!key3 || pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key3];
            if (!key4 || pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key4];
            return pathVal
        } : function cspSafePromiseEnabledGetter(scope, locals) {
            var pathVal = locals && locals.hasOwnProperty(key0) ? locals : scope,
                promise;
            if (pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key0];
            if (pathVal && pathVal.then) {
                promiseWarning(fullExp);
                if (!("$$v" in pathVal)) {
                    promise = pathVal;
                    promise.$$v = undefined;
                    promise.then((function (val) {
                        promise.$$v = val
                    }))
                }
                pathVal = pathVal.$$v
            }
            if (!key1 || pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key1];
            if (pathVal && pathVal.then) {
                promiseWarning(fullExp);
                if (!("$$v" in pathVal)) {
                    promise = pathVal;
                    promise.$$v = undefined;
                    promise.then((function (val) {
                        promise.$$v = val
                    }))
                }
                pathVal = pathVal.$$v
            }
            if (!key2 || pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key2];
            if (pathVal && pathVal.then) {
                promiseWarning(fullExp);
                if (!("$$v" in pathVal)) {
                    promise = pathVal;
                    promise.$$v = undefined;
                    promise.then((function (val) {
                        promise.$$v = val
                    }))
                }
                pathVal = pathVal.$$v
            }
            if (!key3 || pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key3];
            if (pathVal && pathVal.then) {
                promiseWarning(fullExp);
                if (!("$$v" in pathVal)) {
                    promise = pathVal;
                    promise.$$v = undefined;
                    promise.then((function (val) {
                        promise.$$v = val
                    }))
                }
                pathVal = pathVal.$$v
            }
            if (!key4 || pathVal === null || pathVal === undefined) return pathVal;
            pathVal = pathVal[key4];
            if (pathVal && pathVal.then) {
                promiseWarning(fullExp);
                if (!("$$v" in pathVal)) {
                    promise = pathVal;
                    promise.$$v = undefined;
                    promise.then((function (val) {
                        promise.$$v = val
                    }))
                }
                pathVal = pathVal.$$v
            }
            return pathVal
        }
    }

    function getterFn(path, options, fullExp) {
        if (getterFnCache.hasOwnProperty(path)) {
            return getterFnCache[path]
        }
        var pathKeys = path.split("."),
            pathKeysLength = pathKeys.length,
            fn;
        if (options.csp) {
            if (pathKeysLength < 6) {
                fn = cspSafeGetterFn(pathKeys[0], pathKeys[1], pathKeys[2], pathKeys[3], pathKeys[4], fullExp, options)
            } else {
                fn = function (scope, locals) {
                    var i = 0,
                        val;
                    do {
                        val = cspSafeGetterFn(pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++], fullExp, options)(scope, locals);
                        locals = undefined;
                        scope = val
                    } while (i < pathKeysLength);
                    return val
                }
            }
        } else {
            var code = "var l, fn, p;\n";
            forEach(pathKeys, (function (key, index) {
                ensureSafeMemberName(key, fullExp);
                code += "if(s === null || s === undefined) return s;\n" + "l=s;\n" + "s=" + (index ? "s" : '((k&&k.hasOwnProperty("' + key + '"))?k:s)') + '["' + key + '"]' + ";\n" + (options.unwrapPromises ? "if (s && s.then) {\n" + ' pw("' + fullExp.replace(/(["\r\n])/g, "\\$1") + '");\n' + ' if (!("$$v" in s)) {\n' + " p=s;\n" + " p.$$v = undefined;\n" + " p.then(function(v) {p.$$v=v;});\n" + "}\n" + " s=s.$$v\n" + "}\n" : "")
            }));
            code += "return s;";
            var evaledFnGetter = new Function("s", "k", "pw", code);
            evaledFnGetter.toString = function () {
                return code
            };
            fn = function (scope, locals) {
                return evaledFnGetter(scope, locals, promiseWarning)
            }
        }
        if (path !== "hasOwnProperty") {
            getterFnCache[path] = fn
        }
        return fn
    }

    function $ParseProvider() {
        var cache = {};
        var $parseOptions = {
            csp: false,
            unwrapPromises: false,
            logPromiseWarnings: true
        };
        this.unwrapPromises = function (value) {
            if (isDefined(value)) {
                $parseOptions.unwrapPromises = !!value;
                return this
            } else {
                return $parseOptions.unwrapPromises
            }
        };
        this.logPromiseWarnings = function (value) {
            if (isDefined(value)) {
                $parseOptions.logPromiseWarnings = value;
                return this
            } else {
                return $parseOptions.logPromiseWarnings
            }
        };
        this.$get = ["$filter", "$sniffer", "$log", function ($filter, $sniffer, $log) {
            $parseOptions.csp = $sniffer.csp;
            promiseWarning = function promiseWarningFn(fullExp) {
                if (!$parseOptions.logPromiseWarnings || promiseWarningCache.hasOwnProperty(fullExp)) return;
                promiseWarningCache[fullExp] = true;
                $log.warn("[$parse] Promise found in the expression `" + fullExp + "`. " + "Automatic unwrapping of promises in Angular expressions is deprecated.")
            };
            return function (exp) {
                var parsedExpression;
                switch (typeof exp) {
                    case "string":
                        if (cache.hasOwnProperty(exp)) {
                            return cache[exp]
                        }
                        var lexer = new Lexer($parseOptions);
                        var parser = new Parser(lexer, $filter, $parseOptions);
                        parsedExpression = parser.parse(exp, false);
                        if (exp !== "hasOwnProperty") {
                            cache[exp] = parsedExpression
                        }
                        return parsedExpression;
                    case "function":
                        return exp;
                    default:
                        return noop
                }
            }
        }]
    }

    function $QProvider() {
        this.$get = ["$rootScope", "$exceptionHandler", function ($rootScope, $exceptionHandler) {
            return qFactory((function (callback) {
                $rootScope.$evalAsync(callback)
            }), $exceptionHandler)
        }]
    }

    function qFactory(nextTick, exceptionHandler) {
        var defer = function () {
            var pending = [],
                value, deferred;
            deferred = {
                resolve: function (val) {
                    if (pending) {
                        var callbacks = pending;
                        pending = undefined;
                        value = ref(val);
                        if (callbacks.length) {
                            nextTick((function () {
                                var callback;
                                for (var i = 0, ii = callbacks.length; i < ii; i++) {
                                    callback = callbacks[i];
                                    value.then(callback[0], callback[1], callback[2])
                                }
                            }))
                        }
                    }
                },
                reject: function (reason) {
                    deferred.resolve(reject(reason))
                },
                notify: function (progress) {
                    if (pending) {
                        var callbacks = pending;
                        if (pending.length) {
                            nextTick((function () {
                                var callback;
                                for (var i = 0, ii = callbacks.length; i < ii; i++) {
                                    callback = callbacks[i];
                                    callback[2](progress)
                                }
                            }))
                        }
                    }
                },
                promise: {
                    then: function (callback, errback, progressback) {
                        var result = defer();
                        var wrappedCallback = function (value) {
                            try {
                                result.resolve((isFunction(callback) ? callback : defaultCallback)(value))
                            } catch (e) {
                                result.reject(e);
                                exceptionHandler(e)
                            }
                        };
                        var wrappedErrback = function (reason) {
                            try {
                                result.resolve((isFunction(errback) ? errback : defaultErrback)(reason))
                            } catch (e) {
                                result.reject(e);
                                exceptionHandler(e)
                            }
                        };
                        var wrappedProgressback = function (progress) {
                            try {
                                result.notify((isFunction(progressback) ? progressback : defaultCallback)(progress))
                            } catch (e) {
                                exceptionHandler(e)
                            }
                        };
                        if (pending) {
                            pending.push([wrappedCallback, wrappedErrback, wrappedProgressback])
                        } else {
                            value.then(wrappedCallback, wrappedErrback, wrappedProgressback)
                        }
                        return result.promise
                    },
                    catch: function (callback) {
                        return this.then(null, callback)
                    },
                    finally: function (callback) {
                        function makePromise(value, resolved) {
                            var result = defer();
                            if (resolved) {
                                result.resolve(value)
                            } else {
                                result.reject(value)
                            }
                            return result.promise
                        }

                        function handleCallback(value, isResolved) {
                            var callbackOutput = null;
                            try {
                                callbackOutput = (callback || defaultCallback)()
                            } catch (e) {
                                return makePromise(e, false)
                            }
                            if (callbackOutput && isFunction(callbackOutput.then)) {
                                return callbackOutput.then((function () {
                                    return makePromise(value, isResolved)
                                }), (function (error) {
                                    return makePromise(error, false)
                                }))
                            } else {
                                return makePromise(value, isResolved)
                            }
                        }
                        return this.then((function (value) {
                            return handleCallback(value, true)
                        }), (function (error) {
                            return handleCallback(error, false)
                        }))
                    }
                }
            };
            return deferred
        };
        var ref = function (value) {
            if (value && isFunction(value.then)) return value;
            return {
                then: function (callback) {
                    var result = defer();
                    nextTick((function () {
                        result.resolve(callback(value))
                    }));
                    return result.promise
                }
            }
        };
        var reject = function (reason) {
            return {
                then: function (callback, errback) {
                    var result = defer();
                    nextTick((function () {
                        try {
                            result.resolve((isFunction(errback) ? errback : defaultErrback)(reason))
                        } catch (e) {
                            result.reject(e);
                            exceptionHandler(e)
                        }
                    }));
                    return result.promise
                }
            }
        };
        var when = function (value, callback, errback, progressback) {
            var result = defer(),
                done;
            var wrappedCallback = function (value) {
                try {
                    return (isFunction(callback) ? callback : defaultCallback)(value)
                } catch (e) {
                    exceptionHandler(e);
                    return reject(e)
                }
            };
            var wrappedErrback = function (reason) {
                try {
                    return (isFunction(errback) ? errback : defaultErrback)(reason)
                } catch (e) {
                    exceptionHandler(e);
                    return reject(e)
                }
            };
            var wrappedProgressback = function (progress) {
                try {
                    return (isFunction(progressback) ? progressback : defaultCallback)(progress)
                } catch (e) {
                    exceptionHandler(e)
                }
            };
            nextTick((function () {
                ref(value).then((function (value) {
                    if (done) return;
                    done = true;
                    result.resolve(ref(value).then(wrappedCallback, wrappedErrback, wrappedProgressback))
                }), (function (reason) {
                    if (done) return;
                    done = true;
                    result.resolve(wrappedErrback(reason))
                }), (function (progress) {
                    if (done) return;
                    result.notify(wrappedProgressback(progress))
                }))
            }));
            return result.promise
        };

        function defaultCallback(value) {
            return value
        }

        function defaultErrback(reason) {
            return reject(reason)
        }

        function all(promises) {
            var deferred = defer(),
                counter = 0,
                results = isArray(promises) ? [] : {};
            forEach(promises, (function (promise, key) {
                counter++;
                ref(promise).then((function (value) {
                    if (results.hasOwnProperty(key)) return;
                    results[key] = value;
                    if (!--counter) deferred.resolve(results)
                }), (function (reason) {
                    if (results.hasOwnProperty(key)) return;
                    deferred.reject(reason)
                }))
            }));
            if (counter === 0) {
                deferred.resolve(results)
            }
            return deferred.promise
        }
        return {
            defer: defer,
            reject: reject,
            when: when,
            all: all
        }
    }

    function $RootScopeProvider() {
        var TTL = 10;
        var $rootScopeMinErr = minErr("$rootScope");
        var lastDirtyWatch = null;
        this.digestTtl = function (value) {
            if (arguments.length) {
                TTL = value
            }
            return TTL
        };
        this.$get = ["$injector", "$exceptionHandler", "$parse", "$browser", function ($injector, $exceptionHandler, $parse, $browser) {
            function Scope() {
                this.$id = nextUid();
                this.$$phase = this.$parent = this.$$watchers = this.$$nextSibling = this.$$prevSibling = this.$$childHead = this.$$childTail = null;
                this["this"] = this.$root = this;
                this.$$destroyed = false;
                this.$$asyncQueue = [];
                this.$$postDigestQueue = [];
                this.$$listeners = {};
                this.$$isolateBindings = {}
            }
            Scope.prototype = {
                constructor: Scope,
                $new: function (isolate) {
                    var ChildScope, child;
                    if (isolate) {
                        child = new Scope;
                        child.$root = this.$root;
                        child.$$asyncQueue = this.$$asyncQueue;
                        child.$$postDigestQueue = this.$$postDigestQueue
                    } else {
                        ChildScope = function () { };
                        ChildScope.prototype = this;
                        child = new ChildScope;
                        child.$id = nextUid()
                    }
                    child["this"] = child;
                    child.$$listeners = {};
                    child.$parent = this;
                    child.$$watchers = child.$$nextSibling = child.$$childHead = child.$$childTail = null;
                    child.$$prevSibling = this.$$childTail;
                    if (this.$$childHead) {
                        this.$$childTail.$$nextSibling = child;
                        this.$$childTail = child
                    } else {
                        this.$$childHead = this.$$childTail = child
                    }
                    return child
                },
                $watch: function (watchExp, listener, objectEquality) {
                    var scope = this,
                        get = compileToFn(watchExp, "watch"),
                        array = scope.$$watchers,
                        watcher = {
                            fn: listener,
                            last: initWatchVal,
                            get: get,
                            exp: watchExp,
                            eq: !!objectEquality
                        };
                    lastDirtyWatch = null;
                    if (!isFunction(listener)) {
                        var listenFn = compileToFn(listener || noop, "listener");
                        watcher.fn = function (newVal, oldVal, scope) {
                            listenFn(scope)
                        }
                    }
                    if (typeof watchExp == "string" && get.constant) {
                        var originalFn = watcher.fn;
                        watcher.fn = function (newVal, oldVal, scope) {
                            originalFn.call(this, newVal, oldVal, scope);
                            arrayRemove(array, watcher)
                        }
                    }
                    if (!array) {
                        array = scope.$$watchers = []
                    }
                    array.unshift(watcher);
                    return function () {
                        arrayRemove(array, watcher)
                    }
                },
                $watchCollection: function (obj, listener) {
                    var self = this;
                    var oldValue;
                    var newValue;
                    var changeDetected = 0;
                    var objGetter = $parse(obj);
                    var internalArray = [];
                    var internalObject = {};
                    var oldLength = 0;

                    function $watchCollectionWatch() {
                        newValue = objGetter(self);
                        var newLength, key;
                        if (!isObject(newValue)) {
                            if (oldValue !== newValue) {
                                oldValue = newValue;
                                changeDetected++
                            }
                        } else if (isArrayLike(newValue)) {
                            if (oldValue !== internalArray) {
                                oldValue = internalArray;
                                oldLength = oldValue.length = 0;
                                changeDetected++
                            }
                            newLength = newValue.length;
                            if (oldLength !== newLength) {
                                changeDetected++;
                                oldValue.length = oldLength = newLength
                            }
                            for (var i = 0; i < newLength; i++) {
                                if (oldValue[i] !== newValue[i]) {
                                    changeDetected++;
                                    oldValue[i] = newValue[i]
                                }
                            }
                        } else {
                            if (oldValue !== internalObject) {
                                oldValue = internalObject = {};
                                oldLength = 0;
                                changeDetected++
                            }
                            newLength = 0;
                            for (key in newValue) {
                                if (newValue.hasOwnProperty(key)) {
                                    newLength++;
                                    if (oldValue.hasOwnProperty(key)) {
                                        if (oldValue[key] !== newValue[key]) {
                                            changeDetected++;
                                            oldValue[key] = newValue[key]
                                        }
                                    } else {
                                        oldLength++;
                                        oldValue[key] = newValue[key];
                                        changeDetected++
                                    }
                                }
                            }
                            if (oldLength > newLength) {
                                changeDetected++;
                                for (key in oldValue) {
                                    if (oldValue.hasOwnProperty(key) && !newValue.hasOwnProperty(key)) {
                                        oldLength--;
                                        delete oldValue[key]
                                    }
                                }
                            }
                        }
                        return changeDetected
                    }

                    function $watchCollectionAction() {
                        listener(newValue, oldValue, self)
                    }
                    return this.$watch($watchCollectionWatch, $watchCollectionAction)
                },
                $digest: function () {
                    var watch, value, last, watchers, asyncQueue = this.$$asyncQueue,
                        postDigestQueue = this.$$postDigestQueue,
                        length, dirty, ttl = TTL,
                        next, current, target = this,
                        watchLog = [],
                        logIdx, logMsg, asyncTask;
                    beginPhase("$digest");
                    lastDirtyWatch = null;
                    do {
                        dirty = false;
                        current = target;
                        while (asyncQueue.length) {
                            try {
                                asyncTask = asyncQueue.shift();
                                asyncTask.scope.$eval(asyncTask.expression)
                            } catch (e) {
                                clearPhase();
                                $exceptionHandler(e)
                            }
                            lastDirtyWatch = null
                        }
                        traverseScopesLoop: do {
                            if (watchers = current.$$watchers) {
                                length = watchers.length;
                                while (length--) {
                                    try {
                                        watch = watchers[length];
                                        if (watch) {
                                            if ((value = watch.get(current)) !== (last = watch.last) && !(watch.eq ? equals(value, last) : typeof value == "number" && typeof last == "number" && isNaN(value) && isNaN(last))) {
                                                dirty = true;
                                                lastDirtyWatch = watch;
                                                watch.last = watch.eq ? copy(value) : value;
                                                watch.fn(value, last === initWatchVal ? value : last, current);
                                                if (ttl < 5) {
                                                    logIdx = 4 - ttl;
                                                    if (!watchLog[logIdx]) watchLog[logIdx] = [];
                                                    logMsg = isFunction(watch.exp) ? "fn: " + (watch.exp.name || watch.exp.toString()) : watch.exp;
                                                    logMsg += "; newVal: " + toJson(value) + "; oldVal: " + toJson(last);
                                                    watchLog[logIdx].push(logMsg)
                                                }
                                            } else if (watch === lastDirtyWatch) {
                                                dirty = false;
                                                break traverseScopesLoop
                                            }
                                        }
                                    } catch (e) {
                                        clearPhase();
                                        $exceptionHandler(e)
                                    }
                                }
                            }
                            if (!(next = current.$$childHead || current !== target && current.$$nextSibling)) {
                                while (current !== target && !(next = current.$$nextSibling)) {
                                    current = current.$parent
                                }
                            }
                        } while (current = next);
                        if (dirty && !ttl--) {
                            clearPhase();
                            throw $rootScopeMinErr("infdig", "{0} $digest() iterations reached. Aborting!\n" + "Watchers fired in the last 5 iterations: {1}", TTL, toJson(watchLog))
                        }
                    } while (dirty || asyncQueue.length);
                    clearPhase();
                    while (postDigestQueue.length) {
                        try {
                            postDigestQueue.shift()()
                        } catch (e) {
                            $exceptionHandler(e)
                        }
                    }
                },
                $destroy: function () {
                    if (this.$$destroyed) return;
                    var parent = this.$parent;
                    this.$broadcast("$destroy");
                    this.$$destroyed = true;
                    if (this === $rootScope) return;
                    if (parent.$$childHead == this) parent.$$childHead = this.$$nextSibling;
                    if (parent.$$childTail == this) parent.$$childTail = this.$$prevSibling;
                    if (this.$$prevSibling) this.$$prevSibling.$$nextSibling = this.$$nextSibling;
                    if (this.$$nextSibling) this.$$nextSibling.$$prevSibling = this.$$prevSibling;
                    this.$parent = this.$$nextSibling = this.$$prevSibling = this.$$childHead = this.$$childTail = null
                },
                $eval: function (expr, locals) {
                    return $parse(expr)(this, locals)
                },
                $evalAsync: function (expr) {
                    if (!$rootScope.$$phase && !$rootScope.$$asyncQueue.length) {
                        $browser.defer((function () {
                            if ($rootScope.$$asyncQueue.length) {
                                $rootScope.$digest()
                            }
                        }))
                    }
                    this.$$asyncQueue.push({
                        scope: this,
                        expression: expr
                    })
                },
                $$postDigest: function (fn) {
                    this.$$postDigestQueue.push(fn)
                },
                $apply: function (expr) {
                    try {
                        beginPhase("$apply");
                        return this.$eval(expr)
                    } catch (e) {
                        $exceptionHandler(e)
                    } finally {
                        clearPhase();
                        try {
                            $rootScope.$digest()
                        } catch (e) {
                            $exceptionHandler(e);
                            throw e
                        }
                    }
                },
                $on: function (name, listener) {
                    var namedListeners = this.$$listeners[name];
                    if (!namedListeners) {
                        this.$$listeners[name] = namedListeners = []
                    }
                    namedListeners.push(listener);
                    return function () {
                        namedListeners[indexOf(namedListeners, listener)] = null
                    }
                },
                $emit: function (name, args) {
                    var empty = [],
                        namedListeners, scope = this,
                        stopPropagation = false,
                        event = {
                            name: name,
                            targetScope: scope,
                            stopPropagation: function () {
                                stopPropagation = true
                            },
                            preventDefault: function () {
                                event.defaultPrevented = true
                            },
                            defaultPrevented: false
                        },
                        listenerArgs = concat([event], arguments, 1),
                        i, length;
                    do {
                        namedListeners = scope.$$listeners[name] || empty;
                        event.currentScope = scope;
                        for (i = 0, length = namedListeners.length; i < length; i++) {
                            if (!namedListeners[i]) {
                                namedListeners.splice(i, 1);
                                i--;
                                length--;
                                continue
                            }
                            try {
                                namedListeners[i].apply(null, listenerArgs)
                            } catch (e) {
                                $exceptionHandler(e)
                            }
                        }
                        if (stopPropagation) return event;
                        scope = scope.$parent
                    } while (scope);
                    return event
                },
                $broadcast: function (name, args) {
                    var target = this,
                        current = target,
                        next = target,
                        event = {
                            name: name,
                            targetScope: target,
                            preventDefault: function () {
                                event.defaultPrevented = true
                            },
                            defaultPrevented: false
                        },
                        listenerArgs = concat([event], arguments, 1),
                        listeners, i, length;
                    do {
                        current = next;
                        event.currentScope = current;
                        listeners = current.$$listeners[name] || [];
                        for (i = 0, length = listeners.length; i < length; i++) {
                            if (!listeners[i]) {
                                listeners.splice(i, 1);
                                i--;
                                length--;
                                continue
                            }
                            try {
                                listeners[i].apply(null, listenerArgs)
                            } catch (e) {
                                $exceptionHandler(e)
                            }
                        }
                        if (!(next = current.$$childHead || current !== target && current.$$nextSibling)) {
                            while (current !== target && !(next = current.$$nextSibling)) {
                                current = current.$parent
                            }
                        }
                    } while (current = next);
                    return event
                }
            };
            var $rootScope = new Scope;
            return $rootScope;

            function beginPhase(phase) {
                if ($rootScope.$$phase) {
                    throw $rootScopeMinErr("inprog", "{0} already in progress", $rootScope.$$phase)
                }
                $rootScope.$$phase = phase
            }

            function clearPhase() {
                $rootScope.$$phase = null
            }

            function compileToFn(exp, name) {
                var fn = $parse(exp);
                assertArgFn(fn, name);
                return fn
            }

            function initWatchVal() { }
        }]
    }

    function $$SanitizeUriProvider() {
        var aHrefSanitizationWhitelist = /^\s*(https?|ftp|mailto|tel|file):/,
            imgSrcSanitizationWhitelist = /^\s*(https?|ftp|file):|data:image\//;
        this.aHrefSanitizationWhitelist = function (regexp) {
            if (isDefined(regexp)) {
                aHrefSanitizationWhitelist = regexp;
                return this
            }
            return aHrefSanitizationWhitelist
        };
        this.imgSrcSanitizationWhitelist = function (regexp) {
            if (isDefined(regexp)) {
                imgSrcSanitizationWhitelist = regexp;
                return this
            }
            return imgSrcSanitizationWhitelist
        };
        this.$get = function () {
            return function sanitizeUri(uri, isImage) {
                var regex = isImage ? imgSrcSanitizationWhitelist : aHrefSanitizationWhitelist;
                var normalizedVal;
                if (!msie || msie >= 8) {
                    normalizedVal = urlResolve(uri).href;
                    if (normalizedVal !== "" && !normalizedVal.match(regex)) {
                        return "unsafe:" + normalizedVal
                    }
                }
                return uri
            }
        }
    }
    var $sceMinErr = minErr("$sce");
    var SCE_CONTEXTS = {
        HTML: "html",
        CSS: "css",
        URL: "url",
        RESOURCE_URL: "resourceUrl",
        JS: "js"
    };

    function escapeForRegexp(s) {
        return s.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08")
    }

    function adjustMatcher(matcher) {
        if (matcher === "self") {
            return matcher
        } else if (isString(matcher)) {
            if (matcher.indexOf("***") > -1) {
                throw $sceMinErr("iwcard", "Illegal sequence *** in string matcher.  String: {0}", matcher)
            }
            matcher = escapeForRegexp(matcher).replace("\\*\\*", ".*").replace("\\*", "[^:/.?&;]*");
            return new RegExp("^" + matcher + "$")
        } else if (isRegExp(matcher)) {
            return new RegExp("^" + matcher.source + "$")
        } else {
            throw $sceMinErr("imatcher", 'Matchers may only be "self", string patterns or RegExp objects')
        }
    }

    function adjustMatchers(matchers) {
        var adjustedMatchers = [];
        if (isDefined(matchers)) {
            forEach(matchers, (function (matcher) {
                adjustedMatchers.push(adjustMatcher(matcher))
            }))
        }
        return adjustedMatchers
    }

    function $SceDelegateProvider() {
        this.SCE_CONTEXTS = SCE_CONTEXTS;
        var resourceUrlWhitelist = ["self"],
            resourceUrlBlacklist = [];
        this.resourceUrlWhitelist = function (value) {
            if (arguments.length) {
                resourceUrlWhitelist = adjustMatchers(value)
            }
            return resourceUrlWhitelist
        };
        this.resourceUrlBlacklist = function (value) {
            if (arguments.length) {
                resourceUrlBlacklist = adjustMatchers(value)
            }
            return resourceUrlBlacklist
        };
        this.$get = ["$injector", function ($injector) {
            var htmlSanitizer = function htmlSanitizer(html) {
                throw $sceMinErr("unsafe", "Attempting to use an unsafe value in a safe context.")
            };
            if ($injector.has("$sanitize")) {
                htmlSanitizer = $injector.get("$sanitize")
            }

            function matchUrl(matcher, parsedUrl) {
                if (matcher === "self") {
                    return urlIsSameOrigin(parsedUrl)
                } else {
                    return !!matcher.exec(parsedUrl.href)
                }
            }

            function isResourceUrlAllowedByPolicy(url) {
                var parsedUrl = urlResolve(url.toString());
                var i, n, allowed = false;
                for (i = 0, n = resourceUrlWhitelist.length; i < n; i++) {
                    if (matchUrl(resourceUrlWhitelist[i], parsedUrl)) {
                        allowed = true;
                        break
                    }
                }
                if (allowed) {
                    for (i = 0, n = resourceUrlBlacklist.length; i < n; i++) {
                        if (matchUrl(resourceUrlBlacklist[i], parsedUrl)) {
                            allowed = false;
                            break
                        }
                    }
                }
                return allowed
            }

            function generateHolderType(Base) {
                var holderType = function TrustedValueHolderType(trustedValue) {
                    this.$$unwrapTrustedValue = function () {
                        return trustedValue
                    }
                };
                if (Base) {
                    holderType.prototype = new Base
                }
                holderType.prototype.valueOf = function sceValueOf() {
                    return this.$$unwrapTrustedValue()
                };
                holderType.prototype.toString = function sceToString() {
                    return this.$$unwrapTrustedValue().toString()
                };
                return holderType
            }
            var trustedValueHolderBase = generateHolderType(),
                byType = {};
            byType[SCE_CONTEXTS.HTML] = generateHolderType(trustedValueHolderBase);
            byType[SCE_CONTEXTS.CSS] = generateHolderType(trustedValueHolderBase);
            byType[SCE_CONTEXTS.URL] = generateHolderType(trustedValueHolderBase);
            byType[SCE_CONTEXTS.JS] = generateHolderType(trustedValueHolderBase);
            byType[SCE_CONTEXTS.RESOURCE_URL] = generateHolderType(byType[SCE_CONTEXTS.URL]);

            function trustAs(type, trustedValue) {
                var Constructor = byType.hasOwnProperty(type) ? byType[type] : null;
                if (!Constructor) {
                    throw $sceMinErr("icontext", "Attempted to trust a value in invalid context. Context: {0}; Value: {1}", type, trustedValue)
                }
                if (trustedValue === null || trustedValue === undefined || trustedValue === "") {
                    return trustedValue
                }
                if (typeof trustedValue !== "string") {
                    throw $sceMinErr("itype", "Attempted to trust a non-string value in a content requiring a string: Context: {0}", type)
                }
                return new Constructor(trustedValue)
            }

            function valueOf(maybeTrusted) {
                if (maybeTrusted instanceof trustedValueHolderBase) {
                    return maybeTrusted.$$unwrapTrustedValue()
                } else {
                    return maybeTrusted
                }
            }

            function getTrusted(type, maybeTrusted) {
                if (maybeTrusted === null || maybeTrusted === undefined || maybeTrusted === "") {
                    return maybeTrusted
                }
                var constructor = byType.hasOwnProperty(type) ? byType[type] : null;
                if (constructor && maybeTrusted instanceof constructor) {
                    return maybeTrusted.$$unwrapTrustedValue()
                }
                if (type === SCE_CONTEXTS.RESOURCE_URL) {
                    if (isResourceUrlAllowedByPolicy(maybeTrusted)) {
                        return maybeTrusted
                    } else {
                        throw $sceMinErr("insecurl", "Blocked loading resource from url not allowed by $sceDelegate policy.  URL: {0}", maybeTrusted.toString())
                    }
                } else if (type === SCE_CONTEXTS.HTML) {
                    return htmlSanitizer(maybeTrusted)
                }
                throw $sceMinErr("unsafe", "Attempting to use an unsafe value in a safe context.")
            }
            return {
                trustAs: trustAs,
                getTrusted: getTrusted,
                valueOf: valueOf
            }
        }]
    }

    function $SceProvider() {
        var enabled = true;
        this.enabled = function (value) {
            if (arguments.length) {
                enabled = !!value
            }
            return enabled
        };
        this.$get = ["$parse", "$sniffer", "$sceDelegate", function ($parse, $sniffer, $sceDelegate) {
            if (enabled && $sniffer.msie && $sniffer.msieDocumentMode < 8) {
                throw $sceMinErr("iequirks", "Strict Contextual Escaping does not support Internet Explorer version < 9 in quirks " + "mode.  You can fix this by adding the text <!doctype html> to the top of your HTML " + "document.  See http://docs.angularjs.org/api/ng.$sce for more information.")
            }
            var sce = copy(SCE_CONTEXTS);
            sce.isEnabled = function () {
                return enabled
            };
            sce.trustAs = $sceDelegate.trustAs;
            sce.getTrusted = $sceDelegate.getTrusted;
            sce.valueOf = $sceDelegate.valueOf;
            if (!enabled) {
                sce.trustAs = sce.getTrusted = function (type, value) {
                    return value
                };
                sce.valueOf = identity
            }
            sce.parseAs = function sceParseAs(type, expr) {
                var parsed = $parse(expr);
                if (parsed.literal && parsed.constant) {
                    return parsed
                } else {
                    return function sceParseAsTrusted(self, locals) {
                        return sce.getTrusted(type, parsed(self, locals))
                    }
                }
            };
            var parse = sce.parseAs,
                getTrusted = sce.getTrusted,
                trustAs = sce.trustAs;
            forEach(SCE_CONTEXTS, (function (enumValue, name) {
                var lName = lowercase(name);
                sce[camelCase("parse_as_" + lName)] = function (expr) {
                    return parse(enumValue, expr)
                };
                sce[camelCase("get_trusted_" + lName)] = function (value) {
                    return getTrusted(enumValue, value)
                };
                sce[camelCase("trust_as_" + lName)] = function (value) {
                    return trustAs(enumValue, value)
                }
            }));
            return sce
        }]
    }

    function $SnifferProvider() {
        this.$get = ["$window", "$document", function ($window, $document) {
            var eventSupport = {},
                android = int((/android (\d+)/.exec(lowercase(($window.navigator || {}).userAgent)) || [])[1]),
                boxee = /Boxee/i.test(($window.navigator || {}).userAgent),
                document = $document[0] || {},
                documentMode = document.documentMode,
                vendorPrefix, vendorRegex = /^(Moz|webkit|O|ms)(?=[A-Z])/,
                bodyStyle = document.body && document.body.style,
                transitions = false,
                animations = false,
                match;
            if (bodyStyle) {
                for (var prop in bodyStyle) {
                    if (match = vendorRegex.exec(prop)) {
                        vendorPrefix = match[0];
                        vendorPrefix = vendorPrefix.substr(0, 1).toUpperCase() + vendorPrefix.substr(1);
                        break
                    }
                }
                if (!vendorPrefix) {
                    vendorPrefix = "WebkitOpacity" in bodyStyle && "webkit"
                }
                transitions = !!("transition" in bodyStyle || vendorPrefix + "Transition" in bodyStyle);
                animations = !!("animation" in bodyStyle || vendorPrefix + "Animation" in bodyStyle);
                if (android && (!transitions || !animations)) {
                    transitions = isString(document.body.style.webkitTransition);
                    animations = isString(document.body.style.webkitAnimation)
                }
            }
            return {
                history: !!($window.history && $window.history.pushState && !(android < 4) && !boxee),
                hashchange: "onhashchange" in $window && (!documentMode || documentMode > 7),
                hasEvent: function (event) {
                    if (event == "input" && msie == 9) return false;
                    if (isUndefined(eventSupport[event])) {
                        var divElm = document.createElement("div");
                        eventSupport[event] = "on" + event in divElm
                    }
                    return eventSupport[event]
                },
                csp: csp(),
                vendorPrefix: vendorPrefix,
                transitions: transitions,
                animations: animations,
                msie: msie,
                msieDocumentMode: documentMode
            }
        }]
    }

    function $TimeoutProvider() {
        this.$get = ["$rootScope", "$browser", "$q", "$exceptionHandler", function ($rootScope, $browser, $q, $exceptionHandler) {
            var deferreds = {};

            function timeout(fn, delay, invokeApply) {
                var deferred = $q.defer(),
                    promise = deferred.promise,
                    skipApply = isDefined(invokeApply) && !invokeApply,
                    timeoutId;
                timeoutId = $browser.defer((function () {
                    try {
                        deferred.resolve(fn())
                    } catch (e) {
                        deferred.reject(e);
                        $exceptionHandler(e)
                    } finally {
                        delete deferreds[promise.$$timeoutId]
                    }
                    if (!skipApply) $rootScope.$apply()
                }), delay);
                promise.$$timeoutId = timeoutId;
                deferreds[timeoutId] = deferred;
                return promise
            }
            timeout.cancel = function (promise) {
                if (promise && promise.$$timeoutId in deferreds) {
                    deferreds[promise.$$timeoutId].reject("canceled");
                    delete deferreds[promise.$$timeoutId];
                    return $browser.defer.cancel(promise.$$timeoutId)
                }
                return false
            };
            return timeout
        }]
    }
    var urlParsingNode = document.createElement("a");
    var originUrl = urlResolve(window.location.href, true);

    function urlResolve(url, base) {
        var href = url;
        if (msie) {
            urlParsingNode.setAttribute("href", href);
            href = urlParsingNode.href
        }
        urlParsingNode.setAttribute("href", href);
        return {
            href: urlParsingNode.href,
            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
            host: urlParsingNode.host,
            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
            hostname: urlParsingNode.hostname,
            port: urlParsingNode.port,
            pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
        }
    }

    function urlIsSameOrigin(requestUrl) {
        var parsed = isString(requestUrl) ? urlResolve(requestUrl) : requestUrl;
        return parsed.protocol === originUrl.protocol && parsed.host === originUrl.host
    }

    function $WindowProvider() {
        this.$get = valueFn(window)
    }
    $FilterProvider.$inject = ["$provide"];

    function $FilterProvider($provide) {
        var suffix = "Filter";

        function register(name, factory) {
            if (isObject(name)) {
                var filters = {};
                forEach(name, (function (filter, key) {
                    filters[key] = register(key, filter)
                }));
                return filters
            } else {
                return $provide.factory(name + suffix, factory)
            }
        }
        this.register = register;
        this.$get = ["$injector", function ($injector) {
            return function (name) {
                return $injector.get(name + suffix)
            }
        }];
        register("currency", currencyFilter);
        register("date", dateFilter);
        register("filter", filterFilter);
        register("json", jsonFilter);
        register("limitTo", limitToFilter);
        register("lowercase", lowercaseFilter);
        register("number", numberFilter);
        register("orderBy", orderByFilter);
        register("uppercase", uppercaseFilter)
    }

    function filterFilter() {
        return function (array, expression, comparator) {
            if (!isArray(array)) return array;
            var comparatorType = typeof comparator,
                predicates = [];
            predicates.check = function (value) {
                for (var j = 0; j < predicates.length; j++) {
                    if (!predicates[j](value)) {
                        return false
                    }
                }
                return true
            };
            if (comparatorType !== "function") {
                if (comparatorType === "boolean" && comparator) {
                    comparator = function (obj, text) {
                        return angular.equals(obj, text)
                    }
                } else {
                    comparator = function (obj, text) {
                        text = ("" + text).toLowerCase();
                        return ("" + obj).toLowerCase().indexOf(text) > -1
                    }
                }
            }
            var search = function (obj, text) {
                if (typeof text == "string" && text.charAt(0) === "!") {
                    return !search(obj, text.substr(1))
                }
                switch (typeof obj) {
                    case "boolean":
                    case "number":
                    case "string":
                        return comparator(obj, text);
                    case "object":
                        switch (typeof text) {
                            case "object":
                                return comparator(obj, text);
                            default:
                                for (var objKey in obj) {
                                    if (objKey.charAt(0) !== "$" && search(obj[objKey], text)) {
                                        return true
                                    }
                                }
                                break
                        }
                        return false;
                    case "array":
                        for (var i = 0; i < obj.length; i++) {
                            if (search(obj[i], text)) {
                                return true
                            }
                        }
                        return false;
                    default:
                        return false
                }
            };
            switch (typeof expression) {
                case "boolean":
                case "number":
                case "string":
                    expression = {
                        $: expression
                    };
                case "object":
                    for (var key in expression) {
                        if (key == "$") {
                            (function () {
                                if (!expression[key]) return;
                                var path = key;
                                predicates.push((function (value) {
                                    return search(value, expression[path])
                                }))
                            })()
                        } else {
                            (function () {
                                if (typeof expression[key] == "undefined") {
                                    return
                                }
                                var path = key;
                                predicates.push((function (value) {
                                    return search(getter(value, path), expression[path])
                                }))
                            })()
                        }
                    }
                    break;
                case "function":
                    predicates.push(expression);
                    break;
                default:
                    return array
            }
            var filtered = [];
            for (var j = 0; j < array.length; j++) {
                var value = array[j];
                if (predicates.check(value)) {
                    filtered.push(value)
                }
            }
            return filtered
        }
    }
    currencyFilter.$inject = ["$locale"];

    function currencyFilter($locale) {
        var formats = $locale.NUMBER_FORMATS;
        return function (amount, currencySymbol) {
            if (isUndefined(currencySymbol)) currencySymbol = formats.CURRENCY_SYM;
            return formatNumber(amount, formats.PATTERNS[1], formats.GROUP_SEP, formats.DECIMAL_SEP, 2).replace(/\u00A4/g, currencySymbol)
        }
    }
    numberFilter.$inject = ["$locale"];

    function numberFilter($locale) {
        var formats = $locale.NUMBER_FORMATS;
        return function (number, fractionSize) {
            return formatNumber(number, formats.PATTERNS[0], formats.GROUP_SEP, formats.DECIMAL_SEP, fractionSize)
        }
    }
    var DECIMAL_SEP = ".";

    function formatNumber(number, pattern, groupSep, decimalSep, fractionSize) {
        if (isNaN(number) || !isFinite(number)) return "";
        var isNegative = number < 0;
        number = Math.abs(number);
        var numStr = number + "",
            formatedText = "",
            parts = [];
        var hasExponent = false;
        if (numStr.indexOf("e") !== -1) {
            var match = numStr.match(/([\d\.]+)e(-?)(\d+)/);
            if (match && match[2] == "-" && match[3] > fractionSize + 1) {
                numStr = "0"
            } else {
                formatedText = numStr;
                hasExponent = true
            }
        }
        if (!hasExponent) {
            var fractionLen = (numStr.split(DECIMAL_SEP)[1] || "").length;
            if (isUndefined(fractionSize)) {
                fractionSize = Math.min(Math.max(pattern.minFrac, fractionLen), pattern.maxFrac)
            }
            var pow = Math.pow(10, fractionSize);
            number = Math.round(number * pow) / pow;
            var fraction = ("" + number).split(DECIMAL_SEP);
            var whole = fraction[0];
            fraction = fraction[1] || "";
            var i, pos = 0,
                lgroup = pattern.lgSize,
                group = pattern.gSize;
            if (whole.length >= lgroup + group) {
                pos = whole.length - lgroup;
                for (i = 0; i < pos; i++) {
                    if ((pos - i) % group === 0 && i !== 0) {
                        formatedText += groupSep
                    }
                    formatedText += whole.charAt(i)
                }
            }
            for (i = pos; i < whole.length; i++) {
                if ((whole.length - i) % lgroup === 0 && i !== 0) {
                    formatedText += groupSep
                }
                formatedText += whole.charAt(i)
            }
            while (fraction.length < fractionSize) {
                fraction += "0"
            }
            if (fractionSize && fractionSize !== "0") formatedText += decimalSep + fraction.substr(0, fractionSize)
        } else {
            if (fractionSize > 0 && number > -1 && number < 1) {
                formatedText = number.toFixed(fractionSize)
            }
        }
        parts.push(isNegative ? pattern.negPre : pattern.posPre);
        parts.push(formatedText);
        parts.push(isNegative ? pattern.negSuf : pattern.posSuf);
        return parts.join("")
    }

    function padNumber(num, digits, trim) {
        var neg = "";
        if (num < 0) {
            neg = "-";
            num = -num
        }
        num = "" + num;
        while (num.length < digits) num = "0" + num;
        if (trim) num = num.substr(num.length - digits);
        return neg + num
    }

    function dateGetter(name, size, offset, trim) {
        offset = offset || 0;
        return function (date) {
            var value = date["get" + name]();
            if (offset > 0 || value > -offset) value += offset;
            if (value === 0 && offset == -12) value = 12;
            return padNumber(value, size, trim)
        }
    }

    function dateStrGetter(name, shortForm) {
        return function (date, formats) {
            var value = date["get" + name]();
            var get = uppercase(shortForm ? "SHORT" + name : name);
            return formats[get][value]
        }
    }

    function timeZoneGetter(date) {
        var zone = -1 * date.getTimezoneOffset();
        var paddedZone = zone >= 0 ? "+" : "";
        paddedZone += padNumber(Math[zone > 0 ? "floor" : "ceil"](zone / 60), 2) + padNumber(Math.abs(zone % 60), 2);
        return paddedZone
    }

    function ampmGetter(date, formats) {
        return date.getHours() < 12 ? formats.AMPMS[0] : formats.AMPMS[1]
    }
    var DATE_FORMATS = {
        yyyy: dateGetter("FullYear", 4),
        yy: dateGetter("FullYear", 2, 0, true),
        y: dateGetter("FullYear", 1),
        MMMM: dateStrGetter("Month"),
        MMM: dateStrGetter("Month", true),
        MM: dateGetter("Month", 2, 1),
        M: dateGetter("Month", 1, 1),
        dd: dateGetter("Date", 2),
        d: dateGetter("Date", 1),
        HH: dateGetter("Hours", 2),
        H: dateGetter("Hours", 1),
        hh: dateGetter("Hours", 2, -12),
        h: dateGetter("Hours", 1, -12),
        mm: dateGetter("Minutes", 2),
        m: dateGetter("Minutes", 1),
        ss: dateGetter("Seconds", 2),
        s: dateGetter("Seconds", 1),
        sss: dateGetter("Milliseconds", 3),
        EEEE: dateStrGetter("Day"),
        EEE: dateStrGetter("Day", true),
        a: ampmGetter,
        Z: timeZoneGetter
    };
    var DATE_FORMATS_SPLIT = /((?:[^yMdHhmsaZE']+)|(?:'(?:[^']|'')*')|(?:E+|y+|M+|d+|H+|h+|m+|s+|a|Z))(.*)/,
        NUMBER_STRING = /^\-?\d+$/;
    dateFilter.$inject = ["$locale"];

    function dateFilter($locale) {
        var R_ISO8601_STR = /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/;

        function jsonStringToDate(string) {
            var match;
            if (match = string.match(R_ISO8601_STR)) {
                var date = new Date(0),
                    tzHour = 0,
                    tzMin = 0,
                    dateSetter = match[8] ? date.setUTCFullYear : date.setFullYear,
                    timeSetter = match[8] ? date.setUTCHours : date.setHours;
                if (match[9]) {
                    tzHour = int(match[9] + match[10]);
                    tzMin = int(match[9] + match[11])
                }
                dateSetter.call(date, int(match[1]), int(match[2]) - 1, int(match[3]));
                var h = int(match[4] || 0) - tzHour;
                var m = int(match[5] || 0) - tzMin;
                var s = int(match[6] || 0);
                var ms = Math.round(parseFloat("0." + (match[7] || 0)) * 1e3);
                timeSetter.call(date, h, m, s, ms);
                return date
            }
            return string
        }
        return function (date, format) {
            var text = "",
                parts = [],
                fn, match;
            format = format || "mediumDate";
            format = $locale.DATETIME_FORMATS[format] || format;
            if (isString(date)) {
                if (NUMBER_STRING.test(date)) {
                    date = int(date)
                } else {
                    date = jsonStringToDate(date)
                }
            }
            if (isNumber(date)) {
                date = new Date(date)
            }
            if (!isDate(date)) {
                return date
            }
            while (format) {
                match = DATE_FORMATS_SPLIT.exec(format);
                if (match) {
                    parts = concat(parts, match, 1);
                    format = parts.pop()
                } else {
                    parts.push(format);
                    format = null
                }
            }
            forEach(parts, (function (value) {
                fn = DATE_FORMATS[value];
                text += fn ? fn(date, $locale.DATETIME_FORMATS) : value.replace(/(^'|'$)/g, "").replace(/''/g, "'")
            }));
            return text
        }
    }

    function jsonFilter() {
        return function (object) {
            return toJson(object, true)
        }
    }
    var lowercaseFilter = valueFn(lowercase);
    var uppercaseFilter = valueFn(uppercase);

    function limitToFilter() {
        return function (input, limit) {
            if (!isArray(input) && !isString(input)) return input;
            limit = int(limit);
            if (isString(input)) {
                if (limit) {
                    return limit >= 0 ? input.slice(0, limit) : input.slice(limit, input.length)
                } else {
                    return ""
                }
            }
            var out = [],
                i, n;
            if (limit > input.length) limit = input.length;
            else if (limit < -input.length) limit = -input.length;
            if (limit > 0) {
                i = 0;
                n = limit
            } else {
                i = input.length + limit;
                n = input.length
            }
            for (; i < n; i++) {
                out.push(input[i])
            }
            return out
        }
    }
    orderByFilter.$inject = ["$parse"];

    function orderByFilter($parse) {
        return function (array, sortPredicate, reverseOrder) {
            if (!isArray(array)) return array;
            if (!sortPredicate) return array;
            sortPredicate = isArray(sortPredicate) ? sortPredicate : [sortPredicate];
            sortPredicate = map(sortPredicate, (function (predicate) {
                var descending = false,
                    get = predicate || identity;
                if (isString(predicate)) {
                    if (predicate.charAt(0) == "+" || predicate.charAt(0) == "-") {
                        descending = predicate.charAt(0) == "-";
                        predicate = predicate.substring(1)
                    }
                    get = $parse(predicate)
                }
                return reverseComparator((function (a, b) {
                    return compare(get(a), get(b))
                }), descending)
            }));
            var arrayCopy = [];
            for (var i = 0; i < array.length; i++) {
                arrayCopy.push(array[i])
            }
            return arrayCopy.sort(reverseComparator(comparator, reverseOrder));

            function comparator(o1, o2) {
                for (var i = 0; i < sortPredicate.length; i++) {
                    var comp = sortPredicate[i](o1, o2);
                    if (comp !== 0) return comp
                }
                return 0
            }

            function reverseComparator(comp, descending) {
                return toBoolean(descending) ? function (a, b) {
                    return comp(b, a)
                } : comp
            }

            function compare(v1, v2) {
                var t1 = typeof v1;
                var t2 = typeof v2;
                if (t1 == t2) {
                    if (t1 == "string") {
                        v1 = v1.toLowerCase();
                        v2 = v2.toLowerCase()
                    }
                    if (v1 === v2) return 0;
                    return v1 < v2 ? -1 : 1
                } else {
                    return t1 < t2 ? -1 : 1
                }
            }
        }
    }

    function ngDirective(directive) {
        if (isFunction(directive)) {
            directive = {
                link: directive
            }
        }
        directive.restrict = directive.restrict || "AC";
        return valueFn(directive)
    }
    var htmlAnchorDirective = valueFn({
        restrict: "E",
        compile: function (element, attr) {
            if (msie <= 8) {
                if (!attr.href && !attr.name) {
                    attr.$set("href", "")
                }
                element.append(document.createComment("IE fix"))
            }
            if (!attr.href && !attr.name) {
                return function (scope, element) {
                    element.on("click", (function (event) {
                        if (!element.attr("href")) {
                            event.preventDefault()
                        }
                    }))
                }
            }
        }
    });
    var ngAttributeAliasDirectives = {};
    forEach(BOOLEAN_ATTR, (function (propName, attrName) {
        if (propName == "multiple") return;
        var normalized = directiveNormalize("ng-" + attrName);
        ngAttributeAliasDirectives[normalized] = function () {
            return {
                priority: 100,
                compile: function () {
                    return function (scope, element, attr) {
                        scope.$watch(attr[normalized], (function ngBooleanAttrWatchAction(value) {
                            attr.$set(attrName, !!value)
                        }))
                    }
                }
            }
        }
    }));
    forEach(["src", "srcset", "href"], (function (attrName) {
        var normalized = directiveNormalize("ng-" + attrName);
        ngAttributeAliasDirectives[normalized] = function () {
            return {
                priority: 99,
                link: function (scope, element, attr) {
                    attr.$observe(normalized, (function (value) {
                        if (!value) return;
                        attr.$set(attrName, value);
                        if (msie) element.prop(attrName, attr[attrName])
                    }))
                }
            }
        }
    }));
    var nullFormCtrl = {
        $addControl: noop,
        $removeControl: noop,
        $setValidity: noop,
        $setDirty: noop,
        $setPristine: noop
    };
    FormController.$inject = ["$element", "$attrs", "$scope"];

    function FormController(element, attrs) {
        var form = this,
            parentForm = element.parent().controller("form") || nullFormCtrl,
            invalidCount = 0,
            errors = form.$error = {},
            controls = [];
        form.$name = attrs.name || attrs.ngForm;
        form.$dirty = false;
        form.$pristine = true;
        form.$valid = true;
        form.$invalid = false;
        parentForm.$addControl(form);
        element.addClass(PRISTINE_CLASS);
        toggleValidCss(true);

        function toggleValidCss(isValid, validationErrorKey) {
            validationErrorKey = validationErrorKey ? "-" + snake_case(validationErrorKey, "-") : "";
            element.removeClass((isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey).addClass((isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey)
        }
        form.$addControl = function (control) {
            assertNotHasOwnProperty(control.$name, "input");
            controls.push(control);
            if (control.$name) {
                form[control.$name] = control
            }
        };
        form.$removeControl = function (control) {
            if (control.$name && form[control.$name] === control) {
                delete form[control.$name]
            }
            forEach(errors, (function (queue, validationToken) {
                form.$setValidity(validationToken, true, control)
            }));
            arrayRemove(controls, control)
        };
        form.$setValidity = function (validationToken, isValid, control) {
            var queue = errors[validationToken];
            if (isValid) {
                if (queue) {
                    arrayRemove(queue, control);
                    if (!queue.length) {
                        invalidCount--;
                        if (!invalidCount) {
                            toggleValidCss(isValid);
                            form.$valid = true;
                            form.$invalid = false
                        }
                        errors[validationToken] = false;
                        toggleValidCss(true, validationToken);
                        parentForm.$setValidity(validationToken, true, form)
                    }
                }
            } else {
                if (!invalidCount) {
                    toggleValidCss(isValid)
                }
                if (queue) {
                    if (includes(queue, control)) return
                } else {
                    errors[validationToken] = queue = [];
                    invalidCount++;
                    toggleValidCss(false, validationToken);
                    parentForm.$setValidity(validationToken, false, form)
                }
                queue.push(control);
                form.$valid = false;
                form.$invalid = true
            }
        };
        form.$setDirty = function () {
            element.removeClass(PRISTINE_CLASS).addClass(DIRTY_CLASS);
            form.$dirty = true;
            form.$pristine = false;
            parentForm.$setDirty()
        };
        form.$setPristine = function () {
            element.removeClass(DIRTY_CLASS).addClass(PRISTINE_CLASS);
            form.$dirty = false;
            form.$pristine = true;
            forEach(controls, (function (control) {
                control.$setPristine()
            }))
        }
    }
    var formDirectiveFactory = function (isNgForm) {
        return ["$timeout", function ($timeout) {
            var formDirective = {
                name: "form",
                restrict: isNgForm ? "EAC" : "E",
                controller: FormController,
                compile: function () {
                    return {
                        pre: function (scope, formElement, attr, controller) {
                            if (!attr.action) {
                                var preventDefaultListener = function (event) {
                                    event.preventDefault ? event.preventDefault() : event.returnValue = false
                                };
                                addEventListenerFn(formElement[0], "submit", preventDefaultListener);
                                formElement.on("$destroy", (function () {
                                    $timeout((function () {
                                        removeEventListenerFn(formElement[0], "submit", preventDefaultListener)
                                    }), 0, false)
                                }))
                            }
                            var parentFormCtrl = formElement.parent().controller("form"),
                                alias = attr.name || attr.ngForm;
                            if (alias) {
                                setter(scope, alias, controller, alias)
                            }
                            if (parentFormCtrl) {
                                formElement.on("$destroy", (function () {
                                    parentFormCtrl.$removeControl(controller);
                                    if (alias) {
                                        setter(scope, alias, undefined, alias)
                                    }
                                    extend(controller, nullFormCtrl)
                                }))
                            }
                        }
                    }
                }
            };
            return formDirective
        }]
    };
    var formDirective = formDirectiveFactory();
    var ngFormDirective = formDirectiveFactory(true);
    var URL_REGEXP = /^(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?$/;
    var EMAIL_REGEXP = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}$/;
    var NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))\s*$/;
    var inputType = {
        text: textInputType,
        number: numberInputType,
        url: urlInputType,
        email: emailInputType,
        radio: radioInputType,
        checkbox: checkboxInputType,
        hidden: noop,
        button: noop,
        submit: noop,
        reset: noop
    };

    function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {
        var composing = false;
        element.on("compositionstart", (function () {
            composing = true
        }));
        element.on("compositionend", (function () {
            composing = false
        }));
        var listener = function () {
            if (composing) return;
            var value = element.val();
            if (toBoolean(attr.ngTrim || "T")) {
                value = trim(value)
            }
            if (ctrl.$viewValue !== value) {
                scope.$apply((function () {
                    ctrl.$setViewValue(value)
                }))
            }
        };
        if ($sniffer.hasEvent("input")) {
            element.on("input", listener)
        } else {
            var timeout;
            var deferListener = function () {
                if (!timeout) {
                    timeout = $browser.defer((function () {
                        listener();
                        timeout = null
                    }))
                }
            };
            element.on("keydown", (function (event) {
                var key = event.keyCode;
                if (key === 91 || 15 < key && key < 19 || 37 <= key && key <= 40) return;
                deferListener()
            }));
            if ($sniffer.hasEvent("paste")) {
                element.on("paste cut", deferListener)
            }
        }
        element.on("change", listener);
        ctrl.$render = function () {
            element.val(ctrl.$isEmpty(ctrl.$viewValue) ? "" : ctrl.$viewValue)
        };
        var pattern = attr.ngPattern,
            patternValidator, match;
        var validate = function (regexp, value) {
            if (ctrl.$isEmpty(value) || regexp.test(value)) {
                ctrl.$setValidity("pattern", true);
                return value
            } else {
                ctrl.$setValidity("pattern", false);
                return undefined
            }
        };
        if (pattern) {
            match = pattern.match(/^\/(.*)\/([gim]*)$/);
            if (match) {
                pattern = new RegExp(match[1], match[2]);
                patternValidator = function (value) {
                    return validate(pattern, value)
                }
            } else {
                patternValidator = function (value) {
                    var patternObj = scope.$eval(pattern);
                    if (!patternObj || !patternObj.test) {
                        throw minErr("ngPattern")("noregexp", "Expected {0} to be a RegExp but was {1}. Element: {2}", pattern, patternObj, startingTag(element))
                    }
                    return validate(patternObj, value)
                }
            }
            ctrl.$formatters.push(patternValidator);
            ctrl.$parsers.push(patternValidator)
        }
        if (attr.ngMinlength) {
            var minlength = int(attr.ngMinlength);
            var minLengthValidator = function (value) {
                if (!ctrl.$isEmpty(value) && value.length < minlength) {
                    ctrl.$setValidity("minlength", false);
                    return undefined
                } else {
                    ctrl.$setValidity("minlength", true);
                    return value
                }
            };
            ctrl.$parsers.push(minLengthValidator);
            ctrl.$formatters.push(minLengthValidator)
        }
        if (attr.ngMaxlength) {
            var maxlength = int(attr.ngMaxlength);
            var maxLengthValidator = function (value) {
                if (!ctrl.$isEmpty(value) && value.length > maxlength) {
                    ctrl.$setValidity("maxlength", false);
                    return undefined
                } else {
                    ctrl.$setValidity("maxlength", true);
                    return value
                }
            };
            ctrl.$parsers.push(maxLengthValidator);
            ctrl.$formatters.push(maxLengthValidator)
        }
    }

    function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) {
        textInputType(scope, element, attr, ctrl, $sniffer, $browser);
        ctrl.$parsers.push((function (value) {
            var empty = ctrl.$isEmpty(value);
            if (empty || NUMBER_REGEXP.test(value)) {
                ctrl.$setValidity("number", true);
                return value === "" ? null : empty ? value : parseFloat(value)
            } else {
                ctrl.$setValidity("number", false);
                return undefined
            }
        }));
        ctrl.$formatters.push((function (value) {
            return ctrl.$isEmpty(value) ? "" : "" + value
        }));
        if (attr.min) {
            var minValidator = function (value) {
                var min = parseFloat(attr.min);
                if (!ctrl.$isEmpty(value) && value < min) {
                    ctrl.$setValidity("min", false);
                    return undefined
                } else {
                    ctrl.$setValidity("min", true);
                    return value
                }
            };
            ctrl.$parsers.push(minValidator);
            ctrl.$formatters.push(minValidator)
        }
        if (attr.max) {
            var maxValidator = function (value) {
                var max = parseFloat(attr.max);
                if (!ctrl.$isEmpty(value) && value > max) {
                    ctrl.$setValidity("max", false);
                    return undefined
                } else {
                    ctrl.$setValidity("max", true);
                    return value
                }
            };
            ctrl.$parsers.push(maxValidator);
            ctrl.$formatters.push(maxValidator)
        }
        ctrl.$formatters.push((function (value) {
            if (ctrl.$isEmpty(value) || isNumber(value)) {
                ctrl.$setValidity("number", true);
                return value
            } else {
                ctrl.$setValidity("number", false);
                return undefined
            }
        }))
    }

    function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) {
        textInputType(scope, element, attr, ctrl, $sniffer, $browser);
        var urlValidator = function (value) {
            if (ctrl.$isEmpty(value) || URL_REGEXP.test(value)) {
                ctrl.$setValidity("url", true);
                return value
            } else {
                ctrl.$setValidity("url", false);
                return undefined
            }
        };
        ctrl.$formatters.push(urlValidator);
        ctrl.$parsers.push(urlValidator)
    }

    function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {
        textInputType(scope, element, attr, ctrl, $sniffer, $browser);
        var emailValidator = function (value) {
            if (ctrl.$isEmpty(value) || EMAIL_REGEXP.test(value)) {
                ctrl.$setValidity("email", true);
                return value
            } else {
                ctrl.$setValidity("email", false);
                return undefined
            }
        };
        ctrl.$formatters.push(emailValidator);
        ctrl.$parsers.push(emailValidator)
    }

    function radioInputType(scope, element, attr, ctrl) {
        if (isUndefined(attr.name)) {
            element.attr("name", nextUid())
        }
        element.on("click", (function () {
            if (element[0].checked) {
                scope.$apply((function () {
                    ctrl.$setViewValue(attr.value)
                }))
            }
        }));
        ctrl.$render = function () {
            var value = attr.value;
            element[0].checked = value == ctrl.$viewValue
        };
        attr.$observe("value", ctrl.$render)
    }

    function checkboxInputType(scope, element, attr, ctrl) {
        var trueValue = attr.ngTrueValue,
            falseValue = attr.ngFalseValue;
        if (!isString(trueValue)) trueValue = true;
        if (!isString(falseValue)) falseValue = false;
        element.on("click", (function () {
            scope.$apply((function () {
                ctrl.$setViewValue(element[0].checked)
            }))
        }));
        ctrl.$render = function () {
            element[0].checked = ctrl.$viewValue
        };
        ctrl.$isEmpty = function (value) {
            return value !== trueValue
        };
        ctrl.$formatters.push((function (value) {
            return value === trueValue
        }));
        ctrl.$parsers.push((function (value) {
            return value ? trueValue : falseValue
        }))
    }
    var inputDirective = ["$browser", "$sniffer", function ($browser, $sniffer) {
        return {
            restrict: "E",
            require: "?ngModel",
            link: function (scope, element, attr, ctrl) {
                if (ctrl) {
                    (inputType[lowercase(attr.type)] || inputType.text)(scope, element, attr, ctrl, $sniffer, $browser)
                }
            }
        }
    }];
    var VALID_CLASS = "ng-valid",
        INVALID_CLASS = "ng-invalid",
        PRISTINE_CLASS = "ng-pristine",
        DIRTY_CLASS = "ng-dirty";
    var NgModelController = ["$scope", "$exceptionHandler", "$attrs", "$element", "$parse", function ($scope, $exceptionHandler, $attr, $element, $parse) {
        this.$viewValue = Number.NaN;
        this.$modelValue = Number.NaN;
        this.$parsers = [];
        this.$formatters = [];
        this.$viewChangeListeners = [];
        this.$pristine = true;
        this.$dirty = false;
        this.$valid = true;
        this.$invalid = false;
        this.$name = $attr.name;
        var ngModelGet = $parse($attr.ngModel),
            ngModelSet = ngModelGet.assign;
        if (!ngModelSet) {
            throw minErr("ngModel")("nonassign", "Expression '{0}' is non-assignable. Element: {1}", $attr.ngModel, startingTag($element))
        }
        this.$render = noop;
        this.$isEmpty = function (value) {
            return isUndefined(value) || value === "" || value === null || value !== value
        };
        var parentForm = $element.inheritedData("$formController") || nullFormCtrl,
            invalidCount = 0,
            $error = this.$error = {};
        $element.addClass(PRISTINE_CLASS);
        toggleValidCss(true);

        function toggleValidCss(isValid, validationErrorKey) {
            validationErrorKey = validationErrorKey ? "-" + snake_case(validationErrorKey, "-") : "";
            $element.removeClass((isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey).addClass((isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey)
        }
        this.$setValidity = function (validationErrorKey, isValid) {
            if ($error[validationErrorKey] === !isValid) return;
            if (isValid) {
                if ($error[validationErrorKey]) invalidCount--;
                if (!invalidCount) {
                    toggleValidCss(true);
                    this.$valid = true;
                    this.$invalid = false
                }
            } else {
                toggleValidCss(false);
                this.$invalid = true;
                this.$valid = false;
                invalidCount++
            }
            $error[validationErrorKey] = !isValid;
            toggleValidCss(isValid, validationErrorKey);
            parentForm.$setValidity(validationErrorKey, isValid, this)
        };
        this.$setPristine = function () {
            this.$dirty = false;
            this.$pristine = true;
            $element.removeClass(DIRTY_CLASS).addClass(PRISTINE_CLASS)
        };
        this.$setViewValue = function (value) {
            this.$viewValue = value;
            if (this.$pristine) {
                this.$dirty = true;
                this.$pristine = false;
                $element.removeClass(PRISTINE_CLASS).addClass(DIRTY_CLASS);
                parentForm.$setDirty()
            }
            forEach(this.$parsers, (function (fn) {
                value = fn(value)
            }));
            if (this.$modelValue !== value) {
                this.$modelValue = value;
                ngModelSet($scope, value);
                forEach(this.$viewChangeListeners, (function (listener) {
                    try {
                        listener()
                    } catch (e) {
                        $exceptionHandler(e)
                    }
                }))
            }
        };
        var ctrl = this;
        $scope.$watch((function ngModelWatch() {
            var value = ngModelGet($scope);
            if (ctrl.$modelValue !== value) {
                var formatters = ctrl.$formatters,
                    idx = formatters.length;
                ctrl.$modelValue = value;
                while (idx--) {
                    value = formatters[idx](value)
                }
                if (ctrl.$viewValue !== value) {
                    ctrl.$viewValue = value;
                    ctrl.$render()
                }
            }
            return value
        }))
    }];
    var ngModelDirective = function () {
        return {
            require: ["ngModel", "^?form"],
            controller: NgModelController,
            link: function (scope, element, attr, ctrls) {
                var modelCtrl = ctrls[0],
                    formCtrl = ctrls[1] || nullFormCtrl;
                formCtrl.$addControl(modelCtrl);
                scope.$on("$destroy", (function () {
                    formCtrl.$removeControl(modelCtrl)
                }))
            }
        }
    };
    var ngChangeDirective = valueFn({
        require: "ngModel",
        link: function (scope, element, attr, ctrl) {
            ctrl.$viewChangeListeners.push((function () {
                scope.$eval(attr.ngChange)
            }))
        }
    });
    var requiredDirective = function () {
        return {
            require: "?ngModel",
            link: function (scope, elm, attr, ctrl) {
                if (!ctrl) return;
                attr.required = true;
                var validator = function (value) {
                    if (attr.required && ctrl.$isEmpty(value)) {
                        ctrl.$setValidity("required", false);
                        return
                    } else {
                        ctrl.$setValidity("required", true);
                        return value
                    }
                };
                ctrl.$formatters.push(validator);
                ctrl.$parsers.unshift(validator);
                attr.$observe("required", (function () {
                    validator(ctrl.$viewValue)
                }))
            }
        }
    };
    var ngListDirective = function () {
        return {
            require: "ngModel",
            link: function (scope, element, attr, ctrl) {
                var match = /\/(.*)\//.exec(attr.ngList),
                    separator = match && new RegExp(match[1]) || attr.ngList || ",";
                var parse = function (viewValue) {
                    if (isUndefined(viewValue)) return;
                    var list = [];
                    if (viewValue) {
                        forEach(viewValue.split(separator), (function (value) {
                            if (value) list.push(trim(value))
                        }))
                    }
                    return list
                };
                ctrl.$parsers.push(parse);
                ctrl.$formatters.push((function (value) {
                    if (isArray(value)) {
                        return value.join(", ")
                    }
                    return undefined
                }));
                ctrl.$isEmpty = function (value) {
                    return !value || !value.length
                }
            }
        }
    };
    var CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/;
    var ngValueDirective = function () {
        return {
            priority: 100,
            compile: function (tpl, tplAttr) {
                if (CONSTANT_VALUE_REGEXP.test(tplAttr.ngValue)) {
                    return function ngValueConstantLink(scope, elm, attr) {
                        attr.$set("value", scope.$eval(attr.ngValue))
                    }
                } else {
                    return function ngValueLink(scope, elm, attr) {
                        scope.$watch(attr.ngValue, (function valueWatchAction(value) {
                            attr.$set("value", value)
                        }))
                    }
                }
            }
        }
    };
    var ngBindDirective = ngDirective((function (scope, element, attr) {
        element.addClass("ng-binding").data("$binding", attr.ngBind);
        scope.$watch(attr.ngBind, (function ngBindWatchAction(value) {
            element.text(value == undefined ? "" : value)
        }))
    }));
    var ngBindTemplateDirective = ["$interpolate", function ($interpolate) {
        return function (scope, element, attr) {
            var interpolateFn = $interpolate(element.attr(attr.$attr.ngBindTemplate));
            element.addClass("ng-binding").data("$binding", interpolateFn);
            attr.$observe("ngBindTemplate", (function (value) {
                element.text(value)
            }))
        }
    }];
    var ngBindHtmlDirective = ["$sce", "$parse", function ($sce, $parse) {
        return function (scope, element, attr) {
            element.addClass("ng-binding").data("$binding", attr.ngBindHtml);
            var parsed = $parse(attr.ngBindHtml);

            function getStringValue() {
                return (parsed(scope) || "").toString()
            }
            scope.$watch(getStringValue, (function ngBindHtmlWatchAction(value) {
                element.html($sce.getTrustedHtml(parsed(scope)) || "")
            }))
        }
    }];

    function classDirective(name, selector) {
        name = "ngClass" + name;
        return function () {
            return {
                restrict: "AC",
                link: function (scope, element, attr) {
                    var oldVal;
                    scope.$watch(attr[name], ngClassWatchAction, true);
                    attr.$observe("class", (function (value) {
                        ngClassWatchAction(scope.$eval(attr[name]))
                    }));
                    if (name !== "ngClass") {
                        scope.$watch("$index", (function ($index, old$index) {
                            var mod = $index & 1;
                            if (mod !== old$index & 1) {
                                var classes = flattenClasses(scope.$eval(attr[name]));
                                mod === selector ? attr.$addClass(classes) : attr.$removeClass(classes)
                            }
                        }))
                    }

                    function ngClassWatchAction(newVal) {
                        if (selector === true || scope.$index % 2 === selector) {
                            var newClasses = flattenClasses(newVal || "");
                            if (!oldVal) {
                                attr.$addClass(newClasses)
                            } else if (!equals(newVal, oldVal)) {
                                attr.$updateClass(newClasses, flattenClasses(oldVal))
                            }
                        }
                        oldVal = copy(newVal)
                    }

                    function flattenClasses(classVal) {
                        if (isArray(classVal)) {
                            return classVal.join(" ")
                        } else if (isObject(classVal)) {
                            var classes = [],
                                i = 0;
                            forEach(classVal, (function (v, k) {
                                if (v) {
                                    classes.push(k)
                                }
                            }));
                            return classes.join(" ")
                        }
                        return classVal
                    }
                }
            }
        }
    }
    var ngClassDirective = classDirective("", true);
    var ngClassOddDirective = classDirective("Odd", 0);
    var ngClassEvenDirective = classDirective("Even", 1);
    var ngCloakDirective = ngDirective({
        compile: function (element, attr) {
            attr.$set("ngCloak", undefined);
            element.removeClass("ng-cloak")
        }
    });
    var ngControllerDirective = [function () {
        return {
            scope: true,
            controller: "@",
            priority: 500
        }
    }];
    var ngEventDirectives = {};
    forEach("click dblclick mousedown mouseup mouseover mouseout mousemove mouseenter mouseleave keydown keyup keypress submit focus blur copy cut paste".split(" "), (function (name) {
        var directiveName = directiveNormalize("ng-" + name);
        ngEventDirectives[directiveName] = ["$parse", function ($parse) {
            return {
                compile: function ($element, attr) {
                    var fn = $parse(attr[directiveName]);
                    return function (scope, element, attr) {
                        element.on(lowercase(name), (function (event) {
                            scope.$apply((function () {
                                fn(scope, {
                                    $event: event
                                })
                            }))
                        }))
                    }
                }
            }
        }]
    }));
    var ngIfDirective = ["$animate", function ($animate) {
        return {
            transclude: "element",
            priority: 600,
            terminal: true,
            restrict: "A",
            $$tlb: true,
            link: function ($scope, $element, $attr, ctrl, $transclude) {
                var block, childScope;
                $scope.$watch($attr.ngIf, (function ngIfWatchAction(value) {
                    if (toBoolean(value)) {
                        if (!childScope) {
                            childScope = $scope.$new();
                            $transclude(childScope, (function (clone) {
                                clone[clone.length++] = document.createComment(" end ngIf: " + $attr.ngIf + " ");
                                block = {
                                    clone: clone
                                };
                                $animate.enter(clone, $element.parent(), $element)
                            }))
                        }
                    } else {
                        if (childScope) {
                            childScope.$destroy();
                            childScope = null
                        }
                        if (block) {
                            $animate.leave(getBlockElements(block.clone));
                            block = null
                        }
                    }
                }))
            }
        }
    }];
    var ngIncludeDirective = ["$http", "$templateCache", "$anchorScroll", "$animate", "$sce", function ($http, $templateCache, $anchorScroll, $animate, $sce) {
        return {
            restrict: "ECA",
            priority: 400,
            terminal: true,
            transclude: "element",
            controller: angular.noop,
            compile: function (element, attr) {
                var srcExp = attr.ngInclude || attr.src,
                    onloadExp = attr.onload || "",
                    autoScrollExp = attr.autoscroll;
                return function (scope, $element, $attr, ctrl, $transclude) {
                    var changeCounter = 0,
                        currentScope, currentElement;
                    var cleanupLastIncludeContent = function () {
                        if (currentScope) {
                            currentScope.$destroy();
                            currentScope = null
                        }
                        if (currentElement) {
                            $animate.leave(currentElement);
                            currentElement = null
                        }
                    };
                    scope.$watch($sce.parseAsResourceUrl(srcExp), (function ngIncludeWatchAction(src) {
                        var afterAnimation = function () {
                            if (isDefined(autoScrollExp) && (!autoScrollExp || scope.$eval(autoScrollExp))) {
                                $anchorScroll()
                            }
                        };
                        var thisChangeId = ++changeCounter;
                        if (src) {
                            $http.get(src, {
                                cache: $templateCache
                            }).success((function (response) {
                                if (thisChangeId !== changeCounter) return;
                                var newScope = scope.$new();
                                ctrl.template = response;
                                var clone = $transclude(newScope, (function (clone) {
                                    cleanupLastIncludeContent();
                                    $animate.enter(clone, null, $element, afterAnimation)
                                }));
                                currentScope = newScope;
                                currentElement = clone;
                                currentScope.$emit("$includeContentLoaded");
                                scope.$eval(onloadExp)
                            })).error((function () {
                                if (thisChangeId === changeCounter) cleanupLastIncludeContent()
                            }));
                            scope.$emit("$includeContentRequested")
                        } else {
                            cleanupLastIncludeContent();
                            ctrl.template = null
                        }
                    }))
                }
            }
        }
    }];
    var ngIncludeFillContentDirective = ["$compile", function ($compile) {
        return {
            restrict: "ECA",
            priority: -400,
            require: "ngInclude",
            link: function (scope, $element, $attr, ctrl) {
                $element.html(ctrl.template);
                $compile($element.contents())(scope)
            }
        }
    }];
    var ngInitDirective = ngDirective({
        priority: 450,
        compile: function () {
            return {
                pre: function (scope, element, attrs) {
                    scope.$eval(attrs.ngInit)
                }
            }
        }
    });
    var ngNonBindableDirective = ngDirective({
        terminal: true,
        priority: 1e3
    });
    var ngPluralizeDirective = ["$locale", "$interpolate", function ($locale, $interpolate) {
        var BRACE = /{}/g;
        return {
            restrict: "EA",
            link: function (scope, element, attr) {
                var numberExp = attr.count,
                    whenExp = attr.$attr.when && element.attr(attr.$attr.when),
                    offset = attr.offset || 0,
                    whens = scope.$eval(whenExp) || {},
                    whensExpFns = {},
                    startSymbol = $interpolate.startSymbol(),
                    endSymbol = $interpolate.endSymbol(),
                    isWhen = /^when(Minus)?(.+)$/;
                forEach(attr, (function (expression, attributeName) {
                    if (isWhen.test(attributeName)) {
                        whens[lowercase(attributeName.replace("when", "").replace("Minus", "-"))] = element.attr(attr.$attr[attributeName])
                    }
                }));
                forEach(whens, (function (expression, key) {
                    whensExpFns[key] = $interpolate(expression.replace(BRACE, startSymbol + numberExp + "-" + offset + endSymbol))
                }));
                scope.$watch((function ngPluralizeWatch() {
                    var value = parseFloat(scope.$eval(numberExp));
                    if (!isNaN(value)) {
                        if (!(value in whens)) value = $locale.pluralCat(value - offset);
                        return whensExpFns[value](scope, element, true)
                    } else {
                        return ""
                    }
                }), (function ngPluralizeWatchAction(newVal) {
                    element.text(newVal)
                }))
            }
        }
    }];
    var ngRepeatDirective = ["$parse", "$animate", function ($parse, $animate) {
        var NG_REMOVED = "$$NG_REMOVED";
        var ngRepeatMinErr = minErr("ngRepeat");
        return {
            transclude: "element",
            priority: 1e3,
            terminal: true,
            $$tlb: true,
            link: function ($scope, $element, $attr, ctrl, $transclude) {
                var expression = $attr.ngRepeat;
                var match = expression.match(/^\s*(.+)\s+in\s+(.*?)\s*(\s+track\s+by\s+(.+)\s*)?$/),
                    trackByExp, trackByExpGetter, trackByIdExpFn, trackByIdArrayFn, trackByIdObjFn, lhs, rhs, valueIdentifier, keyIdentifier, hashFnLocals = {
                        $id: hashKey
                    };
                if (!match) {
                    throw ngRepeatMinErr("iexp", "Expected expression in form of '_item_ in _collection_[ track by _id_]' but got '{0}'.", expression)
                }
                lhs = match[1];
                rhs = match[2];
                trackByExp = match[4];
                if (trackByExp) {
                    trackByExpGetter = $parse(trackByExp);
                    trackByIdExpFn = function (key, value, index) {
                        if (keyIdentifier) hashFnLocals[keyIdentifier] = key;
                        hashFnLocals[valueIdentifier] = value;
                        hashFnLocals.$index = index;
                        return trackByExpGetter($scope, hashFnLocals)
                    }
                } else {
                    trackByIdArrayFn = function (key, value) {
                        return hashKey(value)
                    };
                    trackByIdObjFn = function (key) {
                        return key
                    }
                }
                match = lhs.match(/^(?:([\$\w]+)|\(([\$\w]+)\s*,\s*([\$\w]+)\))$/);
                if (!match) {
                    throw ngRepeatMinErr("iidexp", "'_item_' in '_item_ in _collection_' should be an identifier or '(_key_, _value_)' expression, but got '{0}'.", lhs)
                }
                valueIdentifier = match[3] || match[1];
                keyIdentifier = match[2];
                var lastBlockMap = {};
                $scope.$watchCollection(rhs, (function ngRepeatAction(collection) {
                    var index, length, previousNode = $element[0],
                        nextNode, nextBlockMap = {},
                        arrayLength, childScope, key, value, trackById, trackByIdFn, collectionKeys, block, nextBlockOrder = [],
                        elementsToRemove;
                    if (isArrayLike(collection)) {
                        collectionKeys = collection;
                        trackByIdFn = trackByIdExpFn || trackByIdArrayFn
                    } else {
                        trackByIdFn = trackByIdExpFn || trackByIdObjFn;
                        collectionKeys = [];
                        for (key in collection) {
                            if (collection.hasOwnProperty(key) && key.charAt(0) != "$") {
                                collectionKeys.push(key)
                            }
                        }
                        collectionKeys.sort()
                    }
                    arrayLength = collectionKeys.length;
                    length = nextBlockOrder.length = collectionKeys.length;
                    for (index = 0; index < length; index++) {
                        key = collection === collectionKeys ? index : collectionKeys[index];
                        value = collection[key];
                        trackById = trackByIdFn(key, value, index);
                        assertNotHasOwnProperty(trackById, "`track by` id");
                        if (lastBlockMap.hasOwnProperty(trackById)) {
                            block = lastBlockMap[trackById];
                            delete lastBlockMap[trackById];
                            nextBlockMap[trackById] = block;
                            nextBlockOrder[index] = block
                        } else if (nextBlockMap.hasOwnProperty(trackById)) {
                            forEach(nextBlockOrder, (function (block) {
                                if (block && block.scope) lastBlockMap[block.id] = block
                            }));
                            throw ngRepeatMinErr("dupes", "Duplicates in a repeater are not allowed. Use 'track by' expression to specify unique keys. Repeater: {0}, Duplicate key: {1}", expression, trackById)
                        } else {
                            nextBlockOrder[index] = {
                                id: trackById
                            };
                            nextBlockMap[trackById] = false
                        }
                    }
                    for (key in lastBlockMap) {
                        if (lastBlockMap.hasOwnProperty(key)) {
                            block = lastBlockMap[key];
                            elementsToRemove = getBlockElements(block.clone);
                            $animate.leave(elementsToRemove);
                            forEach(elementsToRemove, (function (element) {
                                element[NG_REMOVED] = true
                            }));
                            block.scope.$destroy()
                        }
                    }
                    for (index = 0, length = collectionKeys.length; index < length; index++) {
                        key = collection === collectionKeys ? index : collectionKeys[index];
                        value = collection[key];
                        block = nextBlockOrder[index];
                        if (nextBlockOrder[index - 1]) previousNode = getBlockEnd(nextBlockOrder[index - 1]);
                        if (block.scope) {
                            childScope = block.scope;
                            nextNode = previousNode;
                            do {
                                nextNode = nextNode.nextSibling
                            } while (nextNode && nextNode[NG_REMOVED]);
                            if (getBlockStart(block) != nextNode) {
                                $animate.move(getBlockElements(block.clone), null, jqLite(previousNode))
                            }
                            previousNode = getBlockEnd(block)
                        } else {
                            childScope = $scope.$new()
                        }
                        childScope[valueIdentifier] = value;
                        if (keyIdentifier) childScope[keyIdentifier] = key;
                        childScope.$index = index;
                        childScope.$first = index === 0;
                        childScope.$last = index === arrayLength - 1;
                        childScope.$middle = !(childScope.$first || childScope.$last);
                        childScope.$odd = !(childScope.$even = (index & 1) === 0);
                        if (!block.scope) {
                            $transclude(childScope, (function (clone) {
                                clone[clone.length++] = document.createComment(" end ngRepeat: " + expression + " ");
                                $animate.enter(clone, null, jqLite(previousNode));
                                previousNode = clone;
                                block.scope = childScope;
                                block.clone = clone;
                                nextBlockMap[block.id] = block
                            }))
                        }
                    }
                    lastBlockMap = nextBlockMap
                }))
            }
        };

        function getBlockStart(block) {
            return block.clone[0]
        }

        function getBlockEnd(block) {
            return block.clone[block.clone.length - 1]
        }
    }];
    var ngShowDirective = ["$animate", function ($animate) {
        return function (scope, element, attr) {
            scope.$watch(attr.ngShow, (function ngShowWatchAction(value) {
                $animate[toBoolean(value) ? "removeClass" : "addClass"](element, "ng-hide")
            }))
        }
    }];
    var ngHideDirective = ["$animate", function ($animate) {
        return function (scope, element, attr) {
            scope.$watch(attr.ngHide, (function ngHideWatchAction(value) {
                $animate[toBoolean(value) ? "addClass" : "removeClass"](element, "ng-hide")
            }))
        }
    }];
    var ngStyleDirective = ngDirective((function (scope, element, attr) {
        scope.$watch(attr.ngStyle, (function ngStyleWatchAction(newStyles, oldStyles) {
            if (oldStyles && newStyles !== oldStyles) {
                forEach(oldStyles, (function (val, style) {
                    element.css(style, "")
                }))
            }
            if (newStyles) element.css(newStyles)
        }), true)
    }));
    var ngSwitchDirective = ["$animate", function ($animate) {
        return {
            restrict: "EA",
            require: "ngSwitch",
            controller: ["$scope", function ngSwitchController() {
                this.cases = {}
            }],
            link: function (scope, element, attr, ngSwitchController) {
                var watchExpr = attr.ngSwitch || attr.on,
                    selectedTranscludes, selectedElements, selectedScopes = [];
                scope.$watch(watchExpr, (function ngSwitchWatchAction(value) {
                    for (var i = 0, ii = selectedScopes.length; i < ii; i++) {
                        selectedScopes[i].$destroy();
                        $animate.leave(selectedElements[i])
                    }
                    selectedElements = [];
                    selectedScopes = [];
                    if (selectedTranscludes = ngSwitchController.cases["!" + value] || ngSwitchController.cases["?"]) {
                        scope.$eval(attr.change);
                        forEach(selectedTranscludes, (function (selectedTransclude) {
                            var selectedScope = scope.$new();
                            selectedScopes.push(selectedScope);
                            selectedTransclude.transclude(selectedScope, (function (caseElement) {
                                var anchor = selectedTransclude.element;
                                selectedElements.push(caseElement);
                                $animate.enter(caseElement, anchor.parent(), anchor)
                            }))
                        }))
                    }
                }))
            }
        }
    }];
    var ngSwitchWhenDirective = ngDirective({
        transclude: "element",
        priority: 800,
        require: "^ngSwitch",
        compile: function (element, attrs) {
            return function (scope, element, attr, ctrl, $transclude) {
                ctrl.cases["!" + attrs.ngSwitchWhen] = ctrl.cases["!" + attrs.ngSwitchWhen] || [];
                ctrl.cases["!" + attrs.ngSwitchWhen].push({
                    transclude: $transclude,
                    element: element
                })
            }
        }
    });
    var ngSwitchDefaultDirective = ngDirective({
        transclude: "element",
        priority: 800,
        require: "^ngSwitch",
        link: function (scope, element, attr, ctrl, $transclude) {
            ctrl.cases["?"] = ctrl.cases["?"] || [];
            ctrl.cases["?"].push({
                transclude: $transclude,
                element: element
            })
        }
    });
    var ngTranscludeDirective = ngDirective({
        controller: ["$element", "$transclude", function ($element, $transclude) {
            if (!$transclude) {
                throw minErr("ngTransclude")("orphan", "Illegal use of ngTransclude directive in the template! " + "No parent directive that requires a transclusion found. " + "Element: {0}", startingTag($element))
            }
            this.$transclude = $transclude
        }],
        link: function ($scope, $element, $attrs, controller) {
            controller.$transclude((function (clone) {
                $element.empty();
                $element.append(clone)
            }))
        }
    });
    var scriptDirective = ["$templateCache", function ($templateCache) {
        return {
            restrict: "E",
            terminal: true,
            compile: function (element, attr) {
                if (attr.type == "text/ng-template") {
                    var templateUrl = attr.id,
                        text = element[0].text;
                    $templateCache.put(templateUrl, text)
                }
            }
        }
    }];
    var ngOptionsMinErr = minErr("ngOptions");
    var ngOptionsDirective = valueFn({
        terminal: true
    });
    var selectDirective = ["$compile", "$parse", function ($compile, $parse) {
        var NG_OPTIONS_REGEXP = /^\s*(.*?)(?:\s+as\s+(.*?))?(?:\s+group\s+by\s+(.*))?\s+for\s+(?:([\$\w][\$\w]*)|(?:\(\s*([\$\w][\$\w]*)\s*,\s*([\$\w][\$\w]*)\s*\)))\s+in\s+(.*?)(?:\s+track\s+by\s+(.*?))?$/,
            nullModelCtrl = {
                $setViewValue: noop
            };
        return {
            restrict: "E",
            require: ["select", "?ngModel"],
            controller: ["$element", "$scope", "$attrs", function ($element, $scope, $attrs) {
                var self = this,
                    optionsMap = {},
                    ngModelCtrl = nullModelCtrl,
                    nullOption, unknownOption;
                self.databound = $attrs.ngModel;
                self.init = function (ngModelCtrl_, nullOption_, unknownOption_) {
                    ngModelCtrl = ngModelCtrl_;
                    nullOption = nullOption_;
                    unknownOption = unknownOption_
                };
                self.addOption = function (value) {
                    assertNotHasOwnProperty(value, '"option value"');
                    optionsMap[value] = true;
                    if (ngModelCtrl.$viewValue == value) {
                        $element.val(value);
                        if (unknownOption.parent()) unknownOption.remove()
                    }
                };
                self.removeOption = function (value) {
                    if (this.hasOption(value)) {
                        delete optionsMap[value];
                        if (ngModelCtrl.$viewValue == value) {
                            this.renderUnknownOption(value)
                        }
                    }
                };
                self.renderUnknownOption = function (val) {
                    var unknownVal = "? " + hashKey(val) + " ?";
                    unknownOption.val(unknownVal);
                    $element.prepend(unknownOption);
                    $element.val(unknownVal);
                    unknownOption.prop("selected", true)
                };
                self.hasOption = function (value) {
                    return optionsMap.hasOwnProperty(value)
                };
                $scope.$on("$destroy", (function () {
                    self.renderUnknownOption = noop
                }))
            }],
            link: function (scope, element, attr, ctrls) {
                if (!ctrls[1]) return;
                var selectCtrl = ctrls[0],
                    ngModelCtrl = ctrls[1],
                    multiple = attr.multiple,
                    optionsExp = attr.ngOptions,
                    nullOption = false,
                    emptyOption, optionTemplate = jqLite(document.createElement("option")),
                    optGroupTemplate = jqLite(document.createElement("optgroup")),
                    unknownOption = optionTemplate.clone();
                for (var i = 0, children = element.children(), ii = children.length; i < ii; i++) {
                    if (children[i].value === "") {
                        emptyOption = nullOption = children.eq(i);
                        break
                    }
                }
                selectCtrl.init(ngModelCtrl, nullOption, unknownOption);
                if (multiple && (attr.required || attr.ngRequired)) {
                    var requiredValidator = function (value) {
                        ngModelCtrl.$setValidity("required", !attr.required || value && value.length);
                        return value
                    };
                    ngModelCtrl.$parsers.push(requiredValidator);
                    ngModelCtrl.$formatters.unshift(requiredValidator);
                    attr.$observe("required", (function () {
                        requiredValidator(ngModelCtrl.$viewValue)
                    }))
                }
                if (optionsExp) setupAsOptions(scope, element, ngModelCtrl);
                else if (multiple) setupAsMultiple(scope, element, ngModelCtrl);
                else setupAsSingle(scope, element, ngModelCtrl, selectCtrl);

                function setupAsSingle(scope, selectElement, ngModelCtrl, selectCtrl) {
                    ngModelCtrl.$render = function () {
                        var viewValue = ngModelCtrl.$viewValue;
                        if (selectCtrl.hasOption(viewValue)) {
                            if (unknownOption.parent()) unknownOption.remove();
                            selectElement.val(viewValue);
                            if (viewValue === "") emptyOption.prop("selected", true)
                        } else {
                            if (isUndefined(viewValue) && emptyOption) {
                                selectElement.val("")
                            } else {
                                selectCtrl.renderUnknownOption(viewValue)
                            }
                        }
                    };
                    selectElement.on("change", (function () {
                        scope.$apply((function () {
                            if (unknownOption.parent()) unknownOption.remove();
                            ngModelCtrl.$setViewValue(selectElement.val())
                        }))
                    }))
                }

                function setupAsMultiple(scope, selectElement, ctrl) {
                    var lastView;
                    ctrl.$render = function () {
                        var items = new HashMap(ctrl.$viewValue);
                        forEach(selectElement.find("option"), (function (option) {
                            option.selected = isDefined(items.get(option.value))
                        }))
                    };
                    scope.$watch((function selectMultipleWatch() {
                        if (!equals(lastView, ctrl.$viewValue)) {
                            lastView = copy(ctrl.$viewValue);
                            ctrl.$render()
                        }
                    }));
                    selectElement.on("change", (function () {
                        scope.$apply((function () {
                            var array = [];
                            forEach(selectElement.find("option"), (function (option) {
                                if (option.selected) {
                                    array.push(option.value)
                                }
                            }));
                            ctrl.$setViewValue(array)
                        }))
                    }))
                }

                function setupAsOptions(scope, selectElement, ctrl) {
                    var match;
                    if (!(match = optionsExp.match(NG_OPTIONS_REGEXP))) {
                        throw ngOptionsMinErr("iexp", "Expected expression in form of " + "'_select_ (as _label_)? for (_key_,)?_value_ in _collection_'" + " but got '{0}'. Element: {1}", optionsExp, startingTag(selectElement))
                    }
                    var displayFn = $parse(match[2] || match[1]),
                        valueName = match[4] || match[6],
                        keyName = match[5],
                        groupByFn = $parse(match[3] || ""),
                        valueFn = $parse(match[2] ? match[1] : valueName),
                        valuesFn = $parse(match[7]),
                        track = match[8],
                        trackFn = track ? $parse(match[8]) : null,
                        optionGroupsCache = [
                            [{
                                element: selectElement,
                                label: ""
                            }]
                        ];
                    if (nullOption) {
                        $compile(nullOption)(scope);
                        nullOption.removeClass("ng-scope");
                        nullOption.remove()
                    }
                    selectElement.empty();
                    selectElement.on("change", (function () {
                        scope.$apply((function () {
                            var optionGroup, collection = valuesFn(scope) || [],
                                locals = {},
                                key, value, optionElement, index, groupIndex, length, groupLength, trackIndex;
                            if (multiple) {
                                value = [];
                                for (groupIndex = 0, groupLength = optionGroupsCache.length; groupIndex < groupLength; groupIndex++) {
                                    optionGroup = optionGroupsCache[groupIndex];
                                    for (index = 1, length = optionGroup.length; index < length; index++) {
                                        if ((optionElement = optionGroup[index].element)[0].selected) {
                                            key = optionElement.val();
                                            if (keyName) locals[keyName] = key;
                                            if (trackFn) {
                                                for (trackIndex = 0; trackIndex < collection.length; trackIndex++) {
                                                    locals[valueName] = collection[trackIndex];
                                                    if (trackFn(scope, locals) == key) break
                                                }
                                            } else {
                                                locals[valueName] = collection[key]
                                            }
                                            value.push(valueFn(scope, locals))
                                        }
                                    }
                                }
                            } else {
                                key = selectElement.val();
                                if (key == "?") {
                                    value = undefined
                                } else if (key === "") {
                                    value = null
                                } else {
                                    if (trackFn) {
                                        for (trackIndex = 0; trackIndex < collection.length; trackIndex++) {
                                            locals[valueName] = collection[trackIndex];
                                            if (trackFn(scope, locals) == key) {
                                                value = valueFn(scope, locals);
                                                break
                                            }
                                        }
                                    } else {
                                        locals[valueName] = collection[key];
                                        if (keyName) locals[keyName] = key;
                                        value = valueFn(scope, locals)
                                    }
                                }
                            }
                            ctrl.$setViewValue(value)
                        }))
                    }));
                    ctrl.$render = render;
                    scope.$watch(render);

                    function render() {
                        var optionGroups = {
                            "": []
                        },
                            optionGroupNames = [""],
                            optionGroupName, optionGroup, option, existingParent, existingOptions, existingOption, modelValue = ctrl.$modelValue,
                            values = valuesFn(scope) || [],
                            keys = keyName ? sortedKeys(values) : values,
                            key, groupLength, length, groupIndex, index, locals = {},
                            selected, selectedSet = false,
                            lastElement, element, label;
                        if (multiple) {
                            if (trackFn && isArray(modelValue)) {
                                selectedSet = new HashMap([]);
                                for (var trackIndex = 0; trackIndex < modelValue.length; trackIndex++) {
                                    locals[valueName] = modelValue[trackIndex];
                                    selectedSet.put(trackFn(scope, locals), modelValue[trackIndex])
                                }
                            } else {
                                selectedSet = new HashMap(modelValue)
                            }
                        }
                        for (index = 0; length = keys.length, index < length; index++) {
                            key = index;
                            if (keyName) {
                                key = keys[index];
                                if (key.charAt(0) === "$") continue;
                                locals[keyName] = key
                            }
                            locals[valueName] = values[key];
                            optionGroupName = groupByFn(scope, locals) || "";
                            if (!(optionGroup = optionGroups[optionGroupName])) {
                                optionGroup = optionGroups[optionGroupName] = [];
                                optionGroupNames.push(optionGroupName)
                            }
                            if (multiple) {
                                selected = isDefined(selectedSet.remove(trackFn ? trackFn(scope, locals) : valueFn(scope, locals)))
                            } else {
                                if (trackFn) {
                                    var modelCast = {};
                                    modelCast[valueName] = modelValue;
                                    selected = trackFn(scope, modelCast) === trackFn(scope, locals)
                                } else {
                                    selected = modelValue === valueFn(scope, locals)
                                }
                                selectedSet = selectedSet || selected
                            }
                            label = displayFn(scope, locals);
                            label = isDefined(label) ? label : "";
                            optionGroup.push({
                                id: trackFn ? trackFn(scope, locals) : keyName ? keys[index] : index,
                                label: label,
                                selected: selected
                            })
                        }
                        if (!multiple) {
                            if (nullOption || modelValue === null) {
                                optionGroups[""].unshift({
                                    id: "",
                                    label: "",
                                    selected: !selectedSet
                                })
                            } else if (!selectedSet) {
                                optionGroups[""].unshift({
                                    id: "?",
                                    label: "",
                                    selected: true
                                })
                            }
                        }
                        for (groupIndex = 0, groupLength = optionGroupNames.length; groupIndex < groupLength; groupIndex++) {
                            optionGroupName = optionGroupNames[groupIndex];
                            optionGroup = optionGroups[optionGroupName];
                            if (optionGroupsCache.length <= groupIndex) {
                                existingParent = {
                                    element: optGroupTemplate.clone().attr("label", optionGroupName),
                                    label: optionGroup.label
                                };
                                existingOptions = [existingParent];
                                optionGroupsCache.push(existingOptions);
                                selectElement.append(existingParent.element)
                            } else {
                                existingOptions = optionGroupsCache[groupIndex];
                                existingParent = existingOptions[0];
                                if (existingParent.label != optionGroupName) {
                                    existingParent.element.attr("label", existingParent.label = optionGroupName)
                                }
                            }
                            lastElement = null;
                            for (index = 0, length = optionGroup.length; index < length; index++) {
                                option = optionGroup[index];
                                if (existingOption = existingOptions[index + 1]) {
                                    lastElement = existingOption.element;
                                    if (existingOption.label !== option.label) {
                                        lastElement.text(existingOption.label = option.label)
                                    }
                                    if (existingOption.id !== option.id) {
                                        lastElement.val(existingOption.id = option.id)
                                    }
                                    if (lastElement[0].selected !== option.selected) {
                                        lastElement.prop("selected", existingOption.selected = option.selected)
                                    }
                                } else {
                                    if (option.id === "" && nullOption) {
                                        element = nullOption
                                    } else {
                                        (element = optionTemplate.clone()).val(option.id).attr("selected", option.selected).text(option.label)
                                    }
                                    existingOptions.push(existingOption = {
                                        element: element,
                                        label: option.label,
                                        id: option.id,
                                        selected: option.selected
                                    });
                                    if (lastElement) {
                                        lastElement.after(element)
                                    } else {
                                        existingParent.element.append(element)
                                    }
                                    lastElement = element
                                }
                            }
                            index++;
                            while (existingOptions.length > index) {
                                existingOptions.pop().element.remove()
                            }
                        }
                        while (optionGroupsCache.length > groupIndex) {
                            optionGroupsCache.pop()[0].element.remove()
                        }
                    }
                }
            }
        }
    }];
    var optionDirective = ["$interpolate", function ($interpolate) {
        var nullSelectCtrl = {
            addOption: noop,
            removeOption: noop
        };
        return {
            restrict: "E",
            priority: 100,
            compile: function (element, attr) {
                if (isUndefined(attr.value)) {
                    var interpolateFn = $interpolate(element.text(), true);
                    if (!interpolateFn) {
                        attr.$set("value", element.text())
                    }
                }
                return function (scope, element, attr) {
                    var selectCtrlName = "$selectController",
                        parent = element.parent(),
                        selectCtrl = parent.data(selectCtrlName) || parent.parent().data(selectCtrlName);
                    if (selectCtrl && selectCtrl.databound) {
                        element.prop("selected", false)
                    } else {
                        selectCtrl = nullSelectCtrl
                    }
                    if (interpolateFn) {
                        scope.$watch(interpolateFn, (function interpolateWatchAction(newVal, oldVal) {
                            attr.$set("value", newVal);
                            if (newVal !== oldVal) selectCtrl.removeOption(oldVal);
                            selectCtrl.addOption(newVal)
                        }))
                    } else {
                        selectCtrl.addOption(attr.value)
                    }
                    element.on("$destroy", (function () {
                        selectCtrl.removeOption(attr.value)
                    }))
                }
            }
        }
    }];
    var styleDirective = valueFn({
        restrict: "E",
        terminal: true
    });
    bindJQuery();
    publishExternalAPI(angular);
    jqLite(document).ready((function () {
        angularInit(document, bootstrap)
    }))
})(window, document);
!angular.$$csp() && angular.element(document).find("head").prepend('<style type="text/css">@charset "UTF-8";[ng\\:cloak],[ng-cloak],[data-ng-cloak],[x-ng-cloak],.ng-cloak,.x-ng-cloak,.ng-hide{display:none !important;}ng\\:form{display:block;}.ng-animate-start{border-spacing:1px 1px;-ms-zoom:1.0001;}.ng-animate-active{border-spacing:0px 0px;-ms-zoom:1;}</style>');

input.js

// write or paste code here

/**
 * @license AngularJS v1.2.5
 * (c) 2010-2014 Google, Inc. http://angularjs.org
 * License: MIT
 */
(function (window, document, undefined) {
    "use strict";

    /**
     * @description
     *
     * This object provides a utility for producing rich Error messages within
     * Angular. It can be called as follows:
     *
     * var exampleMinErr = minErr('example');
     * throw exampleMinErr('one', 'This {0} is {1}', foo, bar);
     *
     * The above creates an instance of minErr in the example namespace. The
     * resulting error will have a namespaced error code of example.one.  The
     * resulting error will replace {0} with the value of foo, and {1} with the
     * value of bar. The object is not restricted in the number of arguments it can
     * take.
     *
     * If fewer arguments are specified than necessary for interpolation, the extra
     * interpolation markers will be preserved in the final string.
     *
     * Since data will be parsed statically during a build step, some restrictions
     * are applied with respect to how minErr instances are created and called.
     * Instances should have names of the form namespaceMinErr for a minErr created
     * using minErr('namespace') . Error codes, namespaces and template strings
     * should all be static strings, not variables or general expressions.
     *
     * @param {string} module The namespace to use for the new minErr instance.
     * @returns {function(string, string, ...): Error} instance
     */

    function minErr(module) {
        return function () {
            var code = arguments[0],
                prefix = "[" + (module ? module + ":" : "") + code + "] ",
                template = arguments[1],
                templateArgs = arguments,
                stringify = function (obj) {
                    if (typeof obj === "function") {
                        return obj.toString().replace(/ \{[\s\S]*$/, "");
                    } else if (typeof obj === "undefined") {
                        return "undefined";
                    } else if (typeof obj !== "string") {
                        return JSON.stringify(obj);
                    }
                    return obj;
                },
                message,
                i;

            message =
                prefix +
                template.replace(/\{\d+\}/g, function (match) {
                    var index = +match.slice(1, -1),
                        arg;

                    if (index + 2 < templateArgs.length) {
                        arg = templateArgs[index + 2];
                        if (typeof arg === "function") {
                            return arg.toString().replace(/ ?\{[\s\S]*$/, "");
                        } else if (typeof arg === "undefined") {
                            return "undefined";
                        } else if (typeof arg !== "string") {
                            return toJson(arg);
                        }
                        return arg;
                    }
                    return match;
                });

            message =
                message +
                "\nhttp://errors.angularjs.org/1.2.5/" +
                (module ? module + "/" : "") +
                code;
            for (i = 2; i < arguments.length; i++) {
                message =
                    message +
                    (i == 2 ? "?" : "&") +
                    "p" +
                    (i - 2) +
                    "=" +
                    encodeURIComponent(stringify(arguments[i]));
            }

            return new Error(message);
        };
    }

    /* We need to tell jshint what variables are being exported */
    /* global
      -angular,
      -msie,
      -jqLite,
      -jQuery,
      -slice,
      -push,
      -toString,
      -ngMinErr,
      -_angular,
      -angularModule,
      -nodeName_,
      -uid,
  
      -lowercase,
      -uppercase,
      -manualLowercase,
      -manualUppercase,
      -nodeName_,
      -isArrayLike,
      -forEach,
      -sortedKeys,
      -forEachSorted,
      -reverseParams,
      -nextUid,
      -setHashKey,
      -extend,
      -int,
      -inherit,
      -noop,
      -identity,
      -valueFn,
      -isUndefined,
      -isDefined,
      -isObject,
      -isString,
      -isNumber,
      -isDate,
      -isArray,
      -isFunction,
      -isRegExp,
      -isWindow,
      -isScope,
      -isFile,
      -isBoolean,
      -trim,
      -isElement,
      -makeMap,
      -map,
      -size,
      -includes,
      -indexOf,
      -arrayRemove,
      -isLeafNode,
      -copy,
      -shallowCopy,
      -equals,
      -csp,
      -concat,
      -sliceArgs,
      -bind,
      -toJsonReplacer,
      -toJson,
      -fromJson,
      -toBoolean,
      -startingTag,
      -tryDecodeURIComponent,
      -parseKeyValue,
      -toKeyValue,
      -encodeUriSegment,
      -encodeUriQuery,
      -angularInit,
      -bootstrap,
      -snake_case,
      -bindJQuery,
      -assertArg,
      -assertArgFn,
      -assertNotHasOwnProperty,
      -getter,
      -getBlockElements,
  
  */

    ////////////////////////////////////

    /**
     * @ngdoc function
     * @name angular.lowercase
     * @function
     *
     * @description Converts the specified string to lowercase.
     * @param {string} string String to be converted to lowercase.
     * @returns {string} Lowercased string.
     */
    var lowercase = function (string) {
        return isString(string) ? string.toLowerCase() : string;
    };

    /**
     * @ngdoc function
     * @name angular.uppercase
     * @function
     *
     * @description Converts the specified string to uppercase.
     * @param {string} string String to be converted to uppercase.
     * @returns {string} Uppercased string.
     */
    var uppercase = function (string) {
        return isString(string) ? string.toUpperCase() : string;
    };

    var manualLowercase = function (s) {
        /* jshint bitwise: false */
        return isString(s)
            ? s.replace(/[A-Z]/g, function (ch) {
                return String.fromCharCode(ch.charCodeAt(0) | 32);
            })
            : s;
    };
    var manualUppercase = function (s) {
        /* jshint bitwise: false */
        return isString(s)
            ? s.replace(/[a-z]/g, function (ch) {
                return String.fromCharCode(ch.charCodeAt(0) & ~32);
            })
            : s;
    };

    // String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish
    // locale, for this reason we need to detect this case and redefine lowercase/uppercase methods
    // with correct but slower alternatives.
    if ("i" !== "I".toLowerCase()) {
        lowercase = manualLowercase;
        uppercase = manualUppercase;
    }

    var /** holds major version number for IE or NaN for real browsers */
        msie,
        jqLite, // delay binding since jQuery could be loaded after us.
        jQuery, // delay binding
        slice = [].slice,
        push = [].push,
        toString = Object.prototype.toString,
        ngMinErr = minErr("ng"),
        _angular = window.angular,
        /** @name angular */
        angular = window.angular || (window.angular = {}),
        angularModule,
        nodeName_,
        uid = ["0", "0", "0"];

    /**
     * IE 11 changed the format of the UserAgent string.
     * See http://msdn.microsoft.com/en-us/library/ms537503.aspx
     */
    msie = int((/msie (\d+)/.exec(lowercase(navigator.userAgent)) || [])[1]);
    if (isNaN(msie)) {
        msie = int(
            (/trident\/.*; rv:(\d+)/.exec(lowercase(navigator.userAgent)) || [])[1],
        );
    }

    /**
     * @private
     * @param {*} obj
     * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
     *                   String ...)
     */
    function isArrayLike(obj) {
        if (obj == null || isWindow(obj)) {
            return false;
        }

        var length = obj.length;

        if (obj.nodeType === 1 && length) {
            return true;
        }

        return (
            isString(obj) ||
            isArray(obj) ||
            length === 0 ||
            (typeof length === "number" && length > 0 && length - 1 in obj)
        );
    }

    /**
   * @ngdoc function
   * @name angular.forEach
   * @function
   *
   * @description
   * Invokes the `iterator` function once for each item in `obj` collection, which can be either an
   * object or an array. The `iterator` function is invoked with `iterator(value, key)`, where `value`
   * is the value of an object property or an array element and `key` is the object property key or
   * array element index. Specifying a `context` for the function is optional.
   *
   * Note: this function was previously known as `angular.foreach`.
   *
     <pre>
       var values = {name: 'misko', gender: 'male'};
       var log = [];
       angular.forEach(values, function(value, key){
         this.push(key + ': ' + value);
       }, log);
       expect(log).toEqual(['name: misko', 'gender:male']);
     </pre>
   *
   * @param {Object|Array} obj Object to iterate over.
   * @param {Function} iterator Iterator function.
   * @param {Object=} context Object to become context (`this`) for the iterator function.
   * @returns {Object|Array} Reference to `obj`.
   */
    function forEach(obj, iterator, context) {
        var key;
        if (obj) {
            if (isFunction(obj)) {
                for (key in obj) {
                    if (
                        key != "prototype" &&
                        key != "length" &&
                        key != "name" &&
                        obj.hasOwnProperty(key)
                    ) {
                        iterator.call(context, obj[key], key);
                    }
                }
            } else if (obj.forEach && obj.forEach !== forEach) {
                obj.forEach(iterator, context);
            } else if (isArrayLike(obj)) {
                for (key = 0; key < obj.length; key++)
                    iterator.call(context, obj[key], key);
            } else {
                for (key in obj) {
                    if (obj.hasOwnProperty(key)) {
                        iterator.call(context, obj[key], key);
                    }
                }
            }
        }
        return obj;
    }

    function sortedKeys(obj) {
        var keys = [];
        for (var key in obj) {
            if (obj.hasOwnProperty(key)) {
                keys.push(key);
            }
        }
        return keys.sort();
    }

    function forEachSorted(obj, iterator, context) {
        var keys = sortedKeys(obj);
        for (var i = 0; i < keys.length; i++) {
            iterator.call(context, obj[keys[i]], keys[i]);
        }
        return keys;
    }

    /**
     * when using forEach the params are value, key, but it is often useful to have key, value.
     * @param {function(string, *)} iteratorFn
     * @returns {function(*, string)}
     */
    function reverseParams(iteratorFn) {
        return function (value, key) {
            iteratorFn(key, value);
        };
    }

    /**
     * A consistent way of creating unique IDs in angular. The ID is a sequence of alpha numeric
     * characters such as '012ABC'. The reason why we are not using simply a number counter is that
     * the number string gets longer over time, and it can also overflow, where as the nextId
     * will grow much slower, it is a string, and it will never overflow.
     *
     * @returns an unique alpha-numeric string
     */
    function nextUid() {
        var index = uid.length;
        var digit;

        while (index) {
            index--;
            digit = uid[index].charCodeAt(0);
            if (digit == 57 /*'9'*/) {
                uid[index] = "A";
                return uid.join("");
            }
            if (digit == 90 /*'Z'*/) {
                uid[index] = "0";
            } else {
                uid[index] = String.fromCharCode(digit + 1);
                return uid.join("");
            }
        }
        uid.unshift("0");
        return uid.join("");
    }

    /**
     * Set or clear the hashkey for an object.
     * @param obj object
     * @param h the hashkey (!truthy to delete the hashkey)
     */
    function setHashKey(obj, h) {
        if (h) {
            obj.$$hashKey = h;
        } else {
            delete obj.$$hashKey;
        }
    }

    /**
     * @ngdoc function
     * @name angular.extend
     * @function
     *
     * @description
     * Extends the destination object `dst` by copying all of the properties from the `src` object(s)
     * to `dst`. You can specify multiple `src` objects.
     *
     * @param {Object} dst Destination object.
     * @param {...Object} src Source object(s).
     * @returns {Object} Reference to `dst`.
     */
    function extend(dst) {
        var h = dst.$$hashKey;
        forEach(arguments, function (obj) {
            if (obj !== dst) {
                forEach(obj, function (value, key) {
                    dst[key] = value;
                });
            }
        });

        setHashKey(dst, h);
        return dst;
    }

    function int(str) {
        return parseInt(str, 10);
    }

    function inherit(parent, extra) {
        return extend(new (extend(function () { }, { prototype: parent }))(), extra);
    }

    /**
   * @ngdoc function
   * @name angular.noop
   * @function
   *
   * @description
   * A function that performs no operations. This function can be useful when writing code in the
   * functional style.
     <pre>
       function foo(callback) {
         var result = calculateResult();
         (callback || angular.noop)(result);
       }
     </pre>
   */
    function noop() { }
    noop.$inject = [];

    /**
   * @ngdoc function
   * @name angular.identity
   * @function
   *
   * @description
   * A function that returns its first argument. This function is useful when writing code in the
   * functional style.
   *
     <pre>
       function transformer(transformationFn, value) {
         return (transformationFn || angular.identity)(value);
       };
     </pre>
   */
    function identity($) {
        return $;
    }
    identity.$inject = [];

    function valueFn(value) {
        return function () {
            return value;
        };
    }

    /**
     * @ngdoc function
     * @name angular.isUndefined
     * @function
     *
     * @description
     * Determines if a reference is undefined.
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is undefined.
     */
    function isUndefined(value) {
        return typeof value === "undefined";
    }

    /**
     * @ngdoc function
     * @name angular.isDefined
     * @function
     *
     * @description
     * Determines if a reference is defined.
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is defined.
     */
    function isDefined(value) {
        return typeof value !== "undefined";
    }

    /**
     * @ngdoc function
     * @name angular.isObject
     * @function
     *
     * @description
     * Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
     * considered to be objects.
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is an `Object` but not `null`.
     */
    var isObject = globalThis.isObject;

    /**
     * @ngdoc function
     * @name angular.isString
     * @function
     *
     * @description
     * Determines if a reference is a `String`.
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is a `String`.
     */
    function isString(value) {
        return typeof value === "string";
    }

    /**
     * @ngdoc function
     * @name angular.isNumber
     * @function
     *
     * @description
     * Determines if a reference is a `Number`.
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is a `Number`.
     */
    function isNumber(value) {
        return typeof value === "number";
    }

    /**
     * @ngdoc function
     * @name angular.isDate
     * @function
     *
     * @description
     * Determines if a value is a date.
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is a `Date`.
     */
    function isDate(value) {
        return toString.call(value) === "[object Date]";
    }

    /**
     * @ngdoc function
     * @name angular.isArray
     * @function
     *
     * @description
     * Determines if a reference is an `Array`.
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is an `Array`.
     */
    function isArray(value) {
        return toString.call(value) === "[object Array]";
    }

    /**
     * @ngdoc function
     * @name angular.isFunction
     * @function
     *
     * @description
     * Determines if a reference is a `Function`.
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is a `Function`.
     */
    function isFunction(value) {
        return typeof value === "function";
    }

    /**
     * Determines if a value is a regular expression object.
     *
     * @private
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is a `RegExp`.
     */
    function isRegExp(value) {
        return toString.call(value) === "[object RegExp]";
    }

    /**
     * Checks if `obj` is a window object.
     *
     * @private
     * @param {*} obj Object to check
     * @returns {boolean} True if `obj` is a window obj.
     */
    function isWindow(obj) {
        return obj && obj.document && obj.location && obj.alert && obj.setInterval;
    }

    function isScope(obj) {
        return obj && obj.$evalAsync && obj.$watch;
    }

    function isFile(obj) {
        return toString.call(obj) === "[object File]";
    }

    function isBoolean(value) {
        return typeof value === "boolean";
    }

    var trim = (function () {
        // native trim is way faster: http://jsperf.com/angular-trim-test
        // but IE doesn't have it... :-(
        // TODO: we should move this into IE/ES5 polyfill
        if (!String.prototype.trim) {
            return function (value) {
                return isString(value)
                    ? value.replace(/^\s\s*/, "").replace(/\s\s*$/, "")
                    : value;
            };
        }
        return function (value) {
            return isString(value) ? value.trim() : value;
        };
    })();

    /**
     * @ngdoc function
     * @name angular.isElement
     * @function
     *
     * @description
     * Determines if a reference is a DOM element (or wrapped jQuery element).
     *
     * @param {*} value Reference to check.
     * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
     */
    function isElement(node) {
        return !!(
            node &&
            (node.nodeName || // we are a direct element
                (node.on && node.find))
        ); // we have an on and find method part of jQuery API
    }

    /**
     * @param str 'key1,key2,...'
     * @returns {object} in the form of {key1:true, key2:true, ...}
     */
    function makeMap(str) {
        var obj = {},
            items = str.split(","),
            i;
        for (i = 0; i < items.length; i++) obj[items[i]] = true;
        return obj;
    }

    if (msie < 9) {
        nodeName_ = function (element) {
            element = element.nodeName ? element : element[0];
            return element.scopeName && element.scopeName != "HTML"
                ? uppercase(element.scopeName + ":" + element.nodeName)
                : element.nodeName;
        };
    } else {
        nodeName_ = function (element) {
            return element.nodeName ? element.nodeName : element[0].nodeName;
        };
    }

    function map(obj, iterator, context) {
        var results = [];
        forEach(obj, function (value, index, list) {
            results.push(iterator.call(context, value, index, list));
        });
        return results;
    }

    /**
     * @description
     * Determines the number of elements in an array, the number of properties an object has, or
     * the length of a string.
     *
     * Note: This function is used to augment the Object type in Angular expressions. See
     * {@link angular.Object} for more information about Angular arrays.
     *
     * @param {Object|Array|string} obj Object, array, or string to inspect.
     * @param {boolean} [ownPropsOnly=false] Count only "own" properties in an object
     * @returns {number} The size of `obj` or `0` if `obj` is neither an object nor an array.
     */
    function size(obj, ownPropsOnly) {
        var count = 0,
            key;

        if (isArray(obj) || isString(obj)) {
            return obj.length;
        } else if (isObject(obj)) {
            for (key in obj) if (!ownPropsOnly || obj.hasOwnProperty(key)) count++;
        }

        return count;
    }

    function includes(array, obj) {
        return indexOf(array, obj) != -1;
    }

    function indexOf(array, obj) {
        if (array.indexOf) return array.indexOf(obj);

        for (var i = 0; i < array.length; i++) {
            if (obj === array[i]) return i;
        }
        return -1;
    }

    function arrayRemove(array, value) {
        var index = indexOf(array, value);
        if (index >= 0) array.splice(index, 1);
        return value;
    }

    function isLeafNode(node) {
        if (node) {
            switch (node.nodeName) {
                case "OPTION":
                case "PRE":
                case "TITLE":
                    return true;
            }
        }
        return false;
    }

    /**
   * @ngdoc function
   * @name angular.copy
   * @function
   *
   * @description
   * Creates a deep copy of `source`, which should be an object or an array.
   *
   * * If no destination is supplied, a copy of the object or array is created.
   * * If a destination is provided, all of its elements (for array) or properties (for objects)
   *   are deleted and then all elements/properties from the source are copied to it.
   * * If `source` is not an object or array (inc. `null` and `undefined`), `source` is returned.
   * * If `source` is identical to 'destination' an exception will be thrown.
   *
   * @param {*} source The source that will be used to make a copy.
   *                   Can be any type, including primitives, `null`, and `undefined`.
   * @param {(Object|Array)=} destination Destination into which the source is copied. If
   *     provided, must be of the same type as `source`.
   * @returns {*} The copy or updated `destination`, if `destination` was specified.
   *
   * @example
   <doc:example>
   <doc:source>
   <div ng-controller="Controller">
   <form novalidate class="simple-form">
   Name: <input type="text" ng-model="user.name" /><br />
   E-mail: <input type="email" ng-model="user.email" /><br />
   Gender: <input type="radio" ng-model="user.gender" value="male" />male
   <input type="radio" ng-model="user.gender" value="female" />female<br />
   <button ng-click="reset()">RESET</button>
   <button ng-click="update(user)">SAVE</button>
   </form>
   <pre>form = {{user | json}}</pre>
   <pre>master = {{master | json}}</pre>
   </div>
  
   <script>
   function Controller($scope) {
      $scope.master= {};
  
      $scope.update = function(user) {
        // Example with 1 argument
        $scope.master= angular.copy(user);
      };
  
      $scope.reset = function() {
        // Example with 2 arguments
        angular.copy($scope.master, $scope.user);
      };
  
      $scope.reset();
    }
   </script>
   </doc:source>
   </doc:example>
   */
    function copy(source, destination) {
        if (isWindow(source) || isScope(source)) {
            throw ngMinErr(
                "cpws",
                "Can't copy! Making copies of Window or Scope instances is not supported.",
            );
        }

        if (!destination) {
            destination = source;
            if (source) {
                if (isArray(source)) {
                    destination = copy(source, []);
                } else if (isDate(source)) {
                    destination = new Date(source.getTime());
                } else if (isRegExp(source)) {
                    destination = new RegExp(source.source);
                } else if (isObject(source)) {
                    destination = copy(source, {});
                }
            }
        } else {
            if (source === destination)
                throw ngMinErr(
                    "cpi",
                    "Can't copy! Source and destination are identical.",
                );
            if (isArray(source)) {
                destination.length = 0;
                for (var i = 0; i < source.length; i++) {
                    destination.push(copy(source[i]));
                }
            } else {
                var h = destination.$$hashKey;
                forEach(destination, function (value, key) {
                    delete destination[key];
                });
                for (var key in source) {
                    destination[key] = copy(source[key]);
                }
                setHashKey(destination, h);
            }
        }
        return destination;
    }

    /**
     * Create a shallow copy of an object
     */
    function shallowCopy(src, dst) {
        dst = dst || {};

        for (var key in src) {
            // shallowCopy is only ever called by $compile nodeLinkFn, which has control over src
            // so we don't need to worry about using our custom hasOwnProperty here
            if (src.hasOwnProperty(key) && key.substr(0, 2) !== "$$") {
                dst[key] = src[key];
            }
        }

        return dst;
    }

    /**
     * @ngdoc function
     * @name angular.equals
     * @function
     *
     * @description
     * Determines if two objects or two values are equivalent. Supports value types, regular
     * expressions, arrays and objects.
     *
     * Two objects or values are considered equivalent if at least one of the following is true:
     *
     * * Both objects or values pass `===` comparison.
     * * Both objects or values are of the same type and all of their properties are equal by
     *   comparing them with `angular.equals`.
     * * Both values are NaN. (In JavaScript, NaN == NaN => false. But we consider two NaN as equal)
     * * Both values represent the same regular expression (In JavasScript,
     *   /abc/ == /abc/ => false. But we consider two regular expressions as equal when their textual
     *   representation matches).
     *
     * During a property comparison, properties of `function` type and properties with names
     * that begin with `$` are ignored.
     *
     * Scope and DOMWindow objects are being compared only by identify (`===`).
     *
     * @param {*} o1 Object or value to compare.
     * @param {*} o2 Object or value to compare.
     * @returns {boolean} True if arguments are equal.
     */
    function equals(o1, o2) {
        if (o1 === o2) return true;
        if (o1 === null || o2 === null) return false;
        if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
        var t1 = typeof o1,
            t2 = typeof o2,
            length,
            key,
            keySet;
        if (t1 == t2) {
            if (t1 == "object") {
                if (isArray(o1)) {
                    if (!isArray(o2)) return false;
                    if ((length = o1.length) == o2.length) {
                        for (key = 0; key < length; key++) {
                            if (!equals(o1[key], o2[key])) return false;
                        }
                        return true;
                    }
                } else if (isDate(o1)) {
                    return isDate(o2) && o1.getTime() == o2.getTime();
                } else if (isRegExp(o1) && isRegExp(o2)) {
                    return o1.toString() == o2.toString();
                } else {
                    if (
                        isScope(o1) ||
                        isScope(o2) ||
                        isWindow(o1) ||
                        isWindow(o2) ||
                        isArray(o2)
                    )
                        return false;
                    keySet = {};
                    for (key in o1) {
                        if (key.charAt(0) === "$" || isFunction(o1[key])) continue;
                        if (!equals(o1[key], o2[key])) return false;
                        keySet[key] = true;
                    }
                    for (key in o2) {
                        if (
                            !keySet.hasOwnProperty(key) &&
                            key.charAt(0) !== "$" &&
                            o2[key] !== undefined &&
                            !isFunction(o2[key])
                        )
                            return false;
                    }
                    return true;
                }
            }
        }
        return false;
    }

    function csp() {
        return (
            (document.securityPolicy && document.securityPolicy.isActive) ||
            (document.querySelector &&
                !!(
                    document.querySelector("[ng-csp]") ||
                    document.querySelector("[data-ng-csp]")
                ))
        );
    }

    function concat(array1, array2, index) {
        return array1.concat(slice.call(array2, index));
    }

    function sliceArgs(args, startIndex) {
        return slice.call(args, startIndex || 0);
    }

    /* jshint -W101 */
    /**
     * @ngdoc function
     * @name angular.bind
     * @function
     *
     * @description
     * Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
     * `fn`). You can supply optional `args` that are prebound to the function. This feature is also
     * known as [partial application](http://en.wikipedia.org/wiki/Partial_application), as
     * distinguished from [function currying](http://en.wikipedia.org/wiki/Currying#Contrast_with_partial_function_application).
     *
     * @param {Object} self Context which `fn` should be evaluated in.
     * @param {function()} fn Function to be bound.
     * @param {...*} args Optional arguments to be prebound to the `fn` function call.
     * @returns {function()} Function that wraps the `fn` with all the specified bindings.
     */
    /* jshint +W101 */
    function bind(self, fn) {
        var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
        if (isFunction(fn) && !(fn instanceof RegExp)) {
            return curryArgs.length
                ? function () {
                    return arguments.length
                        ? fn.apply(self, curryArgs.concat(slice.call(arguments, 0)))
                        : fn.apply(self, curryArgs);
                }
                : function () {
                    return arguments.length ? fn.apply(self, arguments) : fn.call(self);
                };
        } else {
            // in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
            return fn;
        }
    }

    function toJsonReplacer(key, value) {
        var val = value;

        if (typeof key === "string" && key.charAt(0) === "$") {
            val = undefined;
        } else if (isWindow(value)) {
            val = "$WINDOW";
        } else if (value && document === value) {
            val = "$DOCUMENT";
        } else if (isScope(value)) {
            val = "$SCOPE";
        }

        return val;
    }

    /**
     * @ngdoc function
     * @name angular.toJson
     * @function
     *
     * @description
     * Serializes input into a JSON-formatted string. Properties with leading $ characters will be
     * stripped since angular uses this notation internally.
     *
     * @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
     * @param {boolean=} pretty If set to true, the JSON output will contain newlines and whitespace.
     * @returns {string|undefined} JSON-ified string representing `obj`.
     */
    function toJson(obj, pretty) {
        if (typeof obj === "undefined") return undefined;
        return JSON.stringify(obj, toJsonReplacer, pretty ? "  " : null);
    }

    /**
     * @ngdoc function
     * @name angular.fromJson
     * @function
     *
     * @description
     * Deserializes a JSON string.
     *
     * @param {string} json JSON string to deserialize.
     * @returns {Object|Array|Date|string|number} Deserialized thingy.
     */
    function fromJson(json) {
        return isString(json) ? JSON.parse(json) : json;
    }

    function toBoolean(value) {
        if (value && value.length !== 0) {
            var v = lowercase("" + value);
            value = !(
                v == "f" ||
                v == "0" ||
                v == "false" ||
                v == "no" ||
                v == "n" ||
                v == "[]"
            );
        } else {
            value = false;
        }
        return value;
    }

    /**
     * @returns {string} Returns the string representation of the element.
     */
    function startingTag(element) {
        element = jqLite(element).clone();
        try {
            // turns out IE does not let you set .html() on elements which
            // are not allowed to have children. So we just ignore it.
            element.empty();
        } catch (e) { }
        // As Per DOM Standards
        var TEXT_NODE = 3;
        var elemHtml = jqLite("<div>").append(element).html();
        try {
            return element[0].nodeType === TEXT_NODE
                ? lowercase(elemHtml)
                : elemHtml
                    .match(/^(<[^>]+>)/)[1]
                    .replace(/^<([\w\-]+)/, function (match, nodeName) {
                        return "<" + lowercase(nodeName);
                    });
        } catch (e) {
            return lowercase(elemHtml);
        }
    }

    /////////////////////////////////////////////////

    /**
     * Tries to decode the URI component without throwing an exception.
     *
     * @private
     * @param str value potential URI component to check.
     * @returns {boolean} True if `value` can be decoded
     * with the decodeURIComponent function.
     */
    function tryDecodeURIComponent(value) {
        try {
            return decodeURIComponent(value);
        } catch (e) {
            // Ignore any invalid uri component
        }
    }

    /**
     * Parses an escaped url query string into key-value pairs.
     * @returns Object.<(string|boolean)>
     */
    function parseKeyValue(/**string*/ keyValue) {
        var obj = {},
            key_value,
            key;
        forEach((keyValue || "").split("&"), function (keyValue) {
            if (keyValue) {
                key_value = keyValue.split("=");
                key = tryDecodeURIComponent(key_value[0]);
                if (isDefined(key)) {
                    var val = isDefined(key_value[1])
                        ? tryDecodeURIComponent(key_value[1])
                        : true;
                    if (!obj[key]) {
                        obj[key] = val;
                    } else if (isArray(obj[key])) {
                        obj[key].push(val);
                    } else {
                        obj[key] = [obj[key], val];
                    }
                }
            }
        });
        return obj;
    }

    function toKeyValue(obj) {
        var parts = [];
        forEach(obj, function (value, key) {
            if (isArray(value)) {
                forEach(value, function (arrayValue) {
                    parts.push(
                        encodeUriQuery(key, true) +
                        (arrayValue === true
                            ? ""
                            : "=" + encodeUriQuery(arrayValue, true)),
                    );
                });
            } else {
                parts.push(
                    encodeUriQuery(key, true) +
                    (value === true ? "" : "=" + encodeUriQuery(value, true)),
                );
            }
        });
        return parts.length ? parts.join("&") : "";
    }

    /**
     * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
     * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
     * segments:
     *    segment       = *pchar
     *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
     *    pct-encoded   = "%" HEXDIG HEXDIG
     *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
     *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
     *                     / "*" / "+" / "," / ";" / "="
     */
    function encodeUriSegment(val) {
        return encodeUriQuery(val, true)
            .replace(/%26/gi, "&")
            .replace(/%3D/gi, "=")
            .replace(/%2B/gi, "+");
    }

    /**
     * This method is intended for encoding *key* or *value* parts of query component. We need a custom
     * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
     * encoded per http://tools.ietf.org/html/rfc3986:
     *    query       = *( pchar / "/" / "?" )
     *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
     *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
     *    pct-encoded   = "%" HEXDIG HEXDIG
     *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
     *                     / "*" / "+" / "," / ";" / "="
     */
    function encodeUriQuery(val, pctEncodeSpaces) {
        return encodeURIComponent(val)
            .replace(/%40/gi, "@")
            .replace(/%3A/gi, ":")
            .replace(/%24/g, "$")
            .replace(/%2C/gi, ",")
            .replace(/%20/g, pctEncodeSpaces ? "%20" : "+");
    }

    /**
   * @ngdoc directive
   * @name ng.directive:ngApp
   *
   * @element ANY
   * @param {angular.Module} ngApp an optional application
   *   {@link angular.module module} name to load.
   *
   * @description
   *
   * Use this directive to **auto-bootstrap** an AngularJS application. The `ngApp` directive
   * designates the **root element** of the application and is typically placed near the root element
   * of the page - e.g. on the `<body>` or `<html>` tags.
   *
   * Only one AngularJS application can be auto-bootstrapped per HTML document. The first `ngApp`
   * found in the document will be used to define the root element to auto-bootstrap as an
   * application. To run multiple applications in an HTML document you must manually bootstrap them using
   * {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.
   *
   * You can specify an **AngularJS module** to be used as the root module for the application.  This
   * module will be loaded into the {@link AUTO.$injector} when the application is bootstrapped and
   * should contain the application code needed or have dependencies on other modules that will
   * contain the code. See {@link angular.module} for more information.
   *
   * In the example below if the `ngApp` directive were not placed on the `html` element then the
   * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
   * would not be resolved to `3`.
   *
   * `ngApp` is the easiest, and most common, way to bootstrap an application.
   *
   <example module="ngAppDemo">
     <file name="index.html">
     <div ng-controller="ngAppDemoController">
       I can add: {{a}} + {{b}} =  {{ a+b }}
     </file>
     <file name="script.js">
     angular.module('ngAppDemo', []).controller('ngAppDemoController', function($scope) {
       $scope.a = 1;
       $scope.b = 2;
     });
     </file>
   </example>
   *
   */
    function angularInit(element, bootstrap) {
        var elements = [element],
            appElement,
            module,
            names = ["ng:app", "ng-app", "x-ng-app", "data-ng-app"],
            NG_APP_CLASS_REGEXP = /\sng[:\-]app(:\s*([\w\d_]+);?)?\s/;

        function append(element) {
            element && elements.push(element);
        }

        forEach(names, function (name) {
            names[name] = true;
            append(document.getElementById(name));
            name = name.replace(":", "\\:");
            if (element.querySelectorAll) {
                forEach(element.querySelectorAll("." + name), append);
                forEach(element.querySelectorAll("." + name + "\\:"), append);
                forEach(element.querySelectorAll("[" + name + "]"), append);
            }
        });

        forEach(elements, function (element) {
            if (!appElement) {
                var className = " " + element.className + " ";
                var match = NG_APP_CLASS_REGEXP.exec(className);
                if (match) {
                    appElement = element;
                    module = (match[2] || "").replace(/\s+/g, ",");
                } else {
                    forEach(element.attributes, function (attr) {
                        if (!appElement && names[attr.name]) {
                            appElement = element;
                            module = attr.value;
                        }
                    });
                }
            }
        });
        if (appElement) {
            bootstrap(appElement, module ? [module] : []);
        }
    }

    /**
     * @ngdoc function
     * @name angular.bootstrap
     * @description
     * Use this function to manually start up angular application.
     *
     * See: {@link guide/bootstrap Bootstrap}
     *
     * Note that ngScenario-based end-to-end tests cannot use this function to bootstrap manually.
     * They must use {@link api/ng.directive:ngApp ngApp}.
     *
     * @param {Element} element DOM element which is the root of angular application.
     * @param {Array<String|Function|Array>=} modules an array of modules to load into the application.
     *     Each item in the array should be the name of a predefined module or a (DI annotated)
     *     function that will be invoked by the injector as a run block.
     *     See: {@link angular.module modules}
     * @returns {AUTO.$injector} Returns the newly created injector for this app.
     */
    function bootstrap(element, modules) {
        var doBootstrap = function () {
            element = jqLite(element);

            if (element.injector()) {
                var tag = element[0] === document ? "document" : startingTag(element);
                throw ngMinErr(
                    "btstrpd",
                    "App Already Bootstrapped with this Element '{0}'",
                    tag,
                );
            }

            modules = modules || [];
            modules.unshift([
                "$provide",
                function ($provide) {
                    $provide.value("$rootElement", element);
                },
            ]);
            modules.unshift("ng");
            var injector = createInjector(modules);
            injector.invoke([
                "$rootScope",
                "$rootElement",
                "$compile",
                "$injector",
                "$animate",
                function (scope, element, compile, injector, animate) {
                    scope.$apply(function () {
                        element.data("$injector", injector);
                        compile(element)(scope);
                    });
                },
            ]);
            return injector;
        };

        var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;

        if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
            return doBootstrap();
        }

        window.name = window.name.replace(NG_DEFER_BOOTSTRAP, "");
        angular.resumeBootstrap = function (extraModules) {
            forEach(extraModules, function (module) {
                modules.push(module);
            });
            doBootstrap();
        };
    }

    var SNAKE_CASE_REGEXP = /[A-Z]/g;
    function snake_case(name, separator) {
        separator = separator || "_";
        return name.replace(SNAKE_CASE_REGEXP, function (letter, pos) {
            return (pos ? separator : "") + letter.toLowerCase();
        });
    }

    function bindJQuery() {
        // bind to jQuery if present;
        jQuery = window.jQuery;
        // reset to jQuery or default to us.
        if (jQuery) {
            jqLite = jQuery;
            extend(jQuery.fn, {
                scope: JQLitePrototype.scope,
                isolateScope: JQLitePrototype.isolateScope,
                controller: JQLitePrototype.controller,
                injector: JQLitePrototype.injector,
                inheritedData: JQLitePrototype.inheritedData,
            });
            // Method signature:
            //     jqLitePatchJQueryRemove(name, dispatchThis, filterElems, getterIfNoArguments)
            jqLitePatchJQueryRemove("remove", true, true, false);
            jqLitePatchJQueryRemove("empty", false, false, false);
            jqLitePatchJQueryRemove("html", false, false, true);
        } else {
            jqLite = JQLite;
        }
        angular.element = jqLite;
    }

    /**
     * throw error if the argument is falsy.
     */
    function assertArg(arg, name, reason) {
        if (!arg) {
            throw ngMinErr(
                "areq",
                "Argument '{0}' is {1}",
                name || "?",
                reason || "required",
            );
        }
        return arg;
    }

    function assertArgFn(arg, name, acceptArrayAnnotation) {
        if (acceptArrayAnnotation && isArray(arg)) {
            arg = arg[arg.length - 1];
        }

        assertArg(
            isFunction(arg),
            name,
            "not a function, got " +
            (arg && typeof arg == "object"
                ? arg.constructor.name || "Object"
                : typeof arg),
        );
        return arg;
    }

    /**
     * throw error if the name given is hasOwnProperty
     * @param  {String} name    the name to test
     * @param  {String} context the context in which the name is used, such as module or directive
     */
    function assertNotHasOwnProperty(name, context) {
        if (name === "hasOwnProperty") {
            throw ngMinErr(
                "badname",
                "hasOwnProperty is not a valid {0} name",
                context,
            );
        }
    }

    /**
     * Return the value accessible from the object by path. Any undefined traversals are ignored
     * @param {Object} obj starting object
     * @param {string} path path to traverse
     * @param {boolean=true} bindFnToScope
     * @returns value as accessible by path
     */
    //TODO(misko): this function needs to be removed
    function getter(obj, path, bindFnToScope) {
        if (!path) return obj;
        var keys = path.split(".");
        var key;
        var lastInstance = obj;
        var len = keys.length;

        for (var i = 0; i < len; i++) {
            key = keys[i];
            if (obj) {
                obj = (lastInstance = obj)[key];
            }
        }
        if (!bindFnToScope && isFunction(obj)) {
            return bind(lastInstance, obj);
        }
        return obj;
    }

    /**
     * Return the DOM siblings between the first and last node in the given array.
     * @param {Array} array like object
     * @returns jQlite object containing the elements
     */
    function getBlockElements(nodes) {
        var startNode = nodes[0],
            endNode = nodes[nodes.length - 1];
        if (startNode === endNode) {
            return jqLite(startNode);
        }

        var element = startNode;
        var elements = [element];

        do {
            element = element.nextSibling;
            if (!element) break;
            elements.push(element);
        } while (element !== endNode);

        return jqLite(elements);
    }

    /**
     * @ngdoc interface
     * @name angular.Module
     * @description
     *
     * Interface for configuring angular {@link angular.module modules}.
     */

    function setupModuleLoader(window) {
        var $injectorMinErr = minErr("$injector");
        var ngMinErr = minErr("ng");

        function ensure(obj, name, factory) {
            return obj[name] || (obj[name] = factory());
        }

        var angular = ensure(window, "angular", Object);

        // We need to expose `angular.$$minErr` to modules such as `ngResource` that reference it during bootstrap
        angular.$$minErr = angular.$$minErr || minErr;

        return ensure(angular, "module", function () {
            /** @type {Object.<string, angular.Module>} */
            var modules = {};

            /**
             * @ngdoc function
             * @name angular.module
             * @description
             *
             * The `angular.module` is a global place for creating, registering and retrieving Angular
             * modules.
             * All modules (angular core or 3rd party) that should be available to an application must be
             * registered using this mechanism.
             *
             * When passed two or more arguments, a new module is created.  If passed only one argument, an
             * existing module (the name passed as the first argument to `module`) is retrieved.
             *
             *
             * # Module
             *
             * A module is a collection of services, directives, filters, and configuration information.
             * `angular.module` is used to configure the {@link AUTO.$injector $injector}.
             *
             * <pre>
             * // Create a new module
             * var myModule = angular.module('myModule', []);
             *
             * // register a new service
             * myModule.value('appName', 'MyCoolApp');
             *
             * // configure existing services inside initialization blocks.
             * myModule.config(function($locationProvider) {
             *   // Configure existing providers
             *   $locationProvider.hashPrefix('!');
             * });
             * </pre>
             *
             * Then you can create an injector and load your modules like this:
             *
             * <pre>
             * var injector = angular.injector(['ng', 'MyModule'])
             * </pre>
             *
             * However it's more likely that you'll just use
             * {@link ng.directive:ngApp ngApp} or
             * {@link angular.bootstrap} to simplify this process for you.
             *
             * @param {!string} name The name of the module to create or retrieve.
             * @param {Array.<string>=} requires If specified then new module is being created. If
             *        unspecified then the the module is being retrieved for further configuration.
             * @param {Function} configFn Optional configuration function for the module. Same as
             *        {@link angular.Module#methods_config Module#config()}.
             * @returns {module} new module with the {@link angular.Module} api.
             */
            return function module(name, requires, configFn) {
                var assertNotHasOwnProperty = function (name, context) {
                    if (name === "hasOwnProperty") {
                        throw ngMinErr(
                            "badname",
                            "hasOwnProperty is not a valid {0} name",
                            context,
                        );
                    }
                };

                assertNotHasOwnProperty(name, "module");
                if (requires && modules.hasOwnProperty(name)) {
                    modules[name] = null;
                }
                return ensure(modules, name, function () {
                    if (!requires) {
                        throw $injectorMinErr(
                            "nomod",
                            "Module '{0}' is not available! You either misspelled " +
                            "the module name or forgot to load it. If registering a module ensure that you " +
                            "specify the dependencies as the second argument.",
                            name,
                        );
                    }

                    /** @type {!Array.<Array.<*>>} */
                    var invokeQueue = [];

                    /** @type {!Array.<Function>} */
                    var runBlocks = [];

                    var config = invokeLater("$injector", "invoke");

                    /** @type {angular.Module} */
                    var moduleInstance = {
                        // Private state
                        _invokeQueue: invokeQueue,
                        _runBlocks: runBlocks,

                        /**
                         * @ngdoc property
                         * @name angular.Module#requires
                         * @propertyOf angular.Module
                         * @returns {Array.<string>} List of module names which must be loaded before this module.
                         * @description
                         * Holds the list of modules which the injector will load before the current module is
                         * loaded.
                         */
                        requires: requires,

                        /**
                         * @ngdoc property
                         * @name angular.Module#name
                         * @propertyOf angular.Module
                         * @returns {string} Name of the module.
                         * @description
                         */
                        name: name,

                        /**
                         * @ngdoc method
                         * @name angular.Module#provider
                         * @methodOf angular.Module
                         * @param {string} name service name
                         * @param {Function} providerType Construction function for creating new instance of the
                         *                                service.
                         * @description
                         * See {@link AUTO.$provide#provider $provide.provider()}.
                         */
                        provider: invokeLater("$provide", "provider"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#factory
                         * @methodOf angular.Module
                         * @param {string} name service name
                         * @param {Function} providerFunction Function for creating new instance of the service.
                         * @description
                         * See {@link AUTO.$provide#factory $provide.factory()}.
                         */
                        factory: invokeLater("$provide", "factory"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#service
                         * @methodOf angular.Module
                         * @param {string} name service name
                         * @param {Function} constructor A constructor function that will be instantiated.
                         * @description
                         * See {@link AUTO.$provide#service $provide.service()}.
                         */
                        service: invokeLater("$provide", "service"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#value
                         * @methodOf angular.Module
                         * @param {string} name service name
                         * @param {*} object Service instance object.
                         * @description
                         * See {@link AUTO.$provide#value $provide.value()}.
                         */
                        value: invokeLater("$provide", "value"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#constant
                         * @methodOf angular.Module
                         * @param {string} name constant name
                         * @param {*} object Constant value.
                         * @description
                         * Because the constant are fixed, they get applied before other provide methods.
                         * See {@link AUTO.$provide#constant $provide.constant()}.
                         */
                        constant: invokeLater("$provide", "constant", "unshift"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#animation
                         * @methodOf angular.Module
                         * @param {string} name animation name
                         * @param {Function} animationFactory Factory function for creating new instance of an
                         *                                    animation.
                         * @description
                         *
                         * **NOTE**: animations take effect only if the **ngAnimate** module is loaded.
                         *
                         *
                         * Defines an animation hook that can be later used with
                         * {@link ngAnimate.$animate $animate} service and directives that use this service.
                         *
                         * <pre>
                         * module.animation('.animation-name', function($inject1, $inject2) {
                         *   return {
                         *     eventName : function(element, done) {
                         *       //code to run the animation
                         *       //once complete, then run done()
                         *       return function cancellationFunction(element) {
                         *         //code to cancel the animation
                         *       }
                         *     }
                         *   }
                         * })
                         * </pre>
                         *
                         * See {@link ngAnimate.$animateProvider#register $animateProvider.register()} and
                         * {@link ngAnimate ngAnimate module} for more information.
                         */
                        animation: invokeLater("$animateProvider", "register"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#filter
                         * @methodOf angular.Module
                         * @param {string} name Filter name.
                         * @param {Function} filterFactory Factory function for creating new instance of filter.
                         * @description
                         * See {@link ng.$filterProvider#register $filterProvider.register()}.
                         */
                        filter: invokeLater("$filterProvider", "register"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#controller
                         * @methodOf angular.Module
                         * @param {string|Object} name Controller name, or an object map of controllers where the
                         *    keys are the names and the values are the constructors.
                         * @param {Function} constructor Controller constructor function.
                         * @description
                         * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
                         */
                        controller: invokeLater("$controllerProvider", "register"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#directive
                         * @methodOf angular.Module
                         * @param {string|Object} name Directive name, or an object map of directives where the
                         *    keys are the names and the values are the factories.
                         * @param {Function} directiveFactory Factory function for creating new instance of
                         * directives.
                         * @description
                         * See {@link ng.$compileProvider#methods_directive $compileProvider.directive()}.
                         */
                        directive: invokeLater("$compileProvider", "directive"),

                        /**
                         * @ngdoc method
                         * @name angular.Module#config
                         * @methodOf angular.Module
                         * @param {Function} configFn Execute this function on module load. Useful for service
                         *    configuration.
                         * @description
                         * Use this method to register work which needs to be performed on module loading.
                         */
                        config: config,

                        /**
                         * @ngdoc method
                         * @name angular.Module#run
                         * @methodOf angular.Module
                         * @param {Function} initializationFn Execute this function after injector creation.
                         *    Useful for application initialization.
                         * @description
                         * Use this method to register work which should be performed when the injector is done
                         * loading all modules.
                         */
                        run: function (block) {
                            runBlocks.push(block);
                            return this;
                        },
                    };

                    if (configFn) {
                        config(configFn);
                    }

                    return moduleInstance;

                    /**
                     * @param {string} provider
                     * @param {string} method
                     * @param {String=} insertMethod
                     * @returns {angular.Module}
                     */
                    function invokeLater(provider, method, insertMethod) {
                        return function () {
                            invokeQueue[insertMethod || "push"]([
                                provider,
                                method,
                                arguments,
                            ]);
                            return moduleInstance;
                        };
                    }
                });
            };
        });
    }

    /* global
      angularModule: true,
      version: true,
      
      $LocaleProvider,
      $CompileProvider,
      
      htmlAnchorDirective,
      inputDirective,
      inputDirective,
      formDirective,
      scriptDirective,
      selectDirective,
      styleDirective,
      optionDirective,
      ngBindDirective,
      ngBindHtmlDirective,
      ngBindTemplateDirective,
      ngClassDirective,
      ngClassEvenDirective,
      ngClassOddDirective,
      ngCspDirective,
      ngCloakDirective,
      ngControllerDirective,
      ngFormDirective,
      ngHideDirective,
      ngIfDirective,
      ngIncludeDirective,
      ngIncludeFillContentDirective,
      ngInitDirective,
      ngNonBindableDirective,
      ngPluralizeDirective,
      ngRepeatDirective,
      ngShowDirective,
      ngStyleDirective,
      ngSwitchDirective,
      ngSwitchWhenDirective,
      ngSwitchDefaultDirective,
      ngOptionsDirective,
      ngTranscludeDirective,
      ngModelDirective,
      ngListDirective,
      ngChangeDirective,
      requiredDirective,
      requiredDirective,
      ngValueDirective,
      ngAttributeAliasDirectives,
      ngEventDirectives,
  
      $AnchorScrollProvider,
      $AnimateProvider,
      $BrowserProvider,
      $CacheFactoryProvider,
      $ControllerProvider,
      $DocumentProvider,
      $ExceptionHandlerProvider,
      $FilterProvider,
      $InterpolateProvider,
      $IntervalProvider,
      $HttpProvider,
      $HttpBackendProvider,
      $LocationProvider,
      $LogProvider,
      $ParseProvider,
      $RootScopeProvider,
      $QProvider,
      $$SanitizeUriProvider,
      $SceProvider,
      $SceDelegateProvider,
      $SnifferProvider,
      $TemplateCacheProvider,
      $TimeoutProvider,
      $WindowProvider
  */

    /**
     * @ngdoc property
     * @name angular.version
     * @description
     * An object that contains information about the current AngularJS version. This object has the
     * following properties:
     *
     * - `full` – `{string}` – Full version string, such as "0.9.18".
     * - `major` – `{number}` – Major version number, such as "0".
     * - `minor` – `{number}` – Minor version number, such as "9".
     * - `dot` – `{number}` – Dot version number, such as "18".
     * - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
     */
    var version = {
        full: "1.2.5", // all of these placeholder strings will be replaced by grunt's
        major: 1, // package task
        minor: 2,
        dot: 5,
        codeName: "singularity-expansion",
    };

    function publishExternalAPI(angular) {
        extend(angular, {
            bootstrap: bootstrap,
            copy: copy,
            extend: extend,
            equals: equals,
            element: jqLite,
            forEach: forEach,
            injector: createInjector,
            noop: noop,
            bind: bind,
            toJson: toJson,
            fromJson: fromJson,
            identity: identity,
            isUndefined: isUndefined,
            isDefined: isDefined,
            isString: isString,
            isFunction: isFunction,
            isObject: isObject,
            isNumber: isNumber,
            isElement: isElement,
            isArray: isArray,
            version: version,
            isDate: isDate,
            lowercase: lowercase,
            uppercase: uppercase,
            callbacks: { counter: 0 },
            $$minErr: minErr,
            $$csp: csp,
        });

        angularModule = setupModuleLoader(window);
        try {
            angularModule("ngLocale");
        } catch (e) {
            angularModule("ngLocale", []).provider("$locale", $LocaleProvider);
        }

        angularModule(
            "ng",
            ["ngLocale"],
            [
                "$provide",
                function ngModule($provide) {
                    // $$sanitizeUriProvider needs to be before $compileProvider as it is used by it.
                    $provide.provider({
                        $$sanitizeUri: $$SanitizeUriProvider,
                    });
                    $provide
                        .provider("$compile", $CompileProvider)
                        .directive({
                            a: htmlAnchorDirective,
                            input: inputDirective,
                            textarea: inputDirective,
                            form: formDirective,
                            script: scriptDirective,
                            select: selectDirective,
                            style: styleDirective,
                            option: optionDirective,
                            ngBind: ngBindDirective,
                            ngBindHtml: ngBindHtmlDirective,
                            ngBindTemplate: ngBindTemplateDirective,
                            ngClass: ngClassDirective,
                            ngClassEven: ngClassEvenDirective,
                            ngClassOdd: ngClassOddDirective,
                            ngCloak: ngCloakDirective,
                            ngController: ngControllerDirective,
                            ngForm: ngFormDirective,
                            ngHide: ngHideDirective,
                            ngIf: ngIfDirective,
                            ngInclude: ngIncludeDirective,
                            ngInit: ngInitDirective,
                            ngNonBindable: ngNonBindableDirective,
                            ngPluralize: ngPluralizeDirective,
                            ngRepeat: ngRepeatDirective,
                            ngShow: ngShowDirective,
                            ngStyle: ngStyleDirective,
                            ngSwitch: ngSwitchDirective,
                            ngSwitchWhen: ngSwitchWhenDirective,
                            ngSwitchDefault: ngSwitchDefaultDirective,
                            ngOptions: ngOptionsDirective,
                            ngTransclude: ngTranscludeDirective,
                            ngModel: ngModelDirective,
                            ngList: ngListDirective,
                            ngChange: ngChangeDirective,
                            required: requiredDirective,
                            ngRequired: requiredDirective,
                            ngValue: ngValueDirective,
                        })
                        .directive({
                            ngInclude: ngIncludeFillContentDirective,
                        })
                        .directive(ngAttributeAliasDirectives)
                        .directive(ngEventDirectives);
                    $provide.provider({
                        $anchorScroll: $AnchorScrollProvider,
                        $animate: $AnimateProvider,
                        $browser: $BrowserProvider,
                        $cacheFactory: $CacheFactoryProvider,
                        $controller: $ControllerProvider,
                        $document: $DocumentProvider,
                        $exceptionHandler: $ExceptionHandlerProvider,
                        $filter: $FilterProvider,
                        $interpolate: $InterpolateProvider,
                        $interval: $IntervalProvider,
                        $http: $HttpProvider,
                        $httpBackend: $HttpBackendProvider,
                        $location: $LocationProvider,
                        $log: $LogProvider,
                        $parse: $ParseProvider,
                        $rootScope: $RootScopeProvider,
                        $q: $QProvider,
                        $sce: $SceProvider,
                        $sceDelegate: $SceDelegateProvider,
                        $sniffer: $SnifferProvider,
                        $templateCache: $TemplateCacheProvider,
                        $timeout: $TimeoutProvider,
                        $window: $WindowProvider,
                    });
                },
            ],
        );
    }

    /* global
  
    -JQLitePrototype,
    -addEventListenerFn,
    -removeEventListenerFn,
    -BOOLEAN_ATTR
  */

    //////////////////////////////////
    //JQLite
    //////////////////////////////////

    /**
     * @ngdoc function
     * @name angular.element
     * @function
     *
     * @description
     * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
     *
     * If jQuery is available, `angular.element` is an alias for the
     * [jQuery](http://api.jquery.com/jQuery/) function. If jQuery is not available, `angular.element`
     * delegates to Angular's built-in subset of jQuery, called "jQuery lite" or "jqLite."
     *
     * <div class="alert alert-success">jqLite is a tiny, API-compatible subset of jQuery that allows
     * Angular to manipulate the DOM in a cross-browser compatible way. **jqLite** implements only the most
     * commonly needed functionality with the goal of having a very small footprint.</div>
     *
     * To use jQuery, simply load it before `DOMContentLoaded` event fired.
     *
     * <div class="alert">**Note:** all element references in Angular are always wrapped with jQuery or
     * jqLite; they are never raw DOM references.</div>
     *
     * ## Angular's jqLite
     * jqLite provides only the following jQuery methods:
     *
     * - [`addClass()`](http://api.jquery.com/addClass/)
     * - [`after()`](http://api.jquery.com/after/)
     * - [`append()`](http://api.jquery.com/append/)
     * - [`attr()`](http://api.jquery.com/attr/)
     * - [`bind()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
     * - [`children()`](http://api.jquery.com/children/) - Does not support selectors
     * - [`clone()`](http://api.jquery.com/clone/)
     * - [`contents()`](http://api.jquery.com/contents/)
     * - [`css()`](http://api.jquery.com/css/)
     * - [`data()`](http://api.jquery.com/data/)
     * - [`empty()`](http://api.jquery.com/empty/)
     * - [`eq()`](http://api.jquery.com/eq/)
     * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
     * - [`hasClass()`](http://api.jquery.com/hasClass/)
     * - [`html()`](http://api.jquery.com/html/)
     * - [`next()`](http://api.jquery.com/next/) - Does not support selectors
     * - [`on()`](http://api.jquery.com/on/) - Does not support namespaces, selectors or eventData
     * - [`off()`](http://api.jquery.com/off/) - Does not support namespaces or selectors
     * - [`parent()`](http://api.jquery.com/parent/) - Does not support selectors
     * - [`prepend()`](http://api.jquery.com/prepend/)
     * - [`prop()`](http://api.jquery.com/prop/)
     * - [`ready()`](http://api.jquery.com/ready/)
     * - [`remove()`](http://api.jquery.com/remove/)
     * - [`removeAttr()`](http://api.jquery.com/removeAttr/)
     * - [`removeClass()`](http://api.jquery.com/removeClass/)
     * - [`removeData()`](http://api.jquery.com/removeData/)
     * - [`replaceWith()`](http://api.jquery.com/replaceWith/)
     * - [`text()`](http://api.jquery.com/text/)
     * - [`toggleClass()`](http://api.jquery.com/toggleClass/)
     * - [`triggerHandler()`](http://api.jquery.com/triggerHandler/) - Passes a dummy event object to handlers.
     * - [`unbind()`](http://api.jquery.com/off/) - Does not support namespaces
     * - [`val()`](http://api.jquery.com/val/)
     * - [`wrap()`](http://api.jquery.com/wrap/)
     *
     * ## jQuery/jqLite Extras
     * Angular also provides the following additional methods and events to both jQuery and jqLite:
     *
     * ### Events
     * - `$destroy` - AngularJS intercepts all jqLite/jQuery's DOM destruction apis and fires this event
     *    on all DOM nodes being removed.  This can be used to clean up any 3rd party bindings to the DOM
     *    element before it is removed.
     *
     * ### Methods
     * - `controller(name)` - retrieves the controller of the current element or its parent. By default
     *   retrieves controller associated with the `ngController` directive. If `name` is provided as
     *   camelCase directive name, then the controller for this directive will be retrieved (e.g.
     *   `'ngModel'`).
     * - `injector()` - retrieves the injector of the current element or its parent.
     * - `scope()` - retrieves the {@link api/ng.$rootScope.Scope scope} of the current
     *   element or its parent.
     * - `isolateScope()` - retrieves an isolate {@link api/ng.$rootScope.Scope scope} if one is attached directly to the
     *   current element. This getter should be used only on elements that contain a directive which starts a new isolate
     *   scope. Calling `scope()` on this element always returns the original non-isolate scope.
     * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
     *   parent element is reached.
     *
     * @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
     * @returns {Object} jQuery object.
     */

    var jqCache = (JQLite.cache = {}),
        jqName = (JQLite.expando = "ng-" + new Date().getTime()),
        jqId = 1,
        addEventListenerFn = window.document.addEventListener
            ? function (element, type, fn) {
                element.addEventListener(type, fn, false);
            }
            : function (element, type, fn) {
                element.attachEvent("on" + type, fn);
            },
        removeEventListenerFn = window.document.removeEventListener
            ? function (element, type, fn) {
                element.removeEventListener(type, fn, false);
            }
            : function (element, type, fn) {
                element.detachEvent("on" + type, fn);
            };

    function jqNextId() {
        return ++jqId;
    }

    var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
    var MOZ_HACK_REGEXP = /^moz([A-Z])/;
    var jqLiteMinErr = minErr("jqLite");

    /**
     * Converts snake_case to camelCase.
     * Also there is special case for Moz prefix starting with upper case letter.
     * @param name Name to normalize
     */
    function camelCase(name) {
        return name
            .replace(SPECIAL_CHARS_REGEXP, function (_, separator, letter, offset) {
                return offset ? letter.toUpperCase() : letter;
            })
            .replace(MOZ_HACK_REGEXP, "Moz$1");
    }

    /////////////////////////////////////////////
    // jQuery mutation patch
    //
    // In conjunction with bindJQuery intercepts all jQuery's DOM destruction apis and fires a
    // $destroy event on all DOM nodes being removed.
    //
    /////////////////////////////////////////////

    function jqLitePatchJQueryRemove(
        name,
        dispatchThis,
        filterElems,
        getterIfNoArguments,
    ) {
        var originalJqFn = jQuery.fn[name];
        originalJqFn = originalJqFn.$original || originalJqFn;
        removePatch.$original = originalJqFn;
        jQuery.fn[name] = removePatch;

        function removePatch(param) {
            // jshint -W040
            var list = filterElems && param ? [this.filter(param)] : [this],
                fireEvent = dispatchThis,
                set,
                setIndex,
                setLength,
                element,
                childIndex,
                childLength,
                children;

            if (!getterIfNoArguments || param != null) {
                while (list.length) {
                    set = list.shift();
                    for (
                        setIndex = 0, setLength = set.length;
                        setIndex < setLength;
                        setIndex++
                    ) {
                        element = jqLite(set[setIndex]);
                        if (fireEvent) {
                            element.triggerHandler("$destroy");
                        } else {
                            fireEvent = !fireEvent;
                        }
                        for (
                            childIndex = 0,
                            childLength = (children = element.children()).length;
                            childIndex < childLength;
                            childIndex++
                        ) {
                            list.push(jQuery(children[childIndex]));
                        }
                    }
                }
            }
            return originalJqFn.apply(this, arguments);
        }
    }

    /////////////////////////////////////////////
    function JQLite(element) {
        if (element instanceof JQLite) {
            return element;
        }
        if (!(this instanceof JQLite)) {
            if (isString(element) && element.charAt(0) != "<") {
                throw jqLiteMinErr(
                    "nosel",
                    "Looking up elements via selectors is not supported by jqLite! See: http://docs.angularjs.org/api/angular.element",
                );
            }
            return new JQLite(element);
        }

        if (isString(element)) {
            var div = document.createElement("div");
            // Read about the NoScope elements here:
            // http://msdn.microsoft.com/en-us/library/ms533897(VS.85).aspx
            div.innerHTML = "<div>&#160;</div>" + element; // IE insanity to make NoScope elements work!
            div.removeChild(div.firstChild); // remove the superfluous div
            jqLiteAddNodes(this, div.childNodes);
            var fragment = jqLite(document.createDocumentFragment());
            fragment.append(this); // detach the elements from the temporary DOM div.
        } else {
            jqLiteAddNodes(this, element);
        }
    }

    function jqLiteClone(element) {
        return element.cloneNode(true);
    }

    function jqLiteDealoc(element) {
        jqLiteRemoveData(element);
        for (
            var i = 0, children = element.childNodes || [];
            i < children.length;
            i++
        ) {
            jqLiteDealoc(children[i]);
        }
    }

    function jqLiteOff(element, type, fn, unsupported) {
        if (isDefined(unsupported))
            throw jqLiteMinErr(
                "offargs",
                "jqLite#off() does not support the `selector` argument",
            );

        var events = jqLiteExpandoStore(element, "events"),
            handle = jqLiteExpandoStore(element, "handle");

        if (!handle) return; //no listeners registered

        if (isUndefined(type)) {
            forEach(events, function (eventHandler, type) {
                removeEventListenerFn(element, type, eventHandler);
                delete events[type];
            });
        } else {
            forEach(type.split(" "), function (type) {
                if (isUndefined(fn)) {
                    removeEventListenerFn(element, type, events[type]);
                    delete events[type];
                } else {
                    arrayRemove(events[type] || [], fn);
                }
            });
        }
    }

    function jqLiteRemoveData(element, name) {
        var expandoId = element[jqName],
            expandoStore = jqCache[expandoId];

        if (expandoStore) {
            if (name) {
                delete jqCache[expandoId].data[name];
                return;
            }

            if (expandoStore.handle) {
                expandoStore.events.$destroy && expandoStore.handle({}, "$destroy");
                jqLiteOff(element);
            }
            delete jqCache[expandoId];
            element[jqName] = undefined; // ie does not allow deletion of attributes on elements.
        }
    }

    function jqLiteExpandoStore(element, key, value) {
        var expandoId = element[jqName],
            expandoStore = jqCache[expandoId || -1];

        if (isDefined(value)) {
            if (!expandoStore) {
                element[jqName] = expandoId = jqNextId();
                expandoStore = jqCache[expandoId] = {};
            }
            expandoStore[key] = value;
        } else {
            return expandoStore && expandoStore[key];
        }
    }

    function jqLiteData(element, key, value) {
        var data = jqLiteExpandoStore(element, "data"),
            isSetter = isDefined(value),
            keyDefined = !isSetter && isDefined(key),
            isSimpleGetter = keyDefined && !isObject(key);

        if (!data && !isSimpleGetter) {
            jqLiteExpandoStore(element, "data", (data = {}));
        }

        if (isSetter) {
            data[key] = value;
        } else {
            if (keyDefined) {
                if (isSimpleGetter) {
                    // don't create data in this case.
                    return data && data[key];
                } else {
                    extend(data, key);
                }
            } else {
                return data;
            }
        }
    }

    function jqLiteHasClass(element, selector) {
        if (!element.getAttribute) return false;
        return (
            (" " + (element.getAttribute("class") || "") + " ")
                .replace(/[\n\t]/g, " ")
                .indexOf(" " + selector + " ") > -1
        );
    }

    function jqLiteRemoveClass(element, cssClasses) {
        if (cssClasses && element.setAttribute) {
            forEach(cssClasses.split(" "), function (cssClass) {
                element.setAttribute(
                    "class",
                    trim(
                        (" " + (element.getAttribute("class") || "") + " ")
                            .replace(/[\n\t]/g, " ")
                            .replace(" " + trim(cssClass) + " ", " "),
                    ),
                );
            });
        }
    }

    function jqLiteAddClass(element, cssClasses) {
        if (cssClasses && element.setAttribute) {
            var existingClasses = (
                " " +
                (element.getAttribute("class") || "") +
                " "
            ).replace(/[\n\t]/g, " ");

            forEach(cssClasses.split(" "), function (cssClass) {
                cssClass = trim(cssClass);
                if (existingClasses.indexOf(" " + cssClass + " ") === -1) {
                    existingClasses += cssClass + " ";
                }
            });

            element.setAttribute("class", trim(existingClasses));
        }
    }

    function jqLiteAddNodes(root, elements) {
        if (elements) {
            elements =
                !elements.nodeName && isDefined(elements.length) && !isWindow(elements)
                    ? elements
                    : [elements];
            for (var i = 0; i < elements.length; i++) {
                root.push(elements[i]);
            }
        }
    }

    function jqLiteController(element, name) {
        return jqLiteInheritedData(
            element,
            "$" + (name || "ngController") + "Controller",
        );
    }

    function jqLiteInheritedData(element, name, value) {
        element = jqLite(element);

        // if element is the document object work with the html element instead
        // this makes $(document).scope() possible
        if (element[0].nodeType == 9) {
            element = element.find("html");
        }
        var names = isArray(name) ? name : [name];

        while (element.length) {
            for (var i = 0, ii = names.length; i < ii; i++) {
                if ((value = element.data(names[i])) !== undefined) return value;
            }
            element = element.parent();
        }
    }

    function jqLiteEmpty(element) {
        for (
            var i = 0, childNodes = element.childNodes;
            i < childNodes.length;
            i++
        ) {
            jqLiteDealoc(childNodes[i]);
        }
        while (element.firstChild) {
            element.removeChild(element.firstChild);
        }
    }

    //////////////////////////////////////////
    // Functions which are declared directly.
    //////////////////////////////////////////
    var JQLitePrototype = (JQLite.prototype = {
        ready: function (fn) {
            var fired = false;

            function trigger() {
                if (fired) return;
                fired = true;
                fn();
            }

            // check if document already is loaded
            if (document.readyState === "complete") {
                setTimeout(trigger);
            } else {
                this.on("DOMContentLoaded", trigger); // works for modern browsers and IE9
                // we can not use jqLite since we are not done loading and jQuery could be loaded later.
                // jshint -W064
                JQLite(window).on("load", trigger); // fallback to window.onload for others
                // jshint +W064
            }
        },
        toString: function () {
            var value = [];
            forEach(this, function (e) {
                value.push("" + e);
            });
            return "[" + value.join(", ") + "]";
        },

        eq: function (index) {
            return index >= 0
                ? jqLite(this[index])
                : jqLite(this[this.length + index]);
        },

        length: 0,
        push: push,
        sort: [].sort,
        splice: [].splice,
    });

    //////////////////////////////////////////
    // Functions iterating getter/setters.
    // these functions return self on setter and
    // value on get.
    //////////////////////////////////////////
    var BOOLEAN_ATTR = {};
    forEach(
        "multiple,selected,checked,disabled,readOnly,required,open".split(","),
        function (value) {
            BOOLEAN_ATTR[lowercase(value)] = value;
        },
    );
    var BOOLEAN_ELEMENTS = {};
    forEach(
        "input,select,option,textarea,button,form,details".split(","),
        function (value) {
            BOOLEAN_ELEMENTS[uppercase(value)] = true;
        },
    );

    function getBooleanAttrName(element, name) {
        // check dom last since we will most likely fail on name
        var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];

        // booleanAttr is here twice to minimize DOM access
        return booleanAttr && BOOLEAN_ELEMENTS[element.nodeName] && booleanAttr;
    }

    forEach(
        {
            data: jqLiteData,
            inheritedData: jqLiteInheritedData,

            scope: function (element) {
                // Can't use jqLiteData here directly so we stay compatible with jQuery!
                return (
                    jqLite(element).data("$scope") ||
                    jqLiteInheritedData(element.parentNode || element, [
                        "$isolateScope",
                        "$scope",
                    ])
                );
            },

            isolateScope: function (element) {
                // Can't use jqLiteData here directly so we stay compatible with jQuery!
                return (
                    jqLite(element).data("$isolateScope") ||
                    jqLite(element).data("$isolateScopeNoTemplate")
                );
            },

            controller: jqLiteController,

            injector: function (element) {
                return jqLiteInheritedData(element, "$injector");
            },

            removeAttr: function (element, name) {
                element.removeAttribute(name);
            },

            hasClass: jqLiteHasClass,

            css: function (element, name, value) {
                name = camelCase(name);

                if (isDefined(value)) {
                    element.style[name] = value;
                } else {
                    var val;

                    if (msie <= 8) {
                        // this is some IE specific weirdness that jQuery 1.6.4 does not sure why
                        val = element.currentStyle && element.currentStyle[name];
                        if (val === "") val = "auto";
                    }

                    val = val || element.style[name];

                    if (msie <= 8) {
                        // jquery weirdness :-/
                        val = val === "" ? undefined : val;
                    }

                    return val;
                }
            },

            attr: function (element, name, value) {
                var lowercasedName = lowercase(name);
                if (BOOLEAN_ATTR[lowercasedName]) {
                    if (isDefined(value)) {
                        if (!!value) {
                            element[name] = true;
                            element.setAttribute(name, lowercasedName);
                        } else {
                            element[name] = false;
                            element.removeAttribute(lowercasedName);
                        }
                    } else {
                        return element[name] ||
                            (element.attributes.getNamedItem(name) || noop).specified
                            ? lowercasedName
                            : undefined;
                    }
                } else if (isDefined(value)) {
                    element.setAttribute(name, value);
                } else if (element.getAttribute) {
                    // the extra argument "2" is to get the right thing for a.href in IE, see jQuery code
                    // some elements (e.g. Document) don't have get attribute, so return undefined
                    var ret = element.getAttribute(name, 2);
                    // normalize non-existing attributes to undefined (as jQuery)
                    return ret === null ? undefined : ret;
                }
            },

            prop: function (element, name, value) {
                if (isDefined(value)) {
                    element[name] = value;
                } else {
                    return element[name];
                }
            },

            text: (function () {
                var NODE_TYPE_TEXT_PROPERTY = [];
                if (msie < 9) {
                    NODE_TYPE_TEXT_PROPERTY[1] = "innerText"; /** Element **/
                    NODE_TYPE_TEXT_PROPERTY[3] = "nodeValue"; /** Text **/
                } else {
                    NODE_TYPE_TEXT_PROPERTY[1] =
                        /** Element **/
                        NODE_TYPE_TEXT_PROPERTY[3] = "textContent"; /** Text **/
                }
                getText.$dv = "";
                return getText;

                function getText(element, value) {
                    var textProp = NODE_TYPE_TEXT_PROPERTY[element.nodeType];
                    if (isUndefined(value)) {
                        return textProp ? element[textProp] : "";
                    }
                    element[textProp] = value;
                }
            })(),

            val: function (element, value) {
                if (isUndefined(value)) {
                    if (nodeName_(element) === "SELECT" && element.multiple) {
                        var result = [];
                        forEach(element.options, function (option) {
                            if (option.selected) {
                                result.push(option.value || option.text);
                            }
                        });
                        return result.length === 0 ? null : result;
                    }
                    return element.value;
                }
                element.value = value;
            },

            html: function (element, value) {
                if (isUndefined(value)) {
                    return element.innerHTML;
                }
                for (
                    var i = 0, childNodes = element.childNodes;
                    i < childNodes.length;
                    i++
                ) {
                    jqLiteDealoc(childNodes[i]);
                }
                element.innerHTML = value;
            },

            empty: jqLiteEmpty,
        },
        function (fn, name) {
            /**
             * Properties: writes return selection, reads return first value
             */
            JQLite.prototype[name] = function (arg1, arg2) {
                var i, key;

                // jqLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it
                // in a way that survives minification.
                // jqLiteEmpty takes no arguments but is a setter.
                if (
                    fn !== jqLiteEmpty &&
                    (fn.length == 2 && fn !== jqLiteHasClass && fn !== jqLiteController
                        ? arg1
                        : arg2) === undefined
                ) {
                    if (isObject(arg1)) {
                        // we are a write, but the object properties are the key/values
                        for (i = 0; i < this.length; i++) {
                            if (fn === jqLiteData) {
                                // data() takes the whole object in jQuery
                                fn(this[i], arg1);
                            } else {
                                for (key in arg1) {
                                    fn(this[i], key, arg1[key]);
                                }
                            }
                        }
                        // return self for chaining
                        return this;
                    } else {
                        // we are a read, so read the first child.
                        var value = fn.$dv;
                        // Only if we have $dv do we iterate over all, otherwise it is just the first element.
                        var jj =
                            value === undefined ? Math.min(this.length, 1) : this.length;
                        for (var j = 0; j < jj; j++) {
                            var nodeValue = fn(this[j], arg1, arg2);
                            value = value ? value + nodeValue : nodeValue;
                        }
                        return value;
                    }
                } else {
                    // we are a write, so apply to all children
                    for (i = 0; i < this.length; i++) {
                        fn(this[i], arg1, arg2);
                    }
                    // return self for chaining
                    return this;
                }
            };
        },
    );

    function createEventHandler(element, events) {
        var eventHandler = function (event, type) {
            if (!event.preventDefault) {
                event.preventDefault = function () {
                    event.returnValue = false; //ie
                };
            }

            if (!event.stopPropagation) {
                event.stopPropagation = function () {
                    event.cancelBubble = true; //ie
                };
            }

            if (!event.target) {
                event.target = event.srcElement || document;
            }

            if (isUndefined(event.defaultPrevented)) {
                var prevent = event.preventDefault;
                event.preventDefault = function () {
                    event.defaultPrevented = true;
                    prevent.call(event);
                };
                event.defaultPrevented = false;
            }

            event.isDefaultPrevented = function () {
                return event.defaultPrevented || event.returnValue === false;
            };

            forEach(events[type || event.type], function (fn) {
                fn.call(element, event);
            });

            // Remove monkey-patched methods (IE),
            // as they would cause memory leaks in IE8.
            if (msie <= 8) {
                // IE7/8 does not allow to delete property on native object
                event.preventDefault = null;
                event.stopPropagation = null;
                event.isDefaultPrevented = null;
            } else {
                // It shouldn't affect normal browsers (native methods are defined on prototype).
                delete event.preventDefault;
                delete event.stopPropagation;
                delete event.isDefaultPrevented;
            }
        };
        eventHandler.elem = element;
        return eventHandler;
    }

    //////////////////////////////////////////
    // Functions iterating traversal.
    // These functions chain results into a single
    // selector.
    //////////////////////////////////////////
    forEach(
        {
            removeData: jqLiteRemoveData,

            dealoc: jqLiteDealoc,

            on: function onFn(element, type, fn, unsupported) {
                if (isDefined(unsupported))
                    throw jqLiteMinErr(
                        "onargs",
                        "jqLite#on() does not support the `selector` or `eventData` parameters",
                    );

                var events = jqLiteExpandoStore(element, "events"),
                    handle = jqLiteExpandoStore(element, "handle");

                if (!events) jqLiteExpandoStore(element, "events", (events = {}));
                if (!handle)
                    jqLiteExpandoStore(
                        element,
                        "handle",
                        (handle = createEventHandler(element, events)),
                    );

                forEach(type.split(" "), function (type) {
                    var eventFns = events[type];

                    if (!eventFns) {
                        if (type == "mouseenter" || type == "mouseleave") {
                            var contains =
                                document.body.contains || document.body.compareDocumentPosition
                                    ? function (a, b) {
                                        // jshint bitwise: false
                                        var adown = a.nodeType === 9 ? a.documentElement : a,
                                            bup = b && b.parentNode;
                                        return (
                                            a === bup ||
                                            !!(
                                                bup &&
                                                bup.nodeType === 1 &&
                                                (adown.contains
                                                    ? adown.contains(bup)
                                                    : a.compareDocumentPosition &&
                                                    a.compareDocumentPosition(bup) & 16)
                                            )
                                        );
                                    }
                                    : function (a, b) {
                                        if (b) {
                                            while ((b = b.parentNode)) {
                                                if (b === a) {
                                                    return true;
                                                }
                                            }
                                        }
                                        return false;
                                    };

                            events[type] = [];

                            // Refer to jQuery's implementation of mouseenter & mouseleave
                            // Read about mouseenter and mouseleave:
                            // http://www.quirksmode.org/js/events_mouse.html#link8
                            var eventmap = {
                                mouseleave: "mouseout",
                                mouseenter: "mouseover",
                            };

                            onFn(element, eventmap[type], function (event) {
                                var target = this,
                                    related = event.relatedTarget;
                                // For mousenter/leave call the handler if related is outside the target.
                                // NB: No relatedTarget if the mouse left/entered the browser window
                                if (
                                    !related ||
                                    (related !== target && !contains(target, related))
                                ) {
                                    handle(event, type);
                                }
                            });
                        } else {
                            addEventListenerFn(element, type, handle);
                            events[type] = [];
                        }
                        eventFns = events[type];
                    }
                    eventFns.push(fn);
                });
            },

            off: jqLiteOff,

            replaceWith: function (element, replaceNode) {
                var index,
                    parent = element.parentNode;
                jqLiteDealoc(element);
                forEach(new JQLite(replaceNode), function (node) {
                    if (index) {
                        parent.insertBefore(node, index.nextSibling);
                    } else {
                        parent.replaceChild(node, element);
                    }
                    index = node;
                });
            },

            children: function (element) {
                var children = [];
                forEach(element.childNodes, function (element) {
                    if (element.nodeType === 1) children.push(element);
                });
                return children;
            },

            contents: function (element) {
                return element.childNodes || [];
            },

            append: function (element, node) {
                forEach(new JQLite(node), function (child) {
                    if (element.nodeType === 1 || element.nodeType === 11) {
                        element.appendChild(child);
                    }
                });
            },

            prepend: function (element, node) {
                if (element.nodeType === 1) {
                    var index = element.firstChild;
                    forEach(new JQLite(node), function (child) {
                        element.insertBefore(child, index);
                    });
                }
            },

            wrap: function (element, wrapNode) {
                wrapNode = jqLite(wrapNode)[0];
                var parent = element.parentNode;
                if (parent) {
                    parent.replaceChild(wrapNode, element);
                }
                wrapNode.appendChild(element);
            },

            remove: function (element) {
                jqLiteDealoc(element);
                var parent = element.parentNode;
                if (parent) parent.removeChild(element);
            },

            after: function (element, newElement) {
                var index = element,
                    parent = element.parentNode;
                forEach(new JQLite(newElement), function (node) {
                    parent.insertBefore(node, index.nextSibling);
                    index = node;
                });
            },

            addClass: jqLiteAddClass,
            removeClass: jqLiteRemoveClass,

            toggleClass: function (element, selector, condition) {
                if (isUndefined(condition)) {
                    condition = !jqLiteHasClass(element, selector);
                }
                (condition ? jqLiteAddClass : jqLiteRemoveClass)(element, selector);
            },

            parent: function (element) {
                var parent = element.parentNode;
                return parent && parent.nodeType !== 11 ? parent : null;
            },

            next: function (element) {
                if (element.nextElementSibling) {
                    return element.nextElementSibling;
                }

                // IE8 doesn't have nextElementSibling
                var elm = element.nextSibling;
                while (elm != null && elm.nodeType !== 1) {
                    elm = elm.nextSibling;
                }
                return elm;
            },

            find: function (element, selector) {
                if (element.getElementsByTagName) {
                    return element.getElementsByTagName(selector);
                } else {
                    return [];
                }
            },

            clone: jqLiteClone,

            triggerHandler: function (element, eventName, eventData) {
                var eventFns = (jqLiteExpandoStore(element, "events") || {})[eventName];

                eventData = eventData || [];

                var event = [
                    {
                        preventDefault: noop,
                        stopPropagation: noop,
                    },
                ];

                forEach(eventFns, function (fn) {
                    fn.apply(element, event.concat(eventData));
                });
            },
        },
        function (fn, name) {
            /**
             * chaining functions
             */
            JQLite.prototype[name] = function (arg1, arg2, arg3) {
                var value;
                for (var i = 0; i < this.length; i++) {
                    if (isUndefined(value)) {
                        value = fn(this[i], arg1, arg2, arg3);
                        if (isDefined(value)) {
                            // any function which returns a value needs to be wrapped
                            value = jqLite(value);
                        }
                    } else {
                        jqLiteAddNodes(value, fn(this[i], arg1, arg2, arg3));
                    }
                }
                return isDefined(value) ? value : this;
            };

            // bind legacy bind/unbind to on/off
            JQLite.prototype.bind = JQLite.prototype.on;
            JQLite.prototype.unbind = JQLite.prototype.off;
        },
    );

    /**
     * Computes a hash of an 'obj'.
     * Hash of a:
     *  string is string
     *  number is number as string
     *  object is either result of calling $$hashKey function on the object or uniquely generated id,
     *         that is also assigned to the $$hashKey property of the object.
     *
     * @param obj
     * @returns {string} hash string such that the same input will have the same hash string.
     *         The resulting string key is in 'type:hashKey' format.
     */
    function hashKey(obj) {
        var objType = typeof obj,
            key;

        if (objType == "object" && obj !== null) {
            if (typeof (key = obj.$$hashKey) == "function") {
                // must invoke on object to keep the right this
                key = obj.$$hashKey();
            } else if (key === undefined) {
                key = obj.$$hashKey = nextUid();
            }
        } else {
            key = obj;
        }

        return objType + ":" + key;
    }

    /**
     * HashMap which can use objects as keys
     */
    function HashMap(array) {
        forEach(array, this.put, this);
    }
    HashMap.prototype = {
        /**
         * Store key value pair
         * @param key key to store can be any type
         * @param value value to store can be any type
         */
        put: function (key, value) {
            this[hashKey(key)] = value;
        },

        /**
         * @param key
         * @returns the value for the key
         */
        get: function (key) {
            return this[hashKey(key)];
        },

        /**
         * Remove the key/value pair
         * @param key
         */
        remove: function (key) {
            var value = this[(key = hashKey(key))];
            delete this[key];
            return value;
        },
    };

    /**
   * @ngdoc function
   * @name angular.injector
   * @function
   *
   * @description
   * Creates an injector function that can be used for retrieving services as well as for
   * dependency injection (see {@link guide/di dependency injection}).
   *
  
   * @param {Array.<string|Function>} modules A list of module functions or their aliases. See
   *        {@link angular.module}. The `ng` module must be explicitly added.
   * @returns {function()} Injector function. See {@link AUTO.$injector $injector}.
   *
   * @example
   * Typical usage
   * <pre>
   *   // create an injector
   *   var $injector = angular.injector(['ng']);
   *
   *   // use the injector to kick off your application
   *   // use the type inference to auto inject arguments, or use implicit injection
   *   $injector.invoke(function($rootScope, $compile, $document){
   *     $compile($document)($rootScope);
   *     $rootScope.$digest();
   *   });
   * </pre>
   *
   * Sometimes you want to get access to the injector of a currently running Angular app
   * from outside Angular. Perhaps, you want to inject and compile some markup after the
   * application has been bootstrapped. You can do this using extra `injector()` added
   * to JQuery/jqLite elements. See {@link angular.element}.
   *
   * *This is fairly rare but could be the case if a third party library is injecting the
   * markup.*
   *
   * In the following example a new block of HTML containing a `ng-controller`
   * directive is added to the end of the document body by JQuery. We then compile and link
   * it into the current AngularJS scope.
   *
   * <pre>
   * var $div = $('<div ng-controller="MyCtrl">{{content.label}}</div>');
   * $(document.body).append($div);
   *
   * angular.element(document).injector().invoke(function($compile) {
   *   var scope = angular.element($div).scope();
   *   $compile($div)(scope);
   * });
   * </pre>
   */

    /**
     * @ngdoc overview
     * @name AUTO
     * @description
     *
     * Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.
     */

    var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
    var FN_ARG_SPLIT = /,/;
    var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
    var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
    var $injectorMinErr = minErr("$injector");
    function annotate(fn) {
        var $inject, fnText, argDecl, last;

        if (typeof fn == "function") {
            if (!($inject = fn.$inject)) {
                $inject = [];
                if (fn.length) {
                    fnText = fn.toString().replace(STRIP_COMMENTS, "");
                    argDecl = fnText.match(FN_ARGS);
                    forEach(argDecl[1].split(FN_ARG_SPLIT), function (arg) {
                        arg.replace(FN_ARG, function (all, underscore, name) {
                            $inject.push(name);
                        });
                    });
                }
                fn.$inject = $inject;
            }
        } else if (isArray(fn)) {
            last = fn.length - 1;
            assertArgFn(fn[last], "fn");
            $inject = fn.slice(0, last);
        } else {
            assertArgFn(fn, "fn", true);
        }
        return $inject;
    }

    ///////////////////////////////////////

    /**
     * @ngdoc object
     * @name AUTO.$injector
     * @function
     *
     * @description
     *
     * `$injector` is used to retrieve object instances as defined by
     * {@link AUTO.$provide provider}, instantiate types, invoke methods,
     * and load modules.
     *
     * The following always holds true:
     *
     * <pre>
     *   var $injector = angular.injector();
     *   expect($injector.get('$injector')).toBe($injector);
     *   expect($injector.invoke(function($injector){
     *     return $injector;
     *   }).toBe($injector);
     * </pre>
     *
     * # Injection Function Annotation
     *
     * JavaScript does not have annotations, and annotations are needed for dependency injection. The
     * following are all valid ways of annotating function with injection arguments and are equivalent.
     *
     * <pre>
     *   // inferred (only works if code not minified/obfuscated)
     *   $injector.invoke(function(serviceA){});
     *
     *   // annotated
     *   function explicit(serviceA) {};
     *   explicit.$inject = ['serviceA'];
     *   $injector.invoke(explicit);
     *
     *   // inline
     *   $injector.invoke(['serviceA', function(serviceA){}]);
     * </pre>
     *
     * ## Inference
     *
     * In JavaScript calling `toString()` on a function returns the function definition. The definition
     * can then be parsed and the function arguments can be extracted. *NOTE:* This does not work with
     * minification, and obfuscation tools since these tools change the argument names.
     *
     * ## `$inject` Annotation
     * By adding a `$inject` property onto a function the injection parameters can be specified.
     *
     * ## Inline
     * As an array of injection names, where the last item in the array is the function to call.
     */

    /**
     * @ngdoc method
     * @name AUTO.$injector#get
     * @methodOf AUTO.$injector
     *
     * @description
     * Return an instance of the service.
     *
     * @param {string} name The name of the instance to retrieve.
     * @return {*} The instance.
     */

    /**
     * @ngdoc method
     * @name AUTO.$injector#invoke
     * @methodOf AUTO.$injector
     *
     * @description
     * Invoke the method and supply the method arguments from the `$injector`.
     *
     * @param {!function} fn The function to invoke. Function parameters are injected according to the
     *   {@link guide/di $inject Annotation} rules.
     * @param {Object=} self The `this` for the invoked method.
     * @param {Object=} locals Optional object. If preset then any argument names are read from this
     *                         object first, before the `$injector` is consulted.
     * @returns {*} the value returned by the invoked `fn` function.
     */

    /**
     * @ngdoc method
     * @name AUTO.$injector#has
     * @methodOf AUTO.$injector
     *
     * @description
     * Allows the user to query if the particular service exist.
     *
     * @param {string} Name of the service to query.
     * @returns {boolean} returns true if injector has given service.
     */

    /**
     * @ngdoc method
     * @name AUTO.$injector#instantiate
     * @methodOf AUTO.$injector
     * @description
     * Create a new instance of JS type. The method takes a constructor function invokes the new
     * operator and supplies all of the arguments to the constructor function as specified by the
     * constructor annotation.
     *
     * @param {function} Type Annotated constructor function.
     * @param {Object=} locals Optional object. If preset then any argument names are read from this
     * object first, before the `$injector` is consulted.
     * @returns {Object} new instance of `Type`.
     */

    /**
     * @ngdoc method
     * @name AUTO.$injector#annotate
     * @methodOf AUTO.$injector
     *
     * @description
     * Returns an array of service names which the function is requesting for injection. This API is
     * used by the injector to determine which services need to be injected into the function when the
     * function is invoked. There are three ways in which the function can be annotated with the needed
     * dependencies.
     *
     * # Argument names
     *
     * The simplest form is to extract the dependencies from the arguments of the function. This is done
     * by converting the function into a string using `toString()` method and extracting the argument
     * names.
     * <pre>
     *   // Given
     *   function MyController($scope, $route) {
     *     // ...
     *   }
     *
     *   // Then
     *   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
     * </pre>
     *
     * This method does not work with code minification / obfuscation. For this reason the following
     * annotation strategies are supported.
     *
     * # The `$inject` property
     *
     * If a function has an `$inject` property and its value is an array of strings, then the strings
     * represent names of services to be injected into the function.
     * <pre>
     *   // Given
     *   var MyController = function(obfuscatedScope, obfuscatedRoute) {
     *     // ...
     *   }
     *   // Define function dependencies
     *   MyController['$inject'] = ['$scope', '$route'];
     *
     *   // Then
     *   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
     * </pre>
     *
     * # The array notation
     *
     * It is often desirable to inline Injected functions and that's when setting the `$inject` property
     * is very inconvenient. In these situations using the array notation to specify the dependencies in
     * a way that survives minification is a better choice:
     *
     * <pre>
     *   // We wish to write this (not minification / obfuscation safe)
     *   injector.invoke(function($compile, $rootScope) {
     *     // ...
     *   });
     *
     *   // We are forced to write break inlining
     *   var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
     *     // ...
     *   };
     *   tmpFn.$inject = ['$compile', '$rootScope'];
     *   injector.invoke(tmpFn);
     *
     *   // To better support inline function the inline annotation is supported
     *   injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
     *     // ...
     *   }]);
     *
     *   // Therefore
     *   expect(injector.annotate(
     *      ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
     *    ).toEqual(['$compile', '$rootScope']);
     * </pre>
     *
     * @param {function|Array.<string|Function>} fn Function for which dependent service names need to
     * be retrieved as described above.
     *
     * @returns {Array.<string>} The names of the services which the function requires.
     */

    /**
     * @ngdoc object
     * @name AUTO.$provide
     *
     * @description
     *
     * The {@link AUTO.$provide $provide} service has a number of methods for registering components
     * with the {@link AUTO.$injector $injector}. Many of these functions are also exposed on
     * {@link angular.Module}.
     *
     * An Angular **service** is a singleton object created by a **service factory**.  These **service
     * factories** are functions which, in turn, are created by a **service provider**.
     * The **service providers** are constructor functions. When instantiated they must contain a
     * property called `$get`, which holds the **service factory** function.
     *
     * When you request a service, the {@link AUTO.$injector $injector} is responsible for finding the
     * correct **service provider**, instantiating it and then calling its `$get` **service factory**
     * function to get the instance of the **service**.
     *
     * Often services have no configuration options and there is no need to add methods to the service
     * provider.  The provider will be no more than a constructor function with a `$get` property. For
     * these cases the {@link AUTO.$provide $provide} service has additional helper methods to register
     * services without specifying a provider.
     *
     * * {@link AUTO.$provide#methods_provider provider(provider)} - registers a **service provider** with the
     *     {@link AUTO.$injector $injector}
     * * {@link AUTO.$provide#methods_constant constant(obj)} - registers a value/object that can be accessed by
     *     providers and services.
     * * {@link AUTO.$provide#methods_value value(obj)} - registers a value/object that can only be accessed by
     *     services, not providers.
     * * {@link AUTO.$provide#methods_factory factory(fn)} - registers a service **factory function**, `fn`,
     *     that will be wrapped in a **service provider** object, whose `$get` property will contain the
     *     given factory function.
     * * {@link AUTO.$provide#methods_service service(class)} - registers a **constructor function**, `class` that
     *     that will be wrapped in a **service provider** object, whose `$get` property will instantiate
     *      a new object using the given constructor function.
     *
     * See the individual methods for more information and examples.
     */

    /**
   * @ngdoc method
   * @name AUTO.$provide#provider
   * @methodOf AUTO.$provide
   * @description
   *
   * Register a **provider function** with the {@link AUTO.$injector $injector}. Provider functions
   * are constructor functions, whose instances are responsible for "providing" a factory for a
   * service.
   *
   * Service provider names start with the name of the service they provide followed by `Provider`.
   * For example, the {@link ng.$log $log} service has a provider called
   * {@link ng.$logProvider $logProvider}.
   *
   * Service provider objects can have additional methods which allow configuration of the provider
   * and its service. Importantly, you can configure what kind of service is created by the `$get`
   * method, or how that service will act. For example, the {@link ng.$logProvider $logProvider} has a
   * method {@link ng.$logProvider#debugEnabled debugEnabled}
   * which lets you specify whether the {@link ng.$log $log} service will log debug messages to the
   * console or not.
   *
   * @param {string} name The name of the instance. NOTE: the provider will be available under `name +
                          'Provider'` key.
   * @param {(Object|function())} provider If the provider is:
   *
   *   - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
   *               {@link AUTO.$injector#invoke $injector.invoke()} when an instance needs to be
   *               created.
   *   - `Constructor`: a new instance of the provider will be created using
   *               {@link AUTO.$injector#instantiate $injector.instantiate()}, then treated as
   *               `object`.
   *
   * @returns {Object} registered provider instance
  
   * @example
   *
   * The following example shows how to create a simple event tracking service and register it using
   * {@link AUTO.$provide#methods_provider $provide.provider()}.
   *
   * <pre>
   *  // Define the eventTracker provider
   *  function EventTrackerProvider() {
   *    var trackingUrl = '/track';
   *
   *    // A provider method for configuring where the tracked events should been saved
   *    this.setTrackingUrl = function(url) {
   *      trackingUrl = url;
   *    };
   *
   *    // The service factory function
   *    this.$get = ['$http', function($http) {
   *      var trackedEvents = {};
   *      return {
   *        // Call this to track an event
   *        event: function(event) {
   *          var count = trackedEvents[event] || 0;
   *          count += 1;
   *          trackedEvents[event] = count;
   *          return count;
   *        },
   *        // Call this to save the tracked events to the trackingUrl
   *        save: function() {
   *          $http.post(trackingUrl, trackedEvents);
   *        }
   *      };
   *    }];
   *  }
   *
   *  describe('eventTracker', function() {
   *    var postSpy;
   *
   *    beforeEach(module(function($provide) {
   *      // Register the eventTracker provider
   *      $provide.provider('eventTracker', EventTrackerProvider);
   *    }));
   *
   *    beforeEach(module(function(eventTrackerProvider) {
   *      // Configure eventTracker provider
   *      eventTrackerProvider.setTrackingUrl('/custom-track');
   *    }));
   *
   *    it('tracks events', inject(function(eventTracker) {
   *      expect(eventTracker.event('login')).toEqual(1);
   *      expect(eventTracker.event('login')).toEqual(2);
   *    }));
   *
   *    it('saves to the tracking url', inject(function(eventTracker, $http) {
   *      postSpy = spyOn($http, 'post');
   *      eventTracker.event('login');
   *      eventTracker.save();
   *      expect(postSpy).toHaveBeenCalled();
   *      expect(postSpy.mostRecentCall.args[0]).not.toEqual('/track');
   *      expect(postSpy.mostRecentCall.args[0]).toEqual('/custom-track');
   *      expect(postSpy.mostRecentCall.args[1]).toEqual({ 'login': 1 });
   *    }));
   *  });
   * </pre>
   */

    /**
     * @ngdoc method
     * @name AUTO.$provide#factory
     * @methodOf AUTO.$provide
     * @description
     *
     * Register a **service factory**, which will be called to return the service instance.
     * This is short for registering a service where its provider consists of only a `$get` property,
     * which is the given service factory function.
     * You should use {@link AUTO.$provide#factory $provide.factory(getFn)} if you do not need to
     * configure your service in a provider.
     *
     * @param {string} name The name of the instance.
     * @param {function()} $getFn The $getFn for the instance creation. Internally this is a short hand
     *                            for `$provide.provider(name, {$get: $getFn})`.
     * @returns {Object} registered provider instance
     *
     * @example
     * Here is an example of registering a service
     * <pre>
     *   $provide.factory('ping', ['$http', function($http) {
     *     return function ping() {
     *       return $http.send('/ping');
     *     };
     *   }]);
     * </pre>
     * You would then inject and use this service like this:
     * <pre>
     *   someModule.controller('Ctrl', ['ping', function(ping) {
     *     ping();
     *   }]);
     * </pre>
     */

    /**
     * @ngdoc method
     * @name AUTO.$provide#service
     * @methodOf AUTO.$provide
     * @description
     *
     * Register a **service constructor**, which will be invoked with `new` to create the service
     * instance.
     * This is short for registering a service where its provider's `$get` property is the service
     * constructor function that will be used to instantiate the service instance.
     *
     * You should use {@link AUTO.$provide#methods_service $provide.service(class)} if you define your service
     * as a type/class. This is common when using {@link http://coffeescript.org CoffeeScript}.
     *
     * @param {string} name The name of the instance.
     * @param {Function} constructor A class (constructor function) that will be instantiated.
     * @returns {Object} registered provider instance
     *
     * @example
     * Here is an example of registering a service using
     * {@link AUTO.$provide#methods_service $provide.service(class)} that is defined as a CoffeeScript class.
     * <pre>
     *   class Ping
     *     constructor: (@$http)->
     *     send: ()=>
     *       @$http.get('/ping')
     *
     *   $provide.service('ping', ['$http', Ping])
     * </pre>
     * You would then inject and use this service like this:
     * <pre>
     *   someModule.controller 'Ctrl', ['ping', (ping)->
     *     ping.send()
     *   ]
     * </pre>
     */

    /**
     * @ngdoc method
     * @name AUTO.$provide#value
     * @methodOf AUTO.$provide
     * @description
     *
     * Register a **value service** with the {@link AUTO.$injector $injector}, such as a string, a
     * number, an array, an object or a function.  This is short for registering a service where its
     * provider's `$get` property is a factory function that takes no arguments and returns the **value
     * service**.
     *
     * Value services are similar to constant services, except that they cannot be injected into a
     * module configuration function (see {@link angular.Module#config}) but they can be overridden by
     * an Angular
     * {@link AUTO.$provide#decorator decorator}.
     *
     * @param {string} name The name of the instance.
     * @param {*} value The value.
     * @returns {Object} registered provider instance
     *
     * @example
     * Here are some examples of creating value services.
     * <pre>
     *   $provide.value('ADMIN_USER', 'admin');
     *
     *   $provide.value('RoleLookup', { admin: 0, writer: 1, reader: 2 });
     *
     *   $provide.value('halfOf', function(value) {
     *     return value / 2;
     *   });
     * </pre>
     */

    /**
     * @ngdoc method
     * @name AUTO.$provide#constant
     * @methodOf AUTO.$provide
     * @description
     *
     * Register a **constant service**, such as a string, a number, an array, an object or a function,
     * with the {@link AUTO.$injector $injector}. Unlike {@link AUTO.$provide#value value} it can be
     * injected into a module configuration function (see {@link angular.Module#config}) and it cannot
     * be overridden by an Angular {@link AUTO.$provide#decorator decorator}.
     *
     * @param {string} name The name of the constant.
     * @param {*} value The constant value.
     * @returns {Object} registered instance
     *
     * @example
     * Here a some examples of creating constants:
     * <pre>
     *   $provide.constant('SHARD_HEIGHT', 306);
     *
     *   $provide.constant('MY_COLOURS', ['red', 'blue', 'grey']);
     *
     *   $provide.constant('double', function(value) {
     *     return value * 2;
     *   });
     * </pre>
     */

    /**
     * @ngdoc method
     * @name AUTO.$provide#decorator
     * @methodOf AUTO.$provide
     * @description
     *
     * Register a **service decorator** with the {@link AUTO.$injector $injector}. A service decorator
     * intercepts the creation of a service, allowing it to override or modify the behaviour of the
     * service. The object returned by the decorator may be the original service, or a new service
     * object which replaces or wraps and delegates to the original service.
     *
     * @param {string} name The name of the service to decorate.
     * @param {function()} decorator This function will be invoked when the service needs to be
     *    instantiated and should return the decorated service instance. The function is called using
     *    the {@link AUTO.$injector#invoke injector.invoke} method and is therefore fully injectable.
     *    Local injection arguments:
     *
     *    * `$delegate` - The original service instance, which can be monkey patched, configured,
     *      decorated or delegated to.
     *
     * @example
     * Here we decorate the {@link ng.$log $log} service to convert warnings to errors by intercepting
     * calls to {@link ng.$log#error $log.warn()}.
     * <pre>
     *   $provider.decorator('$log', ['$delegate', function($delegate) {
     *     $delegate.warn = $delegate.error;
     *     return $delegate;
     *   }]);
     * </pre>
     */

    function createInjector(modulesToLoad) {
        var INSTANTIATING = {},
            providerSuffix = "Provider",
            path = [],
            loadedModules = new HashMap(),
            providerCache = {
                $provide: {
                    provider: supportObject(provider),
                    factory: supportObject(factory),
                    service: supportObject(service),
                    value: supportObject(value),
                    constant: supportObject(constant),
                    decorator: decorator,
                },
            },
            providerInjector = (providerCache.$injector = createInternalInjector(
                providerCache,
                function () {
                    throw $injectorMinErr(
                        "unpr",
                        "Unknown provider: {0}",
                        path.join(" <- "),
                    );
                },
            )),
            instanceCache = {},
            instanceInjector = (instanceCache.$injector = createInternalInjector(
                instanceCache,
                function (servicename) {
                    var provider = providerInjector.get(servicename + providerSuffix);
                    return instanceInjector.invoke(provider.$get, provider);
                },
            ));

        forEach(loadModules(modulesToLoad), function (fn) {
            instanceInjector.invoke(fn || noop);
        });

        return instanceInjector;

        ////////////////////////////////////
        // $provider
        ////////////////////////////////////

        function supportObject(delegate) {
            return function (key, value) {
                if (isObject(key)) {
                    forEach(key, reverseParams(delegate));
                } else {
                    return delegate(key, value);
                }
            };
        }

        function provider(name, provider_) {
            assertNotHasOwnProperty(name, "service");
            if (isFunction(provider_) || isArray(provider_)) {
                provider_ = providerInjector.instantiate(provider_);
            }
            if (!provider_.$get) {
                throw $injectorMinErr(
                    "pget",
                    "Provider '{0}' must define $get factory method.",
                    name,
                );
            }
            return (providerCache[name + providerSuffix] = provider_);
        }

        function factory(name, factoryFn) {
            return provider(name, { $get: factoryFn });
        }

        function service(name, constructor) {
            return factory(name, [
                "$injector",
                function ($injector) {
                    return $injector.instantiate(constructor);
                },
            ]);
        }

        function value(name, val) {
            return factory(name, valueFn(val));
        }

        function constant(name, value) {
            assertNotHasOwnProperty(name, "constant");
            providerCache[name] = value;
            instanceCache[name] = value;
        }

        function decorator(serviceName, decorFn) {
            var origProvider = providerInjector.get(serviceName + providerSuffix),
                orig$get = origProvider.$get;

            origProvider.$get = function () {
                var origInstance = instanceInjector.invoke(orig$get, origProvider);
                return instanceInjector.invoke(decorFn, null, {
                    $delegate: origInstance,
                });
            };
        }

        ////////////////////////////////////
        // Module Loading
        ////////////////////////////////////
        function loadModules(modulesToLoad) {
            var runBlocks = [],
                moduleFn,
                invokeQueue,
                i,
                ii;
            forEach(modulesToLoad, function (module) {
                if (loadedModules.get(module)) return;
                loadedModules.put(module, true);

                try {
                    if (isString(module)) {
                        moduleFn = angularModule(module);
                        runBlocks = runBlocks
                            .concat(loadModules(moduleFn.requires))
                            .concat(moduleFn._runBlocks);

                        for (
                            invokeQueue = moduleFn._invokeQueue,
                            i = 0,
                            ii = invokeQueue.length;
                            i < ii;
                            i++
                        ) {
                            var invokeArgs = invokeQueue[i],
                                provider = providerInjector.get(invokeArgs[0]);

                            provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
                        }
                    } else if (isFunction(module)) {
                        runBlocks.push(providerInjector.invoke(module));
                    } else if (isArray(module)) {
                        runBlocks.push(providerInjector.invoke(module));
                    } else {
                        assertArgFn(module, "module");
                    }
                } catch (e) {
                    if (isArray(module)) {
                        module = module[module.length - 1];
                    }
                    if (e.message && e.stack && e.stack.indexOf(e.message) == -1) {
                        // Safari & FF's stack traces don't contain error.message content
                        // unlike those of Chrome and IE
                        // So if stack doesn't contain message, we create a new string that contains both.
                        // Since error.stack is read-only in Safari, I'm overriding e and not e.stack here.
                        /* jshint -W022 */
                        e = e.message + "\n" + e.stack;
                    }
                    throw $injectorMinErr(
                        "modulerr",
                        "Failed to instantiate module {0} due to:\n{1}",
                        module,
                        e.stack || e.message || e,
                    );
                }
            });
            return runBlocks;
        }

        ////////////////////////////////////
        // internal Injector
        ////////////////////////////////////

        function createInternalInjector(cache, factory) {
            function getService(serviceName) {
                if (cache.hasOwnProperty(serviceName)) {
                    if (cache[serviceName] === INSTANTIATING) {
                        throw $injectorMinErr(
                            "cdep",
                            "Circular dependency found: {0}",
                            path.join(" <- "),
                        );
                    }
                    return cache[serviceName];
                } else {
                    try {
                        path.unshift(serviceName);
                        cache[serviceName] = INSTANTIATING;
                        return (cache[serviceName] = factory(serviceName));
                    } finally {
                        path.shift();
                    }
                }
            }

            function invoke(fn, self, locals) {
                var args = [],
                    $inject = annotate(fn),
                    length,
                    i,
                    key;

                for (i = 0, length = $inject.length; i < length; i++) {
                    key = $inject[i];
                    if (typeof key !== "string") {
                        throw $injectorMinErr(
                            "itkn",
                            "Incorrect injection token! Expected service name as string, got {0}",
                            key,
                        );
                    }
                    args.push(
                        locals && locals.hasOwnProperty(key)
                            ? locals[key]
                            : getService(key),
                    );
                }
                if (!fn.$inject) {
                    // this means that we must be an array.
                    fn = fn[length];
                }

                // http://jsperf.com/angularjs-invoke-apply-vs-switch
                // #5388
                return fn.apply(self, args);
            }

            function instantiate(Type, locals) {
                var Constructor = function () { },
                    instance,
                    returnedValue;

                // Check if Type is annotated and use just the given function at n-1 as parameter
                // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
                Constructor.prototype = (
                    isArray(Type) ? Type[Type.length - 1] : Type
                ).prototype;
                instance = new Constructor();
                returnedValue = invoke(Type, instance, locals);

                return isObject(returnedValue) || isFunction(returnedValue)
                    ? returnedValue
                    : instance;
            }

            return {
                invoke: invoke,
                instantiate: instantiate,
                get: getService,
                annotate: annotate,
                has: function (name) {
                    return (
                        providerCache.hasOwnProperty(name + providerSuffix) ||
                        cache.hasOwnProperty(name)
                    );
                },
            };
        }
    }

    /**
   * @ngdoc function
   * @name ng.$anchorScroll
   * @requires $window
   * @requires $location
   * @requires $rootScope
   *
   * @description
   * When called, it checks current value of `$location.hash()` and scroll to related element,
   * according to rules specified in
   * {@link http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document Html5 spec}.
   *
   * It also watches the `$location.hash()` and scrolls whenever it changes to match any anchor.
   * This can be disabled by calling `$anchorScrollProvider.disableAutoScrolling()`.
   * 
   * @example
     <example>
       <file name="index.html">
         <div id="scrollArea" ng-controller="ScrollCtrl">
           <a ng-click="gotoBottom()">Go to bottom</a>
           <a id="bottom"></a> You're at the bottom!
         </div>
       </file>
       <file name="script.js">
         function ScrollCtrl($scope, $location, $anchorScroll) {
           $scope.gotoBottom = function (){
             // set the location.hash to the id of
             // the element you wish to scroll to.
             $location.hash('bottom');
             
             // call $anchorScroll()
             $anchorScroll();
           }
         }
       </file>
       <file name="style.css">
         #scrollArea {
           height: 350px;
           overflow: auto;
         }
  
         #bottom {
           display: block;
           margin-top: 2000px;
         }
       </file>
     </example>
   */
    function $AnchorScrollProvider() {
        var autoScrollingEnabled = true;

        this.disableAutoScrolling = function () {
            autoScrollingEnabled = false;
        };

        this.$get = [
            "$window",
            "$location",
            "$rootScope",
            function ($window, $location, $rootScope) {
                var document = $window.document;

                // helper function to get first anchor from a NodeList
                // can't use filter.filter, as it accepts only instances of Array
                // and IE can't convert NodeList to an array using [].slice
                // TODO(vojta): use filter if we change it to accept lists as well
                function getFirstAnchor(list) {
                    var result = null;
                    forEach(list, function (element) {
                        if (!result && lowercase(element.nodeName) === "a")
                            result = element;
                    });
                    return result;
                }

                function scroll() {
                    var hash = $location.hash(),
                        elm;

                    // empty hash, scroll to the top of the page
                    if (!hash) $window.scrollTo(0, 0);
                    // element with given id
                    else if ((elm = document.getElementById(hash))) elm.scrollIntoView();
                    // first anchor with given name :-D
                    else if ((elm = getFirstAnchor(document.getElementsByName(hash))))
                        elm.scrollIntoView();
                    // no element and hash == 'top', scroll to the top of the page
                    else if (hash === "top") $window.scrollTo(0, 0);
                }

                // does not scroll when user clicks on anchor link that is currently on
                // (no url change, no $location.hash() change), browser native does scroll
                if (autoScrollingEnabled) {
                    $rootScope.$watch(
                        function autoScrollWatch() {
                            return $location.hash();
                        },
                        function autoScrollWatchAction() {
                            $rootScope.$evalAsync(scroll);
                        },
                    );
                }

                return scroll;
            },
        ];
    }

    var $animateMinErr = minErr("$animate");

    /**
     * @ngdoc object
     * @name ng.$animateProvider
     *
     * @description
     * Default implementation of $animate that doesn't perform any animations, instead just
     * synchronously performs DOM
     * updates and calls done() callbacks.
     *
     * In order to enable animations the ngAnimate module has to be loaded.
     *
     * To see the functional implementation check out src/ngAnimate/animate.js
     */
    var $AnimateProvider = [
        "$provide",
        function ($provide) {
            this.$$selectors = {};

            /**
             * @ngdoc function
             * @name ng.$animateProvider#register
             * @methodOf ng.$animateProvider
             *
             * @description
             * Registers a new injectable animation factory function. The factory function produces the
             * animation object which contains callback functions for each event that is expected to be
             * animated.
             *
             *   * `eventFn`: `function(Element, doneFunction)` The element to animate, the `doneFunction`
             *   must be called once the element animation is complete. If a function is returned then the
             *   animation service will use this function to cancel the animation whenever a cancel event is
             *   triggered.
             *
             *
             *<pre>
             *   return {
             *     eventFn : function(element, done) {
             *       //code to run the animation
             *       //once complete, then run done()
             *       return function cancellationFunction() {
             *         //code to cancel the animation
             *       }
             *     }
             *   }
             *</pre>
             *
             * @param {string} name The name of the animation.
             * @param {function} factory The factory function that will be executed to return the animation
             *                           object.
             */
            this.register = function (name, factory) {
                var key = name + "-animation";
                if (name && name.charAt(0) != ".")
                    throw $animateMinErr(
                        "notcsel",
                        "Expecting class selector starting with '.' got '{0}'.",
                        name,
                    );
                this.$$selectors[name.substr(1)] = key;
                $provide.factory(key, factory);
            };

            this.$get = [
                "$timeout",
                function ($timeout) {
                    /**
                     *
                     * @ngdoc object
                     * @name ng.$animate
                     * @description The $animate service provides rudimentary DOM manipulation functions to
                     * insert, remove and move elements within the DOM, as well as adding and removing classes.
                     * This service is the core service used by the ngAnimate $animator service which provides
                     * high-level animation hooks for CSS and JavaScript.
                     *
                     * $animate is available in the AngularJS core, however, the ngAnimate module must be included
                     * to enable full out animation support. Otherwise, $animate will only perform simple DOM
                     * manipulation operations.
                     *
                     * To learn more about enabling animation support, click here to visit the {@link ngAnimate
                     * ngAnimate module page} as well as the {@link ngAnimate.$animate ngAnimate $animate service
                     * page}.
                     */
                    return {
                        /**
                         *
                         * @ngdoc function
                         * @name ng.$animate#enter
                         * @methodOf ng.$animate
                         * @function
                         * @description Inserts the element into the DOM either after the `after` element or within
                         *   the `parent` element. Once complete, the done() callback will be fired (if provided).
                         * @param {jQuery/jqLite element} element the element which will be inserted into the DOM
                         * @param {jQuery/jqLite element} parent the parent element which will append the element as
                         *   a child (if the after element is not present)
                         * @param {jQuery/jqLite element} after the sibling element which will append the element
                         *   after itself
                         * @param {function=} done callback function that will be called after the element has been
                         *   inserted into the DOM
                         */
                        enter: function (element, parent, after, done) {
                            if (after) {
                                after.after(element);
                            } else {
                                if (!parent || !parent[0]) {
                                    parent = after.parent();
                                }
                                parent.append(element);
                            }
                            done && $timeout(done, 0, false);
                        },

                        /**
                         *
                         * @ngdoc function
                         * @name ng.$animate#leave
                         * @methodOf ng.$animate
                         * @function
                         * @description Removes the element from the DOM. Once complete, the done() callback will be
                         *   fired (if provided).
                         * @param {jQuery/jqLite element} element the element which will be removed from the DOM
                         * @param {function=} done callback function that will be called after the element has been
                         *   removed from the DOM
                         */
                        leave: function (element, done) {
                            element.remove();
                            done && $timeout(done, 0, false);
                        },

                        /**
                         *
                         * @ngdoc function
                         * @name ng.$animate#move
                         * @methodOf ng.$animate
                         * @function
                         * @description Moves the position of the provided element within the DOM to be placed
                         * either after the `after` element or inside of the `parent` element. Once complete, the
                         * done() callback will be fired (if provided).
                         *
                         * @param {jQuery/jqLite element} element the element which will be moved around within the
                         *   DOM
                         * @param {jQuery/jqLite element} parent the parent element where the element will be
                         *   inserted into (if the after element is not present)
                         * @param {jQuery/jqLite element} after the sibling element where the element will be
                         *   positioned next to
                         * @param {function=} done the callback function (if provided) that will be fired after the
                         *   element has been moved to its new position
                         */
                        move: function (element, parent, after, done) {
                            // Do not remove element before insert. Removing will cause data associated with the
                            // element to be dropped. Insert will implicitly do the remove.
                            this.enter(element, parent, after, done);
                        },

                        /**
                         *
                         * @ngdoc function
                         * @name ng.$animate#addClass
                         * @methodOf ng.$animate
                         * @function
                         * @description Adds the provided className CSS class value to the provided element. Once
                         * complete, the done() callback will be fired (if provided).
                         * @param {jQuery/jqLite element} element the element which will have the className value
                         *   added to it
                         * @param {string} className the CSS class which will be added to the element
                         * @param {function=} done the callback function (if provided) that will be fired after the
                         *   className value has been added to the element
                         */
                        addClass: function (element, className, done) {
                            className = isString(className)
                                ? className
                                : isArray(className)
                                    ? className.join(" ")
                                    : "";
                            forEach(element, function (element) {
                                jqLiteAddClass(element, className);
                            });
                            done && $timeout(done, 0, false);
                        },

                        /**
                         *
                         * @ngdoc function
                         * @name ng.$animate#removeClass
                         * @methodOf ng.$animate
                         * @function
                         * @description Removes the provided className CSS class value from the provided element.
                         * Once complete, the done() callback will be fired (if provided).
                         * @param {jQuery/jqLite element} element the element which will have the className value
                         *   removed from it
                         * @param {string} className the CSS class which will be removed from the element
                         * @param {function=} done the callback function (if provided) that will be fired after the
                         *   className value has been removed from the element
                         */
                        removeClass: function (element, className, done) {
                            className = isString(className)
                                ? className
                                : isArray(className)
                                    ? className.join(" ")
                                    : "";
                            forEach(element, function (element) {
                                jqLiteRemoveClass(element, className);
                            });
                            done && $timeout(done, 0, false);
                        },

                        enabled: noop,
                    };
                },
            ];
        },
    ];

    /**
     * ! This is a private undocumented service !
     *
     * @name ng.$browser
     * @requires $log
     * @description
     * This object has two goals:
     *
     * - hide all the global state in the browser caused by the window object
     * - abstract away all the browser specific features and inconsistencies
     *
     * For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`
     * service, which can be used for convenient testing of the application without the interaction with
     * the real browser apis.
     */
    /**
     * @param {object} window The global window object.
     * @param {object} document jQuery wrapped document.
     * @param {function()} XHR XMLHttpRequest constructor.
     * @param {object} $log console.log or an object with the same interface.
     * @param {object} $sniffer $sniffer service
     */
    function Browser(window, document, $log, $sniffer) {
        var self = this,
            rawDocument = document[0],
            location = window.location,
            history = window.history,
            setTimeout = window.setTimeout,
            clearTimeout = window.clearTimeout,
            pendingDeferIds = {};

        self.isMock = false;

        var outstandingRequestCount = 0;
        var outstandingRequestCallbacks = [];

        // TODO(vojta): remove this temporary api
        self.$$completeOutstandingRequest = completeOutstandingRequest;
        self.$$incOutstandingRequestCount = function () {
            outstandingRequestCount++;
        };

        /**
         * Executes the `fn` function(supports currying) and decrements the `outstandingRequestCallbacks`
         * counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.
         */
        function completeOutstandingRequest(fn) {
            try {
                fn.apply(null, sliceArgs(arguments, 1));
            } finally {
                outstandingRequestCount--;
                if (outstandingRequestCount === 0) {
                    while (outstandingRequestCallbacks.length) {
                        try {
                            outstandingRequestCallbacks.pop()();
                        } catch (e) {
                            $log.error(e);
                        }
                    }
                }
            }
        }

        /**
         * @private
         * Note: this method is used only by scenario runner
         * TODO(vojta): prefix this method with $$ ?
         * @param {function()} callback Function that will be called when no outstanding request
         */
        self.notifyWhenNoOutstandingRequests = function (callback) {
            // force browser to execute all pollFns - this is needed so that cookies and other pollers fire
            // at some deterministic time in respect to the test runner's actions. Leaving things up to the
            // regular poller would result in flaky tests.
            forEach(pollFns, function (pollFn) {
                pollFn();
            });

            if (outstandingRequestCount === 0) {
                callback();
            } else {
                outstandingRequestCallbacks.push(callback);
            }
        };

        //////////////////////////////////////////////////////////////
        // Poll Watcher API
        //////////////////////////////////////////////////////////////
        var pollFns = [],
            pollTimeout;

        /**
         * @name ng.$browser#addPollFn
         * @methodOf ng.$browser
         *
         * @param {function()} fn Poll function to add
         *
         * @description
         * Adds a function to the list of functions that poller periodically executes,
         * and starts polling if not started yet.
         *
         * @returns {function()} the added function
         */
        self.addPollFn = function (fn) {
            if (isUndefined(pollTimeout)) startPoller(100, setTimeout);
            pollFns.push(fn);
            return fn;
        };

        /**
         * @param {number} interval How often should browser call poll functions (ms)
         * @param {function()} setTimeout Reference to a real or fake `setTimeout` function.
         *
         * @description
         * Configures the poller to run in the specified intervals, using the specified
         * setTimeout fn and kicks it off.
         */
        function startPoller(interval, setTimeout) {
            (function check() {
                forEach(pollFns, function (pollFn) {
                    pollFn();
                });
                pollTimeout = setTimeout(check, interval);
            })();
        }

        //////////////////////////////////////////////////////////////
        // URL API
        //////////////////////////////////////////////////////////////

        var lastBrowserUrl = location.href,
            baseElement = document.find("base"),
            newLocation = null;

        /**
         * @name ng.$browser#url
         * @methodOf ng.$browser
         *
         * @description
         * GETTER:
         * Without any argument, this method just returns current value of location.href.
         *
         * SETTER:
         * With at least one argument, this method sets url to new value.
         * If html5 history api supported, pushState/replaceState is used, otherwise
         * location.href/location.replace is used.
         * Returns its own instance to allow chaining
         *
         * NOTE: this api is intended for use only by the $location service. Please use the
         * {@link ng.$location $location service} to change url.
         *
         * @param {string} url New url (when used as setter)
         * @param {boolean=} replace Should new url replace current history record ?
         */
        self.url = function (url, replace) {
            // Android Browser BFCache causes location reference to become stale.
            if (location !== window.location) location = window.location;

            // setter
            if (url) {
                if (lastBrowserUrl == url) return;
                lastBrowserUrl = url;
                if ($sniffer.history) {
                    if (replace) history.replaceState(null, "", url);
                    else {
                        history.pushState(null, "", url);
                        // Crazy Opera Bug: http://my.opera.com/community/forums/topic.dml?id=1185462
                        baseElement.attr("href", baseElement.attr("href"));
                    }
                } else {
                    newLocation = url;
                    if (replace) {
                        location.replace(url);
                    } else {
                        location.href = url;
                    }
                }
                return self;
                // getter
            } else {
                // - newLocation is a workaround for an IE7-9 issue with location.replace and location.href
                //   methods not updating location.href synchronously.
                // - the replacement is a workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=407172
                return newLocation || location.href.replace(/%27/g, "'");
            }
        };

        var urlChangeListeners = [],
            urlChangeInit = false;

        function fireUrlChange() {
            newLocation = null;
            if (lastBrowserUrl == self.url()) return;

            lastBrowserUrl = self.url();
            forEach(urlChangeListeners, function (listener) {
                listener(self.url());
            });
        }

        /**
         * @name ng.$browser#onUrlChange
         * @methodOf ng.$browser
         * @TODO(vojta): refactor to use node's syntax for events
         *
         * @description
         * Register callback function that will be called, when url changes.
         *
         * It's only called when the url is changed by outside of angular:
         * - user types different url into address bar
         * - user clicks on history (forward/back) button
         * - user clicks on a link
         *
         * It's not called when url is changed by $browser.url() method
         *
         * The listener gets called with new url as parameter.
         *
         * NOTE: this api is intended for use only by the $location service. Please use the
         * {@link ng.$location $location service} to monitor url changes in angular apps.
         *
         * @param {function(string)} listener Listener function to be called when url changes.
         * @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.
         */
        self.onUrlChange = function (callback) {
            if (!urlChangeInit) {
                // We listen on both (hashchange/popstate) when available, as some browsers (e.g. Opera)
                // don't fire popstate when user change the address bar and don't fire hashchange when url
                // changed by push/replaceState

                // html5 history api - popstate event
                if ($sniffer.history) jqLite(window).on("popstate", fireUrlChange);
                // hashchange event
                if ($sniffer.hashchange) jqLite(window).on("hashchange", fireUrlChange);
                // polling
                else self.addPollFn(fireUrlChange);

                urlChangeInit = true;
            }

            urlChangeListeners.push(callback);
            return callback;
        };

        //////////////////////////////////////////////////////////////
        // Misc API
        //////////////////////////////////////////////////////////////

        /**
         * @name ng.$browser#baseHref
         * @methodOf ng.$browser
         *
         * @description
         * Returns current <base href>
         * (always relative - without domain)
         *
         * @returns {string=} current <base href>
         */
        self.baseHref = function () {
            var href = baseElement.attr("href");
            return href ? href.replace(/^https?\:\/\/[^\/]*/, "") : "";
        };

        //////////////////////////////////////////////////////////////
        // Cookies API
        //////////////////////////////////////////////////////////////
        var lastCookies = {};
        var lastCookieString = "";
        var cookiePath = self.baseHref();

        /**
         * @name ng.$browser#cookies
         * @methodOf ng.$browser
         *
         * @param {string=} name Cookie name
         * @param {string=} value Cookie value
         *
         * @description
         * The cookies method provides a 'private' low level access to browser cookies.
         * It is not meant to be used directly, use the $cookie service instead.
         *
         * The return values vary depending on the arguments that the method was called with as follows:
         *
         * - cookies() -> hash of all cookies, this is NOT a copy of the internal state, so do not modify
         *   it
         * - cookies(name, value) -> set name to value, if value is undefined delete the cookie
         * - cookies(name) -> the same as (name, undefined) == DELETES (no one calls it right now that
         *   way)
         *
         * @returns {Object} Hash of all cookies (if called without any parameter)
         */
        self.cookies = function (name, value) {
            /* global escape: false, unescape: false */
            var cookieLength, cookieArray, cookie, i, index;

            if (name) {
                if (value === undefined) {
                    rawDocument.cookie =
                        escape(name) +
                        "=;path=" +
                        cookiePath +
                        ";expires=Thu, 01 Jan 1970 00:00:00 GMT";
                } else {
                    if (isString(value)) {
                        cookieLength =
                            (rawDocument.cookie =
                                escape(name) + "=" + escape(value) + ";path=" + cookiePath)
                                .length + 1;

                        // per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum:
                        // - 300 cookies
                        // - 20 cookies per unique domain
                        // - 4096 bytes per cookie
                        if (cookieLength > 4096) {
                            $log.warn(
                                "Cookie '" +
                                name +
                                "' possibly not set or overflowed because it was too large (" +
                                cookieLength +
                                " > 4096 bytes)!",
                            );
                        }
                    }
                }
            } else {
                if (rawDocument.cookie !== lastCookieString) {
                    lastCookieString = rawDocument.cookie;
                    cookieArray = lastCookieString.split("; ");
                    lastCookies = {};

                    for (i = 0; i < cookieArray.length; i++) {
                        cookie = cookieArray[i];
                        index = cookie.indexOf("=");
                        if (index > 0) {
                            //ignore nameless cookies
                            name = unescape(cookie.substring(0, index));
                            // the first value that is seen for a cookie is the most
                            // specific one.  values for the same cookie name that
                            // follow are for less specific paths.
                            if (lastCookies[name] === undefined) {
                                lastCookies[name] = unescape(cookie.substring(index + 1));
                            }
                        }
                    }
                }
                return lastCookies;
            }
        };

        /**
         * @name ng.$browser#defer
         * @methodOf ng.$browser
         * @param {function()} fn A function, who's execution should be deferred.
         * @param {number=} [delay=0] of milliseconds to defer the function execution.
         * @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.
         *
         * @description
         * Executes a fn asynchronously via `setTimeout(fn, delay)`.
         *
         * Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using
         * `setTimeout` in tests, the fns are queued in an array, which can be programmatically flushed
         * via `$browser.defer.flush()`.
         *
         */
        self.defer = function (fn, delay) {
            var timeoutId;
            outstandingRequestCount++;
            timeoutId = setTimeout(function () {
                delete pendingDeferIds[timeoutId];
                completeOutstandingRequest(fn);
            }, delay || 0);
            pendingDeferIds[timeoutId] = true;
            return timeoutId;
        };

        /**
         * @name ng.$browser#defer.cancel
         * @methodOf ng.$browser.defer
         *
         * @description
         * Cancels a deferred task identified with `deferId`.
         *
         * @param {*} deferId Token returned by the `$browser.defer` function.
         * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
         *                    canceled.
         */
        self.defer.cancel = function (deferId) {
            if (pendingDeferIds[deferId]) {
                delete pendingDeferIds[deferId];
                clearTimeout(deferId);
                completeOutstandingRequest(noop);
                return true;
            }
            return false;
        };
    }

    function $BrowserProvider() {
        this.$get = [
            "$window",
            "$log",
            "$sniffer",
            "$document",
            function ($window, $log, $sniffer, $document) {
                return new Browser($window, $document, $log, $sniffer);
            },
        ];
    }

    /**
     * @ngdoc object
     * @name ng.$cacheFactory
     *
     * @description
     * Factory that constructs cache objects and gives access to them.
     *
     * <pre>
     *
     *  var cache = $cacheFactory('cacheId');
     *  expect($cacheFactory.get('cacheId')).toBe(cache);
     *  expect($cacheFactory.get('noSuchCacheId')).not.toBeDefined();
     *
     *  cache.put("key", "value");
     *  cache.put("another key", "another value");
     *
     *  // We've specified no options on creation
     *  expect(cache.info()).toEqual({id: 'cacheId', size: 2});
     *
     * </pre>
     *
     *
     * @param {string} cacheId Name or id of the newly created cache.
     * @param {object=} options Options object that specifies the cache behavior. Properties:
     *
     *   - `{number=}` `capacity` — turns the cache into LRU cache.
     *
     * @returns {object} Newly created cache object with the following set of methods:
     *
     * - `{object}` `info()` — Returns id, size, and options of cache.
     * - `{{*}}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache and returns
     *   it.
     * - `{{*}}` `get({string} key)` — Returns cached value for `key` or undefined for cache miss.
     * - `{void}` `remove({string} key)` — Removes a key-value pair from the cache.
     * - `{void}` `removeAll()` — Removes all cached values.
     * - `{void}` `destroy()` — Removes references to this cache from $cacheFactory.
     *
     */
    function $CacheFactoryProvider() {
        this.$get = function () {
            var caches = {};

            function cacheFactory(cacheId, options) {
                if (cacheId in caches) {
                    throw minErr("$cacheFactory")(
                        "iid",
                        "CacheId '{0}' is already taken!",
                        cacheId,
                    );
                }

                var size = 0,
                    stats = extend({}, options, { id: cacheId }),
                    data = {},
                    capacity = (options && options.capacity) || Number.MAX_VALUE,
                    lruHash = {},
                    freshEnd = null,
                    staleEnd = null;

                return (caches[cacheId] = {
                    put: function (key, value) {
                        var lruEntry = lruHash[key] || (lruHash[key] = { key: key });

                        refresh(lruEntry);

                        if (isUndefined(value)) return;
                        if (!(key in data)) size++;
                        data[key] = value;

                        if (size > capacity) {
                            this.remove(staleEnd.key);
                        }

                        return value;
                    },

                    get: function (key) {
                        var lruEntry = lruHash[key];

                        if (!lruEntry) return;

                        refresh(lruEntry);

                        return data[key];
                    },

                    remove: function (key) {
                        var lruEntry = lruHash[key];

                        if (!lruEntry) return;

                        if (lruEntry == freshEnd) freshEnd = lruEntry.p;
                        if (lruEntry == staleEnd) staleEnd = lruEntry.n;
                        link(lruEntry.n, lruEntry.p);

                        delete lruHash[key];
                        delete data[key];
                        size--;
                    },

                    removeAll: function () {
                        data = {};
                        size = 0;
                        lruHash = {};
                        freshEnd = staleEnd = null;
                    },

                    destroy: function () {
                        data = null;
                        stats = null;
                        lruHash = null;
                        delete caches[cacheId];
                    },

                    info: function () {
                        return extend({}, stats, { size: size });
                    },
                });

                /**
                 * makes the `entry` the freshEnd of the LRU linked list
                 */
                function refresh(entry) {
                    if (entry != freshEnd) {
                        if (!staleEnd) {
                            staleEnd = entry;
                        } else if (staleEnd == entry) {
                            staleEnd = entry.n;
                        }

                        link(entry.n, entry.p);
                        link(entry, freshEnd);
                        freshEnd = entry;
                        freshEnd.n = null;
                    }
                }

                /**
                 * bidirectionally links two entries of the LRU linked list
                 */
                function link(nextEntry, prevEntry) {
                    if (nextEntry != prevEntry) {
                        if (nextEntry) nextEntry.p = prevEntry; //p stands for previous, 'prev' didn't minify
                        if (prevEntry) prevEntry.n = nextEntry; //n stands for next, 'next' didn't minify
                    }
                }
            }

            /**
             * @ngdoc method
             * @name ng.$cacheFactory#info
             * @methodOf ng.$cacheFactory
             *
             * @description
             * Get information about all the of the caches that have been created
             *
             * @returns {Object} - key-value map of `cacheId` to the result of calling `cache#info`
             */
            cacheFactory.info = function () {
                var info = {};
                forEach(caches, function (cache, cacheId) {
                    info[cacheId] = cache.info();
                });
                return info;
            };

            /**
             * @ngdoc method
             * @name ng.$cacheFactory#get
             * @methodOf ng.$cacheFactory
             *
             * @description
             * Get access to a cache object by the `cacheId` used when it was created.
             *
             * @param {string} cacheId Name or id of a cache to access.
             * @returns {object} Cache object identified by the cacheId or undefined if no such cache.
             */
            cacheFactory.get = function (cacheId) {
                return caches[cacheId];
            };

            return cacheFactory;
        };
    }

    /**
     * @ngdoc object
     * @name ng.$templateCache
     *
     * @description
     * The first time a template is used, it is loaded in the template cache for quick retrieval. You
     * can load templates directly into the cache in a `script` tag, or by consuming the
     * `$templateCache` service directly.
     *
     * Adding via the `script` tag:
     * <pre>
     * <html ng-app>
     * <head>
     * <script type="text/ng-template" id="templateId.html">
     *   This is the content of the template
     * </script>
     * </head>
     *   ...
     * </html>
     * </pre>
     *
     * **Note:** the `script` tag containing the template does not need to be included in the `head` of
     * the document, but it must be below the `ng-app` definition.
     *
     * Adding via the $templateCache service:
     *
     * <pre>
     * var myApp = angular.module('myApp', []);
     * myApp.run(function($templateCache) {
     *   $templateCache.put('templateId.html', 'This is the content of the template');
     * });
     * </pre>
     *
     * To retrieve the template later, simply use it in your HTML:
     * <pre>
     * <div ng-include=" 'templateId.html' "></div>
     * </pre>
     *
     * or get it via Javascript:
     * <pre>
     * $templateCache.get('templateId.html')
     * </pre>
     *
     * See {@link ng.$cacheFactory $cacheFactory}.
     *
     */
    function $TemplateCacheProvider() {
        this.$get = [
            "$cacheFactory",
            function ($cacheFactory) {
                return $cacheFactory("templates");
            },
        ];
    }

    /* ! VARIABLE/FUNCTION NAMING CONVENTIONS THAT APPLY TO THIS FILE!
     *
     * DOM-related variables:
     *
     * - "node" - DOM Node
     * - "element" - DOM Element or Node
     * - "$node" or "$element" - jqLite-wrapped node or element
     *
     *
     * Compiler related stuff:
     *
     * - "linkFn" - linking fn of a single directive
     * - "nodeLinkFn" - function that aggregates all linking fns for a particular node
     * - "childLinkFn" -  function that aggregates all linking fns for child nodes of a particular node
     * - "compositeLinkFn" - function that aggregates all linking fns for a compilation root (nodeList)
     */

    /**
   * @ngdoc function
   * @name ng.$compile
   * @function
   *
   * @description
   * Compiles a piece of HTML string or DOM into a template and produces a template function, which
   * can then be used to link {@link ng.$rootScope.Scope `scope`} and the template together.
   *
   * The compilation is a process of walking the DOM tree and matching DOM elements to
   * {@link ng.$compileProvider#methods_directive directives}.
   *
   * <div class="alert alert-warning">
   * **Note:** This document is an in-depth reference of all directive options.
   * For a gentle introduction to directives with examples of common use cases,
   * see the {@link guide/directive directive guide}.
   * </div>
   *
   * ## Comprehensive Directive API
   *
   * There are many different options for a directive.
   *
   * The difference resides in the return value of the factory function.
   * You can either return a "Directive Definition Object" (see below) that defines the directive properties,
   * or just the `postLink` function (all other properties will have the default values).
   *
   * <div class="alert alert-success">
   * **Best Practice:** It's recommended to use the "directive definition object" form.
   * </div>
   *
   * Here's an example directive declared with a Directive Definition Object:
   *
   * <pre>
   *   var myModule = angular.module(...);
   *
   *   myModule.directive('directiveName', function factory(injectables) {
   *     var directiveDefinitionObject = {
   *       priority: 0,
   *       template: '<div></div>', // or // function(tElement, tAttrs) { ... },
   *       // or
   *       // templateUrl: 'directive.html', // or // function(tElement, tAttrs) { ... },
   *       replace: false,
   *       transclude: false,
   *       restrict: 'A',
   *       scope: false,
   *       controller: function($scope, $element, $attrs, $transclude, otherInjectables) { ... },
   *       require: 'siblingDirectiveName', // or // ['^parentDirectiveName', '?optionalDirectiveName', '?^optionalParent'],
   *       compile: function compile(tElement, tAttrs, transclude) {
   *         return {
   *           pre: function preLink(scope, iElement, iAttrs, controller) { ... },
   *           post: function postLink(scope, iElement, iAttrs, controller) { ... }
   *         }
   *         // or
   *         // return function postLink( ... ) { ... }
   *       },
   *       // or
   *       // link: {
   *       //  pre: function preLink(scope, iElement, iAttrs, controller) { ... },
   *       //  post: function postLink(scope, iElement, iAttrs, controller) { ... }
   *       // }
   *       // or
   *       // link: function postLink( ... ) { ... }
   *     };
   *     return directiveDefinitionObject;
   *   });
   * </pre>
   *
   * <div class="alert alert-warning">
   * **Note:** Any unspecified options will use the default value. You can see the default values below.
   * </div>
   *
   * Therefore the above can be simplified as:
   *
   * <pre>
   *   var myModule = angular.module(...);
   *
   *   myModule.directive('directiveName', function factory(injectables) {
   *     var directiveDefinitionObject = {
   *       link: function postLink(scope, iElement, iAttrs) { ... }
   *     };
   *     return directiveDefinitionObject;
   *     // or
   *     // return function postLink(scope, iElement, iAttrs) { ... }
   *   });
   * </pre>
   *
   *
   *
   * ### Directive Definition Object
   *
   * The directive definition object provides instructions to the {@link api/ng.$compile
   * compiler}. The attributes are:
   *
   * #### `priority`
   * When there are multiple directives defined on a single DOM element, sometimes it
   * is necessary to specify the order in which the directives are applied. The `priority` is used
   * to sort the directives before their `compile` functions get called. Priority is defined as a
   * number. Directives with greater numerical `priority` are compiled first. Pre-link functions
   * are also run in priority order, but post-link functions are run in reverse order. The order
   * of directives with the same priority is undefined. The default priority is `0`.
   *
   * #### `terminal`
   * If set to true then the current `priority` will be the last set of directives
   * which will execute (any directives at the current priority will still execute
   * as the order of execution on same `priority` is undefined).
   *
   * #### `scope`
   * **If set to `true`,** then a new scope will be created for this directive. If multiple directives on the
   * same element request a new scope, only one new scope is created. The new scope rule does not
   * apply for the root of the template since the root of the template always gets a new scope.
   *
   * **If set to `{}` (object hash),** then a new "isolate" scope is created. The 'isolate' scope differs from
   * normal scope in that it does not prototypically inherit from the parent scope. This is useful
   * when creating reusable components, which should not accidentally read or modify data in the
   * parent scope.
   *
   * The 'isolate' scope takes an object hash which defines a set of local scope properties
   * derived from the parent scope. These local properties are useful for aliasing values for
   * templates. Locals definition is a hash of local scope property to its source:
   *
   * * `@` or `@attr` - bind a local scope property to the value of DOM attribute. The result is
   *   always a string since DOM attributes are strings. If no `attr` name is specified  then the
   *   attribute name is assumed to be the same as the local name.
   *   Given `<widget my-attr="hello {{name}}">` and widget definition
   *   of `scope: { localName:'@myAttr' }`, then widget scope property `localName` will reflect
   *   the interpolated value of `hello {{name}}`. As the `name` attribute changes so will the
   *   `localName` property on the widget scope. The `name` is read from the parent scope (not
   *   component scope).
   *
   * * `=` or `=attr` - set up bi-directional binding between a local scope property and the
   *   parent scope property of name defined via the value of the `attr` attribute. If no `attr`
   *   name is specified then the attribute name is assumed to be the same as the local name.
   *   Given `<widget my-attr="parentModel">` and widget definition of
   *   `scope: { localModel:'=myAttr' }`, then widget scope property `localModel` will reflect the
   *   value of `parentModel` on the parent scope. Any changes to `parentModel` will be reflected
   *   in `localModel` and any changes in `localModel` will reflect in `parentModel`. If the parent
   *   scope property doesn't exist, it will throw a NON_ASSIGNABLE_MODEL_EXPRESSION exception. You
   *   can avoid this behavior using `=?` or `=?attr` in order to flag the property as optional.
   *
   * * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope.
   *   If no `attr` name is specified then the attribute name is assumed to be the same as the
   *   local name. Given `<widget my-attr="count = count + value">` and widget definition of
   *   `scope: { localFn:'&myAttr' }`, then isolate scope property `localFn` will point to
   *   a function wrapper for the `count = count + value` expression. Often it's desirable to
   *   pass data from the isolated scope via an expression and to the parent scope, this can be
   *   done by passing a map of local variable names and values into the expression wrapper fn.
   *   For example, if the expression is `increment(amount)` then we can specify the amount value
   *   by calling the `localFn` as `localFn({amount: 22})`.
   *
   *
   *
   * #### `controller`
   * Controller constructor function. The controller is instantiated before the
   * pre-linking phase and it is shared with other directives (see
   * `require` attribute). This allows the directives to communicate with each other and augment
   * each other's behavior. The controller is injectable (and supports bracket notation) with the following locals:
   *
   * * `$scope` - Current scope associated with the element
   * * `$element` - Current element
   * * `$attrs` - Current attributes object for the element
   * * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope.
   *    The scope can be overridden by an optional first argument.
   *   `function([scope], cloneLinkingFn)`.
   *
   *
   * #### `require`
   * Require another directive and inject its controller as the fourth argument to the linking function. The
   * `require` takes a string name (or array of strings) of the directive(s) to pass in. If an array is used, the
   * injected argument will be an array in corresponding order. If no such directive can be
   * found, or if the directive does not have a controller, then an error is raised. The name can be prefixed with:
   *
   * * (no prefix) - Locate the required controller on the current element. Throw an error if not found.
   * * `?` - Attempt to locate the required controller or pass `null` to the `link` fn if not found.
   * * `^` - Locate the required controller by searching the element's parents. Throw an error if not found.
   * * `?^` - Attempt to locate the required controller by searching the element's parents or pass `null` to the
   *   `link` fn if not found.
   *
   *
   * #### `controllerAs`
   * Controller alias at the directive scope. An alias for the controller so it
   * can be referenced at the directive template. The directive needs to define a scope for this
   * configuration to be used. Useful in the case when directive is used as component.
   *
   *
   * #### `restrict`
   * String of subset of `EACM` which restricts the directive to a specific directive
   * declaration style. If omitted, the default (attributes only) is used.
   *
   * * `E` - Element name: `<my-directive></my-directive>`
   * * `A` - Attribute (default): `<div my-directive="exp"></div>`
   * * `C` - Class: `<div class="my-directive: exp;"></div>`
   * * `M` - Comment: `<!-- directive: my-directive exp -->`
   *
   *
   * #### `template`
   * replace the current element with the contents of the HTML. The replacement process
   * migrates all of the attributes / classes from the old element to the new one. See the
   * {@link guide/directive#creating-custom-directives_creating-directives_template-expanding-directive
   * Directives Guide} for an example.
   *
   * You can specify `template` as a string representing the template or as a function which takes
   * two arguments `tElement` and `tAttrs` (described in the `compile` function api below) and
   * returns a string value representing the template.
   *
   *
   * #### `templateUrl`
   * Same as `template` but the template is loaded from the specified URL. Because
   * the template loading is asynchronous the compilation/linking is suspended until the template
   * is loaded.
   *
   * You can specify `templateUrl` as a string representing the URL or as a function which takes two
   * arguments `tElement` and `tAttrs` (described in the `compile` function api below) and returns
   * a string value representing the url.  In either case, the template URL is passed through {@link
   * api/ng.$sce#methods_getTrustedResourceUrl $sce.getTrustedResourceUrl}.
   *
   *
   * #### `replace`
   * specify where the template should be inserted. Defaults to `false`.
   *
   * * `true` - the template will replace the current element.
   * * `false` - the template will replace the contents of the current element.
   *
   *
   * #### `transclude`
   * compile the content of the element and make it available to the directive.
   * Typically used with {@link api/ng.directive:ngTransclude
   * ngTransclude}. The advantage of transclusion is that the linking function receives a
   * transclusion function which is pre-bound to the correct scope. In a typical setup the widget
   * creates an `isolate` scope, but the transclusion is not a child, but a sibling of the `isolate`
   * scope. This makes it possible for the widget to have private state, and the transclusion to
   * be bound to the parent (pre-`isolate`) scope.
   *
   * * `true` - transclude the content of the directive.
   * * `'element'` - transclude the whole element including any directives defined at lower priority.
   *
   *
   * #### `compile`
   *
   * <pre>
   *   function compile(tElement, tAttrs, transclude) { ... }
   * </pre>
   *
   * The compile function deals with transforming the template DOM. Since most directives do not do
   * template transformation, it is not used often. Examples that require compile functions are
   * directives that transform template DOM, such as {@link
   * api/ng.directive:ngRepeat ngRepeat}, or load the contents
   * asynchronously, such as {@link api/ngRoute.directive:ngView ngView}. The
   * compile function takes the following arguments.
   *
   *   * `tElement` - template element - The element where the directive has been declared. It is
   *     safe to do template transformation on the element and child elements only.
   *
   *   * `tAttrs` - template attributes - Normalized list of attributes declared on this element shared
   *     between all directive compile functions.
   *
   *   * `transclude` -  [*DEPRECATED*!] A transclude linking function: `function(scope, cloneLinkingFn)`
   *
   * <div class="alert alert-warning">
   * **Note:** The template instance and the link instance may be different objects if the template has
   * been cloned. For this reason it is **not** safe to do anything other than DOM transformations that
   * apply to all cloned DOM nodes within the compile function. Specifically, DOM listener registration
   * should be done in a linking function rather than in a compile function.
   * </div>
   *
   * <div class="alert alert-error">
   * **Note:** The `transclude` function that is passed to the compile function is deprecated, as it
   *   e.g. does not know about the right outer scope. Please use the transclude function that is passed
   *   to the link function instead.
   * </div>
  
   * A compile function can have a return value which can be either a function or an object.
   *
   * * returning a (post-link) function - is equivalent to registering the linking function via the
   *   `link` property of the config object when the compile function is empty.
   *
   * * returning an object with function(s) registered via `pre` and `post` properties - allows you to
   *   control when a linking function should be called during the linking phase. See info about
   *   pre-linking and post-linking functions below.
   *
   *
   * #### `link`
   * This property is used only if the `compile` property is not defined.
   *
   * <pre>
   *   function link(scope, iElement, iAttrs, controller, transcludeFn) { ... }
   * </pre>
   *
   * The link function is responsible for registering DOM listeners as well as updating the DOM. It is
   * executed after the template has been cloned. This is where most of the directive logic will be
   * put.
   *
   *   * `scope` - {@link api/ng.$rootScope.Scope Scope} - The scope to be used by the
   *     directive for registering {@link api/ng.$rootScope.Scope#methods_$watch watches}.
   *
   *   * `iElement` - instance element - The element where the directive is to be used. It is safe to
   *     manipulate the children of the element only in `postLink` function since the children have
   *     already been linked.
   *
   *   * `iAttrs` - instance attributes - Normalized list of attributes declared on this element shared
   *     between all directive linking functions.
   *
   *   * `controller` - a controller instance - A controller instance if at least one directive on the
   *     element defines a controller. The controller is shared among all the directives, which allows
   *     the directives to use the controllers as a communication channel.
   *
   *   * `transcludeFn` - A transclude linking function pre-bound to the correct transclusion scope.
   *     The scope can be overridden by an optional first argument. This is the same as the `$transclude`
   *     parameter of directive controllers.
   *     `function([scope], cloneLinkingFn)`.
   *
   *
   * #### Pre-linking function
   *
   * Executed before the child elements are linked. Not safe to do DOM transformation since the
   * compiler linking function will fail to locate the correct elements for linking.
   *
   * #### Post-linking function
   *
   * Executed after the child elements are linked. It is safe to do DOM transformation in the post-linking function.
   *
   * <a name="Attributes"></a>
   * ### Attributes
   *
   * The {@link api/ng.$compile.directive.Attributes Attributes} object - passed as a parameter in the
   * `link()` or `compile()` functions. It has a variety of uses.
   *
   * accessing *Normalized attribute names:*
   * Directives like 'ngBind' can be expressed in many ways: 'ng:bind', `data-ng-bind`, or 'x-ng-bind'.
   * the attributes object allows for normalized access to
   *   the attributes.
   *
   * * *Directive inter-communication:* All directives share the same instance of the attributes
   *   object which allows the directives to use the attributes object as inter directive
   *   communication.
   *
   * * *Supports interpolation:* Interpolation attributes are assigned to the attribute object
   *   allowing other directives to read the interpolated value.
   *
   * * *Observing interpolated attributes:* Use `$observe` to observe the value changes of attributes
   *   that contain interpolation (e.g. `src="{{bar}}"`). Not only is this very efficient but it's also
   *   the only way to easily get the actual value because during the linking phase the interpolation
   *   hasn't been evaluated yet and so the value is at this time set to `undefined`.
   *
   * <pre>
   * function linkingFn(scope, elm, attrs, ctrl) {
   *   // get the attribute value
   *   console.log(attrs.ngModel);
   *
   *   // change the attribute
   *   attrs.$set('ngModel', 'new value');
   *
   *   // observe changes to interpolated attribute
   *   attrs.$observe('ngModel', function(value) {
   *     console.log('ngModel has changed value to ' + value);
   *   });
   * }
   * </pre>
   *
   * Below is an example using `$compileProvider`.
   *
   * <div class="alert alert-warning">
   * **Note**: Typically directives are registered with `module.directive`. The example below is
   * to illustrate how `$compile` works.
   * </div>
   *
   <doc:example module="compile">
     <doc:source>
      <script>
        angular.module('compile', [], function($compileProvider) {
          // configure new 'compile' directive by passing a directive
          // factory function. The factory function injects the '$compile'
          $compileProvider.directive('compile', function($compile) {
            // directive factory creates a link function
            return function(scope, element, attrs) {
              scope.$watch(
                function(scope) {
                   // watch the 'compile' expression for changes
                  return scope.$eval(attrs.compile);
                },
                function(value) {
                  // when the 'compile' expression changes
                  // assign it into the current DOM
                  element.html(value);
  
                  // compile the new DOM and link it to the current
                  // scope.
                  // NOTE: we only compile .childNodes so that
                  // we don't get into infinite loop compiling ourselves
                  $compile(element.contents())(scope);
                }
              );
            };
          })
        });
  
        function Ctrl($scope) {
          $scope.name = 'Angular';
          $scope.html = 'Hello {{name}}';
        }
      </script>
      <div ng-controller="Ctrl">
        <input ng-model="name"> <br>
        <textarea ng-model="html"></textarea> <br>
        <div compile="html"></div>
      </div>
     </doc:source>
     <doc:scenario>
       it('should auto compile', function() {
         expect(element('div[compile]').text()).toBe('Hello Angular');
         input('html').enter('{{name}}!');
         expect(element('div[compile]').text()).toBe('Angular!');
       });
     </doc:scenario>
   </doc:example>
  
   *
   *
   * @param {string|DOMElement} element Element or HTML string to compile into a template function.
   * @param {function(angular.Scope[, cloneAttachFn]} transclude function available to directives.
   * @param {number} maxPriority only apply directives lower then given priority (Only effects the
   *                 root element(s), not their children)
   * @returns {function(scope[, cloneAttachFn])} a link function which is used to bind template
   * (a DOM element/tree) to a scope. Where:
   *
   *  * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to.
   *  * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the
   *  `template` and call the `cloneAttachFn` function allowing the caller to attach the
   *  cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is
   *  called as: <br> `cloneAttachFn(clonedElement, scope)` where:
   *
   *      * `clonedElement` - is a clone of the original `element` passed into the compiler.
   *      * `scope` - is the current scope with which the linking function is working with.
   *
   * Calling the linking function returns the element of the template. It is either the original
   * element passed in, or the clone of the element if the `cloneAttachFn` is provided.
   *
   * After linking the view is not updated until after a call to $digest which typically is done by
   * Angular automatically.
   *
   * If you need access to the bound view, there are two ways to do it:
   *
   * - If you are not asking the linking function to clone the template, create the DOM element(s)
   *   before you send them to the compiler and keep this reference around.
   *   <pre>
   *     var element = $compile('<p>{{total}}</p>')(scope);
   *   </pre>
   *
   * - if on the other hand, you need the element to be cloned, the view reference from the original
   *   example would not point to the clone, but rather to the original template that was cloned. In
   *   this case, you can access the clone via the cloneAttachFn:
   *   <pre>
   *     var templateHTML = angular.element('<p>{{total}}</p>'),
   *         scope = ....;
   *
   *     var clonedElement = $compile(templateHTML)(scope, function(clonedElement, scope) {
   *       //attach the clone to DOM document at the right place
   *     });
   *
   *     //now we have reference to the cloned DOM via `clone`
   *   </pre>
   *
   *
   * For information on how the compiler works, see the
   * {@link guide/compiler Angular HTML Compiler} section of the Developer Guide.
   */

    var $compileMinErr = minErr("$compile");

    /**
     * @ngdoc service
     * @name ng.$compileProvider
     * @function
     *
     * @description
     */
    $CompileProvider.$inject = ["$provide", "$$sanitizeUriProvider"];
    function $CompileProvider($provide, $$sanitizeUriProvider) {
        var hasDirectives = {},
            Suffix = "Directive",
            COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\d\w\-_]+)\s+(.*)$/,
            CLASS_DIRECTIVE_REGEXP = /(([\d\w\-_]+)(?:\:([^;]+))?;?)/;

        // Ref: http://developers.whatwg.org/webappapis.html#event-handler-idl-attributes
        // The assumption is that future DOM event attribute names will begin with
        // 'on' and be composed of only English letters.
        var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;

        /**
         * @ngdoc function
         * @name ng.$compileProvider#directive
         * @methodOf ng.$compileProvider
         * @function
         *
         * @description
         * Register a new directive with the compiler.
         *
         * @param {string|Object} name Name of the directive in camel-case (i.e. <code>ngBind</code> which
         *    will match as <code>ng-bind</code>), or an object map of directives where the keys are the
         *    names and the values are the factories.
         * @param {function|Array} directiveFactory An injectable directive factory function. See
         *    {@link guide/directive} for more info.
         * @returns {ng.$compileProvider} Self for chaining.
         */
        this.directive = function registerDirective(name, directiveFactory) {
            assertNotHasOwnProperty(name, "directive");
            if (isString(name)) {
                assertArg(directiveFactory, "directiveFactory");
                if (!hasDirectives.hasOwnProperty(name)) {
                    hasDirectives[name] = [];
                    $provide.factory(name + Suffix, [
                        "$injector",
                        "$exceptionHandler",
                        function ($injector, $exceptionHandler) {
                            var directives = [];
                            forEach(hasDirectives[name], function (directiveFactory, index) {
                                try {
                                    var directive = $injector.invoke(directiveFactory);
                                    if (isFunction(directive)) {
                                        directive = { compile: valueFn(directive) };
                                    } else if (!directive.compile && directive.link) {
                                        directive.compile = valueFn(directive.link);
                                    }
                                    directive.priority = directive.priority || 0;
                                    directive.index = index;
                                    directive.name = directive.name || name;
                                    directive.require =
                                        directive.require ||
                                        (directive.controller && directive.name);
                                    directive.restrict = directive.restrict || "A";
                                    directives.push(directive);
                                } catch (e) {
                                    $exceptionHandler(e);
                                }
                            });
                            return directives;
                        },
                    ]);
                }
                hasDirectives[name].push(directiveFactory);
            } else {
                forEach(name, reverseParams(registerDirective));
            }
            return this;
        };

        /**
         * @ngdoc function
         * @name ng.$compileProvider#aHrefSanitizationWhitelist
         * @methodOf ng.$compileProvider
         * @function
         *
         * @description
         * Retrieves or overrides the default regular expression that is used for whitelisting of safe
         * urls during a[href] sanitization.
         *
         * The sanitization is a security measure aimed at prevent XSS attacks via html links.
         *
         * Any url about to be assigned to a[href] via data-binding is first normalized and turned into
         * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist`
         * regular expression. If a match is found, the original url is written into the dom. Otherwise,
         * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
         *
         * @param {RegExp=} regexp New regexp to whitelist urls with.
         * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
         *    chaining otherwise.
         */
        this.aHrefSanitizationWhitelist = function (regexp) {
            if (isDefined(regexp)) {
                $$sanitizeUriProvider.aHrefSanitizationWhitelist(regexp);
                return this;
            } else {
                return $$sanitizeUriProvider.aHrefSanitizationWhitelist();
            }
        };

        /**
         * @ngdoc function
         * @name ng.$compileProvider#imgSrcSanitizationWhitelist
         * @methodOf ng.$compileProvider
         * @function
         *
         * @description
         * Retrieves or overrides the default regular expression that is used for whitelisting of safe
         * urls during img[src] sanitization.
         *
         * The sanitization is a security measure aimed at prevent XSS attacks via html links.
         *
         * Any url about to be assigned to img[src] via data-binding is first normalized and turned into
         * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist`
         * regular expression. If a match is found, the original url is written into the dom. Otherwise,
         * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
         *
         * @param {RegExp=} regexp New regexp to whitelist urls with.
         * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
         *    chaining otherwise.
         */
        this.imgSrcSanitizationWhitelist = function (regexp) {
            if (isDefined(regexp)) {
                $$sanitizeUriProvider.imgSrcSanitizationWhitelist(regexp);
                return this;
            } else {
                return $$sanitizeUriProvider.imgSrcSanitizationWhitelist();
            }
        };

        this.$get = [
            "$injector",
            "$interpolate",
            "$exceptionHandler",
            "$http",
            "$templateCache",
            "$parse",
            "$controller",
            "$rootScope",
            "$document",
            "$sce",
            "$animate",
            "$$sanitizeUri",
            function (
                $injector,
                $interpolate,
                $exceptionHandler,
                $http,
                $templateCache,
                $parse,
                $controller,
                $rootScope,
                $document,
                $sce,
                $animate,
                $$sanitizeUri,
            ) {
                var Attributes = function (element, attr) {
                    this.$$element = element;
                    this.$attr = attr || {};
                };

                Attributes.prototype = {
                    $normalize: directiveNormalize,

                    /**
                     * @ngdoc function
                     * @name ng.$compile.directive.Attributes#$addClass
                     * @methodOf ng.$compile.directive.Attributes
                     * @function
                     *
                     * @description
                     * Adds the CSS class value specified by the classVal parameter to the element. If animations
                     * are enabled then an animation will be triggered for the class addition.
                     *
                     * @param {string} classVal The className value that will be added to the element
                     */
                    $addClass: function (classVal) {
                        if (classVal && classVal.length > 0) {
                            $animate.addClass(this.$$element, classVal);
                        }
                    },

                    /**
                     * @ngdoc function
                     * @name ng.$compile.directive.Attributes#$removeClass
                     * @methodOf ng.$compile.directive.Attributes
                     * @function
                     *
                     * @description
                     * Removes the CSS class value specified by the classVal parameter from the element. If
                     * animations are enabled then an animation will be triggered for the class removal.
                     *
                     * @param {string} classVal The className value that will be removed from the element
                     */
                    $removeClass: function (classVal) {
                        if (classVal && classVal.length > 0) {
                            $animate.removeClass(this.$$element, classVal);
                        }
                    },

                    /**
                     * @ngdoc function
                     * @name ng.$compile.directive.Attributes#$updateClass
                     * @methodOf ng.$compile.directive.Attributes
                     * @function
                     *
                     * @description
                     * Adds and removes the appropriate CSS class values to the element based on the difference
                     * between the new and old CSS class values (specified as newClasses and oldClasses).
                     *
                     * @param {string} newClasses The current CSS className value
                     * @param {string} oldClasses The former CSS className value
                     */
                    $updateClass: function (newClasses, oldClasses) {
                        this.$removeClass(tokenDifference(oldClasses, newClasses));
                        this.$addClass(tokenDifference(newClasses, oldClasses));
                    },

                    /**
                     * Set a normalized attribute on the element in a way such that all directives
                     * can share the attribute. This function properly handles boolean attributes.
                     * @param {string} key Normalized key. (ie ngAttribute)
                     * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
                     * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
                     *     Defaults to true.
                     * @param {string=} attrName Optional none normalized name. Defaults to key.
                     */
                    $set: function (key, value, writeAttr, attrName) {
                        // TODO: decide whether or not to throw an error if "class"
                        //is set through this function since it may cause $updateClass to
                        //become unstable.

                        var booleanKey = getBooleanAttrName(this.$$element[0], key),
                            normalizedVal,
                            nodeName;

                        if (booleanKey) {
                            this.$$element.prop(key, value);
                            attrName = booleanKey;
                        }

                        this[key] = value;

                        // translate normalized key to actual key
                        if (attrName) {
                            this.$attr[key] = attrName;
                        } else {
                            attrName = this.$attr[key];
                            if (!attrName) {
                                this.$attr[key] = attrName = snake_case(key, "-");
                            }
                        }

                        nodeName = nodeName_(this.$$element);

                        // sanitize a[href] and img[src] values
                        if (
                            (nodeName === "A" && key === "href") ||
                            (nodeName === "IMG" && key === "src")
                        ) {
                            this[key] = value = $$sanitizeUri(value, key === "src");
                        }

                        if (writeAttr !== false) {
                            if (value === null || value === undefined) {
                                this.$$element.removeAttr(attrName);
                            } else {
                                this.$$element.attr(attrName, value);
                            }
                        }

                        // fire observers
                        var $$observers = this.$$observers;
                        $$observers &&
                            forEach($$observers[key], function (fn) {
                                try {
                                    fn(value);
                                } catch (e) {
                                    $exceptionHandler(e);
                                }
                            });
                    },

                    /**
                 * @ngdoc function
                 * @name ng.$compile.directive.Attributes#$observe
                 * @methodOf ng.$compile.directive.Attributes
                 * @function
                 *
                 * @description
                 * Observes an interpolated attribute.
                 *
                 * The observer function will be invoked once during the next `$digest` following
                 * compilation. The observer is then invoked whenever the interpolated value
                 * changes.
                 *
                 * @param {string} key Normalized key. (ie ngAttribute) .
                 * @param {function(interpolatedValue)} fn Function that will be called whenever
                          the interpolated value of the attribute changes.
                 *        See the {@link guide/directive#Attributes Directives} guide for more info.
                 * @returns {function()} the `fn` parameter.
                 */
                    $observe: function (key, fn) {
                        var attrs = this,
                            $$observers = attrs.$$observers || (attrs.$$observers = {}),
                            listeners = $$observers[key] || ($$observers[key] = []);

                        listeners.push(fn);
                        $rootScope.$evalAsync(function () {
                            if (!listeners.$$inter) {
                                // no one registered attribute interpolation function, so lets call it manually
                                fn(attrs[key]);
                            }
                        });
                        return fn;
                    },
                };

                var startSymbol = $interpolate.startSymbol(),
                    endSymbol = $interpolate.endSymbol(),
                    denormalizeTemplate =
                        startSymbol == "{{" || endSymbol == "}}"
                            ? identity
                            : function denormalizeTemplate(template) {
                                return template
                                    .replace(/\{\{/g, startSymbol)
                                    .replace(/}}/g, endSymbol);
                            },
                    NG_ATTR_BINDING = /^ngAttr[A-Z]/;

                return compile;

                //================================

                function compile(
                    $compileNodes,
                    transcludeFn,
                    maxPriority,
                    ignoreDirective,
                    previousCompileContext,
                ) {
                    if (!($compileNodes instanceof jqLite)) {
                        // jquery always rewraps, whereas we need to preserve the original selector so that we can
                        // modify it.
                        $compileNodes = jqLite($compileNodes);
                    }
                    // We can not compile top level text elements since text nodes can be merged and we will
                    // not be able to attach scope data to them, so we will wrap them in <span>
                    forEach($compileNodes, function (node, index) {
                        if (
                            node.nodeType == 3 /* text node */ &&
                            node.nodeValue.match(/\S+/) /* non-empty */
                        ) {
                            $compileNodes[index] = node = jqLite(node)
                                .wrap("<span></span>")
                                .parent()[0];
                        }
                    });
                    var compositeLinkFn = compileNodes(
                        $compileNodes,
                        transcludeFn,
                        $compileNodes,
                        maxPriority,
                        ignoreDirective,
                        previousCompileContext,
                    );
                    return function publicLinkFn(
                        scope,
                        cloneConnectFn,
                        transcludeControllers,
                    ) {
                        assertArg(scope, "scope");
                        // important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart
                        // and sometimes changes the structure of the DOM.
                        var $linkNode = cloneConnectFn
                            ? JQLitePrototype.clone.call($compileNodes) // IMPORTANT!!!
                            : $compileNodes;

                        forEach(transcludeControllers, function (instance, name) {
                            $linkNode.data("$" + name + "Controller", instance);
                        });

                        // Attach scope only to non-text nodes.
                        for (var i = 0, ii = $linkNode.length; i < ii; i++) {
                            var node = $linkNode[i];
                            if (
                                node.nodeType == 1 /* element */ ||
                                node.nodeType == 9 /* document */
                            ) {
                                $linkNode.eq(i).data("$scope", scope);
                            }
                        }
                        safeAddClass($linkNode, "ng-scope");
                        if (cloneConnectFn) cloneConnectFn($linkNode, scope);
                        if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode);
                        return $linkNode;
                    };
                }

                function safeAddClass($element, className) {
                    try {
                        $element.addClass(className);
                    } catch (e) {
                        // ignore, since it means that we are trying to set class on
                        // SVG element, where class name is read-only.
                    }
                }

                /**
                 * Compile function matches each node in nodeList against the directives. Once all directives
                 * for a particular node are collected their compile functions are executed. The compile
                 * functions return values - the linking functions - are combined into a composite linking
                 * function, which is the a linking function for the node.
                 *
                 * @param {NodeList} nodeList an array of nodes or NodeList to compile
                 * @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the
                 *        scope argument is auto-generated to the new child of the transcluded parent scope.
                 * @param {DOMElement=} $rootElement If the nodeList is the root of the compilation tree then
                 *        the rootElement must be set the jqLite collection of the compile root. This is
                 *        needed so that the jqLite collection items can be replaced with widgets.
                 * @param {number=} max directive priority
                 * @returns {?function} A composite linking function of all of the matched directives or null.
                 */
                function compileNodes(
                    nodeList,
                    transcludeFn,
                    $rootElement,
                    maxPriority,
                    ignoreDirective,
                    previousCompileContext,
                ) {
                    var linkFns = [],
                        nodeLinkFn,
                        childLinkFn,
                        directives,
                        attrs,
                        linkFnFound;

                    for (var i = 0; i < nodeList.length; i++) {
                        attrs = new Attributes();

                        // we must always refer to nodeList[i] since the nodes can be replaced underneath us.
                        directives = collectDirectives(
                            nodeList[i],
                            [],
                            attrs,
                            i === 0 ? maxPriority : undefined,
                            ignoreDirective,
                        );

                        nodeLinkFn = directives.length
                            ? applyDirectivesToNode(
                                directives,
                                nodeList[i],
                                attrs,
                                transcludeFn,
                                $rootElement,
                                null,
                                [],
                                [],
                                previousCompileContext,
                            )
                            : null;

                        childLinkFn =
                            (nodeLinkFn && nodeLinkFn.terminal) ||
                                !nodeList[i].childNodes ||
                                !nodeList[i].childNodes.length
                                ? null
                                : compileNodes(
                                    nodeList[i].childNodes,
                                    nodeLinkFn ? nodeLinkFn.transclude : transcludeFn,
                                );

                        linkFns.push(nodeLinkFn);
                        linkFns.push(childLinkFn);
                        linkFnFound = linkFnFound || nodeLinkFn || childLinkFn;
                        //use the previous context only for the first element in the virtual group
                        previousCompileContext = null;
                    }

                    // return a linking function if we have found anything, null otherwise
                    return linkFnFound ? compositeLinkFn : null;

                    function compositeLinkFn(
                        scope,
                        nodeList,
                        $rootElement,
                        boundTranscludeFn,
                    ) {
                        var nodeLinkFn,
                            childLinkFn,
                            node,
                            $node,
                            childScope,
                            childTranscludeFn,
                            i,
                            ii,
                            n;

                        // copy nodeList so that linking doesn't break due to live list updates.
                        var stableNodeList = [];
                        for (i = 0, ii = nodeList.length; i < ii; i++) {
                            stableNodeList.push(nodeList[i]);
                        }

                        for (i = 0, n = 0, ii = linkFns.length; i < ii; n++) {
                            node = stableNodeList[n];
                            nodeLinkFn = linkFns[i++];
                            childLinkFn = linkFns[i++];
                            $node = jqLite(node);

                            if (nodeLinkFn) {
                                if (nodeLinkFn.scope) {
                                    childScope = scope.$new();
                                    $node.data("$scope", childScope);
                                    safeAddClass($node, "ng-scope");
                                } else {
                                    childScope = scope;
                                }
                                childTranscludeFn = nodeLinkFn.transclude;
                                if (childTranscludeFn || (!boundTranscludeFn && transcludeFn)) {
                                    nodeLinkFn(
                                        childLinkFn,
                                        childScope,
                                        node,
                                        $rootElement,
                                        createBoundTranscludeFn(
                                            scope,
                                            childTranscludeFn || transcludeFn,
                                        ),
                                    );
                                } else {
                                    nodeLinkFn(
                                        childLinkFn,
                                        childScope,
                                        node,
                                        $rootElement,
                                        boundTranscludeFn,
                                    );
                                }
                            } else if (childLinkFn) {
                                childLinkFn(
                                    scope,
                                    node.childNodes,
                                    undefined,
                                    boundTranscludeFn,
                                );
                            }
                        }
                    }
                }

                function createBoundTranscludeFn(scope, transcludeFn) {
                    return function boundTranscludeFn(
                        transcludedScope,
                        cloneFn,
                        controllers,
                    ) {
                        var scopeCreated = false;

                        if (!transcludedScope) {
                            transcludedScope = scope.$new();
                            transcludedScope.$$transcluded = true;
                            scopeCreated = true;
                        }

                        var clone = transcludeFn(transcludedScope, cloneFn, controllers);
                        if (scopeCreated) {
                            clone.on(
                                "$destroy",
                                bind(transcludedScope, transcludedScope.$destroy),
                            );
                        }
                        return clone;
                    };
                }

                /**
                 * Looks for directives on the given node and adds them to the directive collection which is
                 * sorted.
                 *
                 * @param node Node to search.
                 * @param directives An array to which the directives are added to. This array is sorted before
                 *        the function returns.
                 * @param attrs The shared attrs object which is used to populate the normalized attributes.
                 * @param {number=} maxPriority Max directive priority.
                 */
                function collectDirectives(
                    node,
                    directives,
                    attrs,
                    maxPriority,
                    ignoreDirective,
                ) {
                    var nodeType = node.nodeType,
                        attrsMap = attrs.$attr,
                        match,
                        className;

                    switch (nodeType) {
                        case 1 /* Element */:
                            // use the node name: <directive>
                            addDirective(
                                directives,
                                directiveNormalize(nodeName_(node).toLowerCase()),
                                "E",
                                maxPriority,
                                ignoreDirective,
                            );

                            // iterate over the attributes
                            for (
                                var attr,
                                name,
                                nName,
                                ngAttrName,
                                value,
                                nAttrs = node.attributes,
                                j = 0,
                                jj = nAttrs && nAttrs.length;
                                j < jj;
                                j++
                            ) {
                                var attrStartName = false;
                                var attrEndName = false;

                                attr = nAttrs[j];
                                if (!msie || msie >= 8 || attr.specified) {
                                    name = attr.name;
                                    // support ngAttr attribute binding
                                    ngAttrName = directiveNormalize(name);
                                    if (NG_ATTR_BINDING.test(ngAttrName)) {
                                        name = snake_case(ngAttrName.substr(6), "-");
                                    }

                                    var directiveNName = ngAttrName.replace(/(Start|End)$/, "");
                                    if (ngAttrName === directiveNName + "Start") {
                                        attrStartName = name;
                                        attrEndName = name.substr(0, name.length - 5) + "end";
                                        name = name.substr(0, name.length - 6);
                                    }

                                    nName = directiveNormalize(name.toLowerCase());
                                    attrsMap[nName] = name;
                                    attrs[nName] = value = trim(
                                        msie && name == "href"
                                            ? decodeURIComponent(node.getAttribute(name, 2))
                                            : attr.value,
                                    );
                                    if (getBooleanAttrName(node, nName)) {
                                        attrs[nName] = true; // presence means true
                                    }
                                    addAttrInterpolateDirective(node, directives, value, nName);
                                    addDirective(
                                        directives,
                                        nName,
                                        "A",
                                        maxPriority,
                                        ignoreDirective,
                                        attrStartName,
                                        attrEndName,
                                    );
                                }
                            }

                            // use class as directive
                            className = node.className;
                            if (isString(className) && className !== "") {
                                while ((match = CLASS_DIRECTIVE_REGEXP.exec(className))) {
                                    nName = directiveNormalize(match[2]);
                                    if (
                                        addDirective(
                                            directives,
                                            nName,
                                            "C",
                                            maxPriority,
                                            ignoreDirective,
                                        )
                                    ) {
                                        attrs[nName] = trim(match[3]);
                                    }
                                    className = className.substr(match.index + match[0].length);
                                }
                            }
                            break;
                        case 3 /* Text Node */:
                            addTextInterpolateDirective(directives, node.nodeValue);
                            break;
                        case 8 /* Comment */:
                            try {
                                match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue);
                                if (match) {
                                    nName = directiveNormalize(match[1]);
                                    if (
                                        addDirective(
                                            directives,
                                            nName,
                                            "M",
                                            maxPriority,
                                            ignoreDirective,
                                        )
                                    ) {
                                        attrs[nName] = trim(match[2]);
                                    }
                                }
                            } catch (e) {
                                // turns out that under some circumstances IE9 throws errors when one attempts to read
                                // comment's node value.
                                // Just ignore it and continue. (Can't seem to reproduce in test case.)
                            }
                            break;
                    }

                    directives.sort(byPriority);
                    return directives;
                }

                /**
                 * Given a node with an directive-start it collects all of the siblings until it finds
                 * directive-end.
                 * @param node
                 * @param attrStart
                 * @param attrEnd
                 * @returns {*}
                 */
                function groupScan(node, attrStart, attrEnd) {
                    var nodes = [];
                    var depth = 0;
                    if (attrStart && node.hasAttribute && node.hasAttribute(attrStart)) {
                        var startNode = node;
                        do {
                            if (!node) {
                                throw $compileMinErr(
                                    "uterdir",
                                    "Unterminated attribute, found '{0}' but no matching '{1}' found.",
                                    attrStart,
                                    attrEnd,
                                );
                            }
                            if (node.nodeType == 1 /** Element **/) {
                                if (node.hasAttribute(attrStart)) depth++;
                                if (node.hasAttribute(attrEnd)) depth--;
                            }
                            nodes.push(node);
                            node = node.nextSibling;
                        } while (depth > 0);
                    } else {
                        nodes.push(node);
                    }

                    return jqLite(nodes);
                }

                /**
                 * Wrapper for linking function which converts normal linking function into a grouped
                 * linking function.
                 * @param linkFn
                 * @param attrStart
                 * @param attrEnd
                 * @returns {Function}
                 */
                function groupElementsLinkFnWrapper(linkFn, attrStart, attrEnd) {
                    return function (scope, element, attrs, controllers, transcludeFn) {
                        element = groupScan(element[0], attrStart, attrEnd);
                        return linkFn(scope, element, attrs, controllers, transcludeFn);
                    };
                }

                /**
                 * Once the directives have been collected, their compile functions are executed. This method
                 * is responsible for inlining directive templates as well as terminating the application
                 * of the directives if the terminal directive has been reached.
                 *
                 * @param {Array} directives Array of collected directives to execute their compile function.
                 *        this needs to be pre-sorted by priority order.
                 * @param {Node} compileNode The raw DOM node to apply the compile functions to
                 * @param {Object} templateAttrs The shared attribute function
                 * @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the
                 *                                                  scope argument is auto-generated to the new
                 *                                                  child of the transcluded parent scope.
                 * @param {JQLite} jqCollection If we are working on the root of the compile tree then this
                 *                              argument has the root jqLite array so that we can replace nodes
                 *                              on it.
                 * @param {Object=} originalReplaceDirective An optional directive that will be ignored when
                 *                                           compiling the transclusion.
                 * @param {Array.<Function>} preLinkFns
                 * @param {Array.<Function>} postLinkFns
                 * @param {Object} previousCompileContext Context used for previous compilation of the current
                 *                                        node
                 * @returns linkFn
                 */
                function applyDirectivesToNode(
                    directives,
                    compileNode,
                    templateAttrs,
                    transcludeFn,
                    jqCollection,
                    originalReplaceDirective,
                    preLinkFns,
                    postLinkFns,
                    previousCompileContext,
                ) {
                    previousCompileContext = previousCompileContext || {};

                    var terminalPriority = -Number.MAX_VALUE,
                        newScopeDirective,
                        controllerDirectives = previousCompileContext.controllerDirectives,
                        newIsolateScopeDirective =
                            previousCompileContext.newIsolateScopeDirective,
                        templateDirective = previousCompileContext.templateDirective,
                        nonTlbTranscludeDirective =
                            previousCompileContext.nonTlbTranscludeDirective,
                        hasTranscludeDirective = false,
                        hasElementTranscludeDirective = false,
                        $compileNode = (templateAttrs.$$element = jqLite(compileNode)),
                        directive,
                        directiveName,
                        $template,
                        replaceDirective = originalReplaceDirective,
                        childTranscludeFn = transcludeFn,
                        linkFn,
                        directiveValue;

                    // executes all directives on the current element
                    for (var i = 0, ii = directives.length; i < ii; i++) {
                        directive = directives[i];
                        var attrStart = directive.$$start;
                        var attrEnd = directive.$$end;

                        // collect multiblock sections
                        if (attrStart) {
                            $compileNode = groupScan(compileNode, attrStart, attrEnd);
                        }
                        $template = undefined;

                        if (terminalPriority > directive.priority) {
                            break; // prevent further processing of directives
                        }

                        if ((directiveValue = directive.scope)) {
                            newScopeDirective = newScopeDirective || directive;

                            // skip the check for directives with async templates, we'll check the derived sync
                            // directive when the template arrives
                            if (!directive.templateUrl) {
                                assertNoDuplicate(
                                    "new/isolated scope",
                                    newIsolateScopeDirective,
                                    directive,
                                    $compileNode,
                                );
                                if (isObject(directiveValue)) {
                                    newIsolateScopeDirective = directive;
                                }
                            }
                        }

                        directiveName = directive.name;

                        if (!directive.templateUrl && directive.controller) {
                            directiveValue = directive.controller;
                            controllerDirectives = controllerDirectives || {};
                            assertNoDuplicate(
                                "'" + directiveName + "' controller",
                                controllerDirectives[directiveName],
                                directive,
                                $compileNode,
                            );
                            controllerDirectives[directiveName] = directive;
                        }

                        if ((directiveValue = directive.transclude)) {
                            hasTranscludeDirective = true;

                            // Special case ngIf and ngRepeat so that we don't complain about duplicate transclusion.
                            // This option should only be used by directives that know how to how to safely handle element transclusion,
                            // where the transcluded nodes are added or replaced after linking.
                            if (!directive.$$tlb) {
                                assertNoDuplicate(
                                    "transclusion",
                                    nonTlbTranscludeDirective,
                                    directive,
                                    $compileNode,
                                );
                                nonTlbTranscludeDirective = directive;
                            }

                            if (directiveValue == "element") {
                                hasElementTranscludeDirective = true;
                                terminalPriority = directive.priority;
                                $template = groupScan(compileNode, attrStart, attrEnd);
                                $compileNode = templateAttrs.$$element = jqLite(
                                    document.createComment(
                                        " " +
                                        directiveName +
                                        ": " +
                                        templateAttrs[directiveName] +
                                        " ",
                                    ),
                                );
                                compileNode = $compileNode[0];
                                replaceWith(
                                    jqCollection,
                                    jqLite(sliceArgs($template)),
                                    compileNode,
                                );

                                childTranscludeFn = compile(
                                    $template,
                                    transcludeFn,
                                    terminalPriority,
                                    replaceDirective && replaceDirective.name,
                                    {
                                        // Don't pass in:
                                        // - controllerDirectives - otherwise we'll create duplicates controllers
                                        // - newIsolateScopeDirective or templateDirective - combining templates with
                                        //   element transclusion doesn't make sense.
                                        //
                                        // We need only nonTlbTranscludeDirective so that we prevent putting transclusion
                                        // on the same element more than once.
                                        nonTlbTranscludeDirective: nonTlbTranscludeDirective,
                                    },
                                );
                            } else {
                                $template = jqLite(jqLiteClone(compileNode)).contents();
                                $compileNode.empty(); // clear contents
                                childTranscludeFn = compile($template, transcludeFn);
                            }
                        }

                        if (directive.template) {
                            assertNoDuplicate(
                                "template",
                                templateDirective,
                                directive,
                                $compileNode,
                            );
                            templateDirective = directive;

                            directiveValue = isFunction(directive.template)
                                ? directive.template($compileNode, templateAttrs)
                                : directive.template;

                            directiveValue = denormalizeTemplate(directiveValue);

                            if (directive.replace) {
                                replaceDirective = directive;
                                $template = jqLite(
                                    "<div>" + trim(directiveValue) + "</div>",
                                ).contents();
                                compileNode = $template[0];

                                if ($template.length != 1 || compileNode.nodeType !== 1) {
                                    throw $compileMinErr(
                                        "tplrt",
                                        "Template for directive '{0}' must have exactly one root element. {1}",
                                        directiveName,
                                        "",
                                    );
                                }

                                replaceWith(jqCollection, $compileNode, compileNode);

                                var newTemplateAttrs = { $attr: {} };

                                // combine directives from the original node and from the template:
                                // - take the array of directives for this element
                                // - split it into two parts, those that already applied (processed) and those that weren't (unprocessed)
                                // - collect directives from the template and sort them by priority
                                // - combine directives as: processed + template + unprocessed
                                var templateDirectives = collectDirectives(
                                    compileNode,
                                    [],
                                    newTemplateAttrs,
                                );
                                var unprocessedDirectives = directives.splice(
                                    i + 1,
                                    directives.length - (i + 1),
                                );

                                if (newIsolateScopeDirective) {
                                    markDirectivesAsIsolate(templateDirectives);
                                }
                                directives = directives
                                    .concat(templateDirectives)
                                    .concat(unprocessedDirectives);
                                mergeTemplateAttributes(templateAttrs, newTemplateAttrs);

                                ii = directives.length;
                            } else {
                                $compileNode.html(directiveValue);
                            }
                        }

                        if (directive.templateUrl) {
                            assertNoDuplicate(
                                "template",
                                templateDirective,
                                directive,
                                $compileNode,
                            );
                            templateDirective = directive;

                            if (directive.replace) {
                                replaceDirective = directive;
                            }

                            nodeLinkFn = compileTemplateUrl(
                                directives.splice(i, directives.length - i),
                                $compileNode,
                                templateAttrs,
                                jqCollection,
                                childTranscludeFn,
                                preLinkFns,
                                postLinkFns,
                                {
                                    controllerDirectives: controllerDirectives,
                                    newIsolateScopeDirective: newIsolateScopeDirective,
                                    templateDirective: templateDirective,
                                    nonTlbTranscludeDirective: nonTlbTranscludeDirective,
                                },
                            );
                            ii = directives.length;
                        } else if (directive.compile) {
                            try {
                                linkFn = directive.compile(
                                    $compileNode,
                                    templateAttrs,
                                    childTranscludeFn,
                                );
                                if (isFunction(linkFn)) {
                                    addLinkFns(null, linkFn, attrStart, attrEnd);
                                } else if (linkFn) {
                                    addLinkFns(linkFn.pre, linkFn.post, attrStart, attrEnd);
                                }
                            } catch (e) {
                                $exceptionHandler(e, startingTag($compileNode));
                            }
                        }

                        if (directive.terminal) {
                            nodeLinkFn.terminal = true;
                            terminalPriority = Math.max(terminalPriority, directive.priority);
                        }
                    }

                    nodeLinkFn.scope =
                        newScopeDirective && newScopeDirective.scope === true;
                    nodeLinkFn.transclude = hasTranscludeDirective && childTranscludeFn;

                    // might be normal or delayed nodeLinkFn depending on if templateUrl is present
                    return nodeLinkFn;

                    ////////////////////

                    function addLinkFns(pre, post, attrStart, attrEnd) {
                        if (pre) {
                            if (attrStart)
                                pre = groupElementsLinkFnWrapper(pre, attrStart, attrEnd);
                            pre.require = directive.require;
                            if (
                                newIsolateScopeDirective === directive ||
                                directive.$$isolateScope
                            ) {
                                pre = cloneAndAnnotateFn(pre, { isolateScope: true });
                            }
                            preLinkFns.push(pre);
                        }
                        if (post) {
                            if (attrStart)
                                post = groupElementsLinkFnWrapper(post, attrStart, attrEnd);
                            post.require = directive.require;
                            if (
                                newIsolateScopeDirective === directive ||
                                directive.$$isolateScope
                            ) {
                                post = cloneAndAnnotateFn(post, { isolateScope: true });
                            }
                            postLinkFns.push(post);
                        }
                    }

                    function getControllers(require, $element, elementControllers) {
                        var value,
                            retrievalMethod = "data",
                            optional = false;
                        if (isString(require)) {
                            while ((value = require.charAt(0)) == "^" || value == "?") {
                                require = require.substr(1);
                                if (value == "^") {
                                    retrievalMethod = "inheritedData";
                                }
                                optional = optional || value == "?";
                            }
                            value = null;

                            if (elementControllers && retrievalMethod === "data") {
                                value = elementControllers[require];
                            }
                            value =
                                value ||
                                $element[retrievalMethod]("$" + require + "Controller");

                            if (!value && !optional) {
                                throw $compileMinErr(
                                    "ctreq",
                                    "Controller '{0}', required by directive '{1}', can't be found!",
                                    require,
                                    directiveName,
                                );
                            }
                            return value;
                        } else if (isArray(require)) {
                            value = [];
                            forEach(require, function (require) {
                                value.push(
                                    getControllers(require, $element, elementControllers),
                                );
                            });
                        }
                        return value;
                    }

                    function nodeLinkFn(
                        childLinkFn,
                        scope,
                        linkNode,
                        $rootElement,
                        boundTranscludeFn,
                    ) {
                        var attrs,
                            $element,
                            i,
                            ii,
                            linkFn,
                            controller,
                            isolateScope,
                            elementControllers = {},
                            transcludeFn;

                        if (compileNode === linkNode) {
                            attrs = templateAttrs;
                        } else {
                            attrs = shallowCopy(
                                templateAttrs,
                                new Attributes(jqLite(linkNode), templateAttrs.$attr),
                            );
                        }
                        $element = attrs.$$element;

                        if (newIsolateScopeDirective) {
                            var LOCAL_REGEXP = /^\s*([@=&])(\??)\s*(\w*)\s*$/;
                            var $linkNode = jqLite(linkNode);

                            isolateScope = scope.$new(true);

                            if (
                                templateDirective &&
                                templateDirective ===
                                newIsolateScopeDirective.$$originalDirective
                            ) {
                                $linkNode.data("$isolateScope", isolateScope);
                            } else {
                                $linkNode.data("$isolateScopeNoTemplate", isolateScope);
                            }

                            safeAddClass($linkNode, "ng-isolate-scope");

                            forEach(
                                newIsolateScopeDirective.scope,
                                function (definition, scopeName) {
                                    var match = definition.match(LOCAL_REGEXP) || [],
                                        attrName = match[3] || scopeName,
                                        optional = match[2] == "?",
                                        mode = match[1], // @, =, or &
                                        lastValue,
                                        parentGet,
                                        parentSet,
                                        compare;

                                    isolateScope.$$isolateBindings[scopeName] = mode + attrName;

                                    switch (mode) {
                                        case "@":
                                            attrs.$observe(attrName, function (value) {
                                                isolateScope[scopeName] = value;
                                            });
                                            attrs.$$observers[attrName].$$scope = scope;
                                            if (attrs[attrName]) {
                                                // If the attribute has been provided then we trigger an interpolation to ensure
                                                // the value is there for use in the link fn
                                                isolateScope[scopeName] = $interpolate(attrs[attrName])(
                                                    scope,
                                                );
                                            }
                                            break;

                                        case "=":
                                            if (optional && !attrs[attrName]) {
                                                return;
                                            }
                                            parentGet = $parse(attrs[attrName]);
                                            if (parentGet.literal) {
                                                compare = equals;
                                            } else {
                                                compare = function (a, b) {
                                                    return a === b;
                                                };
                                            }
                                            parentSet =
                                                parentGet.assign ||
                                                function () {
                                                    // reset the change, or we will throw this exception on every $digest
                                                    lastValue = isolateScope[scopeName] =
                                                        parentGet(scope);
                                                    throw $compileMinErr(
                                                        "nonassign",
                                                        "Expression '{0}' used with directive '{1}' is non-assignable!",
                                                        attrs[attrName],
                                                        newIsolateScopeDirective.name,
                                                    );
                                                };
                                            lastValue = isolateScope[scopeName] = parentGet(scope);
                                            isolateScope.$watch(
                                                function parentValueWatch() {
                                                    var parentValue = parentGet(scope);
                                                    if (!compare(parentValue, isolateScope[scopeName])) {
                                                        // we are out of sync and need to copy
                                                        if (!compare(parentValue, lastValue)) {
                                                            // parent changed and it has precedence
                                                            isolateScope[scopeName] = parentValue;
                                                        } else {
                                                            // if the parent can be assigned then do so
                                                            parentSet(
                                                                scope,
                                                                (parentValue = isolateScope[scopeName]),
                                                            );
                                                        }
                                                    }
                                                    return (lastValue = parentValue);
                                                },
                                                null,
                                                parentGet.literal,
                                            );
                                            break;

                                        case "&":
                                            parentGet = $parse(attrs[attrName]);
                                            isolateScope[scopeName] = function (locals) {
                                                return parentGet(scope, locals);
                                            };
                                            break;

                                        default:
                                            throw $compileMinErr(
                                                "iscp",
                                                "Invalid isolate scope definition for directive '{0}'." +
                                                " Definition: {... {1}: '{2}' ...}",
                                                newIsolateScopeDirective.name,
                                                scopeName,
                                                definition,
                                            );
                                    }
                                },
                            );
                        }
                        transcludeFn = boundTranscludeFn && controllersBoundTransclude;
                        if (controllerDirectives) {
                            forEach(controllerDirectives, function (directive) {
                                var locals = {
                                    $scope:
                                        directive === newIsolateScopeDirective ||
                                            directive.$$isolateScope
                                            ? isolateScope
                                            : scope,
                                    $element: $element,
                                    $attrs: attrs,
                                    $transclude: transcludeFn,
                                },
                                    controllerInstance;

                                controller = directive.controller;
                                if (controller == "@") {
                                    controller = attrs[directive.name];
                                }

                                controllerInstance = $controller(controller, locals);
                                // For directives with element transclusion the element is a comment,
                                // but jQuery .data doesn't support attaching data to comment nodes as it's hard to
                                // clean up (http://bugs.jquery.com/ticket/8335).
                                // Instead, we save the controllers for the element in a local hash and attach to .data
                                // later, once we have the actual element.
                                elementControllers[directive.name] = controllerInstance;
                                if (!hasElementTranscludeDirective) {
                                    $element.data(
                                        "$" + directive.name + "Controller",
                                        controllerInstance,
                                    );
                                }

                                if (directive.controllerAs) {
                                    locals.$scope[directive.controllerAs] = controllerInstance;
                                }
                            });
                        }

                        // PRELINKING
                        for (i = 0, ii = preLinkFns.length; i < ii; i++) {
                            try {
                                linkFn = preLinkFns[i];
                                linkFn(
                                    linkFn.isolateScope ? isolateScope : scope,
                                    $element,
                                    attrs,
                                    linkFn.require &&
                                    getControllers(
                                        linkFn.require,
                                        $element,
                                        elementControllers,
                                    ),
                                    transcludeFn,
                                );
                            } catch (e) {
                                $exceptionHandler(e, startingTag($element));
                            }
                        }

                        // RECURSION
                        // We only pass the isolate scope, if the isolate directive has a template,
                        // otherwise the child elements do not belong to the isolate directive.
                        var scopeToChild = scope;
                        if (
                            newIsolateScopeDirective &&
                            (newIsolateScopeDirective.template ||
                                newIsolateScopeDirective.templateUrl === null)
                        ) {
                            scopeToChild = isolateScope;
                        }
                        childLinkFn &&
                            childLinkFn(
                                scopeToChild,
                                linkNode.childNodes,
                                undefined,
                                boundTranscludeFn,
                            );

                        // POSTLINKING
                        for (i = postLinkFns.length - 1; i >= 0; i--) {
                            try {
                                linkFn = postLinkFns[i];
                                linkFn(
                                    linkFn.isolateScope ? isolateScope : scope,
                                    $element,
                                    attrs,
                                    linkFn.require &&
                                    getControllers(
                                        linkFn.require,
                                        $element,
                                        elementControllers,
                                    ),
                                    transcludeFn,
                                );
                            } catch (e) {
                                $exceptionHandler(e, startingTag($element));
                            }
                        }

                        // This is the function that is injected as `$transclude`.
                        function controllersBoundTransclude(scope, cloneAttachFn) {
                            var transcludeControllers;

                            // no scope passed
                            if (arguments.length < 2) {
                                cloneAttachFn = scope;
                                scope = undefined;
                            }

                            if (hasElementTranscludeDirective) {
                                transcludeControllers = elementControllers;
                            }

                            return boundTranscludeFn(
                                scope,
                                cloneAttachFn,
                                transcludeControllers,
                            );
                        }
                    }
                }

                function markDirectivesAsIsolate(directives) {
                    // mark all directives as needing isolate scope.
                    for (var j = 0, jj = directives.length; j < jj; j++) {
                        directives[j] = inherit(directives[j], { $$isolateScope: true });
                    }
                }

                /**
                 * looks up the directive and decorates it with exception handling and proper parameters. We
                 * call this the boundDirective.
                 *
                 * @param {string} name name of the directive to look up.
                 * @param {string} location The directive must be found in specific format.
                 *   String containing any of theses characters:
                 *
                 *   * `E`: element name
                 *   * `A': attribute
                 *   * `C`: class
                 *   * `M`: comment
                 * @returns true if directive was added.
                 */
                function addDirective(
                    tDirectives,
                    name,
                    location,
                    maxPriority,
                    ignoreDirective,
                    startAttrName,
                    endAttrName,
                ) {
                    if (name === ignoreDirective) return null;
                    var match = null;
                    if (hasDirectives.hasOwnProperty(name)) {
                        for (
                            var directive,
                            directives = $injector.get(name + Suffix),
                            i = 0,
                            ii = directives.length;
                            i < ii;
                            i++
                        ) {
                            try {
                                directive = directives[i];
                                if (
                                    (maxPriority === undefined ||
                                        maxPriority > directive.priority) &&
                                    directive.restrict.indexOf(location) != -1
                                ) {
                                    if (startAttrName) {
                                        directive = inherit(directive, {
                                            $$start: startAttrName,
                                            $$end: endAttrName,
                                        });
                                    }
                                    tDirectives.push(directive);
                                    match = directive;
                                }
                            } catch (e) {
                                $exceptionHandler(e);
                            }
                        }
                    }
                    return match;
                }

                /**
                 * When the element is replaced with HTML template then the new attributes
                 * on the template need to be merged with the existing attributes in the DOM.
                 * The desired effect is to have both of the attributes present.
                 *
                 * @param {object} dst destination attributes (original DOM)
                 * @param {object} src source attributes (from the directive template)
                 */
                function mergeTemplateAttributes(dst, src) {
                    var srcAttr = src.$attr,
                        dstAttr = dst.$attr,
                        $element = dst.$$element;

                    // reapply the old attributes to the new element
                    forEach(dst, function (value, key) {
                        if (key.charAt(0) != "$") {
                            if (src[key]) {
                                value += (key === "style" ? ";" : " ") + src[key];
                            }
                            dst.$set(key, value, true, srcAttr[key]);
                        }
                    });

                    // copy the new attributes on the old attrs object
                    forEach(src, function (value, key) {
                        if (key == "class") {
                            safeAddClass($element, value);
                            dst["class"] = (dst["class"] ? dst["class"] + " " : "") + value;
                        } else if (key == "style") {
                            $element.attr("style", $element.attr("style") + ";" + value);
                            dst["style"] = (dst["style"] ? dst["style"] + ";" : "") + value;
                            // `dst` will never contain hasOwnProperty as DOM parser won't let it.
                            // You will get an "InvalidCharacterError: DOM Exception 5" error if you
                            // have an attribute like "has-own-property" or "data-has-own-property", etc.
                        } else if (key.charAt(0) != "$" && !dst.hasOwnProperty(key)) {
                            dst[key] = value;
                            dstAttr[key] = srcAttr[key];
                        }
                    });
                }

                function compileTemplateUrl(
                    directives,
                    $compileNode,
                    tAttrs,
                    $rootElement,
                    childTranscludeFn,
                    preLinkFns,
                    postLinkFns,
                    previousCompileContext,
                ) {
                    var linkQueue = [],
                        afterTemplateNodeLinkFn,
                        afterTemplateChildLinkFn,
                        beforeTemplateCompileNode = $compileNode[0],
                        origAsyncDirective = directives.shift(),
                        // The fact that we have to copy and patch the directive seems wrong!
                        derivedSyncDirective = extend({}, origAsyncDirective, {
                            templateUrl: null,
                            transclude: null,
                            replace: null,
                            $$originalDirective: origAsyncDirective,
                        }),
                        templateUrl = isFunction(origAsyncDirective.templateUrl)
                            ? origAsyncDirective.templateUrl($compileNode, tAttrs)
                            : origAsyncDirective.templateUrl;

                    $compileNode.empty();

                    $http
                        .get($sce.getTrustedResourceUrl(templateUrl), {
                            cache: $templateCache,
                        })
                        .success(function (content) {
                            var compileNode,
                                tempTemplateAttrs,
                                $template,
                                childBoundTranscludeFn;

                            content = denormalizeTemplate(content);

                            if (origAsyncDirective.replace) {
                                $template = jqLite(
                                    "<div>" + trim(content) + "</div>",
                                ).contents();
                                compileNode = $template[0];

                                if ($template.length != 1 || compileNode.nodeType !== 1) {
                                    throw $compileMinErr(
                                        "tplrt",
                                        "Template for directive '{0}' must have exactly one root element. {1}",
                                        origAsyncDirective.name,
                                        templateUrl,
                                    );
                                }

                                tempTemplateAttrs = { $attr: {} };
                                replaceWith($rootElement, $compileNode, compileNode);
                                var templateDirectives = collectDirectives(
                                    compileNode,
                                    [],
                                    tempTemplateAttrs,
                                );

                                if (isObject(origAsyncDirective.scope)) {
                                    markDirectivesAsIsolate(templateDirectives);
                                }
                                directives = templateDirectives.concat(directives);
                                mergeTemplateAttributes(tAttrs, tempTemplateAttrs);
                            } else {
                                compileNode = beforeTemplateCompileNode;
                                $compileNode.html(content);
                            }

                            directives.unshift(derivedSyncDirective);

                            afterTemplateNodeLinkFn = applyDirectivesToNode(
                                directives,
                                compileNode,
                                tAttrs,
                                childTranscludeFn,
                                $compileNode,
                                origAsyncDirective,
                                preLinkFns,
                                postLinkFns,
                                previousCompileContext,
                            );
                            forEach($rootElement, function (node, i) {
                                if (node == compileNode) {
                                    $rootElement[i] = $compileNode[0];
                                }
                            });
                            afterTemplateChildLinkFn = compileNodes(
                                $compileNode[0].childNodes,
                                childTranscludeFn,
                            );

                            while (linkQueue.length) {
                                var scope = linkQueue.shift(),
                                    beforeTemplateLinkNode = linkQueue.shift(),
                                    linkRootElement = linkQueue.shift(),
                                    boundTranscludeFn = linkQueue.shift(),
                                    linkNode = $compileNode[0];

                                if (beforeTemplateLinkNode !== beforeTemplateCompileNode) {
                                    // it was cloned therefore we have to clone as well.
                                    linkNode = jqLiteClone(compileNode);
                                    replaceWith(
                                        linkRootElement,
                                        jqLite(beforeTemplateLinkNode),
                                        linkNode,
                                    );
                                }
                                if (afterTemplateNodeLinkFn.transclude) {
                                    childBoundTranscludeFn = createBoundTranscludeFn(
                                        scope,
                                        afterTemplateNodeLinkFn.transclude,
                                    );
                                } else {
                                    childBoundTranscludeFn = boundTranscludeFn;
                                }
                                afterTemplateNodeLinkFn(
                                    afterTemplateChildLinkFn,
                                    scope,
                                    linkNode,
                                    $rootElement,
                                    childBoundTranscludeFn,
                                );
                            }
                            linkQueue = null;
                        })
                        .error(function (response, code, headers, config) {
                            throw $compileMinErr(
                                "tpload",
                                "Failed to load template: {0}",
                                config.url,
                            );
                        });

                    return function delayedNodeLinkFn(
                        ignoreChildLinkFn,
                        scope,
                        node,
                        rootElement,
                        boundTranscludeFn,
                    ) {
                        if (linkQueue) {
                            linkQueue.push(scope);
                            linkQueue.push(node);
                            linkQueue.push(rootElement);
                            linkQueue.push(boundTranscludeFn);
                        } else {
                            afterTemplateNodeLinkFn(
                                afterTemplateChildLinkFn,
                                scope,
                                node,
                                rootElement,
                                boundTranscludeFn,
                            );
                        }
                    };
                }

                /**
                 * Sorting function for bound directives.
                 */
                function byPriority(a, b) {
                    var diff = b.priority - a.priority;
                    if (diff !== 0) return diff;
                    if (a.name !== b.name) return a.name < b.name ? -1 : 1;
                    return a.index - b.index;
                }

                function assertNoDuplicate(
                    what,
                    previousDirective,
                    directive,
                    element,
                ) {
                    if (previousDirective) {
                        throw $compileMinErr(
                            "multidir",
                            "Multiple directives [{0}, {1}] asking for {2} on: {3}",
                            previousDirective.name,
                            directive.name,
                            what,
                            startingTag(element),
                        );
                    }
                }

                function addTextInterpolateDirective(directives, text) {
                    var interpolateFn = $interpolate(text, true);
                    if (interpolateFn) {
                        directives.push({
                            priority: 0,
                            compile: valueFn(function textInterpolateLinkFn(scope, node) {
                                var parent = node.parent(),
                                    bindings = parent.data("$binding") || [];
                                bindings.push(interpolateFn);
                                safeAddClass(parent.data("$binding", bindings), "ng-binding");
                                scope.$watch(
                                    interpolateFn,
                                    function interpolateFnWatchAction(value) {
                                        node[0].nodeValue = value;
                                    },
                                );
                            }),
                        });
                    }
                }

                function getTrustedContext(node, attrNormalizedName) {
                    if (attrNormalizedName == "srcdoc") {
                        return $sce.HTML;
                    }
                    var tag = nodeName_(node);
                    // maction[xlink:href] can source SVG.  It's not limited to <maction>.
                    if (
                        attrNormalizedName == "xlinkHref" ||
                        (tag == "FORM" && attrNormalizedName == "action") ||
                        (tag != "IMG" &&
                            (attrNormalizedName == "src" || attrNormalizedName == "ngSrc"))
                    ) {
                        return $sce.RESOURCE_URL;
                    }
                }

                function addAttrInterpolateDirective(node, directives, value, name) {
                    var interpolateFn = $interpolate(value, true);

                    // no interpolation found -> ignore
                    if (!interpolateFn) return;

                    if (name === "multiple" && nodeName_(node) === "SELECT") {
                        throw $compileMinErr(
                            "selmulti",
                            "Binding to the 'multiple' attribute is not supported. Element: {0}",
                            startingTag(node),
                        );
                    }

                    directives.push({
                        priority: 100,
                        compile: function () {
                            return {
                                pre: function attrInterpolatePreLinkFn(scope, element, attr) {
                                    var $$observers = attr.$$observers || (attr.$$observers = {});

                                    if (EVENT_HANDLER_ATTR_REGEXP.test(name)) {
                                        throw $compileMinErr(
                                            "nodomevents",
                                            "Interpolations for HTML DOM event attributes are disallowed.  Please use the " +
                                            "ng- versions (such as ng-click instead of onclick) instead.",
                                        );
                                    }

                                    // we need to interpolate again, in case the attribute value has been updated
                                    // (e.g. by another directive's compile function)
                                    interpolateFn = $interpolate(
                                        attr[name],
                                        true,
                                        getTrustedContext(node, name),
                                    );

                                    // if attribute was updated so that there is no interpolation going on we don't want to
                                    // register any observers
                                    if (!interpolateFn) return;

                                    // TODO(i): this should likely be attr.$set(name, iterpolateFn(scope) so that we reset the
                                    // actual attr value
                                    attr[name] = interpolateFn(scope);
                                    (
                                        $$observers[name] || ($$observers[name] = [])
                                    ).$$inter = true;
                                    (
                                        (attr.$$observers && attr.$$observers[name].$$scope) ||
                                        scope
                                    ).$watch(
                                        interpolateFn,
                                        function interpolateFnWatchAction(newValue, oldValue) {
                                            //special case for class attribute addition + removal
                                            //so that class changes can tap into the animation
                                            //hooks provided by the $animate service. Be sure to
                                            //skip animations when the first digest occurs (when
                                            //both the new and the old values are the same) since
                                            //the CSS classes are the non-interpolated values
                                            if (name === "class" && newValue != oldValue) {
                                                attr.$updateClass(newValue, oldValue);
                                            } else {
                                                attr.$set(name, newValue);
                                            }
                                        },
                                    );
                                },
                            };
                        },
                    });
                }

                /**
                 * This is a special jqLite.replaceWith, which can replace items which
                 * have no parents, provided that the containing jqLite collection is provided.
                 *
                 * @param {JqLite=} $rootElement The root of the compile tree. Used so that we can replace nodes
                 *                               in the root of the tree.
                 * @param {JqLite} elementsToRemove The jqLite element which we are going to replace. We keep
                 *                                  the shell, but replace its DOM node reference.
                 * @param {Node} newNode The new DOM node.
                 */
                function replaceWith($rootElement, elementsToRemove, newNode) {
                    var firstElementToRemove = elementsToRemove[0],
                        removeCount = elementsToRemove.length,
                        parent = firstElementToRemove.parentNode,
                        i,
                        ii;

                    if ($rootElement) {
                        for (i = 0, ii = $rootElement.length; i < ii; i++) {
                            if ($rootElement[i] == firstElementToRemove) {
                                $rootElement[i++] = newNode;
                                for (
                                    var j = i, j2 = j + removeCount - 1, jj = $rootElement.length;
                                    j < jj;
                                    j++, j2++
                                ) {
                                    if (j2 < jj) {
                                        $rootElement[j] = $rootElement[j2];
                                    } else {
                                        delete $rootElement[j];
                                    }
                                }
                                $rootElement.length -= removeCount - 1;
                                break;
                            }
                        }
                    }

                    if (parent) {
                        parent.replaceChild(newNode, firstElementToRemove);
                    }
                    var fragment = document.createDocumentFragment();
                    fragment.appendChild(firstElementToRemove);
                    newNode[jqLite.expando] = firstElementToRemove[jqLite.expando];
                    for (var k = 1, kk = elementsToRemove.length; k < kk; k++) {
                        var element = elementsToRemove[k];
                        jqLite(element).remove(); // must do this way to clean up expando
                        fragment.appendChild(element);
                        delete elementsToRemove[k];
                    }

                    elementsToRemove[0] = newNode;
                    elementsToRemove.length = 1;
                }

                function cloneAndAnnotateFn(fn, annotation) {
                    return extend(
                        function () {
                            return fn.apply(null, arguments);
                        },
                        fn,
                        annotation,
                    );
                }
            },
        ];
    }

    var PREFIX_REGEXP = /^(x[\:\-_]|data[\:\-_])/i;
    /**
     * Converts all accepted directives format into proper directive name.
     * All of these will become 'myDirective':
     *   my:Directive
     *   my-directive
     *   x-my-directive
     *   data-my:directive
     *
     * Also there is special case for Moz prefix starting with upper case letter.
     * @param name Name to normalize
     */
    function directiveNormalize(name) {
        return camelCase(name.replace(PREFIX_REGEXP, ""));
    }

    /**
     * @ngdoc object
     * @name ng.$compile.directive.Attributes
     *
     * @description
     * A shared object between directive compile / linking functions which contains normalized DOM
     * element attributes. The values reflect current binding state `{{ }}`. The normalization is
     * needed since all of these are treated as equivalent in Angular:
     *
     *    <span ng:bind="a" ng-bind="a" data-ng-bind="a" x-ng-bind="a">
     */

    /**
     * @ngdoc property
     * @name ng.$compile.directive.Attributes#$attr
     * @propertyOf ng.$compile.directive.Attributes
     * @returns {object} A map of DOM element attribute names to the normalized name. This is
     *                   needed to do reverse lookup from normalized name back to actual name.
     */

    /**
     * @ngdoc function
     * @name ng.$compile.directive.Attributes#$set
     * @methodOf ng.$compile.directive.Attributes
     * @function
     *
     * @description
     * Set DOM element attribute value.
     *
     *
     * @param {string} name Normalized element attribute name of the property to modify. The name is
     *          revers translated using the {@link ng.$compile.directive.Attributes#$attr $attr}
     *          property to the original name.
     * @param {string} value Value to set the attribute to. The value can be an interpolated string.
     */

    /**
     * Closure compiler type information
     */

    function nodesetLinkingFn(
      /* angular.Scope */ scope,
      /* NodeList */ nodeList,
      /* Element */ rootElement,
      /* function(Function) */ boundTranscludeFn,
    ) { }

    function directiveLinkingFn(
      /* nodesetLinkingFn */ nodesetLinkingFn,
      /* angular.Scope */ scope,
      /* Node */ node,
      /* Element */ rootElement,
      /* function(Function) */ boundTranscludeFn,
    ) { }

    function tokenDifference(str1, str2) {
        var values = "",
            tokens1 = str1.split(/\s+/),
            tokens2 = str2.split(/\s+/);

        outer: for (var i = 0; i < tokens1.length; i++) {
            var token = tokens1[i];
            for (var j = 0; j < tokens2.length; j++) {
                if (token == tokens2[j]) continue outer;
            }
            values += (values.length > 0 ? " " : "") + token;
        }
        return values;
    }

    /**
     * @ngdoc object
     * @name ng.$controllerProvider
     * @description
     * The {@link ng.$controller $controller service} is used by Angular to create new
     * controllers.
     *
     * This provider allows controller registration via the
     * {@link ng.$controllerProvider#methods_register register} method.
     */
    function $ControllerProvider() {
        var controllers = {},
            CNTRL_REG = /^(\S+)(\s+as\s+(\w+))?$/;

        /**
         * @ngdoc function
         * @name ng.$controllerProvider#register
         * @methodOf ng.$controllerProvider
         * @param {string|Object} name Controller name, or an object map of controllers where the keys are
         *    the names and the values are the constructors.
         * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
         *    annotations in the array notation).
         */
        this.register = function (name, constructor) {
            assertNotHasOwnProperty(name, "controller");
            if (isObject(name)) {
                extend(controllers, name);
            } else {
                controllers[name] = constructor;
            }
        };

        this.$get = [
            "$injector",
            "$window",
            function ($injector, $window) {
                /**
                 * @ngdoc function
                 * @name ng.$controller
                 * @requires $injector
                 *
                 * @param {Function|string} constructor If called with a function then it's considered to be the
                 *    controller constructor function. Otherwise it's considered to be a string which is used
                 *    to retrieve the controller constructor using the following steps:
                 *
                 *    * check if a controller with given name is registered via `$controllerProvider`
                 *    * check if evaluating the string on the current scope returns a constructor
                 *    * check `window[constructor]` on the global `window` object
                 *
                 * @param {Object} locals Injection locals for Controller.
                 * @return {Object} Instance of given controller.
                 *
                 * @description
                 * `$controller` service is responsible for instantiating controllers.
                 *
                 * It's just a simple call to {@link AUTO.$injector $injector}, but extracted into
                 * a service, so that one can override this service with {@link https://gist.github.com/1649788
                 * BC version}.
                 */
                return function (expression, locals) {
                    var instance, match, constructor, identifier;

                    if (isString(expression)) {
                        (match = expression.match(CNTRL_REG)),
                            (constructor = match[1]),
                            (identifier = match[3]);
                        expression = controllers.hasOwnProperty(constructor)
                            ? controllers[constructor]
                            : getter(locals.$scope, constructor, true) ||
                            getter($window, constructor, true);

                        assertArgFn(expression, constructor, true);
                    }

                    instance = $injector.instantiate(expression, locals);

                    if (identifier) {
                        if (!(locals && typeof locals.$scope == "object")) {
                            throw minErr("$controller")(
                                "noscp",
                                "Cannot export controller '{0}' as '{1}'! No $scope object provided via `locals`.",
                                constructor || expression.name,
                                identifier,
                            );
                        }

                        locals.$scope[identifier] = instance;
                    }

                    return instance;
                };
            },
        ];
    }

    /**
     * @ngdoc object
     * @name ng.$document
     * @requires $window
     *
     * @description
     * A {@link angular.element jQuery (lite)}-wrapped reference to the browser's `window.document`
     * element.
     */
    function $DocumentProvider() {
        this.$get = [
            "$window",
            function (window) {
                return jqLite(window.document);
            },
        ];
    }

    /**
     * @ngdoc function
     * @name ng.$exceptionHandler
     * @requires $log
     *
     * @description
     * Any uncaught exception in angular expressions is delegated to this service.
     * The default implementation simply delegates to `$log.error` which logs it into
     * the browser console.
     *
     * In unit tests, if `angular-mocks.js` is loaded, this service is overridden by
     * {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing.
     *
     * ## Example:
     *
     * <pre>
     *   angular.module('exceptionOverride', []).factory('$exceptionHandler', function () {
     *     return function (exception, cause) {
     *       exception.message += ' (caused by "' + cause + '")';
     *       throw exception;
     *     };
     *   });
     * </pre>
     *
     * This example will override the normal action of `$exceptionHandler`, to make angular
     * exceptions fail hard when they happen, instead of just logging to the console.
     *
     * @param {Error} exception Exception associated with the error.
     * @param {string=} cause optional information about the context in which
     *       the error was thrown.
     *
     */
    function $ExceptionHandlerProvider() {
        this.$get = [
            "$log",
            function ($log) {
                return function (exception, cause) {
                    $log.error.apply($log, arguments);
                };
            },
        ];
    }

    /**
     * Parse headers into key value object
     *
     * @param {string} headers Raw headers as a string
     * @returns {Object} Parsed headers as key value object
     */
    function parseHeaders(headers) {
        var parsed = {},
            key,
            val,
            i;

        if (!headers) return parsed;

        forEach(headers.split("\n"), function (line) {
            i = line.indexOf(":");
            key = lowercase(trim(line.substr(0, i)));
            val = trim(line.substr(i + 1));

            if (key) {
                if (parsed[key]) {
                    parsed[key] += ", " + val;
                } else {
                    parsed[key] = val;
                }
            }
        });

        return parsed;
    }

    /**
     * Returns a function that provides access to parsed headers.
     *
     * Headers are lazy parsed when first requested.
     * @see parseHeaders
     *
     * @param {(string|Object)} headers Headers to provide access to.
     * @returns {function(string=)} Returns a getter function which if called with:
     *
     *   - if called with single an argument returns a single header value or null
     *   - if called with no arguments returns an object containing all headers.
     */
    function headersGetter(headers) {
        var headersObj = isObject(headers) ? headers : undefined;

        return function (name) {
            if (!headersObj) headersObj = parseHeaders(headers);

            if (name) {
                return headersObj[lowercase(name)] || null;
            }

            return headersObj;
        };
    }

    /**
     * Chain all given functions
     *
     * This function is used for both request and response transforming
     *
     * @param {*} data Data to transform.
     * @param {function(string=)} headers Http headers getter fn.
     * @param {(function|Array.<function>)} fns Function or an array of functions.
     * @returns {*} Transformed data.
     */
    function transformData(data, headers, fns) {
        if (isFunction(fns)) return fns(data, headers);

        forEach(fns, function (fn) {
            data = fn(data, headers);
        });

        return data;
    }

    function isSuccess(status) {
        return 200 <= status && status < 300;
    }

    function $HttpProvider() {
        var JSON_START = /^\s*(\[|\{[^\{])/,
            JSON_END = /[\}\]]\s*$/,
            PROTECTION_PREFIX = /^\)\]\}',?\n/,
            CONTENT_TYPE_APPLICATION_JSON = {
                "Content-Type": "application/json;charset=utf-8",
            };

        var defaults = (this.defaults = {
            // transform incoming response data
            transformResponse: [
                function (data) {
                    if (isString(data)) {
                        // strip json vulnerability protection prefix
                        data = data.replace(PROTECTION_PREFIX, "");
                        if (JSON_START.test(data) && JSON_END.test(data))
                            data = fromJson(data);
                    }
                    return data;
                },
            ],

            // transform outgoing request data
            transformRequest: [
                function (d) {
                    return isObject(d) && !isFile(d) ? toJson(d) : d;
                },
            ],

            // default headers
            headers: {
                common: {
                    Accept: "application/json, text/plain, */*",
                },
                post: CONTENT_TYPE_APPLICATION_JSON,
                put: CONTENT_TYPE_APPLICATION_JSON,
                patch: CONTENT_TYPE_APPLICATION_JSON,
            },

            xsrfCookieName: "XSRF-TOKEN",
            xsrfHeaderName: "X-XSRF-TOKEN",
        });

        /**
         * Are ordered by request, i.e. they are applied in the same order as the
         * array, on request, but reverse order, on response.
         */
        var interceptorFactories = (this.interceptors = []);

        /**
         * For historical reasons, response interceptors are ordered by the order in which
         * they are applied to the response. (This is the opposite of interceptorFactories)
         */
        var responseInterceptorFactories = (this.responseInterceptors = []);

        this.$get = [
            "$httpBackend",
            "$browser",
            "$cacheFactory",
            "$rootScope",
            "$q",
            "$injector",
            function (
                $httpBackend,
                $browser,
                $cacheFactory,
                $rootScope,
                $q,
                $injector,
            ) {
                var defaultCache = $cacheFactory("$http");

                /**
                 * Interceptors stored in reverse order. Inner interceptors before outer interceptors.
                 * The reversal is needed so that we can build up the interception chain around the
                 * server request.
                 */
                var reversedInterceptors = [];

                forEach(interceptorFactories, function (interceptorFactory) {
                    reversedInterceptors.unshift(
                        isString(interceptorFactory)
                            ? $injector.get(interceptorFactory)
                            : $injector.invoke(interceptorFactory),
                    );
                });

                forEach(
                    responseInterceptorFactories,
                    function (interceptorFactory, index) {
                        var responseFn = isString(interceptorFactory)
                            ? $injector.get(interceptorFactory)
                            : $injector.invoke(interceptorFactory);

                        /**
                         * Response interceptors go before "around" interceptors (no real reason, just
                         * had to pick one.) But they are already reversed, so we can't use unshift, hence
                         * the splice.
                         */
                        reversedInterceptors.splice(index, 0, {
                            response: function (response) {
                                return responseFn($q.when(response));
                            },
                            responseError: function (response) {
                                return responseFn($q.reject(response));
                            },
                        });
                    },
                );

                /**
             * @ngdoc function
             * @name ng.$http
             * @requires $httpBackend
             * @requires $browser
             * @requires $cacheFactory
             * @requires $rootScope
             * @requires $q
             * @requires $injector
             *
             * @description
             * The `$http` service is a core Angular service that facilitates communication with the remote
             * HTTP servers via the browser's {@link https://developer.mozilla.org/en/xmlhttprequest
             * XMLHttpRequest} object or via {@link http://en.wikipedia.org/wiki/JSONP JSONP}.
             *
             * For unit testing applications that use `$http` service, see
             * {@link ngMock.$httpBackend $httpBackend mock}.
             *
             * For a higher level of abstraction, please check out the {@link ngResource.$resource
             * $resource} service.
             *
             * The $http API is based on the {@link ng.$q deferred/promise APIs} exposed by
             * the $q service. While for simple usage patterns this doesn't matter much, for advanced usage
             * it is important to familiarize yourself with these APIs and the guarantees they provide.
             *
             *
             * # General usage
             * The `$http` service is a function which takes a single argument — a configuration object —
             * that is used to generate an HTTP request and returns  a {@link ng.$q promise}
             * with two $http specific methods: `success` and `error`.
             *
             * <pre>
             *   $http({method: 'GET', url: '/someUrl'}).
             *     success(function(data, status, headers, config) {
             *       // this callback will be called asynchronously
             *       // when the response is available
             *     }).
             *     error(function(data, status, headers, config) {
             *       // called asynchronously if an error occurs
             *       // or server returns response with an error status.
             *     });
             * </pre>
             *
             * Since the returned value of calling the $http function is a `promise`, you can also use
             * the `then` method to register callbacks, and these callbacks will receive a single argument –
             * an object representing the response. See the API signature and type info below for more
             * details.
             *
             * A response status code between 200 and 299 is considered a success status and
             * will result in the success callback being called. Note that if the response is a redirect,
             * XMLHttpRequest will transparently follow it, meaning that the error callback will not be
             * called for such responses.
             * 
             * # Calling $http from outside AngularJS
             * The `$http` service will not actually send the request until the next `$digest()` is
             * executed. Normally this is not an issue, since almost all the time your call to `$http` will
             * be from within a `$apply()` block.
             * If you are calling `$http` from outside Angular, then you should wrap it in a call to
             * `$apply` to cause a $digest to occur and also to handle errors in the block correctly.
             *
             * ```
             * $scope.$apply(function() {
             *   $http(...);
             * });
             * ```
             *
             * # Writing Unit Tests that use $http
             * When unit testing you are mostly responsible for scheduling the `$digest` cycle. If you do
             * not trigger a `$digest` before calling `$httpBackend.flush()` then the request will not have
             * been made and `$httpBackend.expect(...)` expectations will fail.  The solution is to run the
             * code that calls the `$http()` method inside a $apply block as explained in the previous
             * section.
             *
             * ```
             * $httpBackend.expectGET(...);
             * $scope.$apply(function() {
             *   $http.get(...);
             * });
             * $httpBackend.flush();
             * ```
             *
             * # Shortcut methods
             *
             * Since all invocations of the $http service require passing in an HTTP method and URL, and
             * POST/PUT requests require request data to be provided as well, shortcut methods
             * were created:
             *
             * <pre>
             *   $http.get('/someUrl').success(successCallback);
             *   $http.post('/someUrl', data).success(successCallback);
             * </pre>
             *
             * Complete list of shortcut methods:
             *
             * - {@link ng.$http#methods_get $http.get}
             * - {@link ng.$http#methods_head $http.head}
             * - {@link ng.$http#methods_post $http.post}
             * - {@link ng.$http#methods_put $http.put}
             * - {@link ng.$http#methods_delete $http.delete}
             * - {@link ng.$http#methods_jsonp $http.jsonp}
             *
             *
             * # Setting HTTP Headers
             *
             * The $http service will automatically add certain HTTP headers to all requests. These defaults
             * can be fully configured by accessing the `$httpProvider.defaults.headers` configuration
             * object, which currently contains this default configuration:
             *
             * - `$httpProvider.defaults.headers.common` (headers that are common for all requests):
             *   - `Accept: application/json, text/plain, * / *`
             * - `$httpProvider.defaults.headers.post`: (header defaults for POST requests)
             *   - `Content-Type: application/json`
             * - `$httpProvider.defaults.headers.put` (header defaults for PUT requests)
             *   - `Content-Type: application/json`
             *
             * To add or overwrite these defaults, simply add or remove a property from these configuration
             * objects. To add headers for an HTTP method other than POST or PUT, simply add a new object
             * with the lowercased HTTP method name as the key, e.g.
             * `$httpProvider.defaults.headers.get = { 'My-Header' : 'value' }.
             *
             * The defaults can also be set at runtime via the `$http.defaults` object in the same
             * fashion. In addition, you can supply a `headers` property in the config object passed when
             * calling `$http(config)`, which overrides the defaults without changing them globally.
             *
             *
             * # Transforming Requests and Responses
             *
             * Both requests and responses can be transformed using transform functions. By default, Angular
             * applies these transformations:
             *
             * Request transformations:
             *
             * - If the `data` property of the request configuration object contains an object, serialize it
             *   into JSON format.
             *
             * Response transformations:
             *
             *  - If XSRF prefix is detected, strip it (see Security Considerations section below).
             *  - If JSON response is detected, deserialize it using a JSON parser.
             *
             * To globally augment or override the default transforms, modify the
             * `$httpProvider.defaults.transformRequest` and `$httpProvider.defaults.transformResponse`
             * properties. These properties are by default an array of transform functions, which allows you
             * to `push` or `unshift` a new transformation function into the transformation chain. You can
             * also decide to completely override any default transformations by assigning your
             * transformation functions to these properties directly without the array wrapper.
             *
             * Similarly, to locally override the request/response transforms, augment the
             * `transformRequest` and/or `transformResponse` properties of the configuration object passed
             * into `$http`.
             *
             *
             * # Caching
             *
             * To enable caching, set the request configuration `cache` property to `true` (to use default
             * cache) or to a custom cache object (built with {@link ng.$cacheFactory `$cacheFactory`}).
             * When the cache is enabled, `$http` stores the response from the server in the specified
             * cache. The next time the same request is made, the response is served from the cache without
             * sending a request to the server.
             *
             * Note that even if the response is served from cache, delivery of the data is asynchronous in
             * the same way that real requests are.
             *
             * If there are multiple GET requests for the same URL that should be cached using the same
             * cache, but the cache is not populated yet, only one request to the server will be made and
             * the remaining requests will be fulfilled using the response from the first request.
             *
             * You can change the default cache to a new object (built with
             * {@link ng.$cacheFactory `$cacheFactory`}) by updating the
             * {@link ng.$http#properties_defaults `$http.defaults.cache`} property. All requests who set
             * their `cache` property to `true` will now use this cache object.
             *
             * If you set the default cache to `false` then only requests that specify their own custom
             * cache object will be cached.
             *
             * # Interceptors
             *
             * Before you start creating interceptors, be sure to understand the
             * {@link ng.$q $q and deferred/promise APIs}.
             *
             * For purposes of global error handling, authentication, or any kind of synchronous or
             * asynchronous pre-processing of request or postprocessing of responses, it is desirable to be
             * able to intercept requests before they are handed to the server and
             * responses before they are handed over to the application code that
             * initiated these requests. The interceptors leverage the {@link ng.$q
             * promise APIs} to fulfill this need for both synchronous and asynchronous pre-processing.
             *
             * The interceptors are service factories that are registered with the `$httpProvider` by
             * adding them to the `$httpProvider.interceptors` array. The factory is called and
             * injected with dependencies (if specified) and returns the interceptor.
             *
             * There are two kinds of interceptors (and two kinds of rejection interceptors):
             *
             *   * `request`: interceptors get called with http `config` object. The function is free to
             *     modify the `config` or create a new one. The function needs to return the `config`
             *     directly or as a promise.
             *   * `requestError`: interceptor gets called when a previous interceptor threw an error or
             *     resolved with a rejection.
             *   * `response`: interceptors get called with http `response` object. The function is free to
             *     modify the `response` or create a new one. The function needs to return the `response`
             *     directly or as a promise.
             *   * `responseError`: interceptor gets called when a previous interceptor threw an error or
             *     resolved with a rejection.
             *
             *
             * <pre>
             *   // register the interceptor as a service
             *   $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
             *     return {
             *       // optional method
             *       'request': function(config) {
             *         // do something on success
             *         return config || $q.when(config);
             *       },
             *
             *       // optional method
             *      'requestError': function(rejection) {
             *         // do something on error
             *         if (canRecover(rejection)) {
             *           return responseOrNewPromise
             *         }
             *         return $q.reject(rejection);
             *       },
             *
             *
             *
             *       // optional method
             *       'response': function(response) {
             *         // do something on success
             *         return response || $q.when(response);
             *       },
             *
             *       // optional method
             *      'responseError': function(rejection) {
             *         // do something on error
             *         if (canRecover(rejection)) {
             *           return responseOrNewPromise
             *         }
             *         return $q.reject(rejection);
             *       };
             *     }
             *   });
             *
             *   $httpProvider.interceptors.push('myHttpInterceptor');
             *
             *
             *   // register the interceptor via an anonymous factory
             *   $httpProvider.interceptors.push(function($q, dependency1, dependency2) {
             *     return {
             *      'request': function(config) {
             *          // same as above
             *       },
             *       'response': function(response) {
             *          // same as above
             *       }
             *     };
             *   });
             * </pre>
             *
             * # Response interceptors (DEPRECATED)
             *
             * Before you start creating interceptors, be sure to understand the
             * {@link ng.$q $q and deferred/promise APIs}.
             *
             * For purposes of global error handling, authentication or any kind of synchronous or
             * asynchronous preprocessing of received responses, it is desirable to be able to intercept
             * responses for http requests before they are handed over to the application code that
             * initiated these requests. The response interceptors leverage the {@link ng.$q
             * promise apis} to fulfil this need for both synchronous and asynchronous preprocessing.
             *
             * The interceptors are service factories that are registered with the $httpProvider by
             * adding them to the `$httpProvider.responseInterceptors` array. The factory is called and
             * injected with dependencies (if specified) and returns the interceptor  — a function that
             * takes a {@link ng.$q promise} and returns the original or a new promise.
             *
             * <pre>
             *   // register the interceptor as a service
             *   $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
             *     return function(promise) {
             *       return promise.then(function(response) {
             *         // do something on success
             *         return response;
             *       }, function(response) {
             *         // do something on error
             *         if (canRecover(response)) {
             *           return responseOrNewPromise
             *         }
             *         return $q.reject(response);
             *       });
             *     }
             *   });
             *
             *   $httpProvider.responseInterceptors.push('myHttpInterceptor');
             *
             *
             *   // register the interceptor via an anonymous factory
             *   $httpProvider.responseInterceptors.push(function($q, dependency1, dependency2) {
             *     return function(promise) {
             *       // same as above
             *     }
             *   });
             * </pre>
             *
             *
             * # Security Considerations
             *
             * When designing web applications, consider security threats from:
             *
             * - {@link http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
             *   JSON vulnerability}
             * - {@link http://en.wikipedia.org/wiki/Cross-site_request_forgery XSRF}
             *
             * Both server and the client must cooperate in order to eliminate these threats. Angular comes
             * pre-configured with strategies that address these issues, but for this to work backend server
             * cooperation is required.
             *
             * ## JSON Vulnerability Protection
             *
             * A {@link http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
             * JSON vulnerability} allows third party website to turn your JSON resource URL into
             * {@link http://en.wikipedia.org/wiki/JSONP JSONP} request under some conditions. To
             * counter this your server can prefix all JSON requests with following string `")]}',\n"`.
             * Angular will automatically strip the prefix before processing it as JSON.
             *
             * For example if your server needs to return:
             * <pre>
             * ['one','two']
             * </pre>
             *
             * which is vulnerable to attack, your server can return:
             * <pre>
             * )]}',
             * ['one','two']
             * </pre>
             *
             * Angular will strip the prefix, before processing the JSON.
             *
             *
             * ## Cross Site Request Forgery (XSRF) Protection
             *
             * {@link http://en.wikipedia.org/wiki/Cross-site_request_forgery XSRF} is a technique by which
             * an unauthorized site can gain your user's private data. Angular provides a mechanism
             * to counter XSRF. When performing XHR requests, the $http service reads a token from a cookie
             * (by default, `XSRF-TOKEN`) and sets it as an HTTP header (`X-XSRF-TOKEN`). Since only
             * JavaScript that runs on your domain could read the cookie, your server can be assured that
             * the XHR came from JavaScript running on your domain. The header will not be set for
             * cross-domain requests.
             *
             * To take advantage of this, your server needs to set a token in a JavaScript readable session
             * cookie called `XSRF-TOKEN` on the first HTTP GET request. On subsequent XHR requests the
             * server can verify that the cookie matches `X-XSRF-TOKEN` HTTP header, and therefore be sure
             * that only JavaScript running on your domain could have sent the request. The token must be
             * unique for each user and must be verifiable by the server (to prevent the JavaScript from
             * making up its own tokens). We recommend that the token is a digest of your site's
             * authentication cookie with a {@link https://en.wikipedia.org/wiki/Salt_(cryptography) salt}
             * for added security.
             *
             * The name of the headers can be specified using the xsrfHeaderName and xsrfCookieName
             * properties of either $httpProvider.defaults, or the per-request config object.
             *
             *
             * @param {object} config Object describing the request to be made and how it should be
             *    processed. The object has following properties:
             *
             *    - **method** – `{string}` – HTTP method (e.g. 'GET', 'POST', etc)
             *    - **url** – `{string}` – Absolute or relative URL of the resource that is being requested.
             *    - **params** – `{Object.<string|Object>}` – Map of strings or objects which will be turned
             *      to `?key1=value1&key2=value2` after the url. If the value is not a string, it will be
             *      JSONified.
             *    - **data** – `{string|Object}` – Data to be sent as the request message data.
             *    - **headers** – `{Object}` – Map of strings or functions which return strings representing
             *      HTTP headers to send to the server. If the return value of a function is null, the
             *      header will not be sent.
             *    - **xsrfHeaderName** – `{string}` – Name of HTTP header to populate with the XSRF token.
             *    - **xsrfCookieName** – `{string}` – Name of cookie containing the XSRF token.
             *    - **transformRequest** –
             *      `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
             *      transform function or an array of such functions. The transform function takes the http
             *      request body and headers and returns its transformed (typically serialized) version.
             *    - **transformResponse** –
             *      `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
             *      transform function or an array of such functions. The transform function takes the http
             *      response body and headers and returns its transformed (typically deserialized) version.
             *    - **cache** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the
             *      GET request, otherwise if a cache instance built with
             *      {@link ng.$cacheFactory $cacheFactory}, this cache will be used for
             *      caching.
             *    - **timeout** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise}
             *      that should abort the request when resolved.
             *    - **withCredentials** - `{boolean}` - whether to to set the `withCredentials` flag on the
             *      XHR object. See {@link https://developer.mozilla.org/en/http_access_control#section_5
             *      requests with credentials} for more information.
             *    - **responseType** - `{string}` - see {@link
             *      https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType requestType}.
             *
             * @returns {HttpPromise} Returns a {@link ng.$q promise} object with the
             *   standard `then` method and two http specific methods: `success` and `error`. The `then`
             *   method takes two arguments a success and an error callback which will be called with a
             *   response object. The `success` and `error` methods take a single argument - a function that
             *   will be called when the request succeeds or fails respectively. The arguments passed into
             *   these functions are destructured representation of the response object passed into the
             *   `then` method. The response object has these properties:
             *
             *   - **data** – `{string|Object}` – The response body transformed with the transform
             *     functions.
             *   - **status** – `{number}` – HTTP status code of the response.
             *   - **headers** – `{function([headerName])}` – Header getter function.
             *   - **config** – `{Object}` – The configuration object that was used to generate the request.
             *
             * @property {Array.<Object>} pendingRequests Array of config objects for currently pending
             *   requests. This is primarily meant to be used for debugging purposes.
             *
             *
             * @example
        <example>
        <file name="index.html">
          <div ng-controller="FetchCtrl">
            <select ng-model="method">
              <option>GET</option>
              <option>JSONP</option>
            </select>
            <input type="text" ng-model="url" size="80"/>
            <button ng-click="fetch()">fetch</button><br>
            <button ng-click="updateModel('GET', 'http-hello.html')">Sample GET</button>
            <button
              ng-click="updateModel('JSONP',
                            'http://angularjs.org/greet.php?callback=JSON_CALLBACK&name=Super%20Hero')">
              Sample JSONP
            </button>
            <button
              ng-click="updateModel('JSONP', 'http://angularjs.org/doesntexist&callback=JSON_CALLBACK')">
                Invalid JSONP
              </button>
            <pre>http status code: {{status}}</pre>
            <pre>http response data: {{data}}</pre>
          </div>
        </file>
        <file name="script.js">
          function FetchCtrl($scope, $http, $templateCache) {
            $scope.method = 'GET';
            $scope.url = 'http-hello.html';
        
            $scope.fetch = function() {
              $scope.code = null;
              $scope.response = null;
        
              $http({method: $scope.method, url: $scope.url, cache: $templateCache}).
                success(function(data, status) {
                  $scope.status = status;
                  $scope.data = data;
                }).
                error(function(data, status) {
                  $scope.data = data || "Request failed";
                  $scope.status = status;
              });
            };
        
            $scope.updateModel = function(method, url) {
              $scope.method = method;
              $scope.url = url;
            };
          }
        </file>
        <file name="http-hello.html">
          Hello, $http!
        </file>
        <file name="scenario.js">
          it('should make an xhr GET request', function() {
            element(':button:contains("Sample GET")').click();
            element(':button:contains("fetch")').click();
            expect(binding('status')).toBe('200');
            expect(binding('data')).toMatch(/Hello, \$http!/);
          });
        
          it('should make a JSONP request to angularjs.org', function() {
            element(':button:contains("Sample JSONP")').click();
            element(':button:contains("fetch")').click();
            expect(binding('status')).toBe('200');
            expect(binding('data')).toMatch(/Super Hero!/);
          });
        
          it('should make JSONP request to invalid URL and invoke the error handler',
              function() {
            element(':button:contains("Invalid JSONP")').click();
            element(':button:contains("fetch")').click();
            expect(binding('status')).toBe('0');
            expect(binding('data')).toBe('Request failed');
          });
        </file>
        </example>
             */
                function $http(requestConfig) {
                    var config = {
                        transformRequest: defaults.transformRequest,
                        transformResponse: defaults.transformResponse,
                    };
                    var headers = mergeHeaders(requestConfig);

                    extend(config, requestConfig);
                    config.headers = headers;
                    config.method = uppercase(config.method);

                    var xsrfValue = urlIsSameOrigin(config.url)
                        ? $browser.cookies()[
                        config.xsrfCookieName || defaults.xsrfCookieName
                        ]
                        : undefined;
                    if (xsrfValue) {
                        headers[config.xsrfHeaderName || defaults.xsrfHeaderName] =
                            xsrfValue;
                    }

                    var serverRequest = function (config) {
                        headers = config.headers;
                        var reqData = transformData(
                            config.data,
                            headersGetter(headers),
                            config.transformRequest,
                        );

                        // strip content-type if data is undefined
                        if (isUndefined(config.data)) {
                            forEach(headers, function (value, header) {
                                if (lowercase(header) === "content-type") {
                                    delete headers[header];
                                }
                            });
                        }

                        if (
                            isUndefined(config.withCredentials) &&
                            !isUndefined(defaults.withCredentials)
                        ) {
                            config.withCredentials = defaults.withCredentials;
                        }

                        // send request
                        return sendReq(config, reqData, headers).then(
                            transformResponse,
                            transformResponse,
                        );
                    };

                    var chain = [serverRequest, undefined];
                    var promise = $q.when(config);

                    // apply interceptors
                    forEach(reversedInterceptors, function (interceptor) {
                        if (interceptor.request || interceptor.requestError) {
                            chain.unshift(interceptor.request, interceptor.requestError);
                        }
                        if (interceptor.response || interceptor.responseError) {
                            chain.push(interceptor.response, interceptor.responseError);
                        }
                    });

                    while (chain.length) {
                        var thenFn = chain.shift();
                        var rejectFn = chain.shift();

                        promise = promise.then(thenFn, rejectFn);
                    }

                    promise.success = function (fn) {
                        promise.then(function (response) {
                            fn(response.data, response.status, response.headers, config);
                        });
                        return promise;
                    };

                    promise.error = function (fn) {
                        promise.then(null, function (response) {
                            fn(response.data, response.status, response.headers, config);
                        });
                        return promise;
                    };

                    return promise;

                    function transformResponse(response) {
                        // make a copy since the response must be cacheable
                        var resp = extend({}, response, {
                            data: transformData(
                                response.data,
                                response.headers,
                                config.transformResponse,
                            ),
                        });
                        return isSuccess(response.status) ? resp : $q.reject(resp);
                    }

                    function mergeHeaders(config) {
                        var defHeaders = defaults.headers,
                            reqHeaders = extend({}, config.headers),
                            defHeaderName,
                            lowercaseDefHeaderName,
                            reqHeaderName;

                        defHeaders = extend(
                            {},
                            defHeaders.common,
                            defHeaders[lowercase(config.method)],
                        );

                        // execute if header value is function
                        execHeaders(defHeaders);
                        execHeaders(reqHeaders);

                        // using for-in instead of forEach to avoid unecessary iteration after header has been found
                        defaultHeadersIteration: for (defHeaderName in defHeaders) {
                            lowercaseDefHeaderName = lowercase(defHeaderName);

                            for (reqHeaderName in reqHeaders) {
                                if (lowercase(reqHeaderName) === lowercaseDefHeaderName) {
                                    continue defaultHeadersIteration;
                                }
                            }

                            reqHeaders[defHeaderName] = defHeaders[defHeaderName];
                        }

                        return reqHeaders;

                        function execHeaders(headers) {
                            var headerContent;

                            forEach(headers, function (headerFn, header) {
                                if (isFunction(headerFn)) {
                                    headerContent = headerFn();
                                    if (headerContent != null) {
                                        headers[header] = headerContent;
                                    } else {
                                        delete headers[header];
                                    }
                                }
                            });
                        }
                    }
                }

                $http.pendingRequests = [];

                /**
                 * @ngdoc method
                 * @name ng.$http#get
                 * @methodOf ng.$http
                 *
                 * @description
                 * Shortcut method to perform `GET` request.
                 *
                 * @param {string} url Relative or absolute URL specifying the destination of the request
                 * @param {Object=} config Optional configuration object
                 * @returns {HttpPromise} Future object
                 */

                /**
                 * @ngdoc method
                 * @name ng.$http#delete
                 * @methodOf ng.$http
                 *
                 * @description
                 * Shortcut method to perform `DELETE` request.
                 *
                 * @param {string} url Relative or absolute URL specifying the destination of the request
                 * @param {Object=} config Optional configuration object
                 * @returns {HttpPromise} Future object
                 */

                /**
                 * @ngdoc method
                 * @name ng.$http#head
                 * @methodOf ng.$http
                 *
                 * @description
                 * Shortcut method to perform `HEAD` request.
                 *
                 * @param {string} url Relative or absolute URL specifying the destination of the request
                 * @param {Object=} config Optional configuration object
                 * @returns {HttpPromise} Future object
                 */

                /**
                 * @ngdoc method
                 * @name ng.$http#jsonp
                 * @methodOf ng.$http
                 *
                 * @description
                 * Shortcut method to perform `JSONP` request.
                 *
                 * @param {string} url Relative or absolute URL specifying the destination of the request.
                 *                     Should contain `JSON_CALLBACK` string.
                 * @param {Object=} config Optional configuration object
                 * @returns {HttpPromise} Future object
                 */
                createShortMethods("get", "delete", "head", "jsonp");

                /**
                 * @ngdoc method
                 * @name ng.$http#post
                 * @methodOf ng.$http
                 *
                 * @description
                 * Shortcut method to perform `POST` request.
                 *
                 * @param {string} url Relative or absolute URL specifying the destination of the request
                 * @param {*} data Request content
                 * @param {Object=} config Optional configuration object
                 * @returns {HttpPromise} Future object
                 */

                /**
                 * @ngdoc method
                 * @name ng.$http#put
                 * @methodOf ng.$http
                 *
                 * @description
                 * Shortcut method to perform `PUT` request.
                 *
                 * @param {string} url Relative or absolute URL specifying the destination of the request
                 * @param {*} data Request content
                 * @param {Object=} config Optional configuration object
                 * @returns {HttpPromise} Future object
                 */
                createShortMethodsWithData("post", "put");

                /**
                 * @ngdoc property
                 * @name ng.$http#defaults
                 * @propertyOf ng.$http
                 *
                 * @description
                 * Runtime equivalent of the `$httpProvider.defaults` property. Allows configuration of
                 * default headers, withCredentials as well as request and response transformations.
                 *
                 * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
                 */
                $http.defaults = defaults;

                return $http;

                function createShortMethods(names) {
                    forEach(arguments, function (name) {
                        $http[name] = function (url, config) {
                            return $http(
                                extend(config || {}, {
                                    method: name,
                                    url: url,
                                }),
                            );
                        };
                    });
                }

                function createShortMethodsWithData(name) {
                    forEach(arguments, function (name) {
                        $http[name] = function (url, data, config) {
                            return $http(
                                extend(config || {}, {
                                    method: name,
                                    url: url,
                                    data: data,
                                }),
                            );
                        };
                    });
                }

                /**
                 * Makes the request.
                 *
                 * !!! ACCESSES CLOSURE VARS:
                 * $httpBackend, defaults, $log, $rootScope, defaultCache, $http.pendingRequests
                 */
                function sendReq(config, reqData, reqHeaders) {
                    var deferred = $q.defer(),
                        promise = deferred.promise,
                        cache,
                        cachedResp,
                        url = buildUrl(config.url, config.params);

                    $http.pendingRequests.push(config);
                    promise.then(removePendingReq, removePendingReq);

                    if (
                        (config.cache || defaults.cache) &&
                        config.cache !== false &&
                        config.method == "GET"
                    ) {
                        cache = isObject(config.cache)
                            ? config.cache
                            : isObject(defaults.cache)
                                ? defaults.cache
                                : defaultCache;
                    }

                    if (cache) {
                        cachedResp = cache.get(url);
                        if (isDefined(cachedResp)) {
                            if (cachedResp.then) {
                                // cached request has already been sent, but there is no response yet
                                cachedResp.then(removePendingReq, removePendingReq);
                                return cachedResp;
                            } else {
                                // serving from cache
                                if (isArray(cachedResp)) {
                                    resolvePromise(
                                        cachedResp[1],
                                        cachedResp[0],
                                        copy(cachedResp[2]),
                                    );
                                } else {
                                    resolvePromise(cachedResp, 200, {});
                                }
                            }
                        } else {
                            // put the promise for the non-transformed response into cache as a placeholder
                            cache.put(url, promise);
                        }
                    }

                    // if we won't have the response in cache, send the request to the backend
                    if (isUndefined(cachedResp)) {
                        $httpBackend(
                            config.method,
                            url,
                            reqData,
                            done,
                            reqHeaders,
                            config.timeout,
                            config.withCredentials,
                            config.responseType,
                        );
                    }

                    return promise;

                    /**
                     * Callback registered to $httpBackend():
                     *  - caches the response if desired
                     *  - resolves the raw $http promise
                     *  - calls $apply
                     */
                    function done(status, response, headersString) {
                        if (cache) {
                            if (isSuccess(status)) {
                                cache.put(url, [status, response, parseHeaders(headersString)]);
                            } else {
                                // remove promise from the cache
                                cache.remove(url);
                            }
                        }

                        resolvePromise(response, status, headersString);
                        if (!$rootScope.$$phase) $rootScope.$apply();
                    }

                    /**
                     * Resolves the raw $http promise.
                     */
                    function resolvePromise(response, status, headers) {
                        // normalize internal statuses to 0
                        status = Math.max(status, 0);

                        (isSuccess(status) ? deferred.resolve : deferred.reject)({
                            data: response,
                            status: status,
                            headers: headersGetter(headers),
                            config: config,
                        });
                    }

                    function removePendingReq() {
                        var idx = indexOf($http.pendingRequests, config);
                        if (idx !== -1) $http.pendingRequests.splice(idx, 1);
                    }
                }

                function buildUrl(url, params) {
                    if (!params) return url;
                    var parts = [];
                    forEachSorted(params, function (value, key) {
                        if (value === null || isUndefined(value)) return;
                        if (!isArray(value)) value = [value];

                        forEach(value, function (v) {
                            if (isObject(v)) {
                                v = toJson(v);
                            }
                            parts.push(encodeUriQuery(key) + "=" + encodeUriQuery(v));
                        });
                    });
                    return url + (url.indexOf("?") == -1 ? "?" : "&") + parts.join("&");
                }
            },
        ];
    }

    var XHR =
        window.XMLHttpRequest ||
        function () {
            /* global ActiveXObject */
            try {
                return new ActiveXObject("Msxml2.XMLHTTP.6.0");
            } catch (e1) { }
            try {
                return new ActiveXObject("Msxml2.XMLHTTP.3.0");
            } catch (e2) { }
            try {
                return new ActiveXObject("Msxml2.XMLHTTP");
            } catch (e3) { }
            throw minErr("$httpBackend")(
                "noxhr",
                "This browser does not support XMLHttpRequest.",
            );
        };

    /**
     * @ngdoc object
     * @name ng.$httpBackend
     * @requires $browser
     * @requires $window
     * @requires $document
     *
     * @description
     * HTTP backend used by the {@link ng.$http service} that delegates to
     * XMLHttpRequest object or JSONP and deals with browser incompatibilities.
     *
     * You should never need to use this service directly, instead use the higher-level abstractions:
     * {@link ng.$http $http} or {@link ngResource.$resource $resource}.
     *
     * During testing this implementation is swapped with {@link ngMock.$httpBackend mock
     * $httpBackend} which can be trained with responses.
     */
    function $HttpBackendProvider() {
        this.$get = [
            "$browser",
            "$window",
            "$document",
            function ($browser, $window, $document) {
                return createHttpBackend(
                    $browser,
                    XHR,
                    $browser.defer,
                    $window.angular.callbacks,
                    $document[0],
                );
            },
        ];
    }

    function createHttpBackend(
        $browser,
        XHR,
        $browserDefer,
        callbacks,
        rawDocument,
    ) {
        var ABORTED = -1;

        // TODO(vojta): fix the signature
        return function (
            method,
            url,
            post,
            callback,
            headers,
            timeout,
            withCredentials,
            responseType,
        ) {
            var status;
            $browser.$$incOutstandingRequestCount();
            url = url || $browser.url();

            if (lowercase(method) == "jsonp") {
                var callbackId = "_" + (callbacks.counter++).toString(36);
                callbacks[callbackId] = function (data) {
                    callbacks[callbackId].data = data;
                };

                var jsonpDone = jsonpReq(
                    url.replace("JSON_CALLBACK", "angular.callbacks." + callbackId),
                    function () {
                        if (callbacks[callbackId].data) {
                            completeRequest(callback, 200, callbacks[callbackId].data);
                        } else {
                            completeRequest(callback, status || -2);
                        }
                        delete callbacks[callbackId];
                    },
                );
            } else {
                var xhr = new XHR();
                xhr.open(method, url, true);
                forEach(headers, function (value, key) {
                    if (isDefined(value)) {
                        xhr.setRequestHeader(key, value);
                    }
                });

                // In IE6 and 7, this might be called synchronously when xhr.send below is called and the
                // response is in the cache. the promise api will ensure that to the app code the api is
                // always async
                xhr.onreadystatechange = function () {
                    if (xhr.readyState == 4) {
                        var responseHeaders = null,
                            response = null;

                        if (status !== ABORTED) {
                            responseHeaders = xhr.getAllResponseHeaders();
                            response = xhr.responseType ? xhr.response : xhr.responseText;
                        }

                        // responseText is the old-school way of retrieving response (supported by IE8 & 9)
                        // response/responseType properties were introduced in XHR Level2 spec (supported by IE10)
                        completeRequest(
                            callback,
                            status || xhr.status,
                            response,
                            responseHeaders,
                        );
                    }
                };

                if (withCredentials) {
                    xhr.withCredentials = true;
                }

                if (responseType) {
                    xhr.responseType = responseType;
                }

                xhr.send(post || null);
            }

            if (timeout > 0) {
                var timeoutId = $browserDefer(timeoutRequest, timeout);
            } else if (timeout && timeout.then) {
                timeout.then(timeoutRequest);
            }

            function timeoutRequest() {
                status = ABORTED;
                jsonpDone && jsonpDone();
                xhr && xhr.abort();
            }

            function completeRequest(callback, status, response, headersString) {
                var protocol = urlResolve(url).protocol;

                // cancel timeout and subsequent timeout promise resolution
                timeoutId && $browserDefer.cancel(timeoutId);
                jsonpDone = xhr = null;

                // fix status code for file protocol (it's always 0)
                status =
                    protocol == "file" && status === 0 ? (response ? 200 : 404) : status;

                // normalize IE bug (http://bugs.jquery.com/ticket/1450)
                status = status == 1223 ? 204 : status;

                callback(status, response, headersString);
                $browser.$$completeOutstandingRequest(noop);
            }
        };

        function jsonpReq(url, done) {
            // we can't use jQuery/jqLite here because jQuery does crazy shit with script elements, e.g.:
            // - fetches local scripts via XHR and evals them
            // - adds and immediately removes script elements from the document
            var script = rawDocument.createElement("script"),
                doneWrapper = function () {
                    script.onreadystatechange = script.onload = script.onerror = null;
                    rawDocument.body.removeChild(script);
                    if (done) done();
                };

            script.type = "text/javascript";
            script.src = url;

            if (msie && msie <= 8) {
                script.onreadystatechange = function () {
                    if (/loaded|complete/.test(script.readyState)) {
                        doneWrapper();
                    }
                };
            } else {
                script.onload = script.onerror = function () {
                    doneWrapper();
                };
            }

            rawDocument.body.appendChild(script);
            return doneWrapper;
        }
    }

    var $interpolateMinErr = minErr("$interpolate");

    /**
   * @ngdoc object
   * @name ng.$interpolateProvider
   * @function
   *
   * @description
   *
   * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
   *
   * @example
  <doc:example module="customInterpolationApp">
  <doc:source>
  <script>
    var customInterpolationApp = angular.module('customInterpolationApp', []);
  
    customInterpolationApp.config(function($interpolateProvider) {
      $interpolateProvider.startSymbol('//');
      $interpolateProvider.endSymbol('//');
    });
  
  
    customInterpolationApp.controller('DemoController', function DemoController() {
        this.label = "This binding is brought you by // interpolation symbols.";
    });
  </script>
  <div ng-app="App" ng-controller="DemoController as demo">
      //demo.label//
  </div>
  </doc:source>
  <doc:scenario>
   it('should interpolate binding with custom symbols', function() {
    expect(binding('demo.label')).toBe('This binding is brought you by // interpolation symbols.');
   });
  </doc:scenario>
  </doc:example>
   */
    function $InterpolateProvider() {
        var startSymbol = "{{";
        var endSymbol = "}}";

        /**
         * @ngdoc method
         * @name ng.$interpolateProvider#startSymbol
         * @methodOf ng.$interpolateProvider
         * @description
         * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
         *
         * @param {string=} value new value to set the starting symbol to.
         * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
         */
        this.startSymbol = function (value) {
            if (value) {
                startSymbol = value;
                return this;
            } else {
                return startSymbol;
            }
        };

        /**
         * @ngdoc method
         * @name ng.$interpolateProvider#endSymbol
         * @methodOf ng.$interpolateProvider
         * @description
         * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
         *
         * @param {string=} value new value to set the ending symbol to.
         * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
         */
        this.endSymbol = function (value) {
            if (value) {
                endSymbol = value;
                return this;
            } else {
                return endSymbol;
            }
        };

        this.$get = [
            "$parse",
            "$exceptionHandler",
            "$sce",
            function ($parse, $exceptionHandler, $sce) {
                var startSymbolLength = startSymbol.length,
                    endSymbolLength = endSymbol.length;

                /**
             * @ngdoc function
             * @name ng.$interpolate
             * @function
             *
             * @requires $parse
             * @requires $sce
             *
             * @description
             *
             * Compiles a string with markup into an interpolation function. This service is used by the
             * HTML {@link ng.$compile $compile} service for data binding. See
             * {@link ng.$interpolateProvider $interpolateProvider} for configuring the
             * interpolation markup.
             *
             *
               <pre>
                 var $interpolate = ...; // injected
                 var exp = $interpolate('Hello {{name | uppercase}}!');
                 expect(exp({name:'Angular'}).toEqual('Hello ANGULAR!');
               </pre>
             *
             *
             * @param {string} text The text with markup to interpolate.
             * @param {boolean=} mustHaveExpression if set to true then the interpolation string must have
             *    embedded expression in order to return an interpolation function. Strings with no
             *    embedded expression will return null for the interpolation function.
             * @param {string=} trustedContext when provided, the returned function passes the interpolated
             *    result through {@link ng.$sce#methods_getTrusted $sce.getTrusted(interpolatedResult,
             *    trustedContext)} before returning it.  Refer to the {@link ng.$sce $sce} service that
             *    provides Strict Contextual Escaping for details.
             * @returns {function(context)} an interpolation function which is used to compute the
             *    interpolated string. The function has these parameters:
             *
             *    * `context`: an object against which any expressions embedded in the strings are evaluated
             *      against.
             *
             */
                function $interpolate(text, mustHaveExpression, trustedContext) {
                    var startIndex,
                        endIndex,
                        index = 0,
                        parts = [],
                        length = text.length,
                        hasInterpolation = false,
                        fn,
                        exp,
                        concat = [];

                    while (index < length) {
                        if (
                            (startIndex = text.indexOf(startSymbol, index)) != -1 &&
                            (endIndex = text.indexOf(
                                endSymbol,
                                startIndex + startSymbolLength,
                            )) != -1
                        ) {
                            index != startIndex &&
                                parts.push(text.substring(index, startIndex));
                            parts.push(
                                (fn = $parse(
                                    (exp = text.substring(
                                        startIndex + startSymbolLength,
                                        endIndex,
                                    )),
                                )),
                            );
                            fn.exp = exp;
                            index = endIndex + endSymbolLength;
                            hasInterpolation = true;
                        } else {
                            // we did not find anything, so we have to add the remainder to the parts array
                            index != length && parts.push(text.substring(index));
                            index = length;
                        }
                    }

                    if (!(length = parts.length)) {
                        // we added, nothing, must have been an empty string.
                        parts.push("");
                        length = 1;
                    }

                    // Concatenating expressions makes it hard to reason about whether some combination of
                    // concatenated values are unsafe to use and could easily lead to XSS.  By requiring that a
                    // single expression be used for iframe[src], object[src], etc., we ensure that the value
                    // that's used is assigned or constructed by some JS code somewhere that is more testable or
                    // make it obvious that you bound the value to some user controlled value.  This helps reduce
                    // the load when auditing for XSS issues.
                    if (trustedContext && parts.length > 1) {
                        throw $interpolateMinErr(
                            "noconcat",
                            "Error while interpolating: {0}\nStrict Contextual Escaping disallows " +
                            "interpolations that concatenate multiple expressions when a trusted value is " +
                            "required.  See http://docs.angularjs.org/api/ng.$sce",
                            text,
                        );
                    }

                    if (!mustHaveExpression || hasInterpolation) {
                        concat.length = length;
                        fn = function (context) {
                            try {
                                for (var i = 0, ii = length, part; i < ii; i++) {
                                    if (typeof (part = parts[i]) == "function") {
                                        part = part(context);
                                        if (trustedContext) {
                                            part = $sce.getTrusted(trustedContext, part);
                                        } else {
                                            part = $sce.valueOf(part);
                                        }
                                        if (part === null || isUndefined(part)) {
                                            part = "";
                                        } else if (typeof part != "string") {
                                            part = toJson(part);
                                        }
                                    }
                                    concat[i] = part;
                                }
                                return concat.join("");
                            } catch (err) {
                                var newErr = $interpolateMinErr(
                                    "interr",
                                    "Can't interpolate: {0}\n{1}",
                                    text,
                                    err.toString(),
                                );
                                $exceptionHandler(newErr);
                            }
                        };
                        fn.exp = text;
                        fn.parts = parts;
                        return fn;
                    }
                }

                /**
                 * @ngdoc method
                 * @name ng.$interpolate#startSymbol
                 * @methodOf ng.$interpolate
                 * @description
                 * Symbol to denote the start of expression in the interpolated string. Defaults to `{{`.
                 *
                 * Use {@link ng.$interpolateProvider#startSymbol $interpolateProvider#startSymbol} to change
                 * the symbol.
                 *
                 * @returns {string} start symbol.
                 */
                $interpolate.startSymbol = function () {
                    return startSymbol;
                };

                /**
                 * @ngdoc method
                 * @name ng.$interpolate#endSymbol
                 * @methodOf ng.$interpolate
                 * @description
                 * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
                 *
                 * Use {@link ng.$interpolateProvider#endSymbol $interpolateProvider#endSymbol} to change
                 * the symbol.
                 *
                 * @returns {string} start symbol.
                 */
                $interpolate.endSymbol = function () {
                    return endSymbol;
                };

                return $interpolate;
            },
        ];
    }

    function $IntervalProvider() {
        this.$get = [
            "$rootScope",
            "$window",
            "$q",
            function ($rootScope, $window, $q) {
                var intervals = {};

                /**
                 * @ngdoc function
                 * @name ng.$interval
                 *
                 * @description
                 * Angular's wrapper for `window.setInterval`. The `fn` function is executed every `delay`
                 * milliseconds.
                 *
                 * The return value of registering an interval function is a promise. This promise will be
                 * notified upon each tick of the interval, and will be resolved after `count` iterations, or
                 * run indefinitely if `count` is not defined. The value of the notification will be the
                 * number of iterations that have run.
                 * To cancel an interval, call `$interval.cancel(promise)`.
                 *
                 * In tests you can use {@link ngMock.$interval#methods_flush `$interval.flush(millis)`} to
                 * move forward by `millis` milliseconds and trigger any functions scheduled to run in that
                 * time.
                 *
                 * @param {function()} fn A function that should be called repeatedly.
                 * @param {number} delay Number of milliseconds between each function call.
                 * @param {number=} [count=0] Number of times to repeat. If not set, or 0, will repeat
                 *   indefinitely.
                 * @param {boolean=} [invokeApply=true] If set to `false` skips model dirty checking, otherwise
                 *   will invoke `fn` within the {@link ng.$rootScope.Scope#methods_$apply $apply} block.
                 * @returns {promise} A promise which will be notified on each iteration.
                 */
                function interval(fn, delay, count, invokeApply) {
                    var setInterval = $window.setInterval,
                        clearInterval = $window.clearInterval,
                        deferred = $q.defer(),
                        promise = deferred.promise,
                        iteration = 0,
                        skipApply = isDefined(invokeApply) && !invokeApply;

                    (count = isDefined(count) ? count : 0), promise.then(null, null, fn);

                    promise.$$intervalId = setInterval(function tick() {
                        deferred.notify(iteration++);

                        if (count > 0 && iteration >= count) {
                            deferred.resolve(iteration);
                            clearInterval(promise.$$intervalId);
                            delete intervals[promise.$$intervalId];
                        }

                        if (!skipApply) $rootScope.$apply();
                    }, delay);

                    intervals[promise.$$intervalId] = deferred;

                    return promise;
                }

                /**
                 * @ngdoc function
                 * @name ng.$interval#cancel
                 * @methodOf ng.$interval
                 *
                 * @description
                 * Cancels a task associated with the `promise`.
                 *
                 * @param {number} promise Promise returned by the `$interval` function.
                 * @returns {boolean} Returns `true` if the task was successfully canceled.
                 */
                interval.cancel = function (promise) {
                    if (promise && promise.$$intervalId in intervals) {
                        intervals[promise.$$intervalId].reject("canceled");
                        clearInterval(promise.$$intervalId);
                        delete intervals[promise.$$intervalId];
                        return true;
                    }
                    return false;
                };

                return interval;
            },
        ];
    }

    /**
     * @ngdoc object
     * @name ng.$locale
     *
     * @description
     * $locale service provides localization rules for various Angular components. As of right now the
     * only public api is:
     *
     * * `id` – `{string}` – locale id formatted as `languageId-countryId` (e.g. `en-us`)
     */
    function $LocaleProvider() {
        this.$get = function () {
            return {
                id: "en-us",

                NUMBER_FORMATS: {
                    DECIMAL_SEP: ".",
                    GROUP_SEP: ",",
                    PATTERNS: [
                        {
                            // Decimal Pattern
                            minInt: 1,
                            minFrac: 0,
                            maxFrac: 3,
                            posPre: "",
                            posSuf: "",
                            negPre: "-",
                            negSuf: "",
                            gSize: 3,
                            lgSize: 3,
                        },
                        {
                            //Currency Pattern
                            minInt: 1,
                            minFrac: 2,
                            maxFrac: 2,
                            posPre: "\u00A4",
                            posSuf: "",
                            negPre: "(\u00A4",
                            negSuf: ")",
                            gSize: 3,
                            lgSize: 3,
                        },
                    ],
                    CURRENCY_SYM: "$",
                },

                DATETIME_FORMATS: {
                    MONTH:
                        "January,February,March,April,May,June,July,August,September,October,November,December".split(
                            ",",
                        ),
                    SHORTMONTH: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec".split(
                        ",",
                    ),
                    DAY: "Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday".split(
                        ",",
                    ),
                    SHORTDAY: "Sun,Mon,Tue,Wed,Thu,Fri,Sat".split(","),
                    AMPMS: ["AM", "PM"],
                    medium: "MMM d, y h:mm:ss a",
                    short: "M/d/yy h:mm a",
                    fullDate: "EEEE, MMMM d, y",
                    longDate: "MMMM d, y",
                    mediumDate: "MMM d, y",
                    shortDate: "M/d/yy",
                    mediumTime: "h:mm:ss a",
                    shortTime: "h:mm a",
                },

                pluralCat: function (num) {
                    if (num === 1) {
                        return "one";
                    }
                    return "other";
                },
            };
        };
    }

    var PATH_MATCH = /^([^\?#]*)(\?([^#]*))?(#(.*))?$/,
        DEFAULT_PORTS = { http: 80, https: 443, ftp: 21 };
    var $locationMinErr = minErr("$location");

    /**
     * Encode path using encodeUriSegment, ignoring forward slashes
     *
     * @param {string} path Path to encode
     * @returns {string}
     */
    function encodePath(path) {
        var segments = path.split("/"),
            i = segments.length;

        while (i--) {
            segments[i] = encodeUriSegment(segments[i]);
        }

        return segments.join("/");
    }

    function parseAbsoluteUrl(absoluteUrl, locationObj, appBase) {
        var parsedUrl = urlResolve(absoluteUrl, appBase);

        locationObj.$$protocol = parsedUrl.protocol;
        locationObj.$$host = parsedUrl.hostname;
        locationObj.$$port =
            int(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
    }

    function parseAppUrl(relativeUrl, locationObj, appBase) {
        var prefixed = relativeUrl.charAt(0) !== "/";
        if (prefixed) {
            relativeUrl = "/" + relativeUrl;
        }
        var match = urlResolve(relativeUrl, appBase);
        locationObj.$$path = decodeURIComponent(
            prefixed && match.pathname.charAt(0) === "/"
                ? match.pathname.substring(1)
                : match.pathname,
        );
        locationObj.$$search = parseKeyValue(match.search);
        locationObj.$$hash = decodeURIComponent(match.hash);

        // make sure path starts with '/';
        if (locationObj.$$path && locationObj.$$path.charAt(0) != "/") {
            locationObj.$$path = "/" + locationObj.$$path;
        }
    }

    /**
     *
     * @param {string} begin
     * @param {string} whole
     * @returns {string} returns text from whole after begin or undefined if it does not begin with
     *                   expected string.
     */
    function beginsWith(begin, whole) {
        if (whole.indexOf(begin) === 0) {
            return whole.substr(begin.length);
        }
    }

    function stripHash(url) {
        var index = url.indexOf("#");
        return index == -1 ? url : url.substr(0, index);
    }

    function stripFile(url) {
        return url.substr(0, stripHash(url).lastIndexOf("/") + 1);
    }

    /* return the server only (scheme://host:port) */
    function serverBase(url) {
        return url.substring(0, url.indexOf("/", url.indexOf("//") + 2));
    }

    /**
     * LocationHtml5Url represents an url
     * This object is exposed as $location service when HTML5 mode is enabled and supported
     *
     * @constructor
     * @param {string} appBase application base URL
     * @param {string} basePrefix url path prefix
     */
    function LocationHtml5Url(appBase, basePrefix) {
        this.$$html5 = true;
        basePrefix = basePrefix || "";
        var appBaseNoFile = stripFile(appBase);
        parseAbsoluteUrl(appBase, this, appBase);

        /**
         * Parse given html5 (regular) url string into properties
         * @param {string} newAbsoluteUrl HTML5 url
         * @private
         */
        this.$$parse = function (url) {
            var pathUrl = beginsWith(appBaseNoFile, url);
            if (!isString(pathUrl)) {
                throw $locationMinErr(
                    "ipthprfx",
                    'Invalid url "{0}", missing path prefix "{1}".',
                    url,
                    appBaseNoFile,
                );
            }

            parseAppUrl(pathUrl, this, appBase);

            if (!this.$$path) {
                this.$$path = "/";
            }

            this.$$compose();
        };

        /**
         * Compose url and update `absUrl` property
         * @private
         */
        this.$$compose = function () {
            var search = toKeyValue(this.$$search),
                hash = this.$$hash ? "#" + encodeUriSegment(this.$$hash) : "";

            this.$$url =
                encodePath(this.$$path) + (search ? "?" + search : "") + hash;
            this.$$absUrl = appBaseNoFile + this.$$url.substr(1); // first char is always '/'
        };

        this.$$rewrite = function (url) {
            var appUrl, prevAppUrl;

            if ((appUrl = beginsWith(appBase, url)) !== undefined) {
                prevAppUrl = appUrl;
                if ((appUrl = beginsWith(basePrefix, appUrl)) !== undefined) {
                    return appBaseNoFile + (beginsWith("/", appUrl) || appUrl);
                } else {
                    return appBase + prevAppUrl;
                }
            } else if ((appUrl = beginsWith(appBaseNoFile, url)) !== undefined) {
                return appBaseNoFile + appUrl;
            } else if (appBaseNoFile == url + "/") {
                return appBaseNoFile;
            }
        };
    }

    /**
     * LocationHashbangUrl represents url
     * This object is exposed as $location service when developer doesn't opt into html5 mode.
     * It also serves as the base class for html5 mode fallback on legacy browsers.
     *
     * @constructor
     * @param {string} appBase application base URL
     * @param {string} hashPrefix hashbang prefix
     */
    function LocationHashbangUrl(appBase, hashPrefix) {
        var appBaseNoFile = stripFile(appBase);

        parseAbsoluteUrl(appBase, this, appBase);

        /**
         * Parse given hashbang url into properties
         * @param {string} url Hashbang url
         * @private
         */
        this.$$parse = function (url) {
            var withoutBaseUrl =
                beginsWith(appBase, url) || beginsWith(appBaseNoFile, url);
            var withoutHashUrl =
                withoutBaseUrl.charAt(0) == "#"
                    ? beginsWith(hashPrefix, withoutBaseUrl)
                    : this.$$html5
                        ? withoutBaseUrl
                        : "";

            if (!isString(withoutHashUrl)) {
                throw $locationMinErr(
                    "ihshprfx",
                    'Invalid url "{0}", missing hash prefix "{1}".',
                    url,
                    hashPrefix,
                );
            }
            parseAppUrl(withoutHashUrl, this, appBase);

            this.$$path = removeWindowsDriveName(
                this.$$path,
                withoutHashUrl,
                appBase,
            );

            this.$$compose();

            /*
             * In Windows, on an anchor node on documents loaded from
             * the filesystem, the browser will return a pathname
             * prefixed with the drive name ('/C:/path') when a
             * pathname without a drive is set:
             *  * a.setAttribute('href', '/foo')
             *   * a.pathname === '/C:/foo' //true
             *
             * Inside of Angular, we're always using pathnames that
             * do not include drive names for routing.
             */
            function removeWindowsDriveName(path, url, base) {
                /*
              Matches paths for file protocol on windows,
              such as /C:/foo/bar, and captures only /foo/bar.
              */
                var windowsFilePathExp = /^\/?.*?:(\/.*)/;

                var firstPathSegmentMatch;

                //Get the relative path from the input URL.
                if (url.indexOf(base) === 0) {
                    url = url.replace(base, "");
                }

                /*
                 * The input URL intentionally contains a
                 * first path segment that ends with a colon.
                 */
                if (windowsFilePathExp.exec(url)) {
                    return path;
                }

                firstPathSegmentMatch = windowsFilePathExp.exec(path);
                return firstPathSegmentMatch ? firstPathSegmentMatch[1] : path;
            }
        };

        /**
         * Compose hashbang url and update `absUrl` property
         * @private
         */
        this.$$compose = function () {
            var search = toKeyValue(this.$$search),
                hash = this.$$hash ? "#" + encodeUriSegment(this.$$hash) : "";

            this.$$url =
                encodePath(this.$$path) + (search ? "?" + search : "") + hash;
            this.$$absUrl = appBase + (this.$$url ? hashPrefix + this.$$url : "");
        };

        this.$$rewrite = function (url) {
            if (stripHash(appBase) == stripHash(url)) {
                return url;
            }
        };
    }

    /**
     * LocationHashbangUrl represents url
     * This object is exposed as $location service when html5 history api is enabled but the browser
     * does not support it.
     *
     * @constructor
     * @param {string} appBase application base URL
     * @param {string} hashPrefix hashbang prefix
     */
    function LocationHashbangInHtml5Url(appBase, hashPrefix) {
        this.$$html5 = true;
        LocationHashbangUrl.apply(this, arguments);

        var appBaseNoFile = stripFile(appBase);

        this.$$rewrite = function (url) {
            var appUrl;

            if (appBase == stripHash(url)) {
                return url;
            } else if ((appUrl = beginsWith(appBaseNoFile, url))) {
                return appBase + hashPrefix + appUrl;
            } else if (appBaseNoFile === url + "/") {
                return appBaseNoFile;
            }
        };
    }

    LocationHashbangInHtml5Url.prototype =
        LocationHashbangUrl.prototype =
        LocationHtml5Url.prototype =
        {
            /**
             * Are we in html5 mode?
             * @private
             */
            $$html5: false,

            /**
             * Has any change been replacing ?
             * @private
             */
            $$replace: false,

            /**
             * @ngdoc method
             * @name ng.$location#absUrl
             * @methodOf ng.$location
             *
             * @description
             * This method is getter only.
             *
             * Return full url representation with all segments encoded according to rules specified in
             * {@link http://www.ietf.org/rfc/rfc3986.txt RFC 3986}.
             *
             * @return {string} full url
             */
            absUrl: locationGetter("$$absUrl"),

            /**
             * @ngdoc method
             * @name ng.$location#url
             * @methodOf ng.$location
             *
             * @description
             * This method is getter / setter.
             *
             * Return url (e.g. `/path?a=b#hash`) when called without any parameter.
             *
             * Change path, search and hash, when called with parameter and return `$location`.
             *
             * @param {string=} url New url without base prefix (e.g. `/path?a=b#hash`)
             * @param {string=} replace The path that will be changed
             * @return {string} url
             */
            url: function (url, replace) {
                if (isUndefined(url)) return this.$$url;

                var match = PATH_MATCH.exec(url);
                if (match[1]) this.path(decodeURIComponent(match[1]));
                if (match[2] || match[1]) this.search(match[3] || "");
                this.hash(match[5] || "", replace);

                return this;
            },

            /**
             * @ngdoc method
             * @name ng.$location#protocol
             * @methodOf ng.$location
             *
             * @description
             * This method is getter only.
             *
             * Return protocol of current url.
             *
             * @return {string} protocol of current url
             */
            protocol: locationGetter("$$protocol"),

            /**
             * @ngdoc method
             * @name ng.$location#host
             * @methodOf ng.$location
             *
             * @description
             * This method is getter only.
             *
             * Return host of current url.
             *
             * @return {string} host of current url.
             */
            host: locationGetter("$$host"),

            /**
             * @ngdoc method
             * @name ng.$location#port
             * @methodOf ng.$location
             *
             * @description
             * This method is getter only.
             *
             * Return port of current url.
             *
             * @return {Number} port
             */
            port: locationGetter("$$port"),

            /**
             * @ngdoc method
             * @name ng.$location#path
             * @methodOf ng.$location
             *
             * @description
             * This method is getter / setter.
             *
             * Return path of current url when called without any parameter.
             *
             * Change path when called with parameter and return `$location`.
             *
             * Note: Path should always begin with forward slash (/), this method will add the forward slash
             * if it is missing.
             *
             * @param {string=} path New path
             * @return {string} path
             */
            path: locationGetterSetter("$$path", function (path) {
                return path.charAt(0) == "/" ? path : "/" + path;
            }),

            /**
             * @ngdoc method
             * @name ng.$location#search
             * @methodOf ng.$location
             *
             * @description
             * This method is getter / setter.
             *
             * Return search part (as object) of current url when called without any parameter.
             *
             * Change search part when called with parameter and return `$location`.
             *
             * @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or
             * hash object. Hash object may contain an array of values, which will be decoded as duplicates in
             * the url.
             *
             * @param {(string|Array<string>)=} paramValue If `search` is a string, then `paramValue` will override only a
             * single search parameter. If `paramValue` is an array, it will set the parameter as a
             * comma-separated value. If `paramValue` is `null`, the parameter will be deleted.
             *
             * @return {string} search
             */
            search: function (search, paramValue) {
                switch (arguments.length) {
                    case 0:
                        return this.$$search;
                    case 1:
                        if (isString(search)) {
                            this.$$search = parseKeyValue(search);
                        } else if (isObject(search)) {
                            this.$$search = search;
                        } else {
                            throw $locationMinErr(
                                "isrcharg",
                                "The first argument of the `$location#search()` call must be a string or an object.",
                            );
                        }
                        break;
                    default:
                        if (isUndefined(paramValue) || paramValue === null) {
                            delete this.$$search[search];
                        } else {
                            this.$$search[search] = paramValue;
                        }
                }

                this.$$compose();
                return this;
            },

            /**
             * @ngdoc method
             * @name ng.$location#hash
             * @methodOf ng.$location
             *
             * @description
             * This method is getter / setter.
             *
             * Return hash fragment when called without any parameter.
             *
             * Change hash fragment when called with parameter and return `$location`.
             *
             * @param {string=} hash New hash fragment
             * @return {string} hash
             */
            hash: locationGetterSetter("$$hash", identity),

            /**
             * @ngdoc method
             * @name ng.$location#replace
             * @methodOf ng.$location
             *
             * @description
             * If called, all changes to $location during current `$digest` will be replacing current history
             * record, instead of adding new one.
             */
            replace: function () {
                this.$$replace = true;
                return this;
            },
        };

    function locationGetter(property) {
        return function () {
            return this[property];
        };
    }

    function locationGetterSetter(property, preprocess) {
        return function (value) {
            if (isUndefined(value)) return this[property];

            this[property] = preprocess(value);
            this.$$compose();

            return this;
        };
    }

    /**
     * @ngdoc object
     * @name ng.$location
     *
     * @requires $browser
     * @requires $sniffer
     * @requires $rootElement
     *
     * @description
     * The $location service parses the URL in the browser address bar (based on the
     * {@link https://developer.mozilla.org/en/window.location window.location}) and makes the URL
     * available to your application. Changes to the URL in the address bar are reflected into
     * $location service and changes to $location are reflected into the browser address bar.
     *
     * **The $location service:**
     *
     * - Exposes the current URL in the browser address bar, so you can
     *   - Watch and observe the URL.
     *   - Change the URL.
     * - Synchronizes the URL with the browser when the user
     *   - Changes the address bar.
     *   - Clicks the back or forward button (or clicks a History link).
     *   - Clicks on a link.
     * - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
     *
     * For more information see {@link guide/dev_guide.services.$location Developer Guide: Angular
     * Services: Using $location}
     */

    /**
     * @ngdoc object
     * @name ng.$locationProvider
     * @description
     * Use the `$locationProvider` to configure how the application deep linking paths are stored.
     */
    function $LocationProvider() {
        var hashPrefix = "",
            html5Mode = false;

        /**
         * @ngdoc property
         * @name ng.$locationProvider#hashPrefix
         * @methodOf ng.$locationProvider
         * @description
         * @param {string=} prefix Prefix for hash part (containing path and search)
         * @returns {*} current value if used as getter or itself (chaining) if used as setter
         */
        this.hashPrefix = function (prefix) {
            if (isDefined(prefix)) {
                hashPrefix = prefix;
                return this;
            } else {
                return hashPrefix;
            }
        };

        /**
         * @ngdoc property
         * @name ng.$locationProvider#html5Mode
         * @methodOf ng.$locationProvider
         * @description
         * @param {boolean=} mode Use HTML5 strategy if available.
         * @returns {*} current value if used as getter or itself (chaining) if used as setter
         */
        this.html5Mode = function (mode) {
            if (isDefined(mode)) {
                html5Mode = mode;
                return this;
            } else {
                return html5Mode;
            }
        };

        /**
         * @ngdoc event
         * @name ng.$location#$locationChangeStart
         * @eventOf ng.$location
         * @eventType broadcast on root scope
         * @description
         * Broadcasted before a URL will change. This change can be prevented by calling
         * `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
         * details about event object. Upon successful change
         * {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
         *
         * @param {Object} angularEvent Synthetic event object.
         * @param {string} newUrl New URL
         * @param {string=} oldUrl URL that was before it was changed.
         */

        /**
         * @ngdoc event
         * @name ng.$location#$locationChangeSuccess
         * @eventOf ng.$location
         * @eventType broadcast on root scope
         * @description
         * Broadcasted after a URL was changed.
         *
         * @param {Object} angularEvent Synthetic event object.
         * @param {string} newUrl New URL
         * @param {string=} oldUrl URL that was before it was changed.
         */

        this.$get = [
            "$rootScope",
            "$browser",
            "$sniffer",
            "$rootElement",
            function ($rootScope, $browser, $sniffer, $rootElement) {
                var $location,
                    LocationMode,
                    baseHref = $browser.baseHref(), // if base[href] is undefined, it defaults to ''
                    initialUrl = $browser.url(),
                    appBase;

                if (html5Mode) {
                    appBase = serverBase(initialUrl) + (baseHref || "/");
                    LocationMode = $sniffer.history
                        ? LocationHtml5Url
                        : LocationHashbangInHtml5Url;
                } else {
                    appBase = stripHash(initialUrl);
                    LocationMode = LocationHashbangUrl;
                }
                $location = new LocationMode(appBase, "#" + hashPrefix);
                $location.$$parse($location.$$rewrite(initialUrl));

                $rootElement.on("click", function (event) {
                    // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
                    // currently we open nice url link and redirect then

                    if (event.ctrlKey || event.metaKey || event.which == 2) return;

                    var elm = jqLite(event.target);

                    // traverse the DOM up to find first A tag
                    while (lowercase(elm[0].nodeName) !== "a") {
                        // ignore rewriting if no A tag (reached root element, or no parent - removed from document)
                        if (elm[0] === $rootElement[0] || !(elm = elm.parent())[0]) return;
                    }

                    var absHref = elm.prop("href");
                    var rewrittenUrl = $location.$$rewrite(absHref);

                    if (
                        absHref &&
                        !elm.attr("target") &&
                        rewrittenUrl &&
                        !event.isDefaultPrevented()
                    ) {
                        event.preventDefault();
                        if (rewrittenUrl != $browser.url()) {
                            // update location manually
                            $location.$$parse(rewrittenUrl);
                            $rootScope.$apply();
                            // hack to work around FF6 bug 684208 when scenario runner clicks on links
                            window.angular["ff-684208-preventDefault"] = true;
                        }
                    }
                });

                // rewrite hashbang url <> html5 url
                if ($location.absUrl() != initialUrl) {
                    $browser.url($location.absUrl(), true);
                }

                // update $location when $browser url changes
                $browser.onUrlChange(function (newUrl) {
                    if ($location.absUrl() != newUrl) {
                        if (
                            $rootScope.$broadcast(
                                "$locationChangeStart",
                                newUrl,
                                $location.absUrl(),
                            ).defaultPrevented
                        ) {
                            $browser.url($location.absUrl());
                            return;
                        }
                        $rootScope.$evalAsync(function () {
                            var oldUrl = $location.absUrl();

                            $location.$$parse(newUrl);
                            afterLocationChange(oldUrl);
                        });
                        if (!$rootScope.$$phase) $rootScope.$digest();
                    }
                });

                // update browser
                var changeCounter = 0;
                $rootScope.$watch(function $locationWatch() {
                    var oldUrl = $browser.url();
                    var currentReplace = $location.$$replace;

                    if (!changeCounter || oldUrl != $location.absUrl()) {
                        changeCounter++;
                        $rootScope.$evalAsync(function () {
                            if (
                                $rootScope.$broadcast(
                                    "$locationChangeStart",
                                    $location.absUrl(),
                                    oldUrl,
                                ).defaultPrevented
                            ) {
                                $location.$$parse(oldUrl);
                            } else {
                                $browser.url($location.absUrl(), currentReplace);
                                afterLocationChange(oldUrl);
                            }
                        });
                    }
                    $location.$$replace = false;

                    return changeCounter;
                });

                return $location;

                function afterLocationChange(oldUrl) {
                    $rootScope.$broadcast(
                        "$locationChangeSuccess",
                        $location.absUrl(),
                        oldUrl,
                    );
                }
            },
        ];
    }

    /**
   * @ngdoc object
   * @name ng.$log
   * @requires $window
   *
   * @description
   * Simple service for logging. Default implementation safely writes the message
   * into the browser's console (if present).
   * 
   * The main purpose of this service is to simplify debugging and troubleshooting.
   *
   * The default is to log `debug` messages. You can use
   * {@link ng.$logProvider ng.$logProvider#debugEnabled} to change this.
   *
   * @example
     <example>
       <file name="script.js">
         function LogCtrl($scope, $log) {
           $scope.$log = $log;
           $scope.message = 'Hello World!';
         }
       </file>
       <file name="index.html">
         <div ng-controller="LogCtrl">
           <p>Reload this page with open console, enter text and hit the log button...</p>
           Message:
           <input type="text" ng-model="message"/>
           <button ng-click="$log.log(message)">log</button>
           <button ng-click="$log.warn(message)">warn</button>
           <button ng-click="$log.info(message)">info</button>
           <button ng-click="$log.error(message)">error</button>
         </div>
       </file>
     </example>
   */

    /**
     * @ngdoc object
     * @name ng.$logProvider
     * @description
     * Use the `$logProvider` to configure how the application logs messages
     */
    function $LogProvider() {
        var debug = true,
            self = this;

        /**
         * @ngdoc property
         * @name ng.$logProvider#debugEnabled
         * @methodOf ng.$logProvider
         * @description
         * @param {string=} flag enable or disable debug level messages
         * @returns {*} current value if used as getter or itself (chaining) if used as setter
         */
        this.debugEnabled = function (flag) {
            if (isDefined(flag)) {
                debug = flag;
                return this;
            } else {
                return debug;
            }
        };

        this.$get = [
            "$window",
            function ($window) {
                return {
                    /**
                     * @ngdoc method
                     * @name ng.$log#log
                     * @methodOf ng.$log
                     *
                     * @description
                     * Write a log message
                     */
                    log: consoleLog("log"),

                    /**
                     * @ngdoc method
                     * @name ng.$log#info
                     * @methodOf ng.$log
                     *
                     * @description
                     * Write an information message
                     */
                    info: consoleLog("info"),

                    /**
                     * @ngdoc method
                     * @name ng.$log#warn
                     * @methodOf ng.$log
                     *
                     * @description
                     * Write a warning message
                     */
                    warn: consoleLog("warn"),

                    /**
                     * @ngdoc method
                     * @name ng.$log#error
                     * @methodOf ng.$log
                     *
                     * @description
                     * Write an error message
                     */
                    error: consoleLog("error"),

                    /**
                     * @ngdoc method
                     * @name ng.$log#debug
                     * @methodOf ng.$log
                     *
                     * @description
                     * Write a debug message
                     */
                    debug: (function () {
                        var fn = consoleLog("debug");

                        return function () {
                            if (debug) {
                                fn.apply(self, arguments);
                            }
                        };
                    })(),
                };

                function formatError(arg) {
                    if (arg instanceof Error) {
                        if (arg.stack) {
                            arg =
                                arg.message && arg.stack.indexOf(arg.message) === -1
                                    ? "Error: " + arg.message + "\n" + arg.stack
                                    : arg.stack;
                        } else if (arg.sourceURL) {
                            arg = arg.message + "\n" + arg.sourceURL + ":" + arg.line;
                        }
                    }
                    return arg;
                }

                function consoleLog(type) {
                    var console = $window.console || {},
                        logFn = console[type] || console.log || noop;

                    if (logFn.apply) {
                        return function () {
                            var args = [];
                            forEach(arguments, function (arg) {
                                args.push(formatError(arg));
                            });
                            return logFn.apply(console, args);
                        };
                    }

                    // we are IE which either doesn't have window.console => this is noop and we do nothing,
                    // or we are IE where console.log doesn't have apply so we log at least first 2 args
                    return function (arg1, arg2) {
                        logFn(arg1, arg2 == null ? "" : arg2);
                    };
                }
            },
        ];
    }

    var $parseMinErr = minErr("$parse");
    var promiseWarningCache = {};
    var promiseWarning;

    // Sandboxing Angular Expressions
    // ------------------------------
    // Angular expressions are generally considered safe because these expressions only have direct
    // access to $scope and locals. However, one can obtain the ability to execute arbitrary JS code by
    // obtaining a reference to native JS functions such as the Function constructor.
    //
    // As an example, consider the following Angular expression:
    //
    //   {}.toString.constructor(alert("evil JS code"))
    //
    // We want to prevent this type of access. For the sake of performance, during the lexing phase we
    // disallow any "dotted" access to any member named "constructor".
    //
    // For reflective calls (a[b]) we check that the value of the lookup is not the Function constructor
    // while evaluating the expression, which is a stronger but more expensive test. Since reflective
    // calls are expensive anyway, this is not such a big deal compared to static dereferencing.
    //
    // This sandboxing technique is not perfect and doesn't aim to be. The goal is to prevent exploits
    // against the expression language, but not to prevent exploits that were enabled by exposing
    // sensitive JavaScript or browser apis on Scope. Exposing such objects on a Scope is never a good
    // practice and therefore we are not even trying to protect against interaction with an object
    // explicitly exposed in this way.
    //
    // A developer could foil the name check by aliasing the Function constructor under a different
    // name on the scope.
    //
    // In general, it is not possible to access a Window object from an angular expression unless a
    // window or some DOM object that has a reference to window is published onto a Scope.

    function ensureSafeMemberName(name, fullExpression) {
        if (name === "constructor") {
            throw $parseMinErr(
                "isecfld",
                'Referencing "constructor" field in Angular expressions is disallowed! Expression: {0}',
                fullExpression,
            );
        }
        return name;
    }

    function ensureSafeObject(obj, fullExpression) {
        // nifty check if obj is Function that is fast and works across iframes and other contexts
        if (obj) {
            if (obj.constructor === obj) {
                throw $parseMinErr(
                    "isecfn",
                    "Referencing Function in Angular expressions is disallowed! Expression: {0}",
                    fullExpression,
                );
            } else if (
                // isWindow(obj)
                obj.document &&
                obj.location &&
                obj.alert &&
                obj.setInterval
            ) {
                throw $parseMinErr(
                    "isecwindow",
                    "Referencing the Window in Angular expressions is disallowed! Expression: {0}",
                    fullExpression,
                );
            } else if (
                // isElement(obj)
                obj.children &&
                (obj.nodeName || (obj.on && obj.find))
            ) {
                throw $parseMinErr(
                    "isecdom",
                    "Referencing DOM nodes in Angular expressions is disallowed! Expression: {0}",
                    fullExpression,
                );
            }
        }
        return obj;
    }

    var OPERATORS = {
        /* jshint bitwise : false */
        null: function () {
            return null;
        },
        true: function () {
            return true;
        },
        false: function () {
            return false;
        },
        undefined: noop,
        "+": function (self, locals, a, b) {
            a = a(self, locals);
            b = b(self, locals);
            if (isDefined(a)) {
                if (isDefined(b)) {
                    return a + b;
                }
                return a;
            }
            return isDefined(b) ? b : undefined;
        },
        "-": function (self, locals, a, b) {
            a = a(self, locals);
            b = b(self, locals);
            return (isDefined(a) ? a : 0) - (isDefined(b) ? b : 0);
        },
        "*": function (self, locals, a, b) {
            return a(self, locals) * b(self, locals);
        },
        "/": function (self, locals, a, b) {
            return a(self, locals) / b(self, locals);
        },
        "%": function (self, locals, a, b) {
            return a(self, locals) % b(self, locals);
        },
        "^": function (self, locals, a, b) {
            return a(self, locals) ^ b(self, locals);
        },
        "=": noop,
        "===": function (self, locals, a, b) {
            return a(self, locals) === b(self, locals);
        },
        "!==": function (self, locals, a, b) {
            return a(self, locals) !== b(self, locals);
        },
        "==": function (self, locals, a, b) {
            return a(self, locals) == b(self, locals);
        },
        "!=": function (self, locals, a, b) {
            return a(self, locals) != b(self, locals);
        },
        "<": function (self, locals, a, b) {
            return a(self, locals) < b(self, locals);
        },
        ">": function (self, locals, a, b) {
            return a(self, locals) > b(self, locals);
        },
        "<=": function (self, locals, a, b) {
            return a(self, locals) <= b(self, locals);
        },
        ">=": function (self, locals, a, b) {
            return a(self, locals) >= b(self, locals);
        },
        "&&": function (self, locals, a, b) {
            return a(self, locals) && b(self, locals);
        },
        "||": function (self, locals, a, b) {
            return a(self, locals) || b(self, locals);
        },
        "&": function (self, locals, a, b) {
            return a(self, locals) & b(self, locals);
        },
        //    '|':function(self, locals, a,b){return a|b;},
        "|": function (self, locals, a, b) {
            return b(self, locals)(self, locals, a(self, locals));
        },
        "!": function (self, locals, a) {
            return !a(self, locals);
        },
    };
    /* jshint bitwise: true */
    var ESCAPE = {
        n: "\n",
        f: "\f",
        r: "\r",
        t: "\t",
        v: "\v",
        "'": "'",
        '"': '"',
    };

    /////////////////////////////////////////

    /**
     * @constructor
     */
    var Lexer = function (options) {
        this.options = options;
    };

    Lexer.prototype = {
        constructor: Lexer,

        lex: function (text) {
            this.text = text;

            this.index = 0;
            this.ch = undefined;
            this.lastCh = ":"; // can start regexp

            this.tokens = [];

            var token;
            var json = [];

            while (this.index < this.text.length) {
                this.ch = this.text.charAt(this.index);
                if (this.is("\"'")) {
                    this.readString(this.ch);
                } else if (
                    this.isNumber(this.ch) ||
                    (this.is(".") && this.isNumber(this.peek()))
                ) {
                    this.readNumber();
                } else if (this.isIdent(this.ch)) {
                    this.readIdent();
                    // identifiers can only be if the preceding char was a { or ,
                    if (
                        this.was("{,") &&
                        json[0] === "{" &&
                        (token = this.tokens[this.tokens.length - 1])
                    ) {
                        token.json = token.text.indexOf(".") === -1;
                    }
                } else if (this.is("(){}[].,;:?")) {
                    this.tokens.push({
                        index: this.index,
                        text: this.ch,
                        json: (this.was(":[,") && this.is("{[")) || this.is("}]:,"),
                    });
                    if (this.is("{[")) json.unshift(this.ch);
                    if (this.is("}]")) json.shift();
                    this.index++;
                } else if (this.isWhitespace(this.ch)) {
                    this.index++;
                    continue;
                } else {
                    var ch2 = this.ch + this.peek();
                    var ch3 = ch2 + this.peek(2);
                    var fn = OPERATORS[this.ch];
                    var fn2 = OPERATORS[ch2];
                    var fn3 = OPERATORS[ch3];
                    if (fn3) {
                        this.tokens.push({ index: this.index, text: ch3, fn: fn3 });
                        this.index += 3;
                    } else if (fn2) {
                        this.tokens.push({ index: this.index, text: ch2, fn: fn2 });
                        this.index += 2;
                    } else if (fn) {
                        this.tokens.push({
                            index: this.index,
                            text: this.ch,
                            fn: fn,
                            json: this.was("[,:") && this.is("+-"),
                        });
                        this.index += 1;
                    } else {
                        this.throwError(
                            "Unexpected next character ",
                            this.index,
                            this.index + 1,
                        );
                    }
                }
                this.lastCh = this.ch;
            }
            return this.tokens;
        },

        is: function (chars) {
            return chars.indexOf(this.ch) !== -1;
        },

        was: function (chars) {
            return chars.indexOf(this.lastCh) !== -1;
        },

        peek: function (i) {
            var num = i || 1;
            return this.index + num < this.text.length
                ? this.text.charAt(this.index + num)
                : false;
        },

        isNumber: function (ch) {
            return "0" <= ch && ch <= "9";
        },

        isWhitespace: function (ch) {
            // IE treats non-breaking space as \u00A0
            return (
                ch === " " ||
                ch === "\r" ||
                ch === "\t" ||
                ch === "\n" ||
                ch === "\v" ||
                ch === "\u00A0"
            );
        },

        isIdent: function (ch) {
            return (
                ("a" <= ch && ch <= "z") ||
                ("A" <= ch && ch <= "Z") ||
                "_" === ch ||
                ch === "$"
            );
        },

        isExpOperator: function (ch) {
            return ch === "-" || ch === "+" || this.isNumber(ch);
        },

        throwError: function (error, start, end) {
            end = end || this.index;
            var colStr = isDefined(start)
                ? "s " +
                start +
                "-" +
                this.index +
                " [" +
                this.text.substring(start, end) +
                "]"
                : " " + end;
            throw $parseMinErr(
                "lexerr",
                "Lexer Error: {0} at column{1} in expression [{2}].",
                error,
                colStr,
                this.text,
            );
        },

        readNumber: function () {
            var number = "";
            var start = this.index;
            while (this.index < this.text.length) {
                var ch = lowercase(this.text.charAt(this.index));
                if (ch == "." || this.isNumber(ch)) {
                    number += ch;
                } else {
                    var peekCh = this.peek();
                    if (ch == "e" && this.isExpOperator(peekCh)) {
                        number += ch;
                    } else if (
                        this.isExpOperator(ch) &&
                        peekCh &&
                        this.isNumber(peekCh) &&
                        number.charAt(number.length - 1) == "e"
                    ) {
                        number += ch;
                    } else if (
                        this.isExpOperator(ch) &&
                        (!peekCh || !this.isNumber(peekCh)) &&
                        number.charAt(number.length - 1) == "e"
                    ) {
                        this.throwError("Invalid exponent");
                    } else {
                        break;
                    }
                }
                this.index++;
            }
            number = 1 * number;
            this.tokens.push({
                index: start,
                text: number,
                json: true,
                fn: function () {
                    return number;
                },
            });
        },

        readIdent: function () {
            var parser = this;

            var ident = "";
            var start = this.index;

            var lastDot, peekIndex, methodName, ch;

            while (this.index < this.text.length) {
                ch = this.text.charAt(this.index);
                if (ch === "." || this.isIdent(ch) || this.isNumber(ch)) {
                    if (ch === ".") lastDot = this.index;
                    ident += ch;
                } else {
                    break;
                }
                this.index++;
            }

            //check if this is not a method invocation and if it is back out to last dot
            if (lastDot) {
                peekIndex = this.index;
                while (peekIndex < this.text.length) {
                    ch = this.text.charAt(peekIndex);
                    if (ch === "(") {
                        methodName = ident.substr(lastDot - start + 1);
                        ident = ident.substr(0, lastDot - start);
                        this.index = peekIndex;
                        break;
                    }
                    if (this.isWhitespace(ch)) {
                        peekIndex++;
                    } else {
                        break;
                    }
                }
            }

            var token = {
                index: start,
                text: ident,
            };

            // OPERATORS is our own object so we don't need to use special hasOwnPropertyFn
            if (OPERATORS.hasOwnProperty(ident)) {
                token.fn = OPERATORS[ident];
                token.json = OPERATORS[ident];
            } else {
                var getter = getterFn(ident, this.options, this.text);
                token.fn = extend(
                    function (self, locals) {
                        return getter(self, locals);
                    },
                    {
                        assign: function (self, value) {
                            return setter(self, ident, value, parser.text, parser.options);
                        },
                    },
                );
            }

            this.tokens.push(token);

            if (methodName) {
                this.tokens.push({
                    index: lastDot,
                    text: ".",
                    json: false,
                });
                this.tokens.push({
                    index: lastDot + 1,
                    text: methodName,
                    json: false,
                });
            }
        },

        readString: function (quote) {
            var start = this.index;
            this.index++;
            var string = "";
            var rawString = quote;
            var escape = false;
            while (this.index < this.text.length) {
                var ch = this.text.charAt(this.index);
                rawString += ch;
                if (escape) {
                    if (ch === "u") {
                        var hex = this.text.substring(this.index + 1, this.index + 5);
                        if (!hex.match(/[\da-f]{4}/i))
                            this.throwError("Invalid unicode escape [\\u" + hex + "]");
                        this.index += 4;
                        string += String.fromCharCode(parseInt(hex, 16));
                    } else {
                        var rep = ESCAPE[ch];
                        if (rep) {
                            string += rep;
                        } else {
                            string += ch;
                        }
                    }
                    escape = false;
                } else if (ch === "\\") {
                    escape = true;
                } else if (ch === quote) {
                    this.index++;
                    this.tokens.push({
                        index: start,
                        text: rawString,
                        string: string,
                        json: true,
                        fn: function () {
                            return string;
                        },
                    });
                    return;
                } else {
                    string += ch;
                }
                this.index++;
            }
            this.throwError("Unterminated quote", start);
        },
    };

    /**
     * @constructor
     */
    var Parser = function (lexer, $filter, options) {
        this.lexer = lexer;
        this.$filter = $filter;
        this.options = options;
    };

    Parser.ZERO = function () {
        return 0;
    };

    Parser.prototype = {
        constructor: Parser,

        parse: function (text, json) {
            this.text = text;

            //TODO(i): strip all the obsolte json stuff from this file
            this.json = json;

            this.tokens = this.lexer.lex(text);

            if (json) {
                // The extra level of aliasing is here, just in case the lexer misses something, so that
                // we prevent any accidental execution in JSON.
                this.assignment = this.logicalOR;

                this.functionCall =
                    this.fieldAccess =
                    this.objectIndex =
                    this.filterChain =
                    function () {
                        this.throwError("is not valid json", { text: text, index: 0 });
                    };
            }

            var value = json ? this.primary() : this.statements();

            if (this.tokens.length !== 0) {
                this.throwError("is an unexpected token", this.tokens[0]);
            }

            value.literal = !!value.literal;
            value.constant = !!value.constant;

            return value;
        },

        primary: function () {
            var primary;
            if (this.expect("(")) {
                primary = this.filterChain();
                this.consume(")");
            } else if (this.expect("[")) {
                primary = this.arrayDeclaration();
            } else if (this.expect("{")) {
                primary = this.object();
            } else {
                var token = this.expect();
                primary = token.fn;
                if (!primary) {
                    this.throwError("not a primary expression", token);
                }
                if (token.json) {
                    primary.constant = true;
                    primary.literal = true;
                }
            }

            var next, context;
            while ((next = this.expect("(", "[", "."))) {
                if (next.text === "(") {
                    primary = this.functionCall(primary, context);
                    context = null;
                } else if (next.text === "[") {
                    context = primary;
                    primary = this.objectIndex(primary);
                } else if (next.text === ".") {
                    context = primary;
                    primary = this.fieldAccess(primary);
                } else {
                    this.throwError("IMPOSSIBLE");
                }
            }
            return primary;
        },

        throwError: function (msg, token) {
            throw $parseMinErr(
                "syntax",
                "Syntax Error: Token '{0}' {1} at column {2} of the expression [{3}] starting at [{4}].",
                token.text,
                msg,
                token.index + 1,
                this.text,
                this.text.substring(token.index),
            );
        },

        peekToken: function () {
            if (this.tokens.length === 0)
                throw $parseMinErr(
                    "ueoe",
                    "Unexpected end of expression: {0}",
                    this.text,
                );
            return this.tokens[0];
        },

        peek: function (e1, e2, e3, e4) {
            if (this.tokens.length > 0) {
                var token = this.tokens[0];
                var t = token.text;
                if (
                    t === e1 ||
                    t === e2 ||
                    t === e3 ||
                    t === e4 ||
                    (!e1 && !e2 && !e3 && !e4)
                ) {
                    return token;
                }
            }
            return false;
        },

        expect: function (e1, e2, e3, e4) {
            var token = this.peek(e1, e2, e3, e4);
            if (token) {
                if (this.json && !token.json) {
                    this.throwError("is not valid json", token);
                }
                this.tokens.shift();
                return token;
            }
            return false;
        },

        consume: function (e1) {
            if (!this.expect(e1)) {
                this.throwError("is unexpected, expecting [" + e1 + "]", this.peek());
            }
        },

        unaryFn: function (fn, right) {
            return extend(
                function (self, locals) {
                    return fn(self, locals, right);
                },
                {
                    constant: right.constant,
                },
            );
        },

        ternaryFn: function (left, middle, right) {
            return extend(
                function (self, locals) {
                    return left(self, locals)
                        ? middle(self, locals)
                        : right(self, locals);
                },
                {
                    constant: left.constant && middle.constant && right.constant,
                },
            );
        },

        binaryFn: function (left, fn, right) {
            return extend(
                function (self, locals) {
                    return fn(self, locals, left, right);
                },
                {
                    constant: left.constant && right.constant,
                },
            );
        },

        statements: function () {
            var statements = [];
            while (true) {
                if (this.tokens.length > 0 && !this.peek("}", ")", ";", "]"))
                    statements.push(this.filterChain());
                if (!this.expect(";")) {
                    // optimize for the common case where there is only one statement.
                    // TODO(size): maybe we should not support multiple statements?
                    return statements.length === 1
                        ? statements[0]
                        : function (self, locals) {
                            var value;
                            for (var i = 0; i < statements.length; i++) {
                                var statement = statements[i];
                                if (statement) {
                                    value = statement(self, locals);
                                }
                            }
                            return value;
                        };
                }
            }
        },

        filterChain: function () {
            var left = this.expression();
            var token;
            while (true) {
                if ((token = this.expect("|"))) {
                    left = this.binaryFn(left, token.fn, this.filter());
                } else {
                    return left;
                }
            }
        },

        filter: function () {
            var token = this.expect();
            var fn = this.$filter(token.text);
            var argsFn = [];
            while (true) {
                if ((token = this.expect(":"))) {
                    argsFn.push(this.expression());
                } else {
                    var fnInvoke = function (self, locals, input) {
                        var args = [input];
                        for (var i = 0; i < argsFn.length; i++) {
                            args.push(argsFn[i](self, locals));
                        }
                        return fn.apply(self, args);
                    };
                    return function () {
                        return fnInvoke;
                    };
                }
            }
        },

        expression: function () {
            return this.assignment();
        },

        assignment: function () {
            var left = this.ternary();
            var right;
            var token;
            if ((token = this.expect("="))) {
                if (!left.assign) {
                    this.throwError(
                        "implies assignment but [" +
                        this.text.substring(0, token.index) +
                        "] can not be assigned to",
                        token,
                    );
                }
                right = this.ternary();
                return function (scope, locals) {
                    return left.assign(scope, right(scope, locals), locals);
                };
            }
            return left;
        },

        ternary: function () {
            var left = this.logicalOR();
            var middle;
            var token;
            if ((token = this.expect("?"))) {
                middle = this.ternary();
                if ((token = this.expect(":"))) {
                    return this.ternaryFn(left, middle, this.ternary());
                } else {
                    this.throwError("expected :", token);
                }
            } else {
                return left;
            }
        },

        logicalOR: function () {
            var left = this.logicalAND();
            var token;
            while (true) {
                if ((token = this.expect("||"))) {
                    left = this.binaryFn(left, token.fn, this.logicalAND());
                } else {
                    return left;
                }
            }
        },

        logicalAND: function () {
            var left = this.equality();
            var token;
            if ((token = this.expect("&&"))) {
                left = this.binaryFn(left, token.fn, this.logicalAND());
            }
            return left;
        },

        equality: function () {
            var left = this.relational();
            var token;
            if ((token = this.expect("==", "!=", "===", "!=="))) {
                left = this.binaryFn(left, token.fn, this.equality());
            }
            return left;
        },

        relational: function () {
            var left = this.additive();
            var token;
            if ((token = this.expect("<", ">", "<=", ">="))) {
                left = this.binaryFn(left, token.fn, this.relational());
            }
            return left;
        },

        additive: function () {
            var left = this.multiplicative();
            var token;
            while ((token = this.expect("+", "-"))) {
                left = this.binaryFn(left, token.fn, this.multiplicative());
            }
            return left;
        },

        multiplicative: function () {
            var left = this.unary();
            var token;
            while ((token = this.expect("*", "/", "%"))) {
                left = this.binaryFn(left, token.fn, this.unary());
            }
            return left;
        },

        unary: function () {
            var token;
            if (this.expect("+")) {
                return this.primary();
            } else if ((token = this.expect("-"))) {
                return this.binaryFn(Parser.ZERO, token.fn, this.unary());
            } else if ((token = this.expect("!"))) {
                return this.unaryFn(token.fn, this.unary());
            } else {
                return this.primary();
            }
        },

        fieldAccess: function (object) {
            var parser = this;
            var field = this.expect().text;
            var getter = getterFn(field, this.options, this.text);

            return extend(
                function (scope, locals, self) {
                    return getter(self || object(scope, locals), locals);
                },
                {
                    assign: function (scope, value, locals) {
                        return setter(
                            object(scope, locals),
                            field,
                            value,
                            parser.text,
                            parser.options,
                        );
                    },
                },
            );
        },

        objectIndex: function (obj) {
            var parser = this;

            var indexFn = this.expression();
            this.consume("]");

            return extend(
                function (self, locals) {
                    var o = obj(self, locals),
                        i = indexFn(self, locals),
                        v,
                        p;

                    if (!o) return undefined;
                    v = ensureSafeObject(o[i], parser.text);
                    if (v && v.then && parser.options.unwrapPromises) {
                        p = v;
                        if (!("$$v" in v)) {
                            p.$$v = undefined;
                            p.then(function (val) {
                                p.$$v = val;
                            });
                        }
                        v = v.$$v;
                    }
                    return v;
                },
                {
                    assign: function (self, value, locals) {
                        var key = indexFn(self, locals);
                        // prevent overwriting of Function.constructor which would break ensureSafeObject check
                        var safe = ensureSafeObject(obj(self, locals), parser.text);
                        return (safe[key] = value);
                    },
                },
            );
        },

        functionCall: function (fn, contextGetter) {
            var argsFn = [];
            if (this.peekToken().text !== ")") {
                do {
                    argsFn.push(this.expression());
                } while (this.expect(","));
            }
            this.consume(")");

            var parser = this;

            return function (scope, locals) {
                var args = [];
                var context = contextGetter ? contextGetter(scope, locals) : scope;

                for (var i = 0; i < argsFn.length; i++) {
                    args.push(argsFn[i](scope, locals));
                }
                var fnPtr = fn(scope, locals, context) || noop;

                ensureSafeObject(context, parser.text);
                ensureSafeObject(fnPtr, parser.text);

                // IE stupidity! (IE doesn't have apply for some native functions)
                var v = fnPtr.apply
                    ? fnPtr.apply(context, args)
                    : fnPtr(args[0], args[1], args[2], args[3], args[4]);

                return ensureSafeObject(v, parser.text);
            };
        },

        // This is used with json array declaration
        arrayDeclaration: function () {
            var elementFns = [];
            var allConstant = true;
            if (this.peekToken().text !== "]") {
                do {
                    var elementFn = this.expression();
                    elementFns.push(elementFn);
                    if (!elementFn.constant) {
                        allConstant = false;
                    }
                } while (this.expect(","));
            }
            this.consume("]");

            return extend(
                function (self, locals) {
                    var array = [];
                    for (var i = 0; i < elementFns.length; i++) {
                        array.push(elementFns[i](self, locals));
                    }
                    return array;
                },
                {
                    literal: true,
                    constant: allConstant,
                },
            );
        },

        object: function () {
            var keyValues = [];
            var allConstant = true;
            if (this.peekToken().text !== "}") {
                do {
                    var token = this.expect(),
                        key = token.string || token.text;
                    this.consume(":");
                    var value = this.expression();
                    keyValues.push({ key: key, value: value });
                    if (!value.constant) {
                        allConstant = false;
                    }
                } while (this.expect(","));
            }
            this.consume("}");

            return extend(
                function (self, locals) {
                    var object = {};
                    for (var i = 0; i < keyValues.length; i++) {
                        var keyValue = keyValues[i];
                        object[keyValue.key] = keyValue.value(self, locals);
                    }
                    return object;
                },
                {
                    literal: true,
                    constant: allConstant,
                },
            );
        },
    };

    //////////////////////////////////////////////////
    // Parser helper functions
    //////////////////////////////////////////////////

    function setter(obj, path, setValue, fullExp, options) {
        //needed?
        options = options || {};

        var element = path.split("."),
            key;
        for (var i = 0; element.length > 1; i++) {
            key = ensureSafeMemberName(element.shift(), fullExp);
            var propertyObj = obj[key];
            if (!propertyObj) {
                propertyObj = {};
                obj[key] = propertyObj;
            }
            obj = propertyObj;
            if (obj.then && options.unwrapPromises) {
                promiseWarning(fullExp);
                if (!("$$v" in obj)) {
                    (function (promise) {
                        promise.then(function (val) {
                            promise.$$v = val;
                        });
                    })(obj);
                }
                if (obj.$$v === undefined) {
                    obj.$$v = {};
                }
                obj = obj.$$v;
            }
        }
        key = ensureSafeMemberName(element.shift(), fullExp);
        obj[key] = setValue;
        return setValue;
    }

    var getterFnCache = {};

    /**
     * Implementation of the "Black Hole" variant from:
     * - http://jsperf.com/angularjs-parse-getter/4
     * - http://jsperf.com/path-evaluation-simplified/7
     */
    function cspSafeGetterFn(key0, key1, key2, key3, key4, fullExp, options) {
        ensureSafeMemberName(key0, fullExp);
        ensureSafeMemberName(key1, fullExp);
        ensureSafeMemberName(key2, fullExp);
        ensureSafeMemberName(key3, fullExp);
        ensureSafeMemberName(key4, fullExp);

        return !options.unwrapPromises
            ? function cspSafeGetter(scope, locals) {
                var pathVal = locals && locals.hasOwnProperty(key0) ? locals : scope;

                if (pathVal === null || pathVal === undefined) return pathVal;
                pathVal = pathVal[key0];

                if (!key1 || pathVal === null || pathVal === undefined)
                    return pathVal;
                pathVal = pathVal[key1];

                if (!key2 || pathVal === null || pathVal === undefined)
                    return pathVal;
                pathVal = pathVal[key2];

                if (!key3 || pathVal === null || pathVal === undefined)
                    return pathVal;
                pathVal = pathVal[key3];

                if (!key4 || pathVal === null || pathVal === undefined)
                    return pathVal;
                pathVal = pathVal[key4];

                return pathVal;
            }
            : function cspSafePromiseEnabledGetter(scope, locals) {
                var pathVal = locals && locals.hasOwnProperty(key0) ? locals : scope,
                    promise;

                if (pathVal === null || pathVal === undefined) return pathVal;

                pathVal = pathVal[key0];
                if (pathVal && pathVal.then) {
                    promiseWarning(fullExp);
                    if (!("$$v" in pathVal)) {
                        promise = pathVal;
                        promise.$$v = undefined;
                        promise.then(function (val) {
                            promise.$$v = val;
                        });
                    }
                    pathVal = pathVal.$$v;
                }
                if (!key1 || pathVal === null || pathVal === undefined)
                    return pathVal;

                pathVal = pathVal[key1];
                if (pathVal && pathVal.then) {
                    promiseWarning(fullExp);
                    if (!("$$v" in pathVal)) {
                        promise = pathVal;
                        promise.$$v = undefined;
                        promise.then(function (val) {
                            promise.$$v = val;
                        });
                    }
                    pathVal = pathVal.$$v;
                }
                if (!key2 || pathVal === null || pathVal === undefined)
                    return pathVal;

                pathVal = pathVal[key2];
                if (pathVal && pathVal.then) {
                    promiseWarning(fullExp);
                    if (!("$$v" in pathVal)) {
                        promise = pathVal;
                        promise.$$v = undefined;
                        promise.then(function (val) {
                            promise.$$v = val;
                        });
                    }
                    pathVal = pathVal.$$v;
                }
                if (!key3 || pathVal === null || pathVal === undefined)
                    return pathVal;

                pathVal = pathVal[key3];
                if (pathVal && pathVal.then) {
                    promiseWarning(fullExp);
                    if (!("$$v" in pathVal)) {
                        promise = pathVal;
                        promise.$$v = undefined;
                        promise.then(function (val) {
                            promise.$$v = val;
                        });
                    }
                    pathVal = pathVal.$$v;
                }
                if (!key4 || pathVal === null || pathVal === undefined)
                    return pathVal;

                pathVal = pathVal[key4];
                if (pathVal && pathVal.then) {
                    promiseWarning(fullExp);
                    if (!("$$v" in pathVal)) {
                        promise = pathVal;
                        promise.$$v = undefined;
                        promise.then(function (val) {
                            promise.$$v = val;
                        });
                    }
                    pathVal = pathVal.$$v;
                }
                return pathVal;
            };
    }

    function getterFn(path, options, fullExp) {
        // Check whether the cache has this getter already.
        // We can use hasOwnProperty directly on the cache because we ensure,
        // see below, that the cache never stores a path called 'hasOwnProperty'
        if (getterFnCache.hasOwnProperty(path)) {
            return getterFnCache[path];
        }

        var pathKeys = path.split("."),
            pathKeysLength = pathKeys.length,
            fn;

        if (options.csp) {
            if (pathKeysLength < 6) {
                fn = cspSafeGetterFn(
                    pathKeys[0],
                    pathKeys[1],
                    pathKeys[2],
                    pathKeys[3],
                    pathKeys[4],
                    fullExp,
                    options,
                );
            } else {
                fn = function (scope, locals) {
                    var i = 0,
                        val;
                    do {
                        val = cspSafeGetterFn(
                            pathKeys[i++],
                            pathKeys[i++],
                            pathKeys[i++],
                            pathKeys[i++],
                            pathKeys[i++],
                            fullExp,
                            options,
                        )(scope, locals);

                        locals = undefined; // clear after first iteration
                        scope = val;
                    } while (i < pathKeysLength);
                    return val;
                };
            }
        } else {
            var code = "var l, fn, p;\n";
            forEach(pathKeys, function (key, index) {
                ensureSafeMemberName(key, fullExp);
                code +=
                    "if(s === null || s === undefined) return s;\n" +
                    "l=s;\n" +
                    "s=" +
                    (index
                        ? // we simply dereference 's' on any .dot notation
                        "s"
                        : // but if we are first then we check locals first, and if so read it first
                        '((k&&k.hasOwnProperty("' + key + '"))?k:s)') +
                    '["' +
                    key +
                    '"]' +
                    ";\n" +
                    (options.unwrapPromises
                        ? "if (s && s.then) {\n" +
                        ' pw("' +
                        fullExp.replace(/(["\r\n])/g, "\\$1") +
                        '");\n' +
                        ' if (!("$$v" in s)) {\n' +
                        " p=s;\n" +
                        " p.$$v = undefined;\n" +
                        " p.then(function(v) {p.$$v=v;});\n" +
                        "}\n" +
                        " s=s.$$v\n" +
                        "}\n"
                        : "");
            });
            code += "return s;";

            /* jshint -W054 */
            var evaledFnGetter = new Function("s", "k", "pw", code); // s=scope, k=locals, pw=promiseWarning
            /* jshint +W054 */
            evaledFnGetter.toString = function () {
                return code;
            };
            fn = function (scope, locals) {
                return evaledFnGetter(scope, locals, promiseWarning);
            };
        }

        // Only cache the value if it's not going to mess up the cache object
        // This is more performant that using Object.prototype.hasOwnProperty.call
        if (path !== "hasOwnProperty") {
            getterFnCache[path] = fn;
        }
        return fn;
    }

    ///////////////////////////////////

    /**
     * @ngdoc function
     * @name ng.$parse
     * @function
     *
     * @description
     *
     * Converts Angular {@link guide/expression expression} into a function.
     *
     * <pre>
     *   var getter = $parse('user.name');
     *   var setter = getter.assign;
     *   var context = {user:{name:'angular'}};
     *   var locals = {user:{name:'local'}};
     *
     *   expect(getter(context)).toEqual('angular');
     *   setter(context, 'newValue');
     *   expect(context.user.name).toEqual('newValue');
     *   expect(getter(context, locals)).toEqual('local');
     * </pre>
     *
     *
     * @param {string} expression String expression to compile.
     * @returns {function(context, locals)} a function which represents the compiled expression:
     *
     *    * `context` – `{object}` – an object against which any expressions embedded in the strings
     *      are evaluated against (typically a scope object).
     *    * `locals` – `{object=}` – local variables context object, useful for overriding values in
     *      `context`.
     *
     *    The returned function also has the following properties:
     *      * `literal` – `{boolean}` – whether the expression's top-level node is a JavaScript
     *        literal.
     *      * `constant` – `{boolean}` – whether the expression is made entirely of JavaScript
     *        constant literals.
     *      * `assign` – `{?function(context, value)}` – if the expression is assignable, this will be
     *        set to a function to change its value on the given context.
     *
     */

    /**
     * @ngdoc object
     * @name ng.$parseProvider
     * @function
     *
     * @description
     * `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
     *  service.
     */
    function $ParseProvider() {
        var cache = {};

        var $parseOptions = {
            csp: false,
            unwrapPromises: false,
            logPromiseWarnings: true,
        };

        /**
         * @deprecated Promise unwrapping via $parse is deprecated and will be removed in the future.
         *
         * @ngdoc method
         * @name ng.$parseProvider#unwrapPromises
         * @methodOf ng.$parseProvider
         * @description
         *
         * **This feature is deprecated, see deprecation notes below for more info**
         *
         * If set to true (default is false), $parse will unwrap promises automatically when a promise is
         * found at any part of the expression. In other words, if set to true, the expression will always
         * result in a non-promise value.
         *
         * While the promise is unresolved, it's treated as undefined, but once resolved and fulfilled,
         * the fulfillment value is used in place of the promise while evaluating the expression.
         *
         * **Deprecation notice**
         *
         * This is a feature that didn't prove to be wildly useful or popular, primarily because of the
         * dichotomy between data access in templates (accessed as raw values) and controller code
         * (accessed as promises).
         *
         * In most code we ended up resolving promises manually in controllers anyway and thus unifying
         * the model access there.
         *
         * Other downsides of automatic promise unwrapping:
         *
         * - when building components it's often desirable to receive the raw promises
         * - adds complexity and slows down expression evaluation
         * - makes expression code pre-generation unattractive due to the amount of code that needs to be
         *   generated
         * - makes IDE auto-completion and tool support hard
         *
         * **Warning Logs**
         *
         * If the unwrapping is enabled, Angular will log a warning about each expression that unwraps a
         * promise (to reduce the noise, each expression is logged only once). To disable this logging use
         * `$parseProvider.logPromiseWarnings(false)` api.
         *
         *
         * @param {boolean=} value New value.
         * @returns {boolean|self} Returns the current setting when used as getter and self if used as
         *                         setter.
         */
        this.unwrapPromises = function (value) {
            if (isDefined(value)) {
                $parseOptions.unwrapPromises = !!value;
                return this;
            } else {
                return $parseOptions.unwrapPromises;
            }
        };

        /**
         * @deprecated Promise unwrapping via $parse is deprecated and will be removed in the future.
         *
         * @ngdoc method
         * @name ng.$parseProvider#logPromiseWarnings
         * @methodOf ng.$parseProvider
         * @description
         *
         * Controls whether Angular should log a warning on any encounter of a promise in an expression.
         *
         * The default is set to `true`.
         *
         * This setting applies only if `$parseProvider.unwrapPromises` setting is set to true as well.
         *
         * @param {boolean=} value New value.
         * @returns {boolean|self} Returns the current setting when used as getter and self if used as
         *                         setter.
         */
        this.logPromiseWarnings = function (value) {
            if (isDefined(value)) {
                $parseOptions.logPromiseWarnings = value;
                return this;
            } else {
                return $parseOptions.logPromiseWarnings;
            }
        };

        this.$get = [
            "$filter",
            "$sniffer",
            "$log",
            function ($filter, $sniffer, $log) {
                $parseOptions.csp = $sniffer.csp;

                promiseWarning = function promiseWarningFn(fullExp) {
                    if (
                        !$parseOptions.logPromiseWarnings ||
                        promiseWarningCache.hasOwnProperty(fullExp)
                    )
                        return;
                    promiseWarningCache[fullExp] = true;
                    $log.warn(
                        "[$parse] Promise found in the expression `" +
                        fullExp +
                        "`. " +
                        "Automatic unwrapping of promises in Angular expressions is deprecated.",
                    );
                };

                return function (exp) {
                    var parsedExpression;

                    switch (typeof exp) {
                        case "string":
                            if (cache.hasOwnProperty(exp)) {
                                return cache[exp];
                            }

                            var lexer = new Lexer($parseOptions);
                            var parser = new Parser(lexer, $filter, $parseOptions);
                            parsedExpression = parser.parse(exp, false);

                            if (exp !== "hasOwnProperty") {
                                // Only cache the value if it's not going to mess up the cache object
                                // This is more performant that using Object.prototype.hasOwnProperty.call
                                cache[exp] = parsedExpression;
                            }

                            return parsedExpression;

                        case "function":
                            return exp;

                        default:
                            return noop;
                    }
                };
            },
        ];
    }

    /**
     * @ngdoc service
     * @name ng.$q
     * @requires $rootScope
     *
     * @description
     * A promise/deferred implementation inspired by [Kris Kowal's Q](https://github.com/kriskowal/q).
     *
     * [The CommonJS Promise proposal](http://wiki.commonjs.org/wiki/Promises) describes a promise as an
     * interface for interacting with an object that represents the result of an action that is
     * performed asynchronously, and may or may not be finished at any given point in time.
     *
     * From the perspective of dealing with error handling, deferred and promise APIs are to
     * asynchronous programming what `try`, `catch` and `throw` keywords are to synchronous programming.
     *
     * <pre>
     *   // for the purpose of this example let's assume that variables `$q` and `scope` are
     *   // available in the current lexical scope (they could have been injected or passed in).
     *
     *   function asyncGreet(name) {
     *     var deferred = $q.defer();
     *
     *     setTimeout(function() {
     *       // since this fn executes async in a future turn of the event loop, we need to wrap
     *       // our code into an $apply call so that the model changes are properly observed.
     *       scope.$apply(function() {
     *         deferred.notify('About to greet ' + name + '.');
     *
     *         if (okToGreet(name)) {
     *           deferred.resolve('Hello, ' + name + '!');
     *         } else {
     *           deferred.reject('Greeting ' + name + ' is not allowed.');
     *         }
     *       });
     *     }, 1000);
     *
     *     return deferred.promise;
     *   }
     *
     *   var promise = asyncGreet('Robin Hood');
     *   promise.then(function(greeting) {
     *     alert('Success: ' + greeting);
     *   }, function(reason) {
     *     alert('Failed: ' + reason);
     *   }, function(update) {
     *     alert('Got notification: ' + update);
     *   });
     * </pre>
     *
     * At first it might not be obvious why this extra complexity is worth the trouble. The payoff
     * comes in the way of guarantees that promise and deferred APIs make, see
     * https://github.com/kriskowal/uncommonjs/blob/master/promises/specification.md.
     *
     * Additionally the promise api allows for composition that is very hard to do with the
     * traditional callback ([CPS](http://en.wikipedia.org/wiki/Continuation-passing_style)) approach.
     * For more on this please see the [Q documentation](https://github.com/kriskowal/q) especially the
     * section on serial or parallel joining of promises.
     *
     *
     * # The Deferred API
     *
     * A new instance of deferred is constructed by calling `$q.defer()`.
     *
     * The purpose of the deferred object is to expose the associated Promise instance as well as APIs
     * that can be used for signaling the successful or unsuccessful completion, as well as the status
     * of the task.
     *
     * **Methods**
     *
     * - `resolve(value)` – resolves the derived promise with the `value`. If the value is a rejection
     *   constructed via `$q.reject`, the promise will be rejected instead.
     * - `reject(reason)` – rejects the derived promise with the `reason`. This is equivalent to
     *   resolving it with a rejection constructed via `$q.reject`.
     * - `notify(value)` - provides updates on the status of the promises execution. This may be called
     *   multiple times before the promise is either resolved or rejected.
     *
     * **Properties**
     *
     * - promise – `{Promise}` – promise object associated with this deferred.
     *
     *
     * # The Promise API
     *
     * A new promise instance is created when a deferred instance is created and can be retrieved by
     * calling `deferred.promise`.
     *
     * The purpose of the promise object is to allow for interested parties to get access to the result
     * of the deferred task when it completes.
     *
     * **Methods**
     *
     * - `then(successCallback, errorCallback, notifyCallback)` – regardless of when the promise was or
     *   will be resolved or rejected, `then` calls one of the success or error callbacks asynchronously
     *   as soon as the result is available. The callbacks are called with a single argument: the result
     *   or rejection reason. Additionally, the notify callback may be called zero or more times to
     *   provide a progress indication, before the promise is resolved or rejected.
     *
     *   This method *returns a new promise* which is resolved or rejected via the return value of the
     *   `successCallback`, `errorCallback`. It also notifies via the return value of the
     *   `notifyCallback` method. The promise can not be resolved or rejected from the notifyCallback
     *   method.
     *
     * - `catch(errorCallback)` – shorthand for `promise.then(null, errorCallback)`
     *
     * - `finally(callback)` – allows you to observe either the fulfillment or rejection of a promise,
     *   but to do so without modifying the final value. This is useful to release resources or do some
     *   clean-up that needs to be done whether the promise was rejected or resolved. See the [full
     *   specification](https://github.com/kriskowal/q/wiki/API-Reference#promisefinallycallback) for
     *   more information.
     *
     *   Because `finally` is a reserved word in JavaScript and reserved keywords are not supported as
     *   property names by ES3, you'll need to invoke the method like `promise['finally'](callback)` to
     *   make your code IE8 compatible.
     *
     * # Chaining promises
     *
     * Because calling the `then` method of a promise returns a new derived promise, it is easily
     * possible to create a chain of promises:
     *
     * <pre>
     *   promiseB = promiseA.then(function(result) {
     *     return result + 1;
     *   });
     *
     *   // promiseB will be resolved immediately after promiseA is resolved and its value
     *   // will be the result of promiseA incremented by 1
     * </pre>
     *
     * It is possible to create chains of any length and since a promise can be resolved with another
     * promise (which will defer its resolution further), it is possible to pause/defer resolution of
     * the promises at any point in the chain. This makes it possible to implement powerful APIs like
     * $http's response interceptors.
     *
     *
     * # Differences between Kris Kowal's Q and $q
     *
     *  There are two main differences:
     *
     * - $q is integrated with the {@link ng.$rootScope.Scope} Scope model observation
     *   mechanism in angular, which means faster propagation of resolution or rejection into your
     *   models and avoiding unnecessary browser repaints, which would result in flickering UI.
     * - Q has many more features than $q, but that comes at a cost of bytes. $q is tiny, but contains
     *   all the important functionality needed for common async tasks.
     *
     *  # Testing
     *
     *  <pre>
     *    it('should simulate promise', inject(function($q, $rootScope) {
     *      var deferred = $q.defer();
     *      var promise = deferred.promise;
     *      var resolvedValue;
     *
     *      promise.then(function(value) { resolvedValue = value; });
     *      expect(resolvedValue).toBeUndefined();
     *
     *      // Simulate resolving of promise
     *      deferred.resolve(123);
     *      // Note that the 'then' function does not get called synchronously.
     *      // This is because we want the promise API to always be async, whether or not
     *      // it got called synchronously or asynchronously.
     *      expect(resolvedValue).toBeUndefined();
     *
     *      // Propagate promise resolution to 'then' functions using $apply().
     *      $rootScope.$apply();
     *      expect(resolvedValue).toEqual(123);
     *    }));
     *  </pre>
     */
    function $QProvider() {
        this.$get = [
            "$rootScope",
            "$exceptionHandler",
            function ($rootScope, $exceptionHandler) {
                return qFactory(function (callback) {
                    $rootScope.$evalAsync(callback);
                }, $exceptionHandler);
            },
        ];
    }

    /**
     * Constructs a promise manager.
     *
     * @param {function(function)} nextTick Function for executing functions in the next turn.
     * @param {function(...*)} exceptionHandler Function into which unexpected exceptions are passed for
     *     debugging purposes.
     * @returns {object} Promise manager.
     */
    function qFactory(nextTick, exceptionHandler) {
        /**
         * @ngdoc
         * @name ng.$q#defer
         * @methodOf ng.$q
         * @description
         * Creates a `Deferred` object which represents a task which will finish in the future.
         *
         * @returns {Deferred} Returns a new instance of deferred.
         */
        var defer = function () {
            var pending = [],
                value,
                deferred;

            deferred = {
                resolve: function (val) {
                    if (pending) {
                        var callbacks = pending;
                        pending = undefined;
                        value = ref(val);

                        if (callbacks.length) {
                            nextTick(function () {
                                var callback;
                                for (var i = 0, ii = callbacks.length; i < ii; i++) {
                                    callback = callbacks[i];
                                    value.then(callback[0], callback[1], callback[2]);
                                }
                            });
                        }
                    }
                },

                reject: function (reason) {
                    deferred.resolve(reject(reason));
                },

                notify: function (progress) {
                    if (pending) {
                        var callbacks = pending;

                        if (pending.length) {
                            nextTick(function () {
                                var callback;
                                for (var i = 0, ii = callbacks.length; i < ii; i++) {
                                    callback = callbacks[i];
                                    callback[2](progress);
                                }
                            });
                        }
                    }
                },

                promise: {
                    then: function (callback, errback, progressback) {
                        var result = defer();

                        var wrappedCallback = function (value) {
                            try {
                                result.resolve(
                                    (isFunction(callback) ? callback : defaultCallback)(value),
                                );
                            } catch (e) {
                                result.reject(e);
                                exceptionHandler(e);
                            }
                        };

                        var wrappedErrback = function (reason) {
                            try {
                                result.resolve(
                                    (isFunction(errback) ? errback : defaultErrback)(reason),
                                );
                            } catch (e) {
                                result.reject(e);
                                exceptionHandler(e);
                            }
                        };

                        var wrappedProgressback = function (progress) {
                            try {
                                result.notify(
                                    (isFunction(progressback) ? progressback : defaultCallback)(
                                        progress,
                                    ),
                                );
                            } catch (e) {
                                exceptionHandler(e);
                            }
                        };

                        if (pending) {
                            pending.push([
                                wrappedCallback,
                                wrappedErrback,
                                wrappedProgressback,
                            ]);
                        } else {
                            value.then(wrappedCallback, wrappedErrback, wrappedProgressback);
                        }

                        return result.promise;
                    },

                    catch: function (callback) {
                        return this.then(null, callback);
                    },

                    finally: function (callback) {
                        function makePromise(value, resolved) {
                            var result = defer();
                            if (resolved) {
                                result.resolve(value);
                            } else {
                                result.reject(value);
                            }
                            return result.promise;
                        }

                        function handleCallback(value, isResolved) {
                            var callbackOutput = null;
                            try {
                                callbackOutput = (callback || defaultCallback)();
                            } catch (e) {
                                return makePromise(e, false);
                            }
                            if (callbackOutput && isFunction(callbackOutput.then)) {
                                return callbackOutput.then(
                                    function () {
                                        return makePromise(value, isResolved);
                                    },
                                    function (error) {
                                        return makePromise(error, false);
                                    },
                                );
                            } else {
                                return makePromise(value, isResolved);
                            }
                        }

                        return this.then(
                            function (value) {
                                return handleCallback(value, true);
                            },
                            function (error) {
                                return handleCallback(error, false);
                            },
                        );
                    },
                },
            };

            return deferred;
        };

        var ref = function (value) {
            if (value && isFunction(value.then)) return value;
            return {
                then: function (callback) {
                    var result = defer();
                    nextTick(function () {
                        result.resolve(callback(value));
                    });
                    return result.promise;
                },
            };
        };

        /**
         * @ngdoc
         * @name ng.$q#reject
         * @methodOf ng.$q
         * @description
         * Creates a promise that is resolved as rejected with the specified `reason`. This api should be
         * used to forward rejection in a chain of promises. If you are dealing with the last promise in
         * a promise chain, you don't need to worry about it.
         *
         * When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of
         * `reject` as the `throw` keyword in JavaScript. This also means that if you "catch" an error via
         * a promise error callback and you want to forward the error to the promise derived from the
         * current promise, you have to "rethrow" the error by returning a rejection constructed via
         * `reject`.
         *
         * <pre>
         *   promiseB = promiseA.then(function(result) {
         *     // success: do something and resolve promiseB
         *     //          with the old or a new result
         *     return result;
         *   }, function(reason) {
         *     // error: handle the error if possible and
         *     //        resolve promiseB with newPromiseOrValue,
         *     //        otherwise forward the rejection to promiseB
         *     if (canHandle(reason)) {
         *      // handle the error and recover
         *      return newPromiseOrValue;
         *     }
         *     return $q.reject(reason);
         *   });
         * </pre>
         *
         * @param {*} reason Constant, message, exception or an object representing the rejection reason.
         * @returns {Promise} Returns a promise that was already resolved as rejected with the `reason`.
         */
        var reject = function (reason) {
            return {
                then: function (callback, errback) {
                    var result = defer();
                    nextTick(function () {
                        try {
                            result.resolve(
                                (isFunction(errback) ? errback : defaultErrback)(reason),
                            );
                        } catch (e) {
                            result.reject(e);
                            exceptionHandler(e);
                        }
                    });
                    return result.promise;
                },
            };
        };

        /**
         * @ngdoc
         * @name ng.$q#when
         * @methodOf ng.$q
         * @description
         * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise.
         * This is useful when you are dealing with an object that might or might not be a promise, or if
         * the promise comes from a source that can't be trusted.
         *
         * @param {*} value Value or a promise
         * @returns {Promise} Returns a promise of the passed value or promise
         */
        var when = function (value, callback, errback, progressback) {
            var result = defer(),
                done;

            var wrappedCallback = function (value) {
                try {
                    return (isFunction(callback) ? callback : defaultCallback)(value);
                } catch (e) {
                    exceptionHandler(e);
                    return reject(e);
                }
            };

            var wrappedErrback = function (reason) {
                try {
                    return (isFunction(errback) ? errback : defaultErrback)(reason);
                } catch (e) {
                    exceptionHandler(e);
                    return reject(e);
                }
            };

            var wrappedProgressback = function (progress) {
                try {
                    return (isFunction(progressback) ? progressback : defaultCallback)(
                        progress,
                    );
                } catch (e) {
                    exceptionHandler(e);
                }
            };

            nextTick(function () {
                ref(value).then(
                    function (value) {
                        if (done) return;
                        done = true;
                        result.resolve(
                            ref(value).then(
                                wrappedCallback,
                                wrappedErrback,
                                wrappedProgressback,
                            ),
                        );
                    },
                    function (reason) {
                        if (done) return;
                        done = true;
                        result.resolve(wrappedErrback(reason));
                    },
                    function (progress) {
                        if (done) return;
                        result.notify(wrappedProgressback(progress));
                    },
                );
            });

            return result.promise;
        };

        function defaultCallback(value) {
            return value;
        }

        function defaultErrback(reason) {
            return reject(reason);
        }

        /**
         * @ngdoc
         * @name ng.$q#all
         * @methodOf ng.$q
         * @description
         * Combines multiple promises into a single promise that is resolved when all of the input
         * promises are resolved.
         *
         * @param {Array.<Promise>|Object.<Promise>} promises An array or hash of promises.
         * @returns {Promise} Returns a single promise that will be resolved with an array/hash of values,
         *   each value corresponding to the promise at the same index/key in the `promises` array/hash.
         *   If any of the promises is resolved with a rejection, this resulting promise will be rejected
         *   with the same rejection value.
         */
        function all(promises) {
            var deferred = defer(),
                counter = 0,
                results = isArray(promises) ? [] : {};

            forEach(promises, function (promise, key) {
                counter++;
                ref(promise).then(
                    function (value) {
                        if (results.hasOwnProperty(key)) return;
                        results[key] = value;
                        if (!--counter) deferred.resolve(results);
                    },
                    function (reason) {
                        if (results.hasOwnProperty(key)) return;
                        deferred.reject(reason);
                    },
                );
            });

            if (counter === 0) {
                deferred.resolve(results);
            }

            return deferred.promise;
        }

        return {
            defer: defer,
            reject: reject,
            when: when,
            all: all,
        };
    }

    /**
     * DESIGN NOTES
     *
     * The design decisions behind the scope are heavily favored for speed and memory consumption.
     *
     * The typical use of scope is to watch the expressions, which most of the time return the same
     * value as last time so we optimize the operation.
     *
     * Closures construction is expensive in terms of speed as well as memory:
     *   - No closures, instead use prototypical inheritance for API
     *   - Internal state needs to be stored on scope directly, which means that private state is
     *     exposed as $$____ properties
     *
     * Loop operations are optimized by using while(count--) { ... }
     *   - this means that in order to keep the same order of execution as addition we have to add
     *     items to the array at the beginning (shift) instead of at the end (push)
     *
     * Child scopes are created and removed often
     *   - Using an array would be slow since inserts in middle are expensive so we use linked list
     *
     * There are few watches then a lot of observers. This is why you don't want the observer to be
     * implemented in the same way as watch. Watch requires return of initialization function which
     * are expensive to construct.
     */

    /**
     * @ngdoc object
     * @name ng.$rootScopeProvider
     * @description
     *
     * Provider for the $rootScope service.
     */

    /**
     * @ngdoc function
     * @name ng.$rootScopeProvider#digestTtl
     * @methodOf ng.$rootScopeProvider
     * @description
     *
     * Sets the number of `$digest` iterations the scope should attempt to execute before giving up and
     * assuming that the model is unstable.
     *
     * The current default is 10 iterations.
     *
     * In complex applications it's possible that the dependencies between `$watch`s will result in
     * several digest iterations. However if an application needs more than the default 10 digest
     * iterations for its model to stabilize then you should investigate what is causing the model to
     * continuously change during the digest.
     *
     * Increasing the TTL could have performance implications, so you should not change it without
     * proper justification.
     *
     * @param {number} limit The number of digest iterations.
     */

    /**
     * @ngdoc object
     * @name ng.$rootScope
     * @description
     *
     * Every application has a single root {@link ng.$rootScope.Scope scope}.
     * All other scopes are descendant scopes of the root scope. Scopes provide separation
     * between the model and the view, via a mechanism for watching the model for changes.
     * They also provide an event emission/broadcast and subscription facility. See the
     * {@link guide/scope developer guide on scopes}.
     */
    function $RootScopeProvider() {
        var TTL = 10;
        var $rootScopeMinErr = minErr("$rootScope");
        var lastDirtyWatch = null;

        this.digestTtl = function (value) {
            if (arguments.length) {
                TTL = value;
            }
            return TTL;
        };

        this.$get = [
            "$injector",
            "$exceptionHandler",
            "$parse",
            "$browser",
            function ($injector, $exceptionHandler, $parse, $browser) {
                /**
             * @ngdoc function
             * @name ng.$rootScope.Scope
             *
             * @description
             * A root scope can be retrieved using the {@link ng.$rootScope $rootScope} key from the
             * {@link AUTO.$injector $injector}. Child scopes are created using the
             * {@link ng.$rootScope.Scope#methods_$new $new()} method. (Most scopes are created automatically when
             * compiled HTML template is executed.)
             *
             * Here is a simple scope snippet to show how you can interact with the scope.
             * <pre>
             * <file src="./test/ng/rootScopeSpec.js" tag="docs1" />
             * </pre>
             *
             * # Inheritance
             * A scope can inherit from a parent scope, as in this example:
             * <pre>
                 var parent = $rootScope;
                 var child = parent.$new();
        
                 parent.salutation = "Hello";
                 child.name = "World";
                 expect(child.salutation).toEqual('Hello');
        
                 child.salutation = "Welcome";
                 expect(child.salutation).toEqual('Welcome');
                 expect(parent.salutation).toEqual('Hello');
             * </pre>
             *
             *
             * @param {Object.<string, function()>=} providers Map of service factory which need to be
             *                                       provided for the current scope. Defaults to {@link ng}.
             * @param {Object.<string, *>=} instanceCache Provides pre-instantiated services which should
             *                              append/override services provided by `providers`. This is handy
             *                              when unit-testing and having the need to override a default
             *                              service.
             * @returns {Object} Newly created scope.
             *
             */
                function Scope() {
                    this.$id = nextUid();
                    this.$$phase =
                        this.$parent =
                        this.$$watchers =
                        this.$$nextSibling =
                        this.$$prevSibling =
                        this.$$childHead =
                        this.$$childTail =
                        null;
                    this["this"] = this.$root = this;
                    this.$$destroyed = false;
                    this.$$asyncQueue = [];
                    this.$$postDigestQueue = [];
                    this.$$listeners = {};
                    this.$$isolateBindings = {};
                }

                /**
                 * @ngdoc property
                 * @name ng.$rootScope.Scope#$id
                 * @propertyOf ng.$rootScope.Scope
                 * @returns {number} Unique scope ID (monotonically increasing alphanumeric sequence) useful for
                 *   debugging.
                 */

                Scope.prototype = {
                    constructor: Scope,
                    /**
                     * @ngdoc function
                     * @name ng.$rootScope.Scope#$new
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Creates a new child {@link ng.$rootScope.Scope scope}.
                     *
                     * The parent scope will propagate the {@link ng.$rootScope.Scope#methods_$digest $digest()} and
                     * {@link ng.$rootScope.Scope#methods_$digest $digest()} events. The scope can be removed from the
                     * scope hierarchy using {@link ng.$rootScope.Scope#methods_$destroy $destroy()}.
                     *
                     * {@link ng.$rootScope.Scope#methods_$destroy $destroy()} must be called on a scope when it is
                     * desired for the scope and its child scopes to be permanently detached from the parent and
                     * thus stop participating in model change detection and listener notification by invoking.
                     *
                     * @param {boolean} isolate If true, then the scope does not prototypically inherit from the
                     *         parent scope. The scope is isolated, as it can not see parent scope properties.
                     *         When creating widgets, it is useful for the widget to not accidentally read parent
                     *         state.
                     *
                     * @returns {Object} The newly created child scope.
                     *
                     */
                    $new: function (isolate) {
                        var ChildScope, child;

                        if (isolate) {
                            child = new Scope();
                            child.$root = this.$root;
                            // ensure that there is just one async queue per $rootScope and its children
                            child.$$asyncQueue = this.$$asyncQueue;
                            child.$$postDigestQueue = this.$$postDigestQueue;
                        } else {
                            ChildScope = function () { }; // should be anonymous; This is so that when the minifier munges
                            // the name it does not become random set of chars. This will then show up as class
                            // name in the debugger.
                            ChildScope.prototype = this;
                            child = new ChildScope();
                            child.$id = nextUid();
                        }
                        child["this"] = child;
                        child.$$listeners = {};
                        child.$parent = this;
                        child.$$watchers =
                            child.$$nextSibling =
                            child.$$childHead =
                            child.$$childTail =
                            null;
                        child.$$prevSibling = this.$$childTail;
                        if (this.$$childHead) {
                            this.$$childTail.$$nextSibling = child;
                            this.$$childTail = child;
                        } else {
                            this.$$childHead = this.$$childTail = child;
                        }
                        return child;
                    },

                    /**
                 * @ngdoc function
                 * @name ng.$rootScope.Scope#$watch
                 * @methodOf ng.$rootScope.Scope
                 * @function
                 *
                 * @description
                 * Registers a `listener` callback to be executed whenever the `watchExpression` changes.
                 *
                 * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#methods_$digest
                 *   $digest()} and should return the value that will be watched. (Since
                 *   {@link ng.$rootScope.Scope#methods_$digest $digest()} reruns when it detects changes the
                 *   `watchExpression` can execute multiple times per
                 *   {@link ng.$rootScope.Scope#methods_$digest $digest()} and should be idempotent.)
                 * - The `listener` is called only when the value from the current `watchExpression` and the
                 *   previous call to `watchExpression` are not equal (with the exception of the initial run,
                 *   see below). The inequality is determined according to
                 *   {@link angular.equals} function. To save the value of the object for later comparison,
                 *   the {@link angular.copy} function is used. It also means that watching complex options
                 *   will have adverse memory and performance implications.
                 * - The watch `listener` may change the model, which may trigger other `listener`s to fire.
                 *   This is achieved by rerunning the watchers until no changes are detected. The rerun
                 *   iteration limit is 10 to prevent an infinite loop deadlock.
                 *
                 *
                 * If you want to be notified whenever {@link ng.$rootScope.Scope#methods_$digest $digest} is called,
                 * you can register a `watchExpression` function with no `listener`. (Since `watchExpression`
                 * can execute multiple times per {@link ng.$rootScope.Scope#methods_$digest $digest} cycle when a
                 * change is detected, be prepared for multiple calls to your listener.)
                 *
                 * After a watcher is registered with the scope, the `listener` fn is called asynchronously
                 * (via {@link ng.$rootScope.Scope#methods_$evalAsync $evalAsync}) to initialize the
                 * watcher. In rare cases, this is undesirable because the listener is called when the result
                 * of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you
                 * can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the
                 * listener was called due to initialization.
                 *
                 * The example below contains an illustration of using a function as your $watch listener
                 *
                 *
                 * # Example
                 * <pre>
                     // let's assume that scope was dependency injected as the $rootScope
                     var scope = $rootScope;
                     scope.name = 'misko';
                     scope.counter = 0;
          
                     expect(scope.counter).toEqual(0);
                     scope.$watch('name', function(newValue, oldValue) {
                       scope.counter = scope.counter + 1;
                     });
                     expect(scope.counter).toEqual(0);
          
                     scope.$digest();
                     // no variable change
                     expect(scope.counter).toEqual(0);
          
                     scope.name = 'adam';
                     scope.$digest();
                     expect(scope.counter).toEqual(1);
          
          
          
                     // Using a listener function
                     var food;
                     scope.foodCounter = 0;
                     expect(scope.foodCounter).toEqual(0);
                     scope.$watch(
                       // This is the listener function
                       function() { return food; },
                       // This is the change handler
                       function(newValue, oldValue) {
                         if ( newValue !== oldValue ) {
                           // Only increment the counter if the value changed
                           scope.foodCounter = scope.foodCounter + 1;
                         }
                       }
                     );
                     // No digest has been run so the counter will be zero
                     expect(scope.foodCounter).toEqual(0);
          
                     // Run the digest but since food has not changed cout will still be zero
                     scope.$digest();
                     expect(scope.foodCounter).toEqual(0);
          
                     // Update food and run digest.  Now the counter will increment
                     food = 'cheeseburger';
                     scope.$digest();
                     expect(scope.foodCounter).toEqual(1);
          
                 * </pre>
                 *
                 *
                 *
                 * @param {(function()|string)} watchExpression Expression that is evaluated on each
                 *    {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. A change in the return value triggers
                 *    a call to the `listener`.
                 *
                 *    - `string`: Evaluated as {@link guide/expression expression}
                 *    - `function(scope)`: called with current `scope` as a parameter.
                 * @param {(function()|string)=} listener Callback called whenever the return value of
                 *   the `watchExpression` changes.
                 *
                 *    - `string`: Evaluated as {@link guide/expression expression}
                 *    - `function(newValue, oldValue, scope)`: called with current and previous values as
                 *      parameters.
                 *
                 * @param {boolean=} objectEquality Compare object for equality rather than for reference.
                 * @returns {function()} Returns a deregistration function for this listener.
                 */
                    $watch: function (watchExp, listener, objectEquality) {
                        var scope = this,
                            get = compileToFn(watchExp, "watch"),
                            array = scope.$$watchers,
                            watcher = {
                                fn: listener,
                                last: initWatchVal,
                                get: get,
                                exp: watchExp,
                                eq: !!objectEquality,
                            };

                        lastDirtyWatch = null;

                        // in the case user pass string, we need to compile it, do we really need this ?
                        if (!isFunction(listener)) {
                            var listenFn = compileToFn(listener || noop, "listener");
                            watcher.fn = function (newVal, oldVal, scope) {
                                listenFn(scope);
                            };
                        }

                        if (typeof watchExp == "string" && get.constant) {
                            var originalFn = watcher.fn;
                            watcher.fn = function (newVal, oldVal, scope) {
                                originalFn.call(this, newVal, oldVal, scope);
                                arrayRemove(array, watcher);
                            };
                        }

                        if (!array) {
                            array = scope.$$watchers = [];
                        }
                        // we use unshift since we use a while loop in $digest for speed.
                        // the while loop reads in reverse order.
                        array.unshift(watcher);

                        return function () {
                            arrayRemove(array, watcher);
                        };
                    },

                    /**
                 * @ngdoc function
                 * @name ng.$rootScope.Scope#$watchCollection
                 * @methodOf ng.$rootScope.Scope
                 * @function
                 *
                 * @description
                 * Shallow watches the properties of an object and fires whenever any of the properties change
                 * (for arrays, this implies watching the array items; for object maps, this implies watching
                 * the properties). If a change is detected, the `listener` callback is fired.
                 *
                 * - The `obj` collection is observed via standard $watch operation and is examined on every
                 *   call to $digest() to see if any items have been added, removed, or moved.
                 * - The `listener` is called whenever anything within the `obj` has changed. Examples include
                 *   adding, removing, and moving items belonging to an object or array.
                 *
                 *
                 * # Example
                 * <pre>
                    $scope.names = ['igor', 'matias', 'misko', 'james'];
                    $scope.dataCount = 4;
          
                    $scope.$watchCollection('names', function(newNames, oldNames) {
                      $scope.dataCount = newNames.length;
                    });
          
                    expect($scope.dataCount).toEqual(4);
                    $scope.$digest();
          
                    //still at 4 ... no changes
                    expect($scope.dataCount).toEqual(4);
          
                    $scope.names.pop();
                    $scope.$digest();
          
                    //now there's been a change
                    expect($scope.dataCount).toEqual(3);
                 * </pre>
                 *
                 *
                 * @param {string|Function(scope)} obj Evaluated as {@link guide/expression expression}. The
                 *    expression value should evaluate to an object or an array which is observed on each
                 *    {@link ng.$rootScope.Scope#methods_$digest $digest} cycle. Any shallow change within the
                 *    collection will trigger a call to the `listener`.
                 *
                 * @param {function(newCollection, oldCollection, scope)} listener a callback function that is
                 *    fired with both the `newCollection` and `oldCollection` as parameters.
                 *    The `newCollection` object is the newly modified data obtained from the `obj` expression
                 *    and the `oldCollection` object is a copy of the former collection data.
                 *    The `scope` refers to the current scope.
                 *
                 * @returns {function()} Returns a de-registration function for this listener. When the
                 *    de-registration function is executed, the internal watch operation is terminated.
                 */
                    $watchCollection: function (obj, listener) {
                        var self = this;
                        var oldValue;
                        var newValue;
                        var changeDetected = 0;
                        var objGetter = $parse(obj);
                        var internalArray = [];
                        var internalObject = {};
                        var oldLength = 0;

                        function $watchCollectionWatch() {
                            newValue = objGetter(self);
                            var newLength, key;

                            if (!isObject(newValue)) {
                                if (oldValue !== newValue) {
                                    oldValue = newValue;
                                    changeDetected++;
                                }
                            } else if (isArrayLike(newValue)) {
                                if (oldValue !== internalArray) {
                                    // we are transitioning from something which was not an array into array.
                                    oldValue = internalArray;
                                    oldLength = oldValue.length = 0;
                                    changeDetected++;
                                }

                                newLength = newValue.length;

                                if (oldLength !== newLength) {
                                    // if lengths do not match we need to trigger change notification
                                    changeDetected++;
                                    oldValue.length = oldLength = newLength;
                                }
                                // copy the items to oldValue and look for changes.
                                for (var i = 0; i < newLength; i++) {
                                    if (oldValue[i] !== newValue[i]) {
                                        changeDetected++;
                                        oldValue[i] = newValue[i];
                                    }
                                }
                            } else {
                                if (oldValue !== internalObject) {
                                    // we are transitioning from something which was not an object into object.
                                    oldValue = internalObject = {};
                                    oldLength = 0;
                                    changeDetected++;
                                }
                                // copy the items to oldValue and look for changes.
                                newLength = 0;
                                for (key in newValue) {
                                    if (newValue.hasOwnProperty(key)) {
                                        newLength++;
                                        if (oldValue.hasOwnProperty(key)) {
                                            if (oldValue[key] !== newValue[key]) {
                                                changeDetected++;
                                                oldValue[key] = newValue[key];
                                            }
                                        } else {
                                            oldLength++;
                                            oldValue[key] = newValue[key];
                                            changeDetected++;
                                        }
                                    }
                                }
                                if (oldLength > newLength) {
                                    // we used to have more keys, need to find them and destroy them.
                                    changeDetected++;
                                    for (key in oldValue) {
                                        if (
                                            oldValue.hasOwnProperty(key) &&
                                            !newValue.hasOwnProperty(key)
                                        ) {
                                            oldLength--;
                                            delete oldValue[key];
                                        }
                                    }
                                }
                            }
                            return changeDetected;
                        }

                        function $watchCollectionAction() {
                            listener(newValue, oldValue, self);
                        }

                        return this.$watch($watchCollectionWatch, $watchCollectionAction);
                    },

                    /**
                 * @ngdoc function
                 * @name ng.$rootScope.Scope#$digest
                 * @methodOf ng.$rootScope.Scope
                 * @function
                 *
                 * @description
                 * Processes all of the {@link ng.$rootScope.Scope#methods_$watch watchers} of the current scope and
                 * its children. Because a {@link ng.$rootScope.Scope#methods_$watch watcher}'s listener can change
                 * the model, the `$digest()` keeps calling the {@link ng.$rootScope.Scope#methods_$watch watchers}
                 * until no more listeners are firing. This means that it is possible to get into an infinite
                 * loop. This function will throw `'Maximum iteration limit exceeded.'` if the number of
                 * iterations exceeds 10.
                 *
                 * Usually, you don't call `$digest()` directly in
                 * {@link ng.directive:ngController controllers} or in
                 * {@link ng.$compileProvider#methods_directive directives}.
                 * Instead, you should call {@link ng.$rootScope.Scope#methods_$apply $apply()} (typically from within
                 * a {@link ng.$compileProvider#methods_directive directives}), which will force a `$digest()`.
                 *
                 * If you want to be notified whenever `$digest()` is called,
                 * you can register a `watchExpression` function with
                 * {@link ng.$rootScope.Scope#methods_$watch $watch()} with no `listener`.
                 *
                 * In unit tests, you may need to call `$digest()` to simulate the scope life cycle.
                 *
                 * # Example
                 * <pre>
                     var scope = ...;
                     scope.name = 'misko';
                     scope.counter = 0;
          
                     expect(scope.counter).toEqual(0);
                     scope.$watch('name', function(newValue, oldValue) {
                       scope.counter = scope.counter + 1;
                     });
                     expect(scope.counter).toEqual(0);
          
                     scope.$digest();
                     // no variable change
                     expect(scope.counter).toEqual(0);
          
                     scope.name = 'adam';
                     scope.$digest();
                     expect(scope.counter).toEqual(1);
                 * </pre>
                 *
                 */
                    $digest: function () {
                        var watch,
                            value,
                            last,
                            watchers,
                            asyncQueue = this.$$asyncQueue,
                            postDigestQueue = this.$$postDigestQueue,
                            length,
                            dirty,
                            ttl = TTL,
                            next,
                            current,
                            target = this,
                            watchLog = [],
                            logIdx,
                            logMsg,
                            asyncTask;

                        beginPhase("$digest");

                        lastDirtyWatch = null;

                        do {
                            // "while dirty" loop
                            dirty = false;
                            current = target;

                            while (asyncQueue.length) {
                                try {
                                    asyncTask = asyncQueue.shift();
                                    asyncTask.scope.$eval(asyncTask.expression);
                                } catch (e) {
                                    clearPhase();
                                    $exceptionHandler(e);
                                }
                                lastDirtyWatch = null;
                            }

                            traverseScopesLoop: do {
                                // "traverse the scopes" loop
                                if ((watchers = current.$$watchers)) {
                                    // process our watches
                                    length = watchers.length;
                                    while (length--) {
                                        try {
                                            watch = watchers[length];
                                            // Most common watches are on primitives, in which case we can short
                                            // circuit it with === operator, only when === fails do we use .equals
                                            if (watch) {
                                                if (
                                                    (value = watch.get(current)) !==
                                                    (last = watch.last) &&
                                                    !(watch.eq
                                                        ? equals(value, last)
                                                        : typeof value == "number" &&
                                                        typeof last == "number" &&
                                                        isNaN(value) &&
                                                        isNaN(last))
                                                ) {
                                                    dirty = true;
                                                    lastDirtyWatch = watch;
                                                    watch.last = watch.eq ? copy(value) : value;
                                                    watch.fn(
                                                        value,
                                                        last === initWatchVal ? value : last,
                                                        current,
                                                    );
                                                    if (ttl < 5) {
                                                        logIdx = 4 - ttl;
                                                        if (!watchLog[logIdx]) watchLog[logIdx] = [];
                                                        logMsg = isFunction(watch.exp)
                                                            ? "fn: " +
                                                            (watch.exp.name || watch.exp.toString())
                                                            : watch.exp;
                                                        logMsg +=
                                                            "; newVal: " +
                                                            toJson(value) +
                                                            "; oldVal: " +
                                                            toJson(last);
                                                        watchLog[logIdx].push(logMsg);
                                                    }
                                                } else if (watch === lastDirtyWatch) {
                                                    // If the most recently dirty watcher is now clean, short circuit since the remaining watchers
                                                    // have already been tested.
                                                    dirty = false;
                                                    break traverseScopesLoop;
                                                }
                                            }
                                        } catch (e) {
                                            clearPhase();
                                            $exceptionHandler(e);
                                        }
                                    }
                                }

                                // Insanity Warning: scope depth-first traversal
                                // yes, this code is a bit crazy, but it works and we have tests to prove it!
                                // this piece should be kept in sync with the traversal in $broadcast
                                if (
                                    !(next =
                                        current.$$childHead ||
                                        (current !== target && current.$$nextSibling))
                                ) {
                                    while (
                                        current !== target &&
                                        !(next = current.$$nextSibling)
                                    ) {
                                        current = current.$parent;
                                    }
                                }
                            } while ((current = next));

                            // `break traverseScopesLoop;` takes us to here

                            if (dirty && !ttl--) {
                                clearPhase();
                                throw $rootScopeMinErr(
                                    "infdig",
                                    "{0} $digest() iterations reached. Aborting!\n" +
                                    "Watchers fired in the last 5 iterations: {1}",
                                    TTL,
                                    toJson(watchLog),
                                );
                            }
                        } while (dirty || asyncQueue.length);

                        clearPhase();

                        while (postDigestQueue.length) {
                            try {
                                postDigestQueue.shift()();
                            } catch (e) {
                                $exceptionHandler(e);
                            }
                        }
                    },

                    /**
                     * @ngdoc event
                     * @name ng.$rootScope.Scope#$destroy
                     * @eventOf ng.$rootScope.Scope
                     * @eventType broadcast on scope being destroyed
                     *
                     * @description
                     * Broadcasted when a scope and its children are being destroyed.
                     *
                     * Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
                     * clean up DOM bindings before an element is removed from the DOM.
                     */

                    /**
                     * @ngdoc function
                     * @name ng.$rootScope.Scope#$destroy
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Removes the current scope (and all of its children) from the parent scope. Removal implies
                     * that calls to {@link ng.$rootScope.Scope#methods_$digest $digest()} will no longer
                     * propagate to the current scope and its children. Removal also implies that the current
                     * scope is eligible for garbage collection.
                     *
                     * The `$destroy()` is usually used by directives such as
                     * {@link ng.directive:ngRepeat ngRepeat} for managing the
                     * unrolling of the loop.
                     *
                     * Just before a scope is destroyed, a `$destroy` event is broadcasted on this scope.
                     * Application code can register a `$destroy` event handler that will give it a chance to
                     * perform any necessary cleanup.
                     *
                     * Note that, in AngularJS, there is also a `$destroy` jQuery event, which can be used to
                     * clean up DOM bindings before an element is removed from the DOM.
                     */
                    $destroy: function () {
                        // we can't destroy the root scope or a scope that has been already destroyed
                        if (this.$$destroyed) return;
                        var parent = this.$parent;

                        this.$broadcast("$destroy");
                        this.$$destroyed = true;
                        if (this === $rootScope) return;

                        if (parent.$$childHead == this)
                            parent.$$childHead = this.$$nextSibling;
                        if (parent.$$childTail == this)
                            parent.$$childTail = this.$$prevSibling;
                        if (this.$$prevSibling)
                            this.$$prevSibling.$$nextSibling = this.$$nextSibling;
                        if (this.$$nextSibling)
                            this.$$nextSibling.$$prevSibling = this.$$prevSibling;

                        // This is bogus code that works around Chrome's GC leak
                        // see: https://github.com/angular/angular.js/issues/1313#issuecomment-10378451
                        this.$parent =
                            this.$$nextSibling =
                            this.$$prevSibling =
                            this.$$childHead =
                            this.$$childTail =
                            null;
                    },

                    /**
                 * @ngdoc function
                 * @name ng.$rootScope.Scope#$eval
                 * @methodOf ng.$rootScope.Scope
                 * @function
                 *
                 * @description
                 * Executes the `expression` on the current scope and returns the result. Any exceptions in
                 * the expression are propagated (uncaught). This is useful when evaluating Angular
                 * expressions.
                 *
                 * # Example
                 * <pre>
                     var scope = ng.$rootScope.Scope();
                     scope.a = 1;
                     scope.b = 2;
          
                     expect(scope.$eval('a+b')).toEqual(3);
                     expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
                 * </pre>
                 *
                 * @param {(string|function())=} expression An angular expression to be executed.
                 *
                 *    - `string`: execute using the rules as defined in  {@link guide/expression expression}.
                 *    - `function(scope)`: execute the function with the current `scope` parameter.
                 *
                 * @param {(object)=} locals Local variables object, useful for overriding values in scope.
                 * @returns {*} The result of evaluating the expression.
                 */
                    $eval: function (expr, locals) {
                        return $parse(expr)(this, locals);
                    },

                    /**
                     * @ngdoc function
                     * @name ng.$rootScope.Scope#$evalAsync
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Executes the expression on the current scope at a later point in time.
                     *
                     * The `$evalAsync` makes no guarantees as to when the `expression` will be executed, only
                     * that:
                     *
                     *   - it will execute after the function that scheduled the evaluation (preferably before DOM
                     *     rendering).
                     *   - at least one {@link ng.$rootScope.Scope#methods_$digest $digest cycle} will be performed after
                     *     `expression` execution.
                     *
                     * Any exceptions from the execution of the expression are forwarded to the
                     * {@link ng.$exceptionHandler $exceptionHandler} service.
                     *
                     * __Note:__ if this function is called outside of a `$digest` cycle, a new `$digest` cycle
                     * will be scheduled. However, it is encouraged to always call code that changes the model
                     * from within an `$apply` call. That includes code evaluated via `$evalAsync`.
                     *
                     * @param {(string|function())=} expression An angular expression to be executed.
                     *
                     *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
                     *    - `function(scope)`: execute the function with the current `scope` parameter.
                     *
                     */
                    $evalAsync: function (expr) {
                        // if we are outside of an $digest loop and this is the first time we are scheduling async
                        // task also schedule async auto-flush
                        if (!$rootScope.$$phase && !$rootScope.$$asyncQueue.length) {
                            $browser.defer(function () {
                                if ($rootScope.$$asyncQueue.length) {
                                    $rootScope.$digest();
                                }
                            });
                        }

                        this.$$asyncQueue.push({ scope: this, expression: expr });
                    },

                    $$postDigest: function (fn) {
                        this.$$postDigestQueue.push(fn);
                    },

                    /**
                 * @ngdoc function
                 * @name ng.$rootScope.Scope#$apply
                 * @methodOf ng.$rootScope.Scope
                 * @function
                 *
                 * @description
                 * `$apply()` is used to execute an expression in angular from outside of the angular
                 * framework. (For example from browser DOM events, setTimeout, XHR or third party libraries).
                 * Because we are calling into the angular framework we need to perform proper scope life
                 * cycle of {@link ng.$exceptionHandler exception handling},
                 * {@link ng.$rootScope.Scope#methods_$digest executing watches}.
                 *
                 * ## Life cycle
                 *
                 * # Pseudo-Code of `$apply()`
                 * <pre>
                     function $apply(expr) {
                       try {
                         return $eval(expr);
                       } catch (e) {
                         $exceptionHandler(e);
                       } finally {
                         $root.$digest();
                       }
                     }
                 * </pre>
                 *
                 *
                 * Scope's `$apply()` method transitions through the following stages:
                 *
                 * 1. The {@link guide/expression expression} is executed using the
                 *    {@link ng.$rootScope.Scope#methods_$eval $eval()} method.
                 * 2. Any exceptions from the execution of the expression are forwarded to the
                 *    {@link ng.$exceptionHandler $exceptionHandler} service.
                 * 3. The {@link ng.$rootScope.Scope#methods_$watch watch} listeners are fired immediately after the
                 *    expression was executed using the {@link ng.$rootScope.Scope#methods_$digest $digest()} method.
                 *
                 *
                 * @param {(string|function())=} exp An angular expression to be executed.
                 *
                 *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
                 *    - `function(scope)`: execute the function with current `scope` parameter.
                 *
                 * @returns {*} The result of evaluating the expression.
                 */
                    $apply: function (expr) {
                        try {
                            beginPhase("$apply");
                            return this.$eval(expr);
                        } catch (e) {
                            $exceptionHandler(e);
                        } finally {
                            clearPhase();
                            try {
                                $rootScope.$digest();
                            } catch (e) {
                                $exceptionHandler(e);
                                throw e;
                            }
                        }
                    },

                    /**
                     * @ngdoc function
                     * @name ng.$rootScope.Scope#$on
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Listens on events of a given type. See {@link ng.$rootScope.Scope#methods_$emit $emit} for
                     * discussion of event life cycle.
                     *
                     * The event listener function format is: `function(event, args...)`. The `event` object
                     * passed into the listener has the following attributes:
                     *
                     *   - `targetScope` - `{Scope}`: the scope on which the event was `$emit`-ed or
                     *     `$broadcast`-ed.
                     *   - `currentScope` - `{Scope}`: the current scope which is handling the event.
                     *   - `name` - `{string}`: name of the event.
                     *   - `stopPropagation` - `{function=}`: calling `stopPropagation` function will cancel
                     *     further event propagation (available only for events that were `$emit`-ed).
                     *   - `preventDefault` - `{function}`: calling `preventDefault` sets `defaultPrevented` flag
                     *     to true.
                     *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
                     *
                     * @param {string} name Event name to listen on.
                     * @param {function(event, args...)} listener Function to call when the event is emitted.
                     * @returns {function()} Returns a deregistration function for this listener.
                     */
                    $on: function (name, listener) {
                        var namedListeners = this.$$listeners[name];
                        if (!namedListeners) {
                            this.$$listeners[name] = namedListeners = [];
                        }
                        namedListeners.push(listener);

                        return function () {
                            namedListeners[indexOf(namedListeners, listener)] = null;
                        };
                    },

                    /**
                     * @ngdoc function
                     * @name ng.$rootScope.Scope#$emit
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Dispatches an event `name` upwards through the scope hierarchy notifying the
                     * registered {@link ng.$rootScope.Scope#methods_$on} listeners.
                     *
                     * The event life cycle starts at the scope on which `$emit` was called. All
                     * {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
                     * notified. Afterwards, the event traverses upwards toward the root scope and calls all
                     * registered listeners along the way. The event will stop propagating if one of the listeners
                     * cancels it.
                     *
                     * Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed
                     * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
                     *
                     * @param {string} name Event name to emit.
                     * @param {...*} args Optional set of arguments which will be passed onto the event listeners.
                     * @return {Object} Event object (see {@link ng.$rootScope.Scope#methods_$on}).
                     */
                    $emit: function (name, args) {
                        var empty = [],
                            namedListeners,
                            scope = this,
                            stopPropagation = false,
                            event = {
                                name: name,
                                targetScope: scope,
                                stopPropagation: function () {
                                    stopPropagation = true;
                                },
                                preventDefault: function () {
                                    event.defaultPrevented = true;
                                },
                                defaultPrevented: false,
                            },
                            listenerArgs = concat([event], arguments, 1),
                            i,
                            length;

                        do {
                            namedListeners = scope.$$listeners[name] || empty;
                            event.currentScope = scope;
                            for (i = 0, length = namedListeners.length; i < length; i++) {
                                // if listeners were deregistered, defragment the array
                                if (!namedListeners[i]) {
                                    namedListeners.splice(i, 1);
                                    i--;
                                    length--;
                                    continue;
                                }
                                try {
                                    //allow all listeners attached to the current scope to run
                                    namedListeners[i].apply(null, listenerArgs);
                                } catch (e) {
                                    $exceptionHandler(e);
                                }
                            }
                            //if any listener on the current scope stops propagation, prevent bubbling
                            if (stopPropagation) return event;
                            //traverse upwards
                            scope = scope.$parent;
                        } while (scope);

                        return event;
                    },

                    /**
                     * @ngdoc function
                     * @name ng.$rootScope.Scope#$broadcast
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Dispatches an event `name` downwards to all child scopes (and their children) notifying the
                     * registered {@link ng.$rootScope.Scope#methods_$on} listeners.
                     *
                     * The event life cycle starts at the scope on which `$broadcast` was called. All
                     * {@link ng.$rootScope.Scope#methods_$on listeners} listening for `name` event on this scope get
                     * notified. Afterwards, the event propagates to all direct and indirect scopes of the current
                     * scope and calls all registered listeners along the way. The event cannot be canceled.
                     *
                     * Any exception emitted from the {@link ng.$rootScope.Scope#methods_$on listeners} will be passed
                     * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
                     *
                     * @param {string} name Event name to broadcast.
                     * @param {...*} args Optional set of arguments which will be passed onto the event listeners.
                     * @return {Object} Event object, see {@link ng.$rootScope.Scope#methods_$on}
                     */
                    $broadcast: function (name, args) {
                        var target = this,
                            current = target,
                            next = target,
                            event = {
                                name: name,
                                targetScope: target,
                                preventDefault: function () {
                                    event.defaultPrevented = true;
                                },
                                defaultPrevented: false,
                            },
                            listenerArgs = concat([event], arguments, 1),
                            listeners,
                            i,
                            length;

                        //down while you can, then up and next sibling or up and next sibling until back at root
                        do {
                            current = next;
                            event.currentScope = current;
                            listeners = current.$$listeners[name] || [];
                            for (i = 0, length = listeners.length; i < length; i++) {
                                // if listeners were deregistered, defragment the array
                                if (!listeners[i]) {
                                    listeners.splice(i, 1);
                                    i--;
                                    length--;
                                    continue;
                                }

                                try {
                                    listeners[i].apply(null, listenerArgs);
                                } catch (e) {
                                    $exceptionHandler(e);
                                }
                            }

                            // Insanity Warning: scope depth-first traversal
                            // yes, this code is a bit crazy, but it works and we have tests to prove it!
                            // this piece should be kept in sync with the traversal in $digest
                            if (
                                !(next =
                                    current.$$childHead ||
                                    (current !== target && current.$$nextSibling))
                            ) {
                                while (current !== target && !(next = current.$$nextSibling)) {
                                    current = current.$parent;
                                }
                            }
                        } while ((current = next));

                        return event;
                    },
                };

                var $rootScope = new Scope();

                return $rootScope;

                function beginPhase(phase) {
                    if ($rootScope.$$phase) {
                        throw $rootScopeMinErr(
                            "inprog",
                            "{0} already in progress",
                            $rootScope.$$phase,
                        );
                    }

                    $rootScope.$$phase = phase;
                }

                function clearPhase() {
                    $rootScope.$$phase = null;
                }

                function compileToFn(exp, name) {
                    var fn = $parse(exp);
                    assertArgFn(fn, name);
                    return fn;
                }

                /**
                 * function used as an initial value for watchers.
                 * because it's unique we can easily tell it apart from other values
                 */
                function initWatchVal() { }
            },
        ];
    }

    /**
     * @description
     * Private service to sanitize uris for links and images. Used by $compile and $sanitize.
     */
    function $$SanitizeUriProvider() {
        var aHrefSanitizationWhitelist = /^\s*(https?|ftp|mailto|tel|file):/,
            imgSrcSanitizationWhitelist = /^\s*(https?|ftp|file):|data:image\//;

        /**
         * @description
         * Retrieves or overrides the default regular expression that is used for whitelisting of safe
         * urls during a[href] sanitization.
         *
         * The sanitization is a security measure aimed at prevent XSS attacks via html links.
         *
         * Any url about to be assigned to a[href] via data-binding is first normalized and turned into
         * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist`
         * regular expression. If a match is found, the original url is written into the dom. Otherwise,
         * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
         *
         * @param {RegExp=} regexp New regexp to whitelist urls with.
         * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
         *    chaining otherwise.
         */
        this.aHrefSanitizationWhitelist = function (regexp) {
            if (isDefined(regexp)) {
                aHrefSanitizationWhitelist = regexp;
                return this;
            }
            return aHrefSanitizationWhitelist;
        };

        /**
         * @description
         * Retrieves or overrides the default regular expression that is used for whitelisting of safe
         * urls during img[src] sanitization.
         *
         * The sanitization is a security measure aimed at prevent XSS attacks via html links.
         *
         * Any url about to be assigned to img[src] via data-binding is first normalized and turned into
         * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationWhitelist`
         * regular expression. If a match is found, the original url is written into the dom. Otherwise,
         * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
         *
         * @param {RegExp=} regexp New regexp to whitelist urls with.
         * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
         *    chaining otherwise.
         */
        this.imgSrcSanitizationWhitelist = function (regexp) {
            if (isDefined(regexp)) {
                imgSrcSanitizationWhitelist = regexp;
                return this;
            }
            return imgSrcSanitizationWhitelist;
        };

        this.$get = function () {
            return function sanitizeUri(uri, isImage) {
                var regex = isImage
                    ? imgSrcSanitizationWhitelist
                    : aHrefSanitizationWhitelist;
                var normalizedVal;
                // NOTE: urlResolve() doesn't support IE < 8 so we don't sanitize for that case.
                if (!msie || msie >= 8) {
                    normalizedVal = urlResolve(uri).href;
                    if (normalizedVal !== "" && !normalizedVal.match(regex)) {
                        return "unsafe:" + normalizedVal;
                    }
                }
                return uri;
            };
        };
    }

    var $sceMinErr = minErr("$sce");

    var SCE_CONTEXTS = {
        HTML: "html",
        CSS: "css",
        URL: "url",
        // RESOURCE_URL is a subtype of URL used in contexts where a privileged resource is sourced from a
        // url.  (e.g. ng-include, script src, templateUrl)
        RESOURCE_URL: "resourceUrl",
        JS: "js",
    };

    // Helper functions follow.

    // Copied from:
    // http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962
    // Prereq: s is a string.
    function escapeForRegexp(s) {
        return s
            .replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1")
            .replace(/\x08/g, "\\x08");
    }

    function adjustMatcher(matcher) {
        if (matcher === "self") {
            return matcher;
        } else if (isString(matcher)) {
            // Strings match exactly except for 2 wildcards - '*' and '**'.
            // '*' matches any character except those from the set ':/.?&'.
            // '**' matches any character (like .* in a RegExp).
            // More than 2 *'s raises an error as it's ill defined.
            if (matcher.indexOf("***") > -1) {
                throw $sceMinErr(
                    "iwcard",
                    "Illegal sequence *** in string matcher.  String: {0}",
                    matcher,
                );
            }
            matcher = escapeForRegexp(matcher)
                .replace("\\*\\*", ".*")
                .replace("\\*", "[^:/.?&;]*");
            return new RegExp("^" + matcher + "$");
        } else if (isRegExp(matcher)) {
            // The only other type of matcher allowed is a Regexp.
            // Match entire URL / disallow partial matches.
            // Flags are reset (i.e. no global, ignoreCase or multiline)
            return new RegExp("^" + matcher.source + "$");
        } else {
            throw $sceMinErr(
                "imatcher",
                'Matchers may only be "self", string patterns or RegExp objects',
            );
        }
    }

    function adjustMatchers(matchers) {
        var adjustedMatchers = [];
        if (isDefined(matchers)) {
            forEach(matchers, function (matcher) {
                adjustedMatchers.push(adjustMatcher(matcher));
            });
        }
        return adjustedMatchers;
    }

    /**
     * @ngdoc service
     * @name ng.$sceDelegate
     * @function
     *
     * @description
     *
     * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
     * Contextual Escaping (SCE)} services to AngularJS.
     *
     * Typically, you would configure or override the {@link ng.$sceDelegate $sceDelegate} instead of
     * the `$sce` service to customize the way Strict Contextual Escaping works in AngularJS.  This is
     * because, while the `$sce` provides numerous shorthand methods, etc., you really only need to
     * override 3 core functions (`trustAs`, `getTrusted` and `valueOf`) to replace the way things
     * work because `$sce` delegates to `$sceDelegate` for these operations.
     *
     * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} to configure this service.
     *
     * The default instance of `$sceDelegate` should work out of the box with little pain.  While you
     * can override it completely to change the behavior of `$sce`, the common case would
     * involve configuring the {@link ng.$sceDelegateProvider $sceDelegateProvider} instead by setting
     * your own whitelists and blacklists for trusting URLs used for loading AngularJS resources such as
     * templates.  Refer {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist
     * $sceDelegateProvider.resourceUrlWhitelist} and {@link
     * ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist}
     */

    /**
     * @ngdoc object
     * @name ng.$sceDelegateProvider
     * @description
     *
     * The `$sceDelegateProvider` provider allows developers to configure the {@link ng.$sceDelegate
     * $sceDelegate} service.  This allows one to get/set the whitelists and blacklists used to ensure
     * that the URLs used for sourcing Angular templates are safe.  Refer {@link
     * ng.$sceDelegateProvider#methods_resourceUrlWhitelist $sceDelegateProvider.resourceUrlWhitelist} and
     * {@link ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist}
     *
     * For the general details about this service in Angular, read the main page for {@link ng.$sce
     * Strict Contextual Escaping (SCE)}.
     *
     * **Example**:  Consider the following case. <a name="example"></a>
     *
     * - your app is hosted at url `http://myapp.example.com/`
     * - but some of your templates are hosted on other domains you control such as
     *   `http://srv01.assets.example.com/`,  `http://srv02.assets.example.com/`, etc.
     * - and you have an open redirect at `http://myapp.example.com/clickThru?...`.
     *
     * Here is what a secure configuration for this scenario might look like:
     *
     * <pre class="prettyprint">
     *    angular.module('myApp', []).config(function($sceDelegateProvider) {
     *      $sceDelegateProvider.resourceUrlWhitelist([
     *        // Allow same origin resource loads.
     *        'self',
     *        // Allow loading from our assets domain.  Notice the difference between * and **.
     *        'http://srv*.assets.example.com/**']);
     *
     *      // The blacklist overrides the whitelist so the open redirect here is blocked.
     *      $sceDelegateProvider.resourceUrlBlacklist([
     *        'http://myapp.example.com/clickThru**']);
     *      });
     * </pre>
     */

    function $SceDelegateProvider() {
        this.SCE_CONTEXTS = SCE_CONTEXTS;

        // Resource URLs can also be trusted by policy.
        var resourceUrlWhitelist = ["self"],
            resourceUrlBlacklist = [];

        /**
         * @ngdoc function
         * @name ng.sceDelegateProvider#resourceUrlWhitelist
         * @methodOf ng.$sceDelegateProvider
         * @function
         *
         * @param {Array=} whitelist When provided, replaces the resourceUrlWhitelist with the value
         *     provided.  This must be an array or null.  A snapshot of this array is used so further
         *     changes to the array are ignored.
         *
         *     Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
         *     allowed in this array.
         *
         *     Note: **an empty whitelist array will block all URLs**!
         *
         * @return {Array} the currently set whitelist array.
         *
         * The **default value** when no whitelist has been explicitly set is `['self']` allowing only
         * same origin resource requests.
         *
         * @description
         * Sets/Gets the whitelist of trusted resource URLs.
         */
        this.resourceUrlWhitelist = function (value) {
            if (arguments.length) {
                resourceUrlWhitelist = adjustMatchers(value);
            }
            return resourceUrlWhitelist;
        };

        /**
         * @ngdoc function
         * @name ng.sceDelegateProvider#resourceUrlBlacklist
         * @methodOf ng.$sceDelegateProvider
         * @function
         *
         * @param {Array=} blacklist When provided, replaces the resourceUrlBlacklist with the value
         *     provided.  This must be an array or null.  A snapshot of this array is used so further
         *     changes to the array are ignored.
         *
         *     Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
         *     allowed in this array.
         *
         *     The typical usage for the blacklist is to **block
         *     [open redirects](http://cwe.mitre.org/data/definitions/601.html)** served by your domain as
         *     these would otherwise be trusted but actually return content from the redirected domain.
         *
         *     Finally, **the blacklist overrides the whitelist** and has the final say.
         *
         * @return {Array} the currently set blacklist array.
         *
         * The **default value** when no whitelist has been explicitly set is the empty array (i.e. there
         * is no blacklist.)
         *
         * @description
         * Sets/Gets the blacklist of trusted resource URLs.
         */

        this.resourceUrlBlacklist = function (value) {
            if (arguments.length) {
                resourceUrlBlacklist = adjustMatchers(value);
            }
            return resourceUrlBlacklist;
        };

        this.$get = [
            "$injector",
            function ($injector) {
                var htmlSanitizer = function htmlSanitizer(html) {
                    throw $sceMinErr(
                        "unsafe",
                        "Attempting to use an unsafe value in a safe context.",
                    );
                };

                if ($injector.has("$sanitize")) {
                    htmlSanitizer = $injector.get("$sanitize");
                }

                function matchUrl(matcher, parsedUrl) {
                    if (matcher === "self") {
                        return urlIsSameOrigin(parsedUrl);
                    } else {
                        // definitely a regex.  See adjustMatchers()
                        return !!matcher.exec(parsedUrl.href);
                    }
                }

                function isResourceUrlAllowedByPolicy(url) {
                    var parsedUrl = urlResolve(url.toString());
                    var i,
                        n,
                        allowed = false;
                    // Ensure that at least one item from the whitelist allows this url.
                    for (i = 0, n = resourceUrlWhitelist.length; i < n; i++) {
                        if (matchUrl(resourceUrlWhitelist[i], parsedUrl)) {
                            allowed = true;
                            break;
                        }
                    }
                    if (allowed) {
                        // Ensure that no item from the blacklist blocked this url.
                        for (i = 0, n = resourceUrlBlacklist.length; i < n; i++) {
                            if (matchUrl(resourceUrlBlacklist[i], parsedUrl)) {
                                allowed = false;
                                break;
                            }
                        }
                    }
                    return allowed;
                }

                function generateHolderType(Base) {
                    var holderType = function TrustedValueHolderType(trustedValue) {
                        this.$$unwrapTrustedValue = function () {
                            return trustedValue;
                        };
                    };
                    if (Base) {
                        holderType.prototype = new Base();
                    }
                    holderType.prototype.valueOf = function sceValueOf() {
                        return this.$$unwrapTrustedValue();
                    };
                    holderType.prototype.toString = function sceToString() {
                        return this.$$unwrapTrustedValue().toString();
                    };
                    return holderType;
                }

                var trustedValueHolderBase = generateHolderType(),
                    byType = {};

                byType[SCE_CONTEXTS.HTML] = generateHolderType(trustedValueHolderBase);
                byType[SCE_CONTEXTS.CSS] = generateHolderType(trustedValueHolderBase);
                byType[SCE_CONTEXTS.URL] = generateHolderType(trustedValueHolderBase);
                byType[SCE_CONTEXTS.JS] = generateHolderType(trustedValueHolderBase);
                byType[SCE_CONTEXTS.RESOURCE_URL] = generateHolderType(
                    byType[SCE_CONTEXTS.URL],
                );

                /**
                 * @ngdoc method
                 * @name ng.$sceDelegate#trustAs
                 * @methodOf ng.$sceDelegate
                 *
                 * @description
                 * Returns an object that is trusted by angular for use in specified strict
                 * contextual escaping contexts (such as ng-html-bind-unsafe, ng-include, any src
                 * attribute interpolation, any dom event binding attribute interpolation
                 * such as for onclick,  etc.) that uses the provided value.
                 * See {@link ng.$sce $sce} for enabling strict contextual escaping.
                 *
                 * @param {string} type The kind of context in which this value is safe for use.  e.g. url,
                 *   resourceUrl, html, js and css.
                 * @param {*} value The value that that should be considered trusted/safe.
                 * @returns {*} A value that can be used to stand in for the provided `value` in places
                 * where Angular expects a $sce.trustAs() return value.
                 */
                function trustAs(type, trustedValue) {
                    var Constructor = byType.hasOwnProperty(type) ? byType[type] : null;
                    if (!Constructor) {
                        throw $sceMinErr(
                            "icontext",
                            "Attempted to trust a value in invalid context. Context: {0}; Value: {1}",
                            type,
                            trustedValue,
                        );
                    }
                    if (
                        trustedValue === null ||
                        trustedValue === undefined ||
                        trustedValue === ""
                    ) {
                        return trustedValue;
                    }
                    // All the current contexts in SCE_CONTEXTS happen to be strings.  In order to avoid trusting
                    // mutable objects, we ensure here that the value passed in is actually a string.
                    if (typeof trustedValue !== "string") {
                        throw $sceMinErr(
                            "itype",
                            "Attempted to trust a non-string value in a content requiring a string: Context: {0}",
                            type,
                        );
                    }
                    return new Constructor(trustedValue);
                }

                /**
                 * @ngdoc method
                 * @name ng.$sceDelegate#valueOf
                 * @methodOf ng.$sceDelegate
                 *
                 * @description
                 * If the passed parameter had been returned by a prior call to {@link ng.$sceDelegate#methods_trustAs
                 * `$sceDelegate.trustAs`}, returns the value that had been passed to {@link
                 * ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}.
                 *
                 * If the passed parameter is not a value that had been returned by {@link
                 * ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}, returns it as-is.
                 *
                 * @param {*} value The result of a prior {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`}
                 *      call or anything else.
                 * @returns {*} The value the was originally provided to {@link ng.$sceDelegate#methods_trustAs
                 *     `$sceDelegate.trustAs`} if `value` is the result of such a call.  Otherwise, returns
                 *     `value` unchanged.
                 */
                function valueOf(maybeTrusted) {
                    if (maybeTrusted instanceof trustedValueHolderBase) {
                        return maybeTrusted.$$unwrapTrustedValue();
                    } else {
                        return maybeTrusted;
                    }
                }

                /**
                 * @ngdoc method
                 * @name ng.$sceDelegate#getTrusted
                 * @methodOf ng.$sceDelegate
                 *
                 * @description
                 * Takes the result of a {@link ng.$sceDelegate#methods_trustAs `$sceDelegate.trustAs`} call and
                 * returns the originally supplied value if the queried context type is a supertype of the
                 * created type.  If this condition isn't satisfied, throws an exception.
                 *
                 * @param {string} type The kind of context in which this value is to be used.
                 * @param {*} maybeTrusted The result of a prior {@link ng.$sceDelegate#methods_trustAs
                 *     `$sceDelegate.trustAs`} call.
                 * @returns {*} The value the was originally provided to {@link ng.$sceDelegate#methods_trustAs
                 *     `$sceDelegate.trustAs`} if valid in this context.  Otherwise, throws an exception.
                 */
                function getTrusted(type, maybeTrusted) {
                    if (
                        maybeTrusted === null ||
                        maybeTrusted === undefined ||
                        maybeTrusted === ""
                    ) {
                        return maybeTrusted;
                    }
                    var constructor = byType.hasOwnProperty(type) ? byType[type] : null;
                    if (constructor && maybeTrusted instanceof constructor) {
                        return maybeTrusted.$$unwrapTrustedValue();
                    }
                    // If we get here, then we may only take one of two actions.
                    // 1. sanitize the value for the requested type, or
                    // 2. throw an exception.
                    if (type === SCE_CONTEXTS.RESOURCE_URL) {
                        if (isResourceUrlAllowedByPolicy(maybeTrusted)) {
                            return maybeTrusted;
                        } else {
                            throw $sceMinErr(
                                "insecurl",
                                "Blocked loading resource from url not allowed by $sceDelegate policy.  URL: {0}",
                                maybeTrusted.toString(),
                            );
                        }
                    } else if (type === SCE_CONTEXTS.HTML) {
                        return htmlSanitizer(maybeTrusted);
                    }
                    throw $sceMinErr(
                        "unsafe",
                        "Attempting to use an unsafe value in a safe context.",
                    );
                }

                return { trustAs: trustAs, getTrusted: getTrusted, valueOf: valueOf };
            },
        ];
    }

    /**
     * @ngdoc object
     * @name ng.$sceProvider
     * @description
     *
     * The $sceProvider provider allows developers to configure the {@link ng.$sce $sce} service.
     * -   enable/disable Strict Contextual Escaping (SCE) in a module
     * -   override the default implementation with a custom delegate
     *
     * Read more about {@link ng.$sce Strict Contextual Escaping (SCE)}.
     */

    /* jshint maxlen: false*/

    /**
   * @ngdoc service
   * @name ng.$sce
   * @function
   *
   * @description
   *
   * `$sce` is a service that provides Strict Contextual Escaping services to AngularJS.
   *
   * # Strict Contextual Escaping
   *
   * Strict Contextual Escaping (SCE) is a mode in which AngularJS requires bindings in certain
   * contexts to result in a value that is marked as safe to use for that context.  One example of
   * such a context is binding arbitrary html controlled by the user via `ng-bind-html`.  We refer
   * to these contexts as privileged or SCE contexts.
   *
   * As of version 1.2, Angular ships with SCE enabled by default.
   *
   * Note:  When enabled (the default), IE8 in quirks mode is not supported.  In this mode, IE8 allows
   * one to execute arbitrary javascript by the use of the expression() syntax.  Refer
   * <http://blogs.msdn.com/b/ie/archive/2008/10/16/ending-expressions.aspx> to learn more about them.
   * You can ensure your document is in standards mode and not quirks mode by adding `<!doctype html>`
   * to the top of your HTML document.
   *
   * SCE assists in writing code in way that (a) is secure by default and (b) makes auditing for
   * security vulnerabilities such as XSS, clickjacking, etc. a lot easier.
   *
   * Here's an example of a binding in a privileged context:
   *
   * <pre class="prettyprint">
   *     <input ng-model="userHtml">
   *     <div ng-bind-html="userHtml">
   * </pre>
   *
   * Notice that `ng-bind-html` is bound to `userHtml` controlled by the user.  With SCE
   * disabled, this application allows the user to render arbitrary HTML into the DIV.
   * In a more realistic example, one may be rendering user comments, blog articles, etc. via
   * bindings.  (HTML is just one example of a context where rendering user controlled input creates
   * security vulnerabilities.)
   *
   * For the case of HTML, you might use a library, either on the client side, or on the server side,
   * to sanitize unsafe HTML before binding to the value and rendering it in the document.
   *
   * How would you ensure that every place that used these types of bindings was bound to a value that
   * was sanitized by your library (or returned as safe for rendering by your server?)  How can you
   * ensure that you didn't accidentally delete the line that sanitized the value, or renamed some
   * properties/fields and forgot to update the binding to the sanitized value?
   *
   * To be secure by default, you want to ensure that any such bindings are disallowed unless you can
   * determine that something explicitly says it's safe to use a value for binding in that
   * context.  You can then audit your code (a simple grep would do) to ensure that this is only done
   * for those values that you can easily tell are safe - because they were received from your server,
   * sanitized by your library, etc.  You can organize your codebase to help with this - perhaps
   * allowing only the files in a specific directory to do this.  Ensuring that the internal API
   * exposed by that code doesn't markup arbitrary values as safe then becomes a more manageable task.
   *
   * In the case of AngularJS' SCE service, one uses {@link ng.$sce#methods_trustAs $sce.trustAs} 
   * (and shorthand methods such as {@link ng.$sce#methods_trustAsHtml $sce.trustAsHtml}, etc.) to
   * obtain values that will be accepted by SCE / privileged contexts.
   *
   *
   * ## How does it work?
   *
   * In privileged contexts, directives and code will bind to the result of {@link ng.$sce#methods_getTrusted
   * $sce.getTrusted(context, value)} rather than to the value directly.  Directives use {@link
   * ng.$sce#methods_parse $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs the
   * {@link ng.$sce#methods_getTrusted $sce.getTrusted} behind the scenes on non-constant literals.
   *
   * As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link
   * ng.$sce#methods_parseAsHtml $sce.parseAsHtml(binding expression)}.  Here's the actual code (slightly
   * simplified):
   *
   * <pre class="prettyprint">
   *   var ngBindHtmlDirective = ['$sce', function($sce) {
   *     return function(scope, element, attr) {
   *       scope.$watch($sce.parseAsHtml(attr.ngBindHtml), function(value) {
   *         element.html(value || '');
   *       });
   *     };
   *   }];
   * </pre>
   *
   * ## Impact on loading templates
   *
   * This applies both to the {@link ng.directive:ngInclude `ng-include`} directive as well as
   * `templateUrl`'s specified by {@link guide/directive directives}.
   *
   * By default, Angular only loads templates from the same domain and protocol as the application
   * document.  This is done by calling {@link ng.$sce#methods_getTrustedResourceUrl
   * $sce.getTrustedResourceUrl} on the template URL.  To load templates from other domains and/or
   * protocols, you may either either {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelist
   * them} or {@link ng.$sce#methods_trustAsResourceUrl wrap it} into a trusted value.
   *
   * *Please note*:
   * The browser's
   * {@link https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest
   * Same Origin Policy} and {@link http://www.w3.org/TR/cors/ Cross-Origin Resource Sharing (CORS)}
   * policy apply in addition to this and may further restrict whether the template is successfully
   * loaded.  This means that without the right CORS policy, loading templates from a different domain
   * won't work on all browsers.  Also, loading templates from `file://` URL does not work on some
   * browsers.
   *
   * ## This feels like too much overhead for the developer?
   *
   * It's important to remember that SCE only applies to interpolation expressions.
   *
   * If your expressions are constant literals, they're automatically trusted and you don't need to
   * call `$sce.trustAs` on them.  (e.g.
   * `<div ng-html-bind-unsafe="'<b>implicitly trusted</b>'"></div>`) just works.
   *
   * Additionally, `a[href]` and `img[src]` automatically sanitize their URLs and do not pass them
   * through {@link ng.$sce#methods_getTrusted $sce.getTrusted}.  SCE doesn't play a role here.
   *
   * The included {@link ng.$sceDelegate $sceDelegate} comes with sane defaults to allow you to load
   * templates in `ng-include` from your application's domain without having to even know about SCE.
   * It blocks loading templates from other domains or loading templates over http from an https
   * served document.  You can change these by setting your own custom {@link
   * ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelists} and {@link
   * ng.$sceDelegateProvider#methods_resourceUrlBlacklist blacklists} for matching such URLs.
   *
   * This significantly reduces the overhead.  It is far easier to pay the small overhead and have an
   * application that's secure and can be audited to verify that with much more ease than bolting
   * security onto an application later.
   *
   * <a name="contexts"></a>
   * ## What trusted context types are supported?
   *
   * | Context             | Notes          |
   * |---------------------|----------------|
   * | `$sce.HTML`         | For HTML that's safe to source into the application.  The {@link ng.directive:ngBindHtml ngBindHtml} directive uses this context for bindings. |
   * | `$sce.CSS`          | For CSS that's safe to source into the application.  Currently unused.  Feel free to use it in your own directives. |
   * | `$sce.URL`          | For URLs that are safe to follow as links.  Currently unused (`<a href=` and `<img src=` sanitize their urls and don't consititute an SCE context. |
   * | `$sce.RESOURCE_URL` | For URLs that are not only safe to follow as links, but whose contens are also safe to include in your application.  Examples include `ng-include`, `src` / `ngSrc` bindings for tags other than `IMG` (e.g. `IFRAME`, `OBJECT`, etc.)  <br><br>Note that `$sce.RESOURCE_URL` makes a stronger statement about the URL than `$sce.URL` does and therefore contexts requiring values trusted for `$sce.RESOURCE_URL` can be used anywhere that values trusted for `$sce.URL` are required. |
   * | `$sce.JS`           | For JavaScript that is safe to execute in your application's context.  Currently unused.  Feel free to use it in your own directives. |
   *
   * ## Format of items in {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist resourceUrlWhitelist}/{@link ng.$sceDelegateProvider#methods_resourceUrlBlacklist Blacklist} <a name="resourceUrlPatternItem"></a>
   *
   *  Each element in these arrays must be one of the following:
   *
   *  - **'self'**
   *    - The special **string**, `'self'`, can be used to match against all URLs of the **same
   *      domain** as the application document using the **same protocol**.
   *  - **String** (except the special value `'self'`)
   *    - The string is matched against the full *normalized / absolute URL* of the resource
   *      being tested (substring matches are not good enough.)
   *    - There are exactly **two wildcard sequences** - `*` and `**`.  All other characters
   *      match themselves.
   *    - `*`: matches zero or more occurances of any character other than one of the following 6
   *      characters: '`:`', '`/`', '`.`', '`?`', '`&`' and ';'.  It's a useful wildcard for use
   *      in a whitelist.
   *    - `**`: matches zero or more occurances of *any* character.  As such, it's not
   *      not appropriate to use in for a scheme, domain, etc. as it would match too much.  (e.g.
   *      http://**.example.com/ would match http://evil.com/?ignore=.example.com/ and that might
   *      not have been the intention.)  It's usage at the very end of the path is ok.  (e.g.
   *      http://foo.example.com/templates/**).
   *  - **RegExp** (*see caveat below*)
   *    - *Caveat*:  While regular expressions are powerful and offer great flexibility,  their syntax
   *      (and all the inevitable escaping) makes them *harder to maintain*.  It's easy to
   *      accidentally introduce a bug when one updates a complex expression (imho, all regexes should
   *      have good test coverage.).  For instance, the use of `.` in the regex is correct only in a
   *      small number of cases.  A `.` character in the regex used when matching the scheme or a
   *      subdomain could be matched against a `:` or literal `.` that was likely not intended.   It
   *      is highly recommended to use the string patterns and only fall back to regular expressions
   *      if they as a last resort.
   *    - The regular expression must be an instance of RegExp (i.e. not a string.)  It is
   *      matched against the **entire** *normalized / absolute URL* of the resource being tested
   *      (even when the RegExp did not have the `^` and `$` codes.)  In addition, any flags
   *      present on the RegExp (such as multiline, global, ignoreCase) are ignored.
   *    - If you are generating your Javascript from some other templating engine (not
   *      recommended, e.g. in issue [#4006](https://github.com/angular/angular.js/issues/4006)),
   *      remember to escape your regular expression (and be aware that you might need more than
   *      one level of escaping depending on your templating engine and the way you interpolated
   *      the value.)  Do make use of your platform's escaping mechanism as it might be good
   *      enough before coding your own.  e.g. Ruby has
   *      [Regexp.escape(str)](http://www.ruby-doc.org/core-2.0.0/Regexp.html#method-c-escape)
   *      and Python has [re.escape](http://docs.python.org/library/re.html#re.escape).
   *      Javascript lacks a similar built in function for escaping.  Take a look at Google
   *      Closure library's [goog.string.regExpEscape(s)](
   *      http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962).
   *
   * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} for an example.
   *
   * ## Show me an example using SCE.
   *
   * @example
  <example module="mySceApp">
  <file name="index.ht