angular.js

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

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

    /**
     * @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) {
        return isString(s)
            ? s.replace(/[A-Z]/g, function(ch) {return fromCharCode(ch.charCodeAt(0) | 32);})
            : s;
    };
    var manualUppercase = function(s) {
        return isString(s)
            ? s.replace(/[a-z]/g, function(ch) {return 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;
    }

    function fromCharCode(code) {return String.fromCharCode(code);}


    var Error             = window.Error,
        /** holds major version number for IE or NaN for real browsers */
            msie              = int((/msie (\d+)/.exec(lowercase(navigator.userAgent)) || [])[1]),
        jqLite,           // delay binding since jQuery could be loaded after us.
        jQuery,           // delay binding
        slice             = [].slice,
        push              = [].push,
        toString          = Object.prototype.toString,

        /** @name angular */
            angular           = window.angular || (window.angular = {}),
        angularModule,
        nodeName_,
        uid               = ['0', '0', '0'];

    /**
     * @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 (isObject(obj) && isNumber(obj.length)) {
                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 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('');
    }

    /**
     * @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).
     */
    function extend(dst) {
        forEach(arguments, function(obj){
            if (obj !== dst) {
                forEach(obj, function(value, key){
                    dst[key] = value;
                });
            }
        });
        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 || 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`.
     */
    function isObject(value){return value != null && typeof value == 'object';}


    /**
     * @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.apply(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.apply(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';}


    /**
     * 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.apply(obj) === '[object File]';
    }


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


    function trim(value) {
        return isString(value) ? value.replace(/^\s*/, '').replace(/\s*$/, '') : 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.bind && node.find));  // we have a bind 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 size = 0, key;

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

        return size;
    }


    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, `source` is returned.
     *
     * Note: this function is used to augment the Object type in Angular expressions. See
     * {@link ng.$filter} for more information about Angular arrays.
     *
     * @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.
     */
    function copy(source, destination){
        if (isWindow(source) || isScope(source)) throw Error("Can't copy Window or Scope");
        if (!destination) {
            destination = source;
            if (source) {
                if (isArray(source)) {
                    destination = copy(source, []);
                } else if (isDate(source)) {
                    destination = new Date(source.getTime());
                } else if (isObject(source)) {
                    destination = copy(source, {});
                }
            }
        } else {
            if (source === destination) throw Error("Can't copy equivalent objects or arrays");
            if (isArray(source)) {
                while(destination.length) {
                    destination.pop();
                }
                for ( var i = 0; i < source.length; i++) {
                    destination.push(copy(source[i]));
                }
            } else {
                forEach(destination, function(value, key){
                    delete destination[key];
                });
                for ( var key in source) {
                    destination[key] = copy(source[key]);
                }
            }
        }
        return destination;
    }

    /**
     * Create a shallow copy of an object
     */
    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;
    }


    /**
     * @ngdoc function
     * @name angular.equals
     * @function
     *
     * @description
     * Determines if two objects or two values are equivalent. Supports value types, 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 pass `===` comparison.
     * * Both values are NaN. (In JavasScript, NaN == NaN => false. But we consider two NaN as equal)
     *
     * During a property comparision, properties of `function` type and properties with names
     * that begin with `$` are ignored.
     *
     * Scope and DOMWindow objects are being compared only be 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 ((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 (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2)) return false;
                    keySet = {};
                    for(key in o1) {
                        if (key.charAt(0) !== '$' && !isFunction(o1[key]) && !equals(o1[key], o2[key])) {
                            return false;
                        }
                        keySet[key] = true;
                    }
                    for(key in o2) {
                        if (!keySet[key] && key.charAt(0) !== '$' && !isFunction(o2[key])) return false;
                    }
                    return true;
                }
            }
        }
        return false;
    }


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

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


    /**
     * @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 are prebound to the function. This feature is also
     * known as [function currying](http://en.wikipedia.org/wiki/Currying).
     *
     * @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.
     */
    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 (/^\$+/.test(key)) {
            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.
     *
     * @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} Jsonified string representing `obj`.
     */
    function toJson(obj, pretty) {
        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.html('');
        } catch(e) {}
        return jqLite('<div>').append(element).html().
            match(/^(<[^>]+>)/)[1].
            replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });
    }


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

    /**
     * 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 = decodeURIComponent(key_value[0]);
                obj[key] = isDefined(key_value[1]) ? decodeURIComponent(key_value[1]) : true;
            }
        });
        return obj;
    }

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


    /**
     * We need our custom mehtod because encodeURIComponent is too agressive 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 becuase encodeURIComponent is too agressive 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((pctEncodeSpaces ? null : /%20/g), '+');
    }


    /**
     * @ngdoc directive
     * @name ng.directive:ngApp
     *
     * @element ANY
     * @param {angular.Module} ngApp on optional application
     *   {@link angular.module module} name to load.
     *
     * @description
     *
     * Use this directive to auto-bootstrap on application. Only
     * one directive can be used per HTML document. The directive
     * designates the root of the application and is typically placed
     * ot the root of the page.
     *
     * In the example below if the `ngApp` directive would not be placed
     * on the `html` element then the document would not be compiled
     * and the `{{ 1+2 }}` would not be resolved to `3`.
     *
     * `ngApp` is the easiest way to bootstrap an application.
     *
     <doc:example>
     <doc:source>
     I can add: 1 + 2 =  {{ 1+2 }}
     </doc:source>
     </doc: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}
     *
     * @param {Element} element DOM element which is the root of angular application.
     * @param {Array<String|Function>=} modules an array of module declarations. See: {@link angular.module modules}
     * @returns {AUTO.$injector} Returns the newly created injector for this app.
     */
    function bootstrap(element, modules) {
        element = jqLite(element);
        modules = modules || [];
        modules.unshift(['$provide', function($provide) {
            $provide.value('$rootElement', element);
        }]);
        modules.unshift('ng');
        var injector = createInjector(modules);
        injector.invoke(
            ['$rootScope', '$rootElement', '$compile', '$injector', function(scope, element, compile, injector){
                scope.$apply(function() {
                    element.data('$injector', injector);
                    compile(element)(scope);
                });
            }]
        );
        return injector;
    }

    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,
                controller: JQLitePrototype.controller,
                injector: JQLitePrototype.injector,
                inheritedData: JQLitePrototype.inheritedData
            });
            JQLitePatchJQueryRemove('remove', true);
            JQLitePatchJQueryRemove('empty');
            JQLitePatchJQueryRemove('html');
        } else {
            jqLite = JQLite;
        }
        angular.element = jqLite;
    }

    /**
     * throw error of the argument is falsy.
     */
    function assertArg(arg, name, reason) {
        if (!arg) {
            throw new Error("Argument '" + (name || '?') + "' is " + (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;
    }

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

    function setupModuleLoader(window) {

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

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

            /**
             * @ngdoc function
             * @name angular.module
             * @description
             *
             * The `angular.module` is a global place for creating and registering Angular modules. All
             * modules (angular core or 3rd party) that should be available to an application must be
             * registered using this mechanism.
             *
             *
             * # Module
             *
             * A module is a collocation of services, directives, filters, and configure information. 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 Option configuration function for the module. Same as
             *        {@link angular.Module#config Module#config()}.
             * @returns {module} new module with the {@link angular.Module} api.
             */
            return function module(name, requires, configFn) {
                if (requires && modules.hasOwnProperty(name)) {
                    modules[name] = null;
                }
                return ensure(modules, name, function() {
                    if (!requires) {
                        throw Error('No module: ' + 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#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} name Controller name.
                         * @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} name directive name
                         * @param {Function} directiveFactory Factory function for creating new instance of
                         * directives.
                         * @description
                         * See {@link ng.$compileProvider#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 needs to be performed when the injector with
                         * with the current module is finished loading.
                         */
                        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;
                        }
                    }
                });
            };
        });

    }

    /**
     * @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.0.2',    // all of these placeholder strings will be replaced by rake's
        major: 1,    // compile task
        minor: 0,
        dot: 2,
        codeName: 'debilitating-awesomeness'
    };


    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}
        });

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

        angularModule('ng', ['ngLocale'], ['$provide',
            function ngModule($provide) {
                $provide.provider('$compile', $CompileProvider).
                    directive({
                        a: htmlAnchorDirective,
                        input: inputDirective,
                        textarea: inputDirective,
                        form: formDirective,
                        script: scriptDirective,
                        select: selectDirective,
                        style: styleDirective,
                        option: optionDirective,
                        ngBind: ngBindDirective,
                        ngBindHtmlUnsafe: ngBindHtmlUnsafeDirective,
                        ngBindTemplate: ngBindTemplateDirective,
                        ngClass: ngClassDirective,
                        ngClassEven: ngClassEvenDirective,
                        ngClassOdd: ngClassOddDirective,
                        ngCsp: ngCspDirective,
                        ngCloak: ngCloakDirective,
                        ngController: ngControllerDirective,
                        ngForm: ngFormDirective,
                        ngHide: ngHideDirective,
                        ngInclude: ngIncludeDirective,
                        ngInit: ngInitDirective,
                        ngNonBindable: ngNonBindableDirective,
                        ngPluralize: ngPluralizeDirective,
                        ngRepeat: ngRepeatDirective,
                        ngShow: ngShowDirective,
                        ngSubmit: ngSubmitDirective,
                        ngStyle: ngStyleDirective,
                        ngSwitch: ngSwitchDirective,
                        ngSwitchWhen: ngSwitchWhenDirective,
                        ngSwitchDefault: ngSwitchDefaultDirective,
                        ngOptions: ngOptionsDirective,
                        ngView: ngViewDirective,
                        ngTransclude: ngTranscludeDirective,
                        ngModel: ngModelDirective,
                        ngList: ngListDirective,
                        ngChange: ngChangeDirective,
                        required: requiredDirective,
                        ngRequired: requiredDirective,
                        ngValue: ngValueDirective
                    }).
                    directive(ngAttributeAliasDirectives).
                    directive(ngEventDirectives);
                $provide.provider({
                    $anchorScroll: $AnchorScrollProvider,
                    $browser: $BrowserProvider,
                    $cacheFactory: $CacheFactoryProvider,
                    $controller: $ControllerProvider,
                    $document: $DocumentProvider,
                    $exceptionHandler: $ExceptionHandlerProvider,
                    $filter: $FilterProvider,
                    $interpolate: $InterpolateProvider,
                    $http: $HttpProvider,
                    $httpBackend: $HttpBackendProvider,
                    $location: $LocationProvider,
                    $log: $LogProvider,
                    $parse: $ParseProvider,
                    $route: $RouteProvider,
                    $routeParams: $RouteParamsProvider,
                    $rootScope: $RootScopeProvider,
                    $q: $QProvider,
                    $sniffer: $SnifferProvider,
                    $templateCache: $TemplateCacheProvider,
                    $timeout: $TimeoutProvider,
                    $window: $WindowProvider
                });
            }
        ]);
    }

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

    /**
     * @ngdoc function
     * @name angular.element
     * @function
     *
     * @description
     * Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
     * `angular.element` can be either an alias for [jQuery](http://api.jquery.com/jQuery/) function, if
     * jQuery is available, or a function that wraps the element or string in Angular's jQuery lite
     * implementation (commonly referred to as jqLite).
     *
     * Real jQuery always takes precedence over jqLite, provided it was loaded before `DOMContentLoaded`
     * event fired.
     *
     * jqLite is a tiny, API-compatible subset of jQuery that allows
     * Angular to manipulate the DOM. jqLite implements only the most commonly needed functionality
     * within a very small footprint, so only a subset of the jQuery API - methods, arguments and
     * invocation styles - are supported.
     *
     * Note: All element references in Angular are always wrapped with jQuery or jqLite; they are never
     * raw DOM references.
     *
     * ## Angular's jQuery lite provides the following 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/bind/)
     * - [children()](http://api.jquery.com/children/)
     * - [clone()](http://api.jquery.com/clone/)
     * - [contents()](http://api.jquery.com/contents/)
     * - [css()](http://api.jquery.com/css/)
     * - [data()](http://api.jquery.com/data/)
     * - [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/)
     * - [parent()](http://api.jquery.com/parent/)
     * - [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/)
     * - [unbind()](http://api.jquery.com/unbind/)
     * - [val()](http://api.jquery.com/val/)
     * - [wrap()](http://api.jquery.com/wrap/)
     *
     * ## In addtion to the above, Angular privides an additional method to both jQuery and jQuery lite:
     *
     * - `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.
     * - `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])/;

    /**
     * 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) {
        var originalJqFn = jQuery.fn[name];
        originalJqFn = originalJqFn.$original || originalJqFn;
        removePatch.$original = originalJqFn;
        jQuery.fn[name] = removePatch;

        function removePatch() {
            var list = [this],
                fireEvent = dispatchThis,
                set, setIndex, setLength,
                element, childIndex, childLength, children,
                fns, events;

            while(list.length) {
                set = list.shift();
                for(setIndex = 0, setLength = set.length; setIndex < setLength; setIndex++) {
                    element = jqLite(set[setIndex]);
                    if (fireEvent) {
                        events = element.data('events');
                        if ( (fns = events && events.$destroy) ) {
                            forEach(fns, function(fn){
                                fn.handler();
                            });
                        }
                    } 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 Error('selectors not implemented');
            }
            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);
            this.remove(); // 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 JQLiteUnbind(element, type, fn) {
        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 {
            if (isUndefined(fn)) {
                removeEventListenerFn(element, type, events[type]);
                delete events[type];
            } else {
                arrayRemove(events[type], fn);
            }
        }
    }

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

        if (expandoStore) {
            if (expandoStore.handle) {
                expandoStore.events.$destroy && expandoStore.handle({}, '$destroy');
                JQLiteUnbind(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) {
        return ((" " + element.className + " ").replace(/[\n\t]/g, " ").
            indexOf( " " + selector + " " ) > -1);
    }

    function JQLiteRemoveClass(element, selector) {
        if (selector) {
            forEach(selector.split(' '), function(cssClass) {
                element.className = trim(
                    (" " + element.className + " ")
                        .replace(/[\n\t]/g, " ")
                        .replace(" " + trim(cssClass) + " ", " ")
                );
            });
        }
    }

    function JQLiteAddClass(element, selector) {
        if (selector) {
            forEach(selector.split(' '), function(cssClass) {
                if (!JQLiteHasClass(element, cssClass)) {
                    element.className = trim(element.className + ' ' + trim(cssClass));
                }
            });
        }
    }

    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');
        }

        while (element.length) {
            if (value = element.data(name)) return value;
            element = element.parent();
        }
    }

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

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

            this.bind('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.
            JQLite(window).bind('load', trigger); // fallback to window.onload for others
        },
        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'.split(','), function(value) {
        BOOLEAN_ATTR[lowercase(value)] = value;
    });
    var BOOLEAN_ELEMENTS = {};
    forEach('input,select,option,textarea,button,form'.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) {
            return JQLiteInheritedData(element, '$scope');
        },

        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: extend((msie < 9)
            ? function(element, value) {
            if (element.nodeType == 1 /** Element */) {
                if (isUndefined(value))
                    return element.innerText;
                element.innerText = value;
            } else {
                if (isUndefined(value))
                    return element.nodeValue;
                element.nodeValue = value;
            }
        }
            : function(element, value) {
            if (isUndefined(value)) {
                return element.textContent;
            }
            element.textContent = value;
        }, {$dv:''}),

        val: function(element, value) {
            if (isUndefined(value)) {
                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;
        }
    }, 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.
            if (((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.
                    if (this.length)
                        return fn(this[0], arg1, arg2);
                }
            } 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;
            }
            return fn.$dv;
        };
    });

    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;
            };

            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,

        bind: function bindFn(element, type, fn){
            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 counter = 0;

                        events.mouseenter = [];
                        events.mouseleave = [];

                        bindFn(element, 'mouseover', function(event) {
                            counter++;
                            if (counter == 1) {
                                handle(event, 'mouseenter');
                            }
                        });
                        bindFn(element, 'mouseout', function(event) {
                            counter --;
                            if (counter == 0) {
                                handle(event, 'mouseleave');
                            }
                        });
                    } else {
                        addEventListenerFn(element, type, handle);
                        events[type] = [];
                    }
                    eventFns = events[type]
                }
                eventFns.push(fn);
            });
        },

        unbind: JQLiteUnbind,

        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.nodeName != '#text')
                    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.appendChild(child);
            });
        },

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

        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) {
            return element.nextSibling;
        },

        find: function(element, selector) {
            return element.getElementsByTagName(selector);
        },

        clone: JQLiteClone
    }, function(fn, name){
        /**
         * chaining functions
         */
        JQLite.prototype[name] = function(arg1, arg2) {
            var value;
            for(var i=0; i < this.length; i++) {
                if (value == undefined) {
                    value = fn(this[i], arg1, arg2);
                    if (value !== undefined) {
                        // any function which returns a value needs to be wrapped
                        value = jqLite(value);
                    }
                } else {
                    JQLiteAddNodes(value, fn(this[i], arg1, arg2));
                }
            }
            return value == undefined ? this : value;
        };
    });

    /**
     * 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;
        }
    };

    /**
     * A map where multiple values can be added to the same key such that they form a queue.
     * @returns {HashQueueMap}
     */
    function HashQueueMap() {}
    HashQueueMap.prototype = {
        /**
         * Same as array push, but using an array as the value for the hash
         */
        push: function(key, value) {
            var array = this[key = hashKey(key)];
            if (!array) {
                this[key] = [value];
            } else {
                array.push(value);
            }
        },

        /**
         * Same as array shift, but using an array as the value for the hash
         */
        shift: function(key) {
            var array = this[key = hashKey(key)];
            if (array) {
                if (array.length == 1) {
                    delete this[key];
                    return array[0];
                } else {
                    return array.shift();
                }
            }
        }
    };

    /**
     * @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 of 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>
     */


    /**
     * @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*(_?)(.+?)\1\s*$/;
    var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
    function annotate(fn) {
        var $inject,
            fnText,
            argDecl,
            last;

        if (typeof fn == 'function') {
            if (!($inject = fn.$inject)) {
                $inject = [];
                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 ways are all valid way of annotating function with injection arguments and are equivalent.
     *
     * <pre>
     *   // inferred (only works if code not minified/obfuscated)
     *   $inject.invoke(function(serviceA){});
     *
     *   // annotated
     *   function explicit(serviceA) {};
     *   explicit.$inject = ['serviceA'];
     *   $inject.invoke(explicit);
     *
     *   // inline
     *   $inject.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. The function arguments come form the function annotation.
     * @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#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 minfication / obfuscation. For this reason the following annotation strategies
     * are supported.
     *
     * # The `$injector` 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(tempFn);
     *
     *   // 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
     *
     * Use `$provide` to register new providers with the `$injector`. The providers are the factories for the instance.
     * The providers share the same name as the instance they create with the `Provider` suffixed to them.
     *
     * A provider is an object with a `$get()` method. The injector calls the `$get` method to create a new instance of
     * a service. The Provider can have additional methods which would allow for configuration of the provider.
     *
     * <pre>
     *   function GreetProvider() {
     *     var salutation = 'Hello';
     *
     *     this.salutation = function(text) {
     *       salutation = text;
     *     };
     *
     *     this.$get = function() {
     *       return function (name) {
     *         return salutation + ' ' + name + '!';
     *       };
     *     };
     *   }
     *
     *   describe('Greeter', function(){
     *
     *     beforeEach(module(function($provide) {
     *       $provide.provider('greet', GreetProvider);
     *     });
     *
     *     it('should greet', inject(function(greet) {
     *       expect(greet('angular')).toEqual('Hello angular!');
     *     }));
     *
     *     it('should allow configuration of salutation', function() {
     *       module(function(greetProvider) {
     *         greetProvider.salutation('Ahoj');
     *       });
     *       inject(function(greet) {
     *         expect(greet('angular')).toEqual('Ahoj angular!');
     *       });
     *     )};
     *
     *   });
     * </pre>
     */

    /**
     * @ngdoc method
     * @name AUTO.$provide#provider
     * @methodOf AUTO.$provide
     * @description
     *
     * Register a provider for a service. The providers can be retrieved and can have additional configuration methods.
     *
     * @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
     */

    /**
     * @ngdoc method
     * @name AUTO.$provide#factory
     * @methodOf AUTO.$provide
     * @description
     *
     * A short hand for configuring services if only `$get` method is required.
     *
     * @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
     */


    /**
     * @ngdoc method
     * @name AUTO.$provide#service
     * @methodOf AUTO.$provide
     * @description
     *
     * A short hand for registering service of given class.
     *
     * @param {string} name The name of the instance.
     * @param {Function} constructor A class (constructor function) that will be instantiated.
     * @returns {Object} registered provider instance
     */


    /**
     * @ngdoc method
     * @name AUTO.$provide#value
     * @methodOf AUTO.$provide
     * @description
     *
     * A short hand for configuring services if the `$get` method is a constant.
     *
     * @param {string} name The name of the instance.
     * @param {*} value The value.
     * @returns {Object} registered provider instance
     */


    /**
     * @ngdoc method
     * @name AUTO.$provide#constant
     * @methodOf AUTO.$provide
     * @description
     *
     * A constant value, but unlike {@link AUTO.$provide#value value} it can be injected
     * into configuration function (other modules) and it is not interceptable by
     * {@link AUTO.$provide#decorator decorator}.
     *
     * @param {string} name The name of the constant.
     * @param {*} value The constant value.
     * @returns {Object} registered instance
     */


    /**
     * @ngdoc method
     * @name AUTO.$provide#decorator
     * @methodOf AUTO.$provide
     * @description
     *
     * Decoration of service, allows the decorator to intercept the service instance creation. The
     * returned instance may be the original instance, or a new instance which delegates to the
     * original instance.
     *
     * @param {string} name The name of the service to decorate.
     * @param {function()} decorator This function will be invoked when the service needs to be
     *    instanciated. 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.
     */


    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 = createInternalInjector(providerCache, function() {
                throw Error("Unknown provider: " + 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_) {
            if (isFunction(provider_)) {
                provider_ = providerInjector.instantiate(provider_);
            }
            if (!provider_.$get) {
                throw Error('Provider ' + name + ' must define $get factory method.');
            }
            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, value) { return factory(name, valueFn(value)); }

        function constant(name, value) {
            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 = [];
            forEach(modulesToLoad, function(module) {
                if (loadedModules.get(module)) return;
                loadedModules.put(module, true);
                if (isString(module)) {
                    var moduleFn = angularModule(module);
                    runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);

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

                            provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
                        }
                    } catch (e) {
                        if (e.message) e.message += ' from ' + module;
                        throw e;
                    }
                } else if (isFunction(module)) {
                    try {
                        runBlocks.push(providerInjector.invoke(module));
                    } catch (e) {
                        if (e.message) e.message += ' from ' + module;
                        throw e;
                    }
                } else if (isArray(module)) {
                    try {
                        runBlocks.push(providerInjector.invoke(module));
                    } catch (e) {
                        if (e.message) e.message += ' from ' + String(module[module.length - 1]);
                        throw e;
                    }
                } else {
                    assertArgFn(module, 'module');
                }
            });
            return runBlocks;
        }

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

        function createInternalInjector(cache, factory) {

            function getService(serviceName) {
                if (typeof serviceName !== 'string') {
                    throw Error('Service name expected');
                }
                if (cache.hasOwnProperty(serviceName)) {
                    if (cache[serviceName] === INSTANTIATING) {
                        throw Error('Circular dependency: ' + 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];
                    args.push(
                        locals && locals.hasOwnProperty(key)
                            ? locals[key]
                            : getService(key, path)
                    );
                }
                if (!fn.$inject) {
                    // this means that we must be an array.
                    fn = fn[length];
                }


                // Performance optimization: http://jsperf.com/apply-vs-call-vs-invoke
                switch (self ? -1 : args.length) {
                    case  0: return fn();
                    case  1: return fn(args[0]);
                    case  2: return fn(args[0], args[1]);
                    case  3: return fn(args[0], args[1], args[2]);
                    case  4: return fn(args[0], args[1], args[2], args[3]);
                    case  5: return fn(args[0], args[1], args[2], args[3], args[4]);
                    case  6: return fn(args[0], args[1], args[2], args[3], args[4], args[5]);
                    case  7: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
                    case  8: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
                    case  9: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
                    case 10: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]);
                    default: 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) ? returnedValue : instance;
            }

            return {
                invoke: invoke,
                instantiate: instantiate,
                get: getService,
                annotate: annotate
            };
        }
    }
    /**
     * @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 scroll whenever it changes to match any anchor.
     * This can be disabled by calling `$anchorScrollProvider.disableAutoScrolling()`.
     */
    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 $locaiton.hash() change), browser native does scroll
            if (autoScrollingEnabled) {
                $rootScope.$watch(function() {return $location.hash();}, function() {
                    $rootScope.$evalAsync(scroll);
                });
            }

            return scroll;
        }];
    }

    /**
     * ! 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');

        /**
         * @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) {
            // 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 {
                    if (replace) location.replace(url);
                    else location.href = url;
                }
                return self;
                // getter
            } else {
                // the replacement is a workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=407172
                return location.href.replace(/%27/g,"'");
            }
        };

        var urlChangeListeners = [],
            urlChangeInit = false;

        function fireUrlChange() {
            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).bind('popstate', fireUrlChange);
                // hashchange event
                if ($sniffer.hashchange) jqLite(window).bind('hashchange', fireUrlChange);
                // polling
                else self.addPollFn(fireUrlChange);

                urlChangeInit = true;
            }

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

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

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

        //////////////////////////////////////////////////////////////
        // 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 Cokkie 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:
         * <ul>
         *   <li>cookies() -> hash of all cookies, this is NOT a copy of the internal state, so do not modify it</li>
         *   <li>cookies(name, value) -> set name to value, if value is undefined delete the cookie</li>
         *   <li>cookies(name) -> the same as (name, undefined) == DELETES (no one calls it right now that way)</li>
         * </ul>
         *
         * @returns {Object} Hash of all cookies (if called without any parameter)
         */
        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)!");
                        }
                        if (lastCookies.length > 20) {
                            $log.warn("Cookie '"+ name +"' possibly not set or overflowed because too many cookies " +
                                "were already set (" + lastCookies.length + " > 20 )");
                        }
                    }
                }
            } 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
                            lastCookies[unescape(cookie.substring(0, index))] = unescape(cookie.substring(index + 1));
                        }
                    }
                }
                return lastCookies;
            }
        };


        /**
         * @name ng.$browser#defer
         * @methodOf ng.$browser
         * @param {function()} fn A function, who's execution should be defered.
         * @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 asynchroniously 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 defered 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 successfuly 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.
     *
     *
     * @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.
     * - `{void}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache.
     * - `{{*}} `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 Error('cacheId ' + cacheId + ' taken');
                }

                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);
                        }
                    },


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

                        if (!lruEntry) return;

                        refresh(lruEntry);

                        return data[key];
                    },


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

                        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
                    }
                }
            }


            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;
        };
    }

    /**
     * @ngdoc object
     * @name ng.$templateCache
     *
     * @description
     * Cache used for storing html templates.
     *
     * 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)
     */


    var NON_ASSIGNABLE_MODEL_EXPRESSION = 'Non-assignable model expression: ';


    /**
     * @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 trying to match DOM elements to
     * {@link ng.$compileProvider#directive directives}. For each match it
     * executes corresponding template function and collects the
     * instance functions into a single template function which is then returned.
     *
     * The template function can then be used once to produce the view or as it is the case with
     * {@link ng.directive:ngRepeat repeater} many-times, in which
     * case each call results in a view that is a DOM clone of the original template.
     *
     <doc:example module="compile">
     <doc:source>
     <script>
     // declare a new module, and inject the $compileProvider
     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.
     */


    /**
     * @ngdoc service
     * @name ng.$compileProvider
     * @function
     *
     * @description
     */
    $CompileProvider.$inject = ['$provide'];
    function $CompileProvider($provide) {
        var hasDirectives = {},
            Suffix = 'Directive',
            COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\d\w\-_]+)\s+(.*)$/,
            CLASS_DIRECTIVE_REGEXP = /(([\d\w\-_]+)(?:\:([^;]+))?;?)/,
            MULTI_ROOT_TEMPLATE_ERROR = 'Template must have exactly one root element. was: ';


        /**
         * @ngdoc function
         * @name ng.$compileProvider#directive
         * @methodOf ng.$compileProvider
         * @function
         *
         * @description
         * Register a new directives with the compiler.
         *
         * @param {string} name Name of the directive in camel-case. (ie <code>ngBind</code> which will match as
         *                <code>ng-bind</code>).
         * @param {function} directiveFactory An injectable directive factroy function. See {@link guide/directive} for more
         *                info.
         * @returns {ng.$compileProvider} Self for chaining.
         */
        this.directive = function registerDirective(name, directiveFactory) {
            if (isString(name)) {
                assertArg(directiveFactory, 'directive');
                if (!hasDirectives.hasOwnProperty(name)) {
                    hasDirectives[name] = [];
                    $provide.factory(name + Suffix, ['$injector', '$exceptionHandler',
                        function($injector, $exceptionHandler) {
                            var directives = [];
                            forEach(hasDirectives[name], function(directiveFactory) {
                                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.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.$get = [
            '$injector', '$interpolate', '$exceptionHandler', '$http', '$templateCache', '$parse',
            '$controller', '$rootScope',
            function($injector,   $interpolate,   $exceptionHandler,   $http,   $templateCache,   $parse,
                     $controller,   $rootScope) {

                var Attributes = function(element, attr) {
                    this.$$element = element;
                    this.$attr = attr || {};
                };

                Attributes.prototype = {
                    $normalize: directiveNormalize,


                    /**
                     * 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) {
                        var booleanKey = getBooleanAttrName(this.$$element[0], key),
                            $$observers = this.$$observers;

                        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, '-');
                            }
                        }

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

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


                    /**
                     * Observe an interpolated attribute.
                     * The observer will never be called, if given attribute is not interpolated.
                     *
                     * @param {string} key Normalized key. (ie ngAttribute) .
                     * @param {function(*)} fn Function that will be called whenever the attribute value changes.
                     * @returns {function(*)} the `fn` Function passed in.
                     */
                    $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);
                    };


                return compile;

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

                function compile($compileNode, transcludeFn, maxPriority) {
                    if (!($compileNode instanceof jqLite)) {
                        // jquery always rewraps, where as we need to preserve the original selector so that we can modify it.
                        $compileNode = jqLite($compileNode);
                    }
                    // 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($compileNode, function(node, index){
                        if (node.nodeType == 3 /* text node */) {
                            $compileNode[index] = jqLite(node).wrap('<span></span>').parent()[0];
                        }
                    });
                    var compositeLinkFn = compileNodes($compileNode, transcludeFn, $compileNode, maxPriority);
                    return function(scope, cloneConnectFn){
                        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($compileNode) // IMPORTANT!!!
                            : $compileNode;
                        $linkNode.data('$scope', scope);
                        safeAddClass($linkNode, 'ng-scope');
                        if (cloneConnectFn) cloneConnectFn($linkNode, scope);
                        if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode);
                        return $linkNode;
                    };
                }

                function wrongMode(localName, mode) {
                    throw Error("Unsupported '" + mode + "' for '" + localName + "'.");
                }

                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 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) {
                    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, maxPriority);

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

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

                        linkFns.push(nodeLinkFn);
                        linkFns.push(childLinkFn);
                        linkFnFound = (linkFnFound || nodeLinkFn || childLinkFn);
                    }

                    // 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, childScope, childTranscludeFn;

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

                            if (nodeLinkFn) {
                                if (nodeLinkFn.scope) {
                                    childScope = scope.$new(isObject(nodeLinkFn.scope));
                                    jqLite(node).data('$scope', childScope);
                                } else {
                                    childScope = scope;
                                }
                                childTranscludeFn = nodeLinkFn.transclude;
                                if (childTranscludeFn || (!boundTranscludeFn && transcludeFn)) {
                                    nodeLinkFn(childLinkFn, childScope, node, $rootElement,
                                        (function(transcludeFn) {
                                            return function(cloneFn) {
                                                var transcludeScope = scope.$new();

                                                return transcludeFn(transcludeScope, cloneFn).
                                                    bind('$destroy', bind(transcludeScope, transcludeScope.$destroy));
                                            };
                                        })(childTranscludeFn || transcludeFn)
                                    );
                                } else {
                                    nodeLinkFn(childLinkFn, childScope, node, undefined, boundTranscludeFn);
                                }
                            } else if (childLinkFn) {
                                childLinkFn(scope, node.childNodes, undefined, boundTranscludeFn);
                            }
                        }
                    }
                }


                /**
                 * Looks for directives on the given node ands 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=} max directive priority
                 */
                function collectDirectives(node, directives, attrs, maxPriority) {
                    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);

                            // iterate over the attributes
                            for (var attr, name, nName, value, nAttrs = node.attributes,
                                     j = 0, jj = nAttrs && nAttrs.length; j < jj; j++) {
                                attr = nAttrs[j];
                                if (attr.specified) {
                                    name = attr.name;
                                    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);
                                }
                            }

                            // use class as directive
                            className = node.className;
                            if (isString(className)) {
                                while (match = CLASS_DIRECTIVE_REGEXP.exec(className)) {
                                    nName = directiveNormalize(match[2]);
                                    if (addDirective(directives, nName, 'C', maxPriority)) {
                                        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)) {
                                        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;
                }


                /**
                 * Once the directives have been collected their compile functions is 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 {DOMElement} $rootElement If we are working on the root of the compile tree then this
                 *        argument has the root jqLite array so that we can replace widgets on it.
                 * @returns linkFn
                 */
                function applyDirectivesToNode(directives, compileNode, templateAttrs, transcludeFn, $rootElement) {
                    var terminalPriority = -Number.MAX_VALUE,
                        preLinkFns = [],
                        postLinkFns = [],
                        newScopeDirective = null,
                        newIsolatedScopeDirective = null,
                        templateDirective = null,
                        $compileNode = templateAttrs.$$element = jqLite(compileNode),
                        directive,
                        directiveName,
                        $template,
                        transcludeDirective,
                        childTranscludeFn = transcludeFn,
                        controllerDirectives,
                        linkFn,
                        directiveValue;

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

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

                        if (directiveValue = directive.scope) {
                            assertNoDuplicate('isolated scope', newIsolatedScopeDirective, directive, $compileNode);
                            if (isObject(directiveValue)) {
                                safeAddClass($compileNode, 'ng-isolate-scope');
                                newIsolatedScopeDirective = directive;
                            }
                            safeAddClass($compileNode, 'ng-scope');
                            newScopeDirective = newScopeDirective || directive;
                        }

                        directiveName = directive.name;

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

                        if (directiveValue = directive.transclude) {
                            assertNoDuplicate('transclusion', transcludeDirective, directive, $compileNode);
                            transcludeDirective = directive;
                            terminalPriority = directive.priority;
                            if (directiveValue == 'element') {
                                $template = jqLite(compileNode);
                                $compileNode = templateAttrs.$$element =
                                    jqLite('<!-- ' + directiveName + ': ' + templateAttrs[directiveName]  + ' -->');
                                compileNode = $compileNode[0];
                                replaceWith($rootElement, jqLite($template[0]), compileNode);
                                childTranscludeFn = compile($template, transcludeFn, terminalPriority);
                            } else {
                                $template = jqLite(JQLiteClone(compileNode)).contents();
                                $compileNode.html(''); // clear contents
                                childTranscludeFn = compile($template, transcludeFn);
                            }
                        }

                        if ((directiveValue = directive.template)) {
                            assertNoDuplicate('template', templateDirective, directive, $compileNode);
                            templateDirective = directive;
                            directiveValue = denormalizeTemplate(directiveValue);

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

                                if ($template.length != 1 || compileNode.nodeType !== 1) {
                                    throw new Error(MULTI_ROOT_TEMPLATE_ERROR + directiveValue);
                                }

                                replaceWith($rootElement, $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 were already applied and those that weren't
                                // - collect directives from the template, add them to the second group and sort them
                                // - append the second group with new directives to the first group
                                directives = directives.concat(
                                    collectDirectives(
                                        compileNode,
                                        directives.splice(i + 1, directives.length - (i + 1)),
                                        newTemplateAttrs
                                    )
                                );
                                mergeTemplateAttributes(templateAttrs, newTemplateAttrs);

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

                        if (directive.templateUrl) {
                            assertNoDuplicate('template', templateDirective, directive, $compileNode);
                            templateDirective = directive;
                            nodeLinkFn = compileTemplateUrl(directives.splice(i, directives.length - i),
                                nodeLinkFn, $compileNode, templateAttrs, $rootElement, directive.replace,
                                childTranscludeFn);
                            ii = directives.length;
                        } else if (directive.compile) {
                            try {
                                linkFn = directive.compile($compileNode, templateAttrs, childTranscludeFn);
                                if (isFunction(linkFn)) {
                                    addLinkFns(null, linkFn);
                                } else if (linkFn) {
                                    addLinkFns(linkFn.pre, linkFn.post);
                                }
                            } catch (e) {
                                $exceptionHandler(e, startingTag($compileNode));
                            }
                        }

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

                    }

                    nodeLinkFn.scope = newScopeDirective && newScopeDirective.scope;
                    nodeLinkFn.transclude = transcludeDirective && childTranscludeFn;

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

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

                    function addLinkFns(pre, post) {
                        if (pre) {
                            pre.require = directive.require;
                            preLinkFns.push(pre);
                        }
                        if (post) {
                            post.require = directive.require;
                            postLinkFns.push(post);
                        }
                    }


                    function getControllers(require, $element) {
                        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 = $element[retrievalMethod]('$' + require + 'Controller');
                            if (!value && !optional) {
                                throw Error("No controller: " + require);
                            }
                            return value;
                        } else if (isArray(require)) {
                            value = [];
                            forEach(require, function(require) {
                                value.push(getControllers(require, $element));
                            });
                        }
                        return value;
                    }


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

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

                        if (newScopeDirective && isObject(newScopeDirective.scope)) {
                            var LOCAL_REGEXP = /^\s*([@=&])\s*(\w*)\s*$/;

                            var parentScope = scope.$parent || scope;

                            forEach(newScopeDirective.scope, function(definiton, scopeName) {
                                var match = definiton.match(LOCAL_REGEXP) || [],
                                    attrName = match[2]|| scopeName,
                                    mode = match[1], // @, =, or &
                                    lastValue,
                                    parentGet, parentSet;

                                switch (mode) {

                                    case '@': {
                                        attrs.$observe(attrName, function(value) {
                                            scope[scopeName] = value;
                                        });
                                        attrs.$$observers[attrName].$$scope = parentScope;
                                        break;
                                    }

                                    case '=': {
                                        parentGet = $parse(attrs[attrName]);
                                        parentSet = parentGet.assign || function() {
                                            // reset the change, or we will throw this exception on every $digest
                                            lastValue = scope[scopeName] = parentGet(parentScope);
                                            throw Error(NON_ASSIGNABLE_MODEL_EXPRESSION + attrs[attrName] +
                                                ' (directive: ' + newScopeDirective.name + ')');
                                        };
                                        lastValue = scope[scopeName] = parentGet(parentScope);
                                        scope.$watch(function() {
                                            var parentValue = parentGet(parentScope);

                                            if (parentValue !== scope[scopeName]) {
                                                // we are out of sync and need to copy
                                                if (parentValue !== lastValue) {
                                                    // parent changed and it has precedence
                                                    lastValue = scope[scopeName] = parentValue;
                                                } else {
                                                    // if the parent can be assigned then do so
                                                    parentSet(parentScope, lastValue = scope[scopeName]);
                                                }
                                            }
                                            return parentValue;
                                        });
                                        break;
                                    }

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

                                    default: {
                                        throw Error('Invalid isolate scope definition for directive ' +
                                            newScopeDirective.name + ': ' + definiton);
                                    }
                                }
                            });
                        }

                        if (controllerDirectives) {
                            forEach(controllerDirectives, function(directive) {
                                var locals = {
                                    $scope: scope,
                                    $element: $element,
                                    $attrs: attrs,
                                    $transclude: boundTranscludeFn
                                };

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

                                $element.data(
                                    '$' + directive.name + 'Controller',
                                    $controller(controller, locals));
                            });
                        }

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

                        // RECURSION
                        childLinkFn && childLinkFn(scope, linkNode.childNodes, undefined, boundTranscludeFn);

                        // POSTLINKING
                        for(i = 0, ii = postLinkFns.length; i < ii; i++) {
                            try {
                                linkFn = postLinkFns[i];
                                linkFn(scope, $element, attrs,
                                    linkFn.require && getControllers(linkFn.require, $element));
                            } catch (e) {
                                $exceptionHandler(e, startingTag($element));
                            }
                        }
                    }
                }


                /**
                 * 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) {
                    var match = false;
                    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) {
                                    tDirectives.push(directive);
                                    match = true;
                                }
                            } 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);
                        } else if (key.charAt(0) != '$' && !dst.hasOwnProperty(key)) {
                            dst[key] = value;
                            dstAttr[key] = srcAttr[key];
                        }
                    });
                }


                function compileTemplateUrl(directives, beforeTemplateNodeLinkFn, $compileNode, tAttrs,
                                            $rootElement, replace, childTranscludeFn) {
                    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, {
                            controller: null, templateUrl: null, transclude: null
                        });

                    $compileNode.html('');

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

                            content = denormalizeTemplate(content);

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

                                if ($template.length != 1 || compileNode.nodeType !== 1) {
                                    throw new Error(MULTI_ROOT_TEMPLATE_ERROR + content);
                                }

                                tempTemplateAttrs = {$attr: {}};
                                replaceWith($rootElement, $compileNode, compileNode);
                                collectDirectives(compileNode, directives, tempTemplateAttrs);
                                mergeTemplateAttributes(tAttrs, tempTemplateAttrs);
                            } else {
                                compileNode = beforeTemplateCompileNode;
                                $compileNode.html(content);
                            }

                            directives.unshift(derivedSyncDirective);
                            afterTemplateNodeLinkFn = applyDirectivesToNode(directives, $compileNode, tAttrs, childTranscludeFn);
                            afterTemplateChildLinkFn = compileNodes($compileNode.contents(), childTranscludeFn);


                            while(linkQueue.length) {
                                var controller = linkQueue.pop(),
                                    linkRootElement = linkQueue.pop(),
                                    beforeTemplateLinkNode = linkQueue.pop(),
                                    scope = linkQueue.pop(),
                                    linkNode = compileNode;

                                if (beforeTemplateLinkNode !== beforeTemplateCompileNode) {
                                    // it was cloned therefore we have to clone as well.
                                    linkNode = JQLiteClone(compileNode);
                                    replaceWith(linkRootElement, jqLite(beforeTemplateLinkNode), linkNode);
                                }

                                afterTemplateNodeLinkFn(function() {
                                    beforeTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, linkNode, $rootElement, controller);
                                }, scope, linkNode, $rootElement, controller);
                            }
                            linkQueue = null;
                        }).
                        error(function(response, code, headers, config) {
                            throw Error('Failed to load template: ' + config.url);
                        });

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


                /**
                 * Sorting function for bound directives.
                 */
                function byPriority(a, b) {
                    return b.priority - a.priority;
                }


                function assertNoDuplicate(what, previousDirective, directive, element) {
                    if (previousDirective) {
                        throw Error('Multiple directives [' + previousDirective.name + ', ' +
                            directive.name + '] asking for ' + what + ' on: ' +  startingTag(element));
                    }
                }


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


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


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

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

                            if (name === 'class') {
                                // we need to interpolate classes again, in the case the element was replaced
                                // and therefore the two class attrs got merged - we want to interpolate the result
                                interpolateFn = $interpolate(attr[name], true);
                            }

                            attr[name] = undefined;
                            ($$observers[name] || ($$observers[name] = [])).$$inter = true;
                            (attr.$$observers && attr.$$observers[name].$$scope || scope).
                                $watch(interpolateFn, function(value) {
                                    attr.$set(name, value);
                                });
                        })
                    });
                }


                /**
                 * 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} $element 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, $element, newNode) {
                    var oldNode = $element[0],
                        parent = oldNode.parentNode,
                        i, ii;

                    if ($rootElement) {
                        for(i = 0, ii = $rootElement.length; i < ii; i++) {
                            if ($rootElement[i] == oldNode) {
                                $rootElement[i] = newNode;
                                break;
                            }
                        }
                    }

                    if (parent) {
                        parent.replaceChild(newNode, oldNode);
                    }

                    newNode[jqLite.expando] = oldNode[jqLite.expando];
                    $element[0] = newNode;
                }
            }];
    }

    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 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.
     */



    /**
     * 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
        ){}

    /**
     * @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#register register} method.
     */
    function $ControllerProvider() {
        var controllers = {};


        /**
         * @ngdoc function
         * @name ng.$controllerProvider#register
         * @methodOf ng.$controllerProvider
         * @param {string} name Controller name
         * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
         *    annotations in the array notation).
         */
        this.register = function(name, constructor) {
            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 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(constructor, locals) {
                if(isString(constructor)) {
                    var name = constructor;
                    constructor = controllers.hasOwnProperty(name)
                        ? controllers[name]
                        : getter(locals.$scope, name, true) || getter($window, name, true);

                    assertArgFn(constructor, name, true);
                }

                return $injector.instantiate(constructor, locals);
            };
        }];
    }

    /**
     * @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}
     *
     * @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);
            };
        }];
    }

    /**
     * @ngdoc object
     * @name ng.$interpolateProvider
     * @function
     *
     * @description
     *
     * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
     */
    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', function($parse) {
            var startSymbolLength = startSymbol.length,
                endSymbolLength = endSymbol.length;

            /**
             * @ngdoc function
             * @name ng.$interpolate
             * @function
             *
             * @requires $parse
             *
             * @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}}!');
             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.
             * @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) {
                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;
                }

                if (!mustHaveExpression  || hasInterpolation) {
                    concat.length = length;
                    fn = function(context) {
                        for(var i = 0, ii = length, part; i<ii; i++) {
                            if (typeof (part = parts[i]) == 'function') {
                                part = part(context);
                                if (part == null || part == undefined) {
                                    part = '';
                                } else if (typeof part != 'string') {
                                    part = toJson(part);
                                }
                            }
                            concat[i] = part;
                        }
                        return concat.join('');
                    };
                    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;
        }];
    }

    var URL_MATCH = /^([^:]+):\/\/(\w+:{0,1}\w*@)?([\w\.-]*)(:([0-9]+))?(\/[^\?#]*)?(\?([^#]*))?(#(.*))?$/,
        PATH_MATCH = /^([^\?#]*)?(\?([^#]*))?(#(.*))?$/,
        HASH_MATCH = PATH_MATCH,
        DEFAULT_PORTS = {'http': 80, 'https': 443, 'ftp': 21};


    /**
     * 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 stripHash(url) {
        return url.split('#')[0];
    }


    function matchUrl(url, obj) {
        var match = URL_MATCH.exec(url);

        match = {
            protocol: match[1],
            host: match[3],
            port: int(match[5]) || DEFAULT_PORTS[match[1]] || null,
            path: match[6] || '/',
            search: match[8],
            hash: match[10]
        };

        if (obj) {
            obj.$$protocol = match.protocol;
            obj.$$host = match.host;
            obj.$$port = match.port;
        }

        return match;
    }


    function composeProtocolHostPort(protocol, host, port) {
        return protocol + '://' + host + (port == DEFAULT_PORTS[protocol] ? '' : ':' + port);
    }


    function pathPrefixFromBase(basePath) {
        return basePath.substr(0, basePath.lastIndexOf('/'));
    }


    function convertToHtml5Url(url, basePath, hashPrefix) {
        var match = matchUrl(url);

        // already html5 url
        if (decodeURIComponent(match.path) != basePath || isUndefined(match.hash) ||
            match.hash.indexOf(hashPrefix) !== 0) {
            return url;
            // convert hashbang url -> html5 url
        } else {
            return composeProtocolHostPort(match.protocol, match.host, match.port) +
                pathPrefixFromBase(basePath) + match.hash.substr(hashPrefix.length);
        }
    }


    function convertToHashbangUrl(url, basePath, hashPrefix) {
        var match = matchUrl(url);

        // already hashbang url
        if (decodeURIComponent(match.path) == basePath) {
            return url;
            // convert html5 url -> hashbang url
        } else {
            var search = match.search && '?' + match.search || '',
                hash = match.hash && '#' + match.hash || '',
                pathPrefix = pathPrefixFromBase(basePath),
                path = match.path.substr(pathPrefix.length);

            if (match.path.indexOf(pathPrefix) !== 0) {
                throw Error('Invalid url "' + url + '", missing path prefix "' + pathPrefix + '" !');
            }

            return composeProtocolHostPort(match.protocol, match.host, match.port) + basePath +
                '#' + hashPrefix + path + search + hash;
        }
    }


    /**
     * LocationUrl represents an url
     * This object is exposed as $location service when HTML5 mode is enabled and supported
     *
     * @constructor
     * @param {string} url HTML5 url
     * @param {string} pathPrefix
     */
    function LocationUrl(url, pathPrefix, appBaseUrl) {
        pathPrefix = pathPrefix || '';

        /**
         * Parse given html5 (regular) url string into properties
         * @param {string} newAbsoluteUrl HTML5 url
         * @private
         */
        this.$$parse = function(newAbsoluteUrl) {
            var match = matchUrl(newAbsoluteUrl, this);

            if (match.path.indexOf(pathPrefix) !== 0) {
                throw Error('Invalid url "' + newAbsoluteUrl + '", missing path prefix "' + pathPrefix + '" !');
            }

            this.$$path = decodeURIComponent(match.path.substr(pathPrefix.length));
            this.$$search = parseKeyValue(match.search);
            this.$$hash = match.hash && decodeURIComponent(match.hash) || '';

            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 = composeProtocolHostPort(this.$$protocol, this.$$host, this.$$port) +
                pathPrefix + this.$$url;
        };


        this.$$rewriteAppUrl = function(absoluteLinkUrl) {
            if(absoluteLinkUrl.indexOf(appBaseUrl) == 0) {
                return absoluteLinkUrl;
            }
        }


        this.$$parse(url);
    }


    /**
     * LocationHashbangUrl represents url
     * This object is exposed as $location service when html5 history api is disabled or not supported
     *
     * @constructor
     * @param {string} url Legacy url
     * @param {string} hashPrefix Prefix for hash part (containing path and search)
     */
    function LocationHashbangUrl(url, hashPrefix, appBaseUrl) {
        var basePath;

        /**
         * Parse given hashbang url into properties
         * @param {string} url Hashbang url
         * @private
         */
        this.$$parse = function(url) {
            var match = matchUrl(url, this);


            if (match.hash && match.hash.indexOf(hashPrefix) !== 0) {
                throw Error('Invalid url "' + url + '", missing hash prefix "' + hashPrefix + '" !');
            }

            basePath = match.path + (match.search ? '?' + match.search : '');
            match = HASH_MATCH.exec((match.hash || '').substr(hashPrefix.length));
            if (match[1]) {
                this.$$path = (match[1].charAt(0) == '/' ? '' : '/') + decodeURIComponent(match[1]);
            } else {
                this.$$path = '';
            }

            this.$$search = parseKeyValue(match[3]);
            this.$$hash = match[5] && decodeURIComponent(match[5]) || '';

            this.$$compose();
        };

        /**
         * 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 = composeProtocolHostPort(this.$$protocol, this.$$host, this.$$port) +
                basePath + (this.$$url ? '#' + hashPrefix + this.$$url : '');
        };

        this.$$rewriteAppUrl = function(absoluteLinkUrl) {
            if(absoluteLinkUrl.indexOf(appBaseUrl) == 0) {
                return absoluteLinkUrl;
            }
        }


        this.$$parse(url);
    }


    LocationUrl.prototype = {

        /**
         * 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`)
         * @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,string>=} search New search params - string or hash object
         * @param {string=} paramValue If `search` is a string, then `paramValue` will override only a
         *    single search parameter. If the value is `null`, the parameter will be deleted.
         *
         * @return {string} search
         */
        search: function(search, paramValue) {
            if (isUndefined(search))
                return this.$$search;

            if (isDefined(paramValue)) {
                if (paramValue === null) {
                    delete this.$$search[search];
                } else {
                    this.$$search[search] = paramValue;
                }
            } else {
                this.$$search = isString(search) ? parseKeyValue(search) : search;
            }

            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;
        }
    };

    LocationHashbangUrl.prototype = inherit(LocationUrl.prototype);

    function LocationHashbangInHtml5Url(url, hashPrefix, appBaseUrl, baseExtra) {
        LocationHashbangUrl.apply(this, arguments);


        this.$$rewriteAppUrl = function(absoluteLinkUrl) {
            if (absoluteLinkUrl.indexOf(appBaseUrl) == 0) {
                return appBaseUrl + baseExtra + '#' + hashPrefix  + absoluteLinkUrl.substr(appBaseUrl.length);
            }
        }
    }

    LocationHashbangInHtml5Url.prototype = inherit(LocationHashbangUrl.prototype);

    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 {string=} 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;
            }
        };

        this.$get = ['$rootScope', '$browser', '$sniffer', '$rootElement',
            function( $rootScope,   $browser,   $sniffer,   $rootElement) {
                var $location,
                    basePath,
                    pathPrefix,
                    initUrl = $browser.url(),
                    initUrlParts = matchUrl(initUrl),
                    appBaseUrl;

                if (html5Mode) {
                    basePath = $browser.baseHref() || '/';
                    pathPrefix = pathPrefixFromBase(basePath);
                    appBaseUrl =
                        composeProtocolHostPort(initUrlParts.protocol, initUrlParts.host, initUrlParts.port) +
                            pathPrefix + '/';

                    if ($sniffer.history) {
                        $location = new LocationUrl(
                            convertToHtml5Url(initUrl, basePath, hashPrefix),
                            pathPrefix, appBaseUrl);
                    } else {
                        $location = new LocationHashbangInHtml5Url(
                            convertToHashbangUrl(initUrl, basePath, hashPrefix),
                            hashPrefix, appBaseUrl, basePath.substr(pathPrefix.length + 1));
                    }
                } else {
                    appBaseUrl =
                        composeProtocolHostPort(initUrlParts.protocol, initUrlParts.host, initUrlParts.port) +
                            (initUrlParts.path || '') +
                            (initUrlParts.search ? ('?' + initUrlParts.search) : '') +
                            '#' + hashPrefix + '/';

                    $location = new LocationHashbangUrl(initUrl, hashPrefix, appBaseUrl);
                }

                $rootElement.bind('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'),
                        rewrittenUrl = $location.$$rewriteAppUrl(absHref);

                    if (absHref && !elm.attr('target') && rewrittenUrl) {
                        // update location manually
                        $location.$$parse(rewrittenUrl);
                        $rootScope.$apply();
                        event.preventDefault();
                        // 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() != initUrl) {
                    $browser.url($location.absUrl(), true);
                }

                // update $location when $browser url changes
                $browser.onUrlChange(function(newUrl) {
                    if ($location.absUrl() != newUrl) {
                        $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();

                    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(), $location.$$replace);
                                $location.$$replace = false;
                                afterLocationChange(oldUrl);
                            }
                        });
                    }

                    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 writes the message
     * into the browser's console (if present).
     *
     * The main purpose of this service is to simplify debugging and troubleshooting.
     *
     * @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>
     */

    function $LogProvider(){
        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#warn
                 * @methodOf ng.$log
                 *
                 * @description
                 * Write a warning message
                 */
                warn: consoleLog('warn'),

                /**
                 * @ngdoc method
                 * @name ng.$log#info
                 * @methodOf ng.$log
                 *
                 * @description
                 * Write an information message
                 */
                info: consoleLog('info'),

                /**
                 * @ngdoc method
                 * @name ng.$log#error
                 * @methodOf ng.$log
                 *
                 * @description
                 * Write an error message
                 */
                error: consoleLog('error')
            };

            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);
                }
            }
        }];
    }

    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); return (isDefined(a)?a:0)+(isDefined(b)?b:0);},
        '-':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|b;},
        '|':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", "'":"'", '"':'"'};

    function lex(text, csp){
        var tokens = [],
            token,
            index = 0,
            json = [],
            ch,
            lastCh = ':'; // can start regexp

        while (index < text.length) {
            ch = text.charAt(index);
            if (is('"\'')) {
                readString(ch);
            } else if (isNumber(ch) || is('.') && isNumber(peek())) {
                readNumber();
            } else if (isIdent(ch)) {
                readIdent();
                // identifiers can only be if the preceding char was a { or ,
                if (was('{,') && json[0]=='{' &&
                    (token=tokens[tokens.length-1])) {
                    token.json = token.text.indexOf('.') == -1;
                }
            } else if (is('(){}[].,;:')) {
                tokens.push({
                    index:index,
                    text:ch,
                    json:(was(':[,') && is('{[')) || is('}]:,')
                });
                if (is('{[')) json.unshift(ch);
                if (is('}]')) json.shift();
                index++;
            } else if (isWhitespace(ch)) {
                index++;
                continue;
            } else {
                var ch2 = ch + peek(),
                    fn = OPERATORS[ch],
                    fn2 = OPERATORS[ch2];
                if (fn2) {
                    tokens.push({index:index, text:ch2, fn:fn2});
                    index += 2;
                } else if (fn) {
                    tokens.push({index:index, text:ch, fn:fn, json: was('[,:') && is('+-')});
                    index += 1;
                } else {
                    throwError("Unexpected next character ", index, index+1);
                }
            }
            lastCh = ch;
        }
        return tokens;

        function is(chars) {
            return chars.indexOf(ch) != -1;
        }

        function was(chars) {
            return chars.indexOf(lastCh) != -1;
        }

        function peek() {
            return index + 1 < text.length ? text.charAt(index + 1) : false;
        }
        function isNumber(ch) {
            return '0' <= ch && ch <= '9';
        }
        function isWhitespace(ch) {
            return ch == ' ' || ch == '\r' || ch == '\t' ||
                ch == '\n' || ch == '\v' || ch == '\u00A0'; // IE treats non-breaking space as \u00A0
        }
        function isIdent(ch) {
            return 'a' <= ch && ch <= 'z' ||
                'A' <= ch && ch <= 'Z' ||
                '_' == ch || ch == '$';
        }
        function isExpOperator(ch) {
            return ch == '-' || ch == '+' || isNumber(ch);
        }

        function throwError(error, start, end) {
            end = end || index;
            throw Error("Lexer Error: " + error + " at column" +
                (isDefined(start)
                    ? "s " + start +  "-" + index + " [" + text.substring(start, end) + "]"
                    : " " + end) +
                " in expression [" + text + "].");
        }

        function readNumber() {
            var number = "";
            var start = index;
            while (index < text.length) {
                var ch = lowercase(text.charAt(index));
                if (ch == '.' || isNumber(ch)) {
                    number += ch;
                } else {
                    var peekCh = peek();
                    if (ch == 'e' && isExpOperator(peekCh)) {
                        number += ch;
                    } else if (isExpOperator(ch) &&
                        peekCh && isNumber(peekCh) &&
                        number.charAt(number.length - 1) == 'e') {
                        number += ch;
                    } else if (isExpOperator(ch) &&
                        (!peekCh || !isNumber(peekCh)) &&
                        number.charAt(number.length - 1) == 'e') {
                        throwError('Invalid exponent');
                    } else {
                        break;
                    }
                }
                index++;
            }
            number = 1 * number;
            tokens.push({index:start, text:number, json:true,
                fn:function() {return number;}});
        }
        function readIdent() {
            var ident = "",
                start = index,
                lastDot, peekIndex, methodName;

            while (index < text.length) {
                var ch = text.charAt(index);
                if (ch == '.' || isIdent(ch) || isNumber(ch)) {
                    if (ch == '.') lastDot = index;
                    ident += ch;
                } else {
                    break;
                }
                index++;
            }

            //check if this is not a method invocation and if it is back out to last dot
            if (lastDot) {
                peekIndex = index;
                while(peekIndex < text.length) {
                    var ch = text.charAt(peekIndex);
                    if (ch == '(') {
                        methodName = ident.substr(lastDot - start + 1);
                        ident = ident.substr(0, lastDot - start);
                        index = peekIndex;
                        break;
                    }
                    if(isWhitespace(ch)) {
                        peekIndex++;
                    } else {
                        break;
                    }
                }
            }


            var token = {
                index:start,
                text:ident
            };

            if (OPERATORS.hasOwnProperty(ident)) {
                token.fn = token.json = OPERATORS[ident];
            } else {
                var getter = getterFn(ident, csp);
                token.fn = extend(function(self, locals) {
                    return (getter(self, locals));
                }, {
                    assign: function(self, value) {
                        return setter(self, ident, value);
                    }
                });
            }

            tokens.push(token);

            if (methodName) {
                tokens.push({
                    index:lastDot,
                    text: '.',
                    json: false
                });
                tokens.push({
                    index: lastDot + 1,
                    text: methodName,
                    json: false
                });
            }
        }

        function readString(quote) {
            var start = index;
            index++;
            var string = "";
            var rawString = quote;
            var escape = false;
            while (index < text.length) {
                var ch = text.charAt(index);
                rawString += ch;
                if (escape) {
                    if (ch == 'u') {
                        var hex = text.substring(index + 1, index + 5);
                        if (!hex.match(/[\da-f]{4}/i))
                            throwError( "Invalid unicode escape [\\u" + hex + "]");
                        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) {
                    index++;
                    tokens.push({
                        index:start,
                        text:rawString,
                        string:string,
                        json:true,
                        fn:function() { return string; }
                    });
                    return;
                } else {
                    string += ch;
                }
                index++;
            }
            throwError("Unterminated quote", start);
        }
    }

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

    function parser(text, json, $filter, csp){
        var ZERO = valueFn(0),
            value,
            tokens = lex(text, csp),
            assignment = _assignment,
            functionCall = _functionCall,
            fieldAccess = _fieldAccess,
            objectIndex = _objectIndex,
            filterChain = _filterChain;

        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.
            assignment = logicalOR;
            functionCall =
                fieldAccess =
                    objectIndex =
                        filterChain =
                            function() { throwError("is not valid json", {text:text, index:0}); };
            value = primary();
        } else {
            value = statements();
        }
        if (tokens.length !== 0) {
            throwError("is an unexpected token", tokens[0]);
        }
        return value;

        ///////////////////////////////////
        function throwError(msg, token) {
            throw Error("Syntax Error: Token '" + token.text +
                "' " + msg + " at column " +
                (token.index + 1) + " of the expression [" +
                text + "] starting at [" + text.substring(token.index) + "].");
        }

        function peekToken() {
            if (tokens.length === 0)
                throw Error("Unexpected end of expression: " + text);
            return tokens[0];
        }

        function peek(e1, e2, e3, e4) {
            if (tokens.length > 0) {
                var token = tokens[0];
                var t = token.text;
                if (t==e1 || t==e2 || t==e3 || t==e4 ||
                    (!e1 && !e2 && !e3 && !e4)) {
                    return token;
                }
            }
            return false;
        }

        function expect(e1, e2, e3, e4){
            var token = peek(e1, e2, e3, e4);
            if (token) {
                if (json && !token.json) {
                    throwError("is not valid json", token);
                }
                tokens.shift();
                return token;
            }
            return false;
        }

        function consume(e1){
            if (!expect(e1)) {
                throwError("is unexpected, expecting [" + e1 + "]", peek());
            }
        }

        function unaryFn(fn, right) {
            return function(self, locals) {
                return fn(self, locals, right);
            };
        }

        function binaryFn(left, fn, right) {
            return function(self, locals) {
                return fn(self, locals, left, right);
            };
        }

        function statements() {
            var statements = [];
            while(true) {
                if (tokens.length > 0 && !peek('}', ')', ';', ']'))
                    statements.push(filterChain());
                if (!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;
                    };
                }
            }
        }

        function _filterChain() {
            var left = expression();
            var token;
            while(true) {
                if ((token = expect('|'))) {
                    left = binaryFn(left, token.fn, filter());
                } else {
                    return left;
                }
            }
        }

        function filter() {
            var token = expect();
            var fn = $filter(token.text);
            var argsFn = [];
            while(true) {
                if ((token = expect(':'))) {
                    argsFn.push(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;
                    };
                }
            }
        }

        function expression() {
            return assignment();
        }

        function _assignment() {
            var left = logicalOR();
            var right;
            var token;
            if ((token = expect('='))) {
                if (!left.assign) {
                    throwError("implies assignment but [" +
                        text.substring(0, token.index) + "] can not be assigned to", token);
                }
                right = logicalOR();
                return function(self, locals){
                    return left.assign(self, right(self, locals), locals);
                };
            } else {
                return left;
            }
        }

        function logicalOR() {
            var left = logicalAND();
            var token;
            while(true) {
                if ((token = expect('||'))) {
                    left = binaryFn(left, token.fn, logicalAND());
                } else {
                    return left;
                }
            }
        }

        function logicalAND() {
            var left = equality();
            var token;
            if ((token = expect('&&'))) {
                left = binaryFn(left, token.fn, logicalAND());
            }
            return left;
        }

        function equality() {
            var left = relational();
            var token;
            if ((token = expect('==','!='))) {
                left = binaryFn(left, token.fn, equality());
            }
            return left;
        }

        function relational() {
            var left = additive();
            var token;
            if ((token = expect('<', '>', '<=', '>='))) {
                left = binaryFn(left, token.fn, relational());
            }
            return left;
        }

        function additive() {
            var left = multiplicative();
            var token;
            while ((token = expect('+','-'))) {
                left = binaryFn(left, token.fn, multiplicative());
            }
            return left;
        }

        function multiplicative() {
            var left = unary();
            var token;
            while ((token = expect('*','/','%'))) {
                left = binaryFn(left, token.fn, unary());
            }
            return left;
        }

        function unary() {
            var token;
            if (expect('+')) {
                return primary();
            } else if ((token = expect('-'))) {
                return binaryFn(ZERO, token.fn, unary());
            } else if ((token = expect('!'))) {
                return unaryFn(token.fn, unary());
            } else {
                return primary();
            }
        }


        function primary() {
            var primary;
            if (expect('(')) {
                primary = filterChain();
                consume(')');
            } else if (expect('[')) {
                primary = arrayDeclaration();
            } else if (expect('{')) {
                primary = object();
            } else {
                var token = expect();
                primary = token.fn;
                if (!primary) {
                    throwError("not a primary expression", token);
                }
            }

            var next, context;
            while ((next = expect('(', '[', '.'))) {
                if (next.text === '(') {
                    primary = functionCall(primary, context);
                    context = null;
                } else if (next.text === '[') {
                    context = primary;
                    primary = objectIndex(primary);
                } else if (next.text === '.') {
                    context = primary;
                    primary = fieldAccess(primary);
                } else {
                    throwError("IMPOSSIBLE");
                }
            }
            return primary;
        }

        function _fieldAccess(object) {
            var field = expect().text;
            var getter = getterFn(field, csp);
            return extend(
                function(self, locals) {
                    return getter(object(self, locals), locals);
                },
                {
                    assign:function(self, value, locals) {
                        return setter(object(self, locals), field, value);
                    }
                }
            );
        }

        function _objectIndex(obj) {
            var indexFn = expression();
            consume(']');
            return extend(
                function(self, locals){
                    var o = obj(self, locals),
                        i = indexFn(self, locals),
                        v, p;

                    if (!o) return undefined;
                    v = o[i];
                    if (v && v.then) {
                        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){
                        return obj(self, locals)[indexFn(self, locals)] = value;
                    }
                });
        }

        function _functionCall(fn, contextGetter) {
            var argsFn = [];
            if (peekToken().text != ')') {
                do {
                    argsFn.push(expression());
                } while (expect(','));
            }
            consume(')');
            return function(self, locals){
                var args = [],
                    context = contextGetter ? contextGetter(self, locals) : self;

                for ( var i = 0; i < argsFn.length; i++) {
                    args.push(argsFn[i](self, locals));
                }
                var fnPtr = fn(self, locals) || noop;
                // IE stupidity!
                return fnPtr.apply
                    ? fnPtr.apply(context, args)
                    : fnPtr(args[0], args[1], args[2], args[3], args[4]);
            };
        }

        // This is used with json array declaration
        function arrayDeclaration () {
            var elementFns = [];
            if (peekToken().text != ']') {
                do {
                    elementFns.push(expression());
                } while (expect(','));
            }
            consume(']');
            return function(self, locals){
                var array = [];
                for ( var i = 0; i < elementFns.length; i++) {
                    array.push(elementFns[i](self, locals));
                }
                return array;
            };
        }

        function object () {
            var keyValues = [];
            if (peekToken().text != '}') {
                do {
                    var token = expect(),
                        key = token.string || token.text;
                    consume(":");
                    var value = expression();
                    keyValues.push({key:key, value:value});
                } while (expect(','));
            }
            consume('}');
            return function(self, locals){
                var object = {};
                for ( var i = 0; i < keyValues.length; i++) {
                    var keyValue = keyValues[i];
                    var value = keyValue.value(self, locals);
                    object[keyValue.key] = value;
                }
                return object;
            };
        }
    }

//////////////////////////////////////////////////
// Parser helper functions
//////////////////////////////////////////////////

    function setter(obj, path, setValue) {
        var element = path.split('.');
        for (var i = 0; element.length > 1; i++) {
            var key = element.shift();
            var propertyObj = obj[key];
            if (!propertyObj) {
                propertyObj = {};
                obj[key] = propertyObj;
            }
            obj = propertyObj;
        }
        obj[element.shift()] = setValue;
        return setValue;
    }

    /**
     * Return the value accesible 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 accesbile 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;
    }

    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) {
        return function(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) {
                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) {
                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) {
                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) {
                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) {
                if (!("$$v" in pathVal)) {
                    promise = pathVal;
                    promise.$$v = undefined;
                    promise.then(function(val) { promise.$$v = val; });
                }
                pathVal = pathVal.$$v;
            }
            return pathVal;
        };
    };

    function getterFn(path, csp) {
        if (getterFnCache.hasOwnProperty(path)) {
            return getterFnCache[path];
        }

        var pathKeys = path.split('.'),
            pathKeysLength = pathKeys.length,
            fn;

        if (csp) {
            fn = (pathKeysLength < 6)
                ? cspSafeGetterFn(pathKeys[0], pathKeys[1], pathKeys[2], pathKeys[3], pathKeys[4])
                : function(scope, locals) {
                var i = 0, val
                do {
                    val = cspSafeGetterFn(
                        pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++]
                    )(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) {
                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' +
                    'if (s && s.then) {\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;';
            fn = Function('s', 'k', code); // s=scope, k=locals
            fn.toString = function() { return code; };
        }

        return getterFnCache[path] = 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`: an object against which any expressions embedded in the strings are evaluated
     *      against (Topically a scope object).
     *    * `locals`: local variables context object, useful for overriding values in `context`.
     *
     *    The return function also has an `assign` property, if the expression is assignable, which
     *    allows one to set values to expressions.
     *
     */
    function $ParseProvider() {
        var cache = {};
        this.$get = ['$filter', '$sniffer', function($filter, $sniffer) {
            return function(exp) {
                switch(typeof exp) {
                    case 'string':
                        return cache.hasOwnProperty(exp)
                            ? cache[exp]
                            : cache[exp] =  parser(exp, false, $filter, $sniffer.csp);
                    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 programing what `try`, `catch` and `throw` keywords are to synchronous programing.
     *
     * <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() {
     *         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);
     *   );
     * </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](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 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`.
     *
     * **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)` – regardless of when the promise was or will be resolved
     *   or rejected 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.
     *
     *   This method *returns a new promise* which is resolved or rejected via the return value of the
     *   `successCallback` or `errorCallback`.
     *
     *
     * # Chaining promises
     *
     * Because calling `then` api 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 it's 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 three 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 promises are recognized by the templating engine in angular, which means that in templates
     *   you can treat promises attached to a scope as if they were the resulting values.
     * - Q has many more features that $q, but that comes at a cost of bytes. $q is tiny, but contains
     *   all the important functionality needed for common async tasks.
     */
    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]);
                                }
                            });
                        }
                    }
                },


                reject: function(reason) {
                    deferred.resolve(reject(reason));
                },


                promise: {
                    then: function(callback, errback) {
                        var result = defer();

                        var wrappedCallback = function(value) {
                            try {
                                result.resolve((callback || defaultCallback)(value));
                            } catch(e) {
                                exceptionHandler(e);
                                result.reject(e);
                            }
                        };

                        var wrappedErrback = function(reason) {
                            try {
                                result.resolve((errback || defaultErrback)(reason));
                            } catch(e) {
                                exceptionHandler(e);
                                result.reject(e);
                            }
                        };

                        if (pending) {
                            pending.push([wrappedCallback, wrappedErrback]);
                        } else {
                            value.then(wrappedCallback, wrappedErrback);
                        }

                        return result.promise;
                    }
                }
            };

            return deferred;
        };


        var ref = function(value) {
            if (value && 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() {
                        result.resolve((errback || defaultErrback)(reason));
                    });
                    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 on 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 single promise that will be resolved with an array of values,
         *   each value coresponding to the promise at the same index in the `promises` array. If any of
         *   the promises is resolved with a rejection, this resulting promise will be resolved with the
         *   same rejection.
         */
        var when = function(value, callback, errback) {
            var result = defer(),
                done;

            var wrappedCallback = function(value) {
                try {
                    return (callback || defaultCallback)(value);
                } catch (e) {
                    exceptionHandler(e);
                    return reject(e);
                }
            };

            var wrappedErrback = function(reason) {
                try {
                    return (errback || defaultErrback)(reason);
                } catch (e) {
                    exceptionHandler(e);
                    return reject(e);
                }
            };

            nextTick(function() {
                ref(value).then(function(value) {
                    if (done) return;
                    done = true;
                    result.resolve(ref(value).then(wrappedCallback, wrappedErrback));
                }, function(reason) {
                    if (done) return;
                    done = true;
                    result.resolve(wrappedErrback(reason));
                });
            });

            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>} promises An array of promises.
         * @returns {Promise} Returns a single promise that will be resolved with an array of values,
         *   each value coresponding to the promise at the same index in the `promises` array. If any of
         *   the promises is resolved with a rejection, this resulting promise will be resolved with the
         *   same rejection.
         */
        function all(promises) {
            var deferred = defer(),
                counter = promises.length,
                results = [];

            if (counter) {
                forEach(promises, function(promise, index) {
                    ref(promise).then(function(value) {
                        if (index in results) return;
                        results[index] = value;
                        if (!(--counter)) deferred.resolve(results);
                    }, function(reason) {
                        if (index in results) return;
                        deferred.reject(reason);
                    });
                });
            } else {
                deferred.resolve(results);
            }

            return deferred.promise;
        }

        return {
            defer: defer,
            reject: reject,
            when: when,
            all: all
        };
    }

    /**
     * @ngdoc object
     * @name ng.$routeProvider
     * @function
     *
     * @description
     *
     * Used for configuring routes. See {@link ng.$route $route} for an example.
     */
    function $RouteProvider(){
        var routes = {};

        /**
         * @ngdoc method
         * @name ng.$routeProvider#when
         * @methodOf ng.$routeProvider
         *
         * @param {string} path Route path (matched against `$location.path`). If `$location.path`
         *    contains redundant trailing slash or is missing one, the route will still match and the
         *    `$location.path` will be updated to add or drop the trailing slash to exacly match the
         *    route definition.
         * @param {Object} route Mapping information to be assigned to `$route.current` on route
         *    match.
         *
         *    Object properties:
         *
         *    - `controller` – `{(string|function()=}` – Controller fn that should be associated with newly
         *      created scope or the name of a {@link angular.Module#controller registered controller}
         *      if passed as a string.
         *    - `template` – `{string=}` –  html template as a string that should be used by
         *      {@link ng.directive:ngView ngView} or
         *      {@link ng.directive:ngInclude ngInclude} directives.
         *      this property takes precedence over `templateUrl`.
         *    - `templateUrl` – `{string=}` – path to an html template that should be used by
         *      {@link ng.directive:ngView ngView}.
         *    - `resolve` - `{Object.<string, function>=}` - An optional map of dependencies which should
         *      be injected into the controller. If any of these dependencies are promises, they will be
         *      resolved and converted to a value before the controller is instantiated and the
         *      `$afterRouteChange` event is fired. The map object is:
         *
         *      - `key` – `{string}`: a name of a dependency to be injected into the controller.
         *      - `factory` - `{string|function}`: If `string` then it is an alias for a service.
         *        Otherwise if function, then it is {@link api/AUTO.$injector#invoke injected}
         *        and the return value is treated as the dependency. If the result is a promise, it is resolved
         *        before its value is injected into the controller.
         *
         *    - `redirectTo` – {(string|function())=} – value to update
         *      {@link ng.$location $location} path with and trigger route redirection.
         *
         *      If `redirectTo` is a function, it will be called with the following parameters:
         *
         *      - `{Object.<string>}` - route parameters extracted from the current
         *        `$location.path()` by applying the current route templateUrl.
         *      - `{string}` - current `$location.path()`
         *      - `{Object}` - current `$location.search()`
         *
         *      The custom `redirectTo` function is expected to return a string which will be used
         *      to update `$location.path()` and `$location.search()`.
         *
         *    - `[reloadOnSearch=true]` - {boolean=} - reload route when only $location.search()
         *    changes.
         *
         *      If the option is set to `false` and url in the browser changes, then
         *      `$routeUpdate` event is broadcasted on the root scope.
         *
         * @returns {Object} self
         *
         * @description
         * Adds a new route definition to the `$route` service.
         */
        this.when = function(path, route) {
            routes[path] = extend({reloadOnSearch: true}, route);

            // create redirection for trailing slashes
            if (path) {
                var redirectPath = (path[path.length-1] == '/')
                    ? path.substr(0, path.length-1)
                    : path +'/';

                routes[redirectPath] = {redirectTo: path};
            }

            return this;
        };

        /**
         * @ngdoc method
         * @name ng.$routeProvider#otherwise
         * @methodOf ng.$routeProvider
         *
         * @description
         * Sets route definition that will be used on route change when no other route definition
         * is matched.
         *
         * @param {Object} params Mapping information to be assigned to `$route.current`.
         * @returns {Object} self
         */
        this.otherwise = function(params) {
            this.when(null, params);
            return this;
        };


        this.$get = ['$rootScope', '$location', '$routeParams', '$q', '$injector', '$http', '$templateCache',
            function( $rootScope,   $location,   $routeParams,   $q,   $injector,   $http,   $templateCache) {

                /**
                 * @ngdoc object
                 * @name ng.$route
                 * @requires $location
                 * @requires $routeParams
                 *
                 * @property {Object} current Reference to the current route definition.
                 * The route definition contains:
                 *
                 *   - `controller`: The controller constructor as define in route definition.
                 *   - `locals`: A map of locals which is used by {@link ng.$controller $controller} service for
                 *     controller instantiation. The `locals` contain
                 *     the resolved values of the `resolve` map. Additionally the `locals` also contain:
                 *
                 *     - `$scope` - The current route scope.
                 *     - `$template` - The current route template HTML.
                 *
                 * @property {Array.<Object>} routes Array of all configured routes.
                 *
                 * @description
                 * Is used for deep-linking URLs to controllers and views (HTML partials).
                 * It watches `$location.url()` and tries to map the path to an existing route definition.
                 *
                 * You can define routes through {@link ng.$routeProvider $routeProvider}'s API.
                 *
                 * The `$route` service is typically used in conjunction with {@link ng.directive:ngView ngView}
                 * directive and the {@link ng.$routeParams $routeParams} service.
                 *
                 * @example
                 This example shows how changing the URL hash causes the `$route` to match a route against the
                 URL, and the `ngView` pulls in the partial.

                 Note that this example is using {@link ng.directive:script inlined templates}
                 to get it working on jsfiddle as well.

                 <example module="ngView">
                 <file name="index.html">
                 <div ng-controller="MainCntl">
                 Choose:
                 <a href="Book/Moby">Moby</a> |
                 <a href="Book/Moby/ch/1">Moby: Ch1</a> |
                 <a href="Book/Gatsby">Gatsby</a> |
                 <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> |
                 <a href="Book/Scarlet">Scarlet Letter</a><br/>

                 <div ng-view></div>
                 <hr />

                 <pre>$location.path() = {{$location.path()}}</pre>
                 <pre>$route.current.templateUrl = {{$route.current.templateUrl}}</pre>
                 <pre>$route.current.params = {{$route.current.params}}</pre>
                 <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre>
                 <pre>$routeParams = {{$routeParams}}</pre>
                 </div>
                 </file>

                 <file name="book.html">
                 controller: {{name}}<br />
                 Book Id: {{params.bookId}}<br />
                 </file>

                 <file name="chapter.html">
                 controller: {{name}}<br />
                 Book Id: {{params.bookId}}<br />
                 Chapter Id: {{params.chapterId}}
                 </file>

                 <file name="script.js">
                 angular.module('ngView', [], function($routeProvider, $locationProvider) {
                 $routeProvider.when('/Book/:bookId', {
                 templateUrl: 'book.html',
                 controller: BookCntl,
                 resolve: {
                 // I will cause a 1 second delay
                 delay: function($q, $timeout) {
                 var delay = $q.defer();
                 $timeout(delay.resolve, 1000);
                 return delay.promise;
                 }
                 }
                 });
                 $routeProvider.when('/Book/:bookId/ch/:chapterId', {
                 templateUrl: 'chapter.html',
                 controller: ChapterCntl
                 });

                 // configure html5 to get links working on jsfiddle
                 $locationProvider.html5Mode(true);
                 });

                 function MainCntl($scope, $route, $routeParams, $location) {
                 $scope.$route = $route;
                 $scope.$location = $location;
                 $scope.$routeParams = $routeParams;
                 }

                 function BookCntl($scope, $routeParams) {
                 $scope.name = "BookCntl";
                 $scope.params = $routeParams;
                 }

                 function ChapterCntl($scope, $routeParams) {
                 $scope.name = "ChapterCntl";
                 $scope.params = $routeParams;
                 }
                 </file>

                 <file name="scenario.js">
                 it('should load and compile correct template', function() {
                 element('a:contains("Moby: Ch1")').click();
                 var content = element('.doc-example-live [ng-view]').text();
                 expect(content).toMatch(/controller\: ChapterCntl/);
                 expect(content).toMatch(/Book Id\: Moby/);
                 expect(content).toMatch(/Chapter Id\: 1/);

                 element('a:contains("Scarlet")').click();
                 sleep(2); // promises are not part of scenario waiting
                 content = element('.doc-example-live [ng-view]').text();
                 expect(content).toMatch(/controller\: BookCntl/);
                 expect(content).toMatch(/Book Id\: Scarlet/);
                 });
                 </file>
                 </example>
                 */

                /**
                 * @ngdoc event
                 * @name ng.$route#$routeChangeStart
                 * @eventOf ng.$route
                 * @eventType broadcast on root scope
                 * @description
                 * Broadcasted before a route change. At this  point the route services starts
                 * resolving all of the dependencies needed for the route change to occurs.
                 * Typically this involves fetching the view template as well as any dependencies
                 * defined in `resolve` route property. Once  all of the dependencies are resolved
                 * `$routeChangeSuccess` is fired.
                 *
                 * @param {Route} next Future route information.
                 * @param {Route} current Current route information.
                 */

                /**
                 * @ngdoc event
                 * @name ng.$route#$routeChangeSuccess
                 * @eventOf ng.$route
                 * @eventType broadcast on root scope
                 * @description
                 * Broadcasted after a route dependencies are resolved.
                 * {@link ng.directive:ngView ngView} listens for the directive
                 * to instantiate the controller and render the view.
                 *
                 * @param {Route} current Current route information.
                 * @param {Route} previous Previous route information.
                 */

                /**
                 * @ngdoc event
                 * @name ng.$route#$routeChangeError
                 * @eventOf ng.$route
                 * @eventType broadcast on root scope
                 * @description
                 * Broadcasted if any of the resolve promises are rejected.
                 *
                 * @param {Route} current Current route information.
                 * @param {Route} previous Previous route information.
                 * @param {Route} rejection Rejection of the promise. Usually the error of the failed promise.
                 */

                /**
                 * @ngdoc event
                 * @name ng.$route#$routeUpdate
                 * @eventOf ng.$route
                 * @eventType broadcast on root scope
                 * @description
                 *
                 * The `reloadOnSearch` property has been set to false, and we are reusing the same
                 * instance of the Controller.
                 */

                var matcher = switchRouteMatcher,
                    forceReload = false,
                    $route = {
                        routes: routes,

                        /**
                         * @ngdoc method
                         * @name ng.$route#reload
                         * @methodOf ng.$route
                         *
                         * @description
                         * Causes `$route` service to reload the current route even if
                         * {@link ng.$location $location} hasn't changed.
                         *
                         * As a result of that, {@link ng.directive:ngView ngView}
                         * creates new scope, reinstantiates the controller.
                         */
                        reload: function() {
                            forceReload = true;
                            $rootScope.$evalAsync(updateRoute);
                        }
                    };

                $rootScope.$on('$locationChangeSuccess', updateRoute);

                return $route;

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

                function switchRouteMatcher(on, when) {
                    // TODO(i): this code is convoluted and inefficient, we should construct the route matching
                    //   regex only once and then reuse it
                    var regex = '^' + when.replace(/([\.\\\(\)\^\$])/g, "\\$1") + '$',
                        params = [],
                        dst = {};
                    forEach(when.split(/\W/), function(param) {
                        if (param) {
                            var paramRegExp = new RegExp(":" + param + "([\\W])");
                            if (regex.match(paramRegExp)) {
                                regex = regex.replace(paramRegExp, "([^\\/]*)$1");
                                params.push(param);
                            }
                        }
                    });
                    var match = on.match(new RegExp(regex));
                    if (match) {
                        forEach(params, function(name, index) {
                            dst[name] = match[index + 1];
                        });
                    }
                    return match ? dst : null;
                }

                function updateRoute() {
                    var next = parseRoute(),
                        last = $route.current;

                    if (next && last && next.$route === last.$route
                        && equals(next.pathParams, last.pathParams) && !next.reloadOnSearch && !forceReload) {
                        last.params = next.params;
                        copy(last.params, $routeParams);
                        $rootScope.$broadcast('$routeUpdate', last);
                    } else if (next || last) {
                        forceReload = false;
                        $rootScope.$broadcast('$routeChangeStart', next, last);
                        $route.current = next;
                        if (next) {
                            if (next.redirectTo) {
                                if (isString(next.redirectTo)) {
                                    $location.path(interpolate(next.redirectTo, next.params)).search(next.params)
                                        .replace();
                                } else {
                                    $location.url(next.redirectTo(next.pathParams, $location.path(), $location.search()))
                                        .replace();
                                }
                            }
                        }

                        $q.when(next).
                            then(function() {
                                if (next) {
                                    var keys = [],
                                        values = [],
                                        template;

                                    forEach(next.resolve || {}, function(value, key) {
                                        keys.push(key);
                                        values.push(isFunction(value) ? $injector.invoke(value) : $injector.get(value));
                                    });
                                    if (isDefined(template = next.template)) {
                                    } else if (isDefined(template = next.templateUrl)) {
                                        template = $http.get(template, {cache: $templateCache}).
                                            then(function(response) { return response.data; });
                                    }
                                    if (isDefined(template)) {
                                        keys.push('$template');
                                        values.push(template);
                                    }
                                    return $q.all(values).then(function(values) {
                                        var locals = {};
                                        forEach(values, function(value, index) {
                                            locals[keys[index]] = value;
                                        });
                                        return locals;
                                    });
                                }
                            }).
                            // after route change
                            then(function(locals) {
                                if (next == $route.current) {
                                    if (next) {
                                        next.locals = locals;
                                        copy(next.params, $routeParams);
                                    }
                                    $rootScope.$broadcast('$routeChangeSuccess', next, last);
                                }
                            }, function(error) {
                                if (next == $route.current) {
                                    $rootScope.$broadcast('$routeChangeError', next, last, error);
                                }
                            });
                    }
                }


                /**
                 * @returns the current active route, by matching it against the URL
                 */
                function parseRoute() {
                    // Match a route
                    var params, match;
                    forEach(routes, function(route, path) {
                        if (!match && (params = matcher($location.path(), path))) {
                            match = inherit(route, {
                                params: extend({}, $location.search(), params),
                                pathParams: params});
                            match.$route = route;
                        }
                    });
                    // No route matched; fallback to "otherwise" route
                    return match || routes[null] && inherit(routes[null], {params: {}, pathParams:{}});
                }

                /**
                 * @returns interpolation of the redirect path with the parametrs
                 */
                function interpolate(string, params) {
                    var result = [];
                    forEach((string||'').split(':'), function(segment, i) {
                        if (i == 0) {
                            result.push(segment);
                        } else {
                            var segmentMatch = segment.match(/(\w+)(.*)/);
                            var key = segmentMatch[1];
                            result.push(params[key]);
                            result.push(segmentMatch[2] || '');
                            delete params[key];
                        }
                    });
                    return result.join('');
                }
            }];
    }

    /**
     * @ngdoc object
     * @name ng.$routeParams
     * @requires $route
     *
     * @description
     * Current set of route parameters. The route parameters are a combination of the
     * {@link ng.$location $location} `search()`, and `path()`. The `path` parameters
     * are extracted when the {@link ng.$route $route} path is matched.
     *
     * In case of parameter name collision, `path` params take precedence over `search` params.
     *
     * The service guarantees that the identity of the `$routeParams` object will remain unchanged
     * (but its properties will likely change) even when a route change occurs.
     *
     * @example
     * <pre>
     *  // Given:
     *  // URL: http://server.com/index.html#/Chapter/1/Section/2?search=moby
     *  // Route: /Chapter/:chapterId/Section/:sectionId
     *  //
     *  // Then
     *  $routeParams ==> {chapterId:1, sectionId:2, search:'moby'}
     * </pre>
     */
    function $RouteParamsProvider() {
        this.$get = valueFn({});
    }

    /**
     * DESIGN NOTES
     *
     * The design decisions behind the scope ware 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 from speed as well as memory:
     *   - no closures, instead ups 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 begging (shift) instead of at the end (push)
     *
     * Child scopes are created and removed often
     *   - Using array would be slow since inserts in meddle 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 iteration the scope should attempt to execute before giving up and
     * assuming that the model is unstable.
     *
     * The current default is 10 iterations.
     *
     * @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 child scopes of the root scope. Scopes provide mechanism for watching the model and provide
     * event processing life-cycle. See {@link guide/scope developer guide on scopes}.
     */
    function $RootScopeProvider(){
        var TTL = 10;

        this.digestTtl = function(value) {
            if (arguments.length) {
                TTL = value;
            }
            return TTL;
        };

        this.$get = ['$injector', '$exceptionHandler', '$parse',
            function( $injector,   $exceptionHandler,   $parse) {

                /**
                 * @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#$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>
                 angular.injector(['ng']).invoke(function($rootScope) {
                 var scope = $rootScope.$new();
                 scope.salutation = 'Hello';
                 scope.name = 'World';

                 expect(scope.greeting).toEqual(undefined);

                 scope.$watch('name', function() {
                 this.greeting = this.salutation + ' ' + this.name + '!';
                 }); // initialize the watch

                 expect(scope.greeting).toEqual(undefined);
                 scope.name = 'Misko';
                 // still old value, since watches have not been called yet
                 expect(scope.greeting).toEqual(undefined);

                 scope.$digest(); // fire all  the watches
                 expect(scope.greeting).toEqual('Hello Misko!');
                 });
                 * </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.$$asyncQueue = [];
                    this.$$listeners = {};
                }

                /**
                 * @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 = {
                    /**
                     * @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#$digest $digest()} and
                     * {@link ng.$rootScope.Scope#$digest $digest()} events. The scope can be removed from the scope
                     * hierarchy using {@link ng.$rootScope.Scope#$destroy $destroy()}.
                     *
                     * {@link ng.$rootScope.Scope#$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 scoped does not prototypically inherit from the
                     *         parent scope. The scope is isolated, as it can not se parent scope properties.
                     *         When creating widgets it is useful for the widget to not accidently read parent
                     *         state.
                     *
                     * @returns {Object} The newly created child scope.
                     *
                     */
                    $new: function(isolate) {
                        var Child,
                            child;

                        if (isFunction(isolate)) {
                            // TODO: remove at some point
                            throw Error('API-CHANGE: Use $controller to instantiate controllers.');
                        }
                        if (isolate) {
                            child = new Scope();
                            child.$root = this.$root;
                        } else {
                            Child = function() {}; // should be anonymous; This is so that when the minifier munges
                            // the name it does not become random set of chars. These will then show up as class
                            // name in the debugger.
                            Child.prototype = this;
                            child = new Child();
                            child.$id = nextUid();
                        }
                        child['this'] = child;
                        child.$$listeners = {};
                        child.$parent = this;
                        child.$$asyncQueue = [];
                        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#$digest $digest()} and
                     *   should return the value which will be watched. (Since {@link ng.$rootScope.Scope#$digest $digest()}
                     *   reruns when it detects changes the `watchExpression` can execute multiple times per
                     *   {@link ng.$rootScope.Scope#$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
                     *   {@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 100 to prevent infinity loop deadlock.
                     *
                     *
                     * If you want to be notified whenever {@link ng.$rootScope.Scope#$digest $digest} is called,
                     * you can register an `watchExpression` function with no `listener`. (Since `watchExpression`,
                     * can execute multiple times per {@link ng.$rootScope.Scope#$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#$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.
                     *
                     *
                     * # 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) { counter = 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>
                     *
                     *
                     *
                     * @param {(function()|string)} watchExpression Expression that is evaluated on each
                     *    {@link ng.$rootScope.Scope#$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 then for refference.
                     * @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
                            };

                        // 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 (!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#$digest
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Process all of the {@link ng.$rootScope.Scope#$watch watchers} of the current scope and its children.
                     * Because a {@link ng.$rootScope.Scope#$watch watcher}'s listener can change the model, the
                     * `$digest()` keeps calling the {@link ng.$rootScope.Scope#$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#directive directives}.
                     * Instead a call to {@link ng.$rootScope.Scope#$apply $apply()} (typically from within a
                     * {@link ng.$compileProvider#directive directives}) 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#$watch $watch()}
                     * with no `listener`.
                     *
                     * You may have a need to call `$digest()` from within unit-tests, 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) {
                     counter = 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,
                            length,
                            dirty, ttl = TTL,
                            next, current, target = this,
                            watchLog = [],
                            logIdx, logMsg;

                        beginPhase('$digest');

                        do {
                            dirty = false;
                            current = target;
                            do {
                                asyncQueue = current.$$asyncQueue;
                                while(asyncQueue.length) {
                                    try {
                                        current.$eval(asyncQueue.shift());
                                    } catch (e) {
                                        $exceptionHandler(e);
                                    }
                                }
                                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 ((value = watch.get(current)) !== (last = watch.last) &&
                                                !(watch.eq
                                                    ? equals(value, last)
                                                    : (typeof value == 'number' && typeof last == 'number'
                                                    && isNaN(value) && isNaN(last)))) {
                                                dirty = true;
                                                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);
                                                }
                                            }
                                        } 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 $broadcast
                                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 Error(TTL + ' $digest() iterations reached. Aborting!\n' +
                                    'Watchers fired in the last 5 iterations: ' + toJson(watchLog));
                            }
                        } while (dirty || asyncQueue.length);

                        clearPhase();
                    },


                    /**
                     * @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.
                     */

                    /**
                     * @ngdoc function
                     * @name ng.$rootScope.Scope#$destroy
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Remove the current scope (and all of its children) from the parent scope. Removal implies
                     * that calls to {@link ng.$rootScope.Scope#$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 chance to
                     * perform any necessary cleanup.
                     */
                    $destroy: function() {
                        if ($rootScope == this) return; // we can't remove the root node;
                        var parent = this.$parent;

                        this.$broadcast('$destroy');

                        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;
                    },

                    /**
                     * @ngdoc function
                     * @name ng.$rootScope.Scope#$eval
                     * @methodOf ng.$rootScope.Scope
                     * @function
                     *
                     * @description
                     * Executes the `expression` on the current scope returning the result. Any exceptions in the
                     * expression are propagated (uncaught). This is useful when evaluating engular 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.
                     *
                     * @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 in the current script execution context (before any DOM rendering).
                     *   - at least one {@link ng.$rootScope.Scope#$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.
                     *
                     * @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) {
                        this.$$asyncQueue.push(expr);
                    },

                    /**
                     * @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#$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#$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#$watch watch} listeners are fired immediately after the expression
                     *    was executed using the {@link ng.$rootScope.Scope#$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
                     * Listen on events of a given type. See {@link ng.$rootScope.Scope#$emit $emit} for discussion of
                     * event life cycle.
                     *
                     * @param {string} name Event name to listen on.
                     * @param {function(event)} listener Function to call when the event is emitted.
                     * @returns {function()} Returns a deregistration function for this listener.
                     *
                     * 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.
                     */
                    $on: function(name, listener) {
                        var namedListeners = this.$$listeners[name];
                        if (!namedListeners) {
                            this.$$listeners[name] = namedListeners = [];
                        }
                        namedListeners.push(listener);

                        return function() {
                            arrayRemove(namedListeners, listener);
                        };
                    },


                    /**
                     * @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#$on} listeners.
                     *
                     * The event life cycle starts at the scope on which `$emit` was called. All
                     * {@link ng.$rootScope.Scope#$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 emmited from the {@link ng.$rootScope.Scope#$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#$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++) {
                                try {
                                    namedListeners[i].apply(null, listenerArgs);
                                    if (stopPropagation) return event;
                                } catch (e) {
                                    $exceptionHandler(e);
                                }
                            }
                            //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#$on} listeners.
                     *
                     * The event life cycle starts at the scope on which `$broadcast` was called. All
                     * {@link ng.$rootScope.Scope#$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 emmited from the {@link ng.$rootScope.Scope#$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#$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);

                        //down while you can, then up and next sibling or up and next sibling until back at root
                        do {
                            current = next;
                            event.currentScope = current;
                            forEach(current.$$listeners[name], function(listener) {
                                try {
                                    listener.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 Error($rootScope.$$phase + ' already in progress');
                    }

                    $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 uniqueue we can easily tell it apart from other values
                 */
                function initWatchVal() {}
            }];
    }

    /**
     * !!! This is an undocumented "private" service !!!
     *
     * @name ng.$sniffer
     * @requires $window
     *
     * @property {boolean} history Does the browser support html5 history api ?
     * @property {boolean} hashchange Does the browser support hashchange event ?
     *
     * @description
     * This is very simple implementation of testing browser's features.
     */
    function $SnifferProvider() {
        this.$get = ['$window', function($window) {
            var eventSupport = {},
                android = int((/android (\d+)/.exec(lowercase($window.navigator.userAgent)) || [])[1]);

            return {
                // Android has history.pushState, but it does not update location correctly
                // so let's not use the history API at all.
                // http://code.google.com/p/android/issues/detail?id=17471
                // https://github.com/angular/angular.js/issues/904
                history: !!($window.history && $window.history.pushState && !(android < 4)),
                hashchange: 'onhashchange' in $window &&
                    // IE8 compatible mode lies
                    (!$window.document.documentMode || $window.document.documentMode > 7),
                hasEvent: function(event) {
                    // IE9 implements 'input' event it's so fubared that we rather pretend that it doesn't have
                    // it. In particular the event is not fired when backspace or delete key are pressed or
                    // when cut operation is performed.
                    if (event == 'input' && msie == 9) return false;

                    if (isUndefined(eventSupport[event])) {
                        var divElm = $window.document.createElement('div');
                        eventSupport[event] = 'on' + event in divElm;
                    }

                    return eventSupport[event];
                },
                // TODO(i): currently there is no way to feature detect CSP without triggering alerts
                csp: false
            };
        }];
    }

    /**
     * @ngdoc object
     * @name ng.$window
     *
     * @description
     * A reference to the browser's `window` object. While `window`
     * is globally available in JavaScript, it causes testability problems, because
     * it is a global variable. In angular we always refer to it through the
     * `$window` service, so it may be overriden, removed or mocked for testing.
     *
     * All expressions are evaluated with respect to current scope so they don't
     * suffer from window globality.
     *
     * @example
     <doc:example>
     <doc:source>
     <input ng-init="$window = $service('$window'); greeting='Hello World!'" type="text" ng-model="greeting" />
     <button ng-click="$window.alert(greeting)">ALERT</button>
     </doc:source>
     <doc:scenario>
     </doc:scenario>
     </doc:example>
     */
    function $WindowProvider(){
        this.$get = valueFn(window);
    }

    /**
     * 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/;

        var $config = 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, true);
                }
                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, */*',
                    'X-Requested-With': 'XMLHttpRequest'
                },
                post: {'Content-Type': 'application/json;charset=utf-8'},
                put:  {'Content-Type': 'application/json;charset=utf-8'}
            }
        };

        var providerResponseInterceptors = this.responseInterceptors = [];

        this.$get = ['$httpBackend', '$browser', '$cacheFactory', '$rootScope', '$q', '$injector',
            function($httpBackend, $browser, $cacheFactory, $rootScope, $q, $injector) {

                var defaultCache = $cacheFactory('$http'),
                    responseInterceptors = [];

                forEach(providerResponseInterceptors, function(interceptor) {
                    responseInterceptors.push(
                        isString(interceptor)
                            ? $injector.get(interceptor)
                            : $injector.invoke(interceptor)
                    );
                });


                /**
                 * @ngdoc function
                 * @name ng.$http
                 * @requires $httpBacked
                 * @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 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 patters this doesn't matter much, for advanced usage,
                 * it is important to familiarize yourself with these apis and 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 status
                 *       // code outside of the <200, 400) range
                 *     });
                 * </pre>
                 *
                 * Since the returned value of calling the $http function is a Promise object, 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.
                 *
                 *
                 * # Shortcut methods
                 *
                 * Since all invocation of the $http service require definition of the http method and url and
                 * POST and PUT requests require response body/data to be provided as well, shortcut methods
                 * were created to simplify using the api:
                 *
                 * <pre>
                 *   $http.get('/someUrl').success(successCallback);
                 *   $http.post('/someUrl', data).success(successCallback);
                 * </pre>
                 *
                 * Complete list of shortcut methods:
                 *
                 * - {@link ng.$http#get $http.get}
                 * - {@link ng.$http#head $http.head}
                 * - {@link ng.$http#post $http.post}
                 * - {@link ng.$http#put $http.put}
                 * - {@link ng.$http#delete $http.delete}
                 * - {@link ng.$http#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, * / *`
                 *   - `X-Requested-With: XMLHttpRequest`
                 * - `$httpProvider.defaults.headers.post`: (header defaults for HTTP POST requests)
                 *   - `Content-Type: application/json`
                 * - `$httpProvider.defaults.headers.put` (header defaults for HTTP PUT requests)
                 *   - `Content-Type: application/json`
                 *
                 * To add or overwrite these defaults, simply add or remove a property from this configuration
                 * objects. To add headers for an HTTP method other than POST or PUT, simply add a new object
                 * with name equal to the lower-cased http method name, e.g.
                 * `$httpProvider.defaults.headers.get['My-Header']='value'`.
                 *
                 * Additionally, the defaults can be set at runtime via the `$http.defaults` object in a similar
                 * fassion as described above.
                 *
                 *
                 * # 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 config 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 override these transformation locally, specify transform functions as `transformRequest`
                 * and/or `transformResponse` properties of the config object. To globally override the default
                 * transforms, override the `$httpProvider.defaults.transformRequest` and
                 * `$httpProvider.defaults.transformResponse` properties of the `$httpProvider`.
                 *
                 *
                 * # Caching
                 *
                 * To enable caching set the configuration property `cache` to `true`. When the cache is
                 * enabled, `$http` stores the response from the server in local cache. Next time 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 for the first request.
                 *
                 *
                 * # Response 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 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
                 *       }, 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 web-site to turn your JSON resource URL into
                 * {@link http://en.wikipedia.org/wiki/JSON#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 following mechanism
                 * to counter XSRF. When performing XHR requests, the $http service reads a token from a cookie
                 * called `XSRF-TOKEN` and sets it as the 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.
                 *
                 * To take advantage of this, your server needs to set a token in a JavaScript readable session
                 * cookie called `XSRF-TOKEN` on first HTTP GET request. On subsequent non-GET 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 read the token. The token must be
                 * unique for each user and must be verifiable by the server (to prevent the JavaScript making
                 * up its own tokens). We recommend that the token is a digest of your site's authentication
                 * cookie with {@link http://en.wikipedia.org/wiki/Rainbow_table salt for added security}.
                 *
                 *
                 * @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 representing HTTP headers to send to the server.
                 *    - **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}` – timeout in milliseconds.
                 *    - **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.
                 *
                 * @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(config) {
                    config.method = uppercase(config.method);

                    var reqTransformFn = config.transformRequest || $config.transformRequest,
                        respTransformFn = config.transformResponse || $config.transformResponse,
                        defHeaders = $config.headers,
                        reqHeaders = extend({'X-XSRF-TOKEN': $browser.cookies()['XSRF-TOKEN']},
                            defHeaders.common, defHeaders[lowercase(config.method)], config.headers),
                        reqData = transformData(config.data, headersGetter(reqHeaders), reqTransformFn),
                        promise;

                    // strip content-type if data is undefined
                    if (isUndefined(config.data)) {
                        delete reqHeaders['Content-Type'];
                    }

                    // send request
                    promise = sendReq(config, reqData, reqHeaders);


                    // transform future response
                    promise = promise.then(transformResponse, transformResponse);

                    // apply interceptors
                    forEach(responseInterceptors, function(interceptor) {
                        promise = interceptor(promise);
                    });

                    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, respTransformFn)
                        });
                        return (isSuccess(response.status))
                            ? resp
                            : $q.reject(resp);
                    }
                }

                $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 as well as request and response transformations.
                 *
                 * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
                 */
                $http.defaults = $config;


                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, $config, $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 && config.method == 'GET') {
                        cache = isObject(config.cache) ? config.cache : defaultCache;
                    }

                    if (cache) {
                        cachedResp = cache.get(url);
                        if (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 (!cachedResp) {
                        $httpBackend(config.method, url, reqData, done, reqHeaders, config.timeout,
                            config.withCredentials);
                    }

                    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);
                        $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 || value == undefined) return;
                        if (isObject(value)) {
                            value = toJson(value);
                        }
                        parts.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
                    });
                    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 new Error("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], $window.location.protocol.replace(':', ''));
        }];
    }

    function createHttpBackend($browser, XHR, $browserDefer, callbacks, rawDocument, locationProtocol) {
        // TODO(vojta): fix the signature
        return function(method, url, post, callback, headers, timeout, withCredentials) {
            $browser.$$incOutstandingRequestCount();
            url = url || $browser.url();

            if (lowercase(method) == 'jsonp') {
                var callbackId = '_' + (callbacks.counter++).toString(36);
                callbacks[callbackId] = function(data) {
                    callbacks[callbackId].data = data;
                };

                jsonpReq(url.replace('JSON_CALLBACK', 'angular.callbacks.' + callbackId),
                    function() {
                        if (callbacks[callbackId].data) {
                            completeRequest(callback, 200, callbacks[callbackId].data);
                        } else {
                            completeRequest(callback, -2);
                        }
                        delete callbacks[callbackId];
                    });
            } else {
                var xhr = new XHR();
                xhr.open(method, url, true);
                forEach(headers, function(value, key) {
                    if (value) xhr.setRequestHeader(key, value);
                });

                var status;

                // 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) {
                        completeRequest(
                            callback, status || xhr.status, xhr.responseText, xhr.getAllResponseHeaders());
                    }
                };

                if (withCredentials) {
                    xhr.withCredentials = true;
                }

                xhr.send(post || '');

                if (timeout > 0) {
                    $browserDefer(function() {
                        status = -1;
                        xhr.abort();
                    }, timeout);
                }
            }


            function completeRequest(callback, status, response, headersString) {
                // URL_MATCH is defined in src/service/location.js
                var protocol = (url.match(URL_MATCH) || ['', locationProtocol])[1];

                // fix status code for file protocol (it's always 0)
                status = (protocol == 'file') ? (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() {
                    rawDocument.body.removeChild(script);
                    if (done) done();
                };

            script.type = 'text/javascript';
            script.src = url;

            if (msie) {
                script.onreadystatechange = function() {
                    if (/loaded|complete/.test(script.readyState)) doneWrapper();
                };
            } else {
                script.onload = script.onerror = doneWrapper;
            }

            rawDocument.body.appendChild(script);
        }
    }

    /**
     * @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';
                }
            };
        };
    }

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


                /**
                 * @ngdoc function
                 * @name ng.$timeout
                 * @requires $browser
                 *
                 * @description
                 * Angular's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
                 * block and delegates any exceptions to
                 * {@link ng.$exceptionHandler $exceptionHandler} service.
                 *
                 * The return value of registering a timeout function is a promise which will be resolved when
                 * the timeout is reached and the timeout function is executed.
                 *
                 * To cancel a the timeout request, call `$timeout.cancel(promise)`.
                 *
                 * In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
                 * synchronously flush the queue of deferred functions.
                 *
                 * @param {function()} fn A function, who's execution should be delayed.
                 * @param {number=} [delay=0] Delay in milliseconds.
                 * @param {boolean=} [invokeApply=true] If set to false skips model dirty checking, otherwise
                 *   will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
                 * @returns {*} Promise that will be resolved when the timeout is reached. The value this
                 *   promise will be resolved with is the return value of the `fn` function.
                 */
                function timeout(fn, delay, invokeApply) {
                    var deferred = $q.defer(),
                        promise = deferred.promise,
                        skipApply = (isDefined(invokeApply) && !invokeApply),
                        timeoutId, cleanup;

                    timeoutId = $browser.defer(function() {
                        try {
                            deferred.resolve(fn());
                        } catch(e) {
                            deferred.reject(e);
                            $exceptionHandler(e);
                        }

                        if (!skipApply) $rootScope.$apply();
                    }, delay);

                    cleanup = function() {
                        delete deferreds[promise.$$timeoutId];
                    };

                    promise.$$timeoutId = timeoutId;
                    deferreds[timeoutId] = deferred;
                    promise.then(cleanup, cleanup);

                    return promise;
                }


                /**
                 * @ngdoc function
                 * @name ng.$timeout#cancel
                 * @methodOf ng.$timeout
                 *
                 * @description
                 * Cancels a task associated with the `promise`. As a result of this the promise will be
                 * resolved with a rejection.
                 *
                 * @param {Promise=} promise Promise returned by the `$timeout` function.
                 * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
                 *   canceled.
                 */
                timeout.cancel = function(promise) {
                    if (promise && promise.$$timeoutId in deferreds) {
                        deferreds[promise.$$timeoutId].reject('canceled');
                        return $browser.defer.cancel(promise.$$timeoutId);
                    }
                    return false;
                };

                return timeout;
            }];
    }

    /**
     * @ngdoc object
     * @name ng.$filterProvider
     * @description
     *
     * Filters are just functions which transform input to an output. However filters need to be Dependency Injected. To
     * achieve this a filter definition consists of a factory function which is annotated with dependencies and is
     * responsible for creating a the filter function.
     *
     * <pre>
     *   // Filter registration
     *   function MyModule($provide, $filterProvider) {
     *     // create a service to demonstrate injection (not always needed)
     *     $provide.value('greet', function(name){
     *       return 'Hello ' + name + '!';
     *     });
     *
     *     // register a filter factory which uses the
     *     // greet service to demonstrate DI.
     *     $filterProvider.register('greet', function(greet){
     *       // return the filter function which uses the greet service
     *       // to generate salutation
     *       return function(text) {
     *         // filters need to be forgiving so check input validity
     *         return text && greet(text) || text;
     *       };
     *     });
     *   }
     * </pre>
     *
     * The filter function is registered with the `$injector` under the filter name suffixe with `Filter`.
     * <pre>
     *   it('should be the same instance', inject(
     *     function($filterProvider) {
     *       $filterProvider.register('reverse', function(){
     *         return ...;
     *       });
     *     },
     *     function($filter, reverseFilter) {
     *       expect($filter('reverse')).toBe(reverseFilter);
     *     });
     * </pre>
     *
     *
     * For more information about how angular filters work, and how to create your own filters, see
     * {@link guide/dev_guide.templates.filters Understanding Angular Filters} in the angular Developer
     * Guide.
     */
    /**
     * @ngdoc method
     * @name ng.$filterProvider#register
     * @methodOf ng.$filterProvider
     * @description
     * Register filter factory function.
     *
     * @param {String} name Name of the filter.
     * @param {function} fn The filter factory function which is injectable.
     */


    /**
     * @ngdoc function
     * @name ng.$filter
     * @function
     * @description
     * Filters are used for formatting data displayed to the user.
     *
     * The general syntax in templates is as follows:
     *
     *         {{ expression | [ filter_name ] }}
     *
     * @param {String} name Name of the filter function to retrieve
     * @return {Function} the filter function
     */
    $FilterProvider.$inject = ['$provide'];
    function $FilterProvider($provide) {
        var suffix = 'Filter';

        function register(name, factory) {
            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);
    }

    /**
     * @ngdoc filter
     * @name ng.filter:filter
     * @function
     *
     * @description
     * Selects a subset of items from `array` and returns it as a new array.
     *
     * Note: This function is used to augment the `Array` type in Angular expressions. See
     * {@link ng.$filter} for more information about Angular arrays.
     *
     * @param {Array} array The source array.
     * @param {string|Object|function()} expression The predicate to be used for selecting items from
     *   `array`.
     *
     *   Can be one of:
     *
     *   - `string`: Predicate that results in a substring match using the value of `expression`
     *     string. All strings or objects with string properties in `array` that contain this string
     *     will be returned. The predicate can be negated by prefixing the string with `!`.
     *
     *   - `Object`: A pattern object can be used to filter specific properties on objects contained
     *     by `array`. For example `{name:"M", phone:"1"}` predicate will return an array of items
     *     which have property `name` containing "M" and property `phone` containing "1". A special
     *     property name `$` can be used (as in `{$:"text"}`) to accept a match against any
     *     property of the object. That's equivalent to the simple substring match with a `string`
     *     as described above.
     *
     *   - `function`: A predicate function can be used to write arbitrary filters. The function is
     *     called for each element of `array`. The final result is an array of those elements that
     *     the predicate returned true for.
     *
     * @example
     <doc:example>
     <doc:source>
     <div ng-init="friends = [{name:'John', phone:'555-1276'},
     {name:'Mary', phone:'800-BIG-MARY'},
     {name:'Mike', phone:'555-4321'},
     {name:'Adam', phone:'555-5678'},
     {name:'Julie', phone:'555-8765'}]"></div>

     Search: <input ng-model="searchText">
     <table id="searchTextResults">
     <tr><th>Name</th><th>Phone</th><tr>
     <tr ng-repeat="friend in friends | filter:searchText">
     <td>{{friend.name}}</td>
     <td>{{friend.phone}}</td>
     <tr>
     </table>
     <hr>
     Any: <input ng-model="search.$"> <br>
     Name only <input ng-model="search.name"><br>
     Phone only <input ng-model="search.phone"å><br>
     <table id="searchObjResults">
     <tr><th>Name</th><th>Phone</th><tr>
     <tr ng-repeat="friend in friends | filter:search">
     <td>{{friend.name}}</td>
     <td>{{friend.phone}}</td>
     <tr>
     </table>
     </doc:source>
     <doc:scenario>
     it('should search across all fields when filtering with a string', function() {
     input('searchText').enter('m');
     expect(repeater('#searchTextResults tr', 'friend in friends').column('friend.name')).
     toEqual(['Mary', 'Mike', 'Adam']);

     input('searchText').enter('76');
     expect(repeater('#searchTextResults tr', 'friend in friends').column('friend.name')).
     toEqual(['John', 'Julie']);
     });

     it('should search in specific fields when filtering with a predicate object', function() {
     input('search.$').enter('i');
     expect(repeater('#searchObjResults tr', 'friend in friends').column('friend.name')).
     toEqual(['Mary', 'Mike', 'Julie']);
     });
     </doc:scenario>
     </doc:example>
     */
    function filterFilter() {
        return function(array, expression) {
            if (!(array instanceof Array)) return array;
            var predicates = [];
            predicates.check = function(value) {
                for (var j = 0; j < predicates.length; j++) {
                    if(!predicates[j](value)) {
                        return false;
                    }
                }
                return true;
            };
            var search = function(obj, text){
                if (text.charAt(0) === '!') {
                    return !search(obj, text.substr(1));
                }
                switch (typeof obj) {
                    case "boolean":
                    case "number":
                    case "string":
                        return ('' + obj).toLowerCase().indexOf(text) > -1;
                    case "object":
                        for ( var objKey in obj) {
                            if (objKey.charAt(0) !== '$' && search(obj[objKey], text)) {
                                return true;
                            }
                        }
                        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() {
                                var text = (''+expression[key]).toLowerCase();
                                if (!text) return;
                                predicates.push(function(value) {
                                    return search(value, text);
                                });
                            })();
                        } else {
                            (function() {
                                var path = key;
                                var text = (''+expression[key]).toLowerCase();
                                if (!text) return;
                                predicates.push(function(value) {
                                    return search(getter(value, path), text);
                                });
                            })();
                        }
                    }
                    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;
        }
    }

    /**
     * @ngdoc filter
     * @name ng.filter:currency
     * @function
     *
     * @description
     * Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default
     * symbol for current locale is used.
     *
     * @param {number} amount Input to filter.
     * @param {string=} symbol Currency symbol or identifier to be displayed.
     * @returns {string} Formatted number.
     *
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.amount = 1234.56;
     }
     </script>
     <div ng-controller="Ctrl">
     <input type="number" ng-model="amount"> <br>
     default currency symbol ($): {{amount | currency}}<br>
     custom currency identifier (USD$): {{amount | currency:"USD$"}}
     </div>
     </doc:source>
     <doc:scenario>
     it('should init with 1234.56', function() {
     expect(binding('amount | currency')).toBe('$1,234.56');
     expect(binding('amount | currency:"USD$"')).toBe('USD$1,234.56');
     });
     it('should update', function() {
     input('amount').enter('-1234');
     expect(binding('amount | currency')).toBe('($1,234.00)');
     expect(binding('amount | currency:"USD$"')).toBe('(USD$1,234.00)');
     });
     </doc:scenario>
     </doc:example>
     */
    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);
        };
    }

    /**
     * @ngdoc filter
     * @name ng.filter:number
     * @function
     *
     * @description
     * Formats a number as text.
     *
     * If the input is not a number an empty string is returned.
     *
     * @param {number|string} number Number to format.
     * @param {(number|string)=} [fractionSize=2] Number of decimal places to round the number to.
     * @returns {string} Number rounded to decimalPlaces and places a “,” after each third digit.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.val = 1234.56789;
     }
     </script>
     <div ng-controller="Ctrl">
     Enter number: <input ng-model='val'><br>
     Default formatting: {{val | number}}<br>
     No fractions: {{val | number:0}}<br>
     Negative number: {{-val | number:4}}
     </div>
     </doc:source>
     <doc:scenario>
     it('should format numbers', function() {
     expect(binding('val | number')).toBe('1,234.568');
     expect(binding('val | number:0')).toBe('1,235');
     expect(binding('-val | number:4')).toBe('-1,234.5679');
     });

     it('should update', function() {
     input('val').enter('3374.333');
     expect(binding('val | number')).toBe('3,374.333');
     expect(binding('val | number:0')).toBe('3,374');
     expect(binding('-val | number:4')).toBe('-3,374.3330');
     });
     </doc:scenario>
     </doc:example>
     */


    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 = [];

        if (numStr.indexOf('e') !== -1) {
            formatedText = numStr;
        } else {
            var fractionLen = (numStr.split(DECIMAL_SEP)[1] || '').length;

            // determine fractionSize if it is not specified
            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 pos = 0,
                lgroup = pattern.lgSize,
                group = pattern.gSize;

            if (whole.length >= (lgroup + group)) {
                pos = whole.length - lgroup;
                for (var 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);
            }

            // format fraction part.
            while(fraction.length < fractionSize) {
                fraction += '0';
            }

            if (fractionSize) formatedText += decimalSep + fraction.substr(0, 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) {
        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 offset = date.getTimezoneOffset();
        return padNumber(offset / 60, 2) + padNumber(Math.abs(offset % 60), 2);
    }

    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),
        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+$/;

    /**
     * @ngdoc filter
     * @name ng.filter:date
     * @function
     *
     * @description
     *   Formats `date` to a string based on the requested `format`.
     *
     *   `format` string can be composed of the following elements:
     *
     *   * `'yyyy'`: 4 digit representation of year (e.g. AD 1 => 0001, AD 2010 => 2010)
     *   * `'yy'`: 2 digit representation of year, padded (00-99). (e.g. AD 2001 => 01, AD 2010 => 10)
     *   * `'y'`: 1 digit representation of year, e.g. (AD 1 => 1, AD 199 => 199)
     *   * `'MMMM'`: Month in year (January-December)
     *   * `'MMM'`: Month in year (Jan-Dec)
     *   * `'MM'`: Month in year, padded (01-12)
     *   * `'M'`: Month in year (1-12)
     *   * `'dd'`: Day in month, padded (01-31)
     *   * `'d'`: Day in month (1-31)
     *   * `'EEEE'`: Day in Week,(Sunday-Saturday)
     *   * `'EEE'`: Day in Week, (Sun-Sat)
     *   * `'HH'`: Hour in day, padded (00-23)
     *   * `'H'`: Hour in day (0-23)
     *   * `'hh'`: Hour in am/pm, padded (01-12)
     *   * `'h'`: Hour in am/pm, (1-12)
     *   * `'mm'`: Minute in hour, padded (00-59)
     *   * `'m'`: Minute in hour (0-59)
     *   * `'ss'`: Second in minute, padded (00-59)
     *   * `'s'`: Second in minute (0-59)
     *   * `'a'`: am/pm marker
     *   * `'Z'`: 4 digit (+sign) representation of the timezone offset (-1200-1200)
     *
     *   `format` string can also be one of the following predefined
     *   {@link guide/i18n localizable formats}:
     *
     *   * `'medium'`: equivalent to `'MMM d, y h:mm:ss a'` for en_US locale
     *     (e.g. Sep 3, 2010 12:05:08 pm)
     *   * `'short'`: equivalent to `'M/d/yy h:mm a'` for en_US  locale (e.g. 9/3/10 12:05 pm)
     *   * `'fullDate'`: equivalent to `'EEEE, MMMM d,y'` for en_US  locale
     *     (e.g. Friday, September 3, 2010)
     *   * `'longDate'`: equivalent to `'MMMM d, y'` for en_US  locale (e.g. September 3, 2010
     *   * `'mediumDate'`: equivalent to `'MMM d, y'` for en_US  locale (e.g. Sep 3, 2010)
     *   * `'shortDate'`: equivalent to `'M/d/yy'` for en_US locale (e.g. 9/3/10)
     *   * `'mediumTime'`: equivalent to `'h:mm:ss a'` for en_US locale (e.g. 12:05:08 pm)
     *   * `'shortTime'`: equivalent to `'h:mm a'` for en_US locale (e.g. 12:05 pm)
     *
     *   `format` string can contain literal values. These need to be quoted with single quotes (e.g.
     *   `"h 'in the morning'"`). In order to output single quote, use two single quotes in a sequence
     *   (e.g. `"h o''clock"`).
     *
     * @param {(Date|number|string)} date Date to format either as Date object, milliseconds (string or
     *    number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.SSSZ and it's
     *    shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ).
     * @param {string=} format Formatting rules (see Description). If not specified,
     *    `mediumDate` is used.
     * @returns {string} Formatted string or the input if input is not recognized as date/millis.
     *
     * @example
     <doc:example>
     <doc:source>
     <span ng-non-bindable>{{1288323623006 | date:'medium'}}</span>:
     {{1288323623006 | date:'medium'}}<br>
     <span ng-non-bindable>{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}</span>:
     {{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}<br>
     <span ng-non-bindable>{{1288323623006 | date:'MM/dd/yyyy @ h:mma'}}</span>:
     {{'1288323623006' | date:'MM/dd/yyyy @ h:mma'}}<br>
     </doc:source>
     <doc:scenario>
     it('should format date', function() {
     expect(binding("1288323623006 | date:'medium'")).
     toMatch(/Oct 2\d, 2010 \d{1,2}:\d{2}:\d{2} (AM|PM)/);
     expect(binding("1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'")).
     toMatch(/2010\-10\-2\d \d{2}:\d{2}:\d{2} \-?\d{4}/);
     expect(binding("'1288323623006' | date:'MM/dd/yyyy @ h:mma'")).
     toMatch(/10\/2\d\/2010 @ \d{1,2}:\d{2}(AM|PM)/);
     });
     </doc:scenario>
     </doc:example>
     */
    dateFilter.$inject = ['$locale'];
    function dateFilter($locale) {


        var R_ISO8601_STR = /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d{3}))?)?)?(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;
                if (match[9]) {
                    tzHour = int(match[9] + match[10]);
                    tzMin = int(match[9] + match[11]);
                }
                date.setUTCFullYear(int(match[1]), int(match[2]) - 1, int(match[3]));
                date.setUTCHours(int(match[4]||0) - tzHour, int(match[5]||0) - tzMin, int(match[6]||0), int(match[7]||0));
                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;
        };
    }


    /**
     * @ngdoc filter
     * @name ng.filter:json
     * @function
     *
     * @description
     *   Allows you to convert a JavaScript object into JSON string.
     *
     *   This filter is mostly useful for debugging. When using the double curly {{value}} notation
     *   the binding is automatically converted to JSON.
     *
     * @param {*} object Any JavaScript object (including arrays and primitive types) to filter.
     * @returns {string} JSON string.
     *
     *
     * @example:
     <doc:example>
     <doc:source>
     <pre>{{ {'name':'value'} | json }}</pre>
     </doc:source>
     <doc:scenario>
     it('should jsonify filtered objects', function() {
     expect(binding("{'name':'value'}")).toMatch(/\{\n  "name": ?"value"\n}/);
     });
     </doc:scenario>
     </doc:example>
     *
     */
    function jsonFilter() {
        return function(object) {
            return toJson(object, true);
        };
    }


    /**
     * @ngdoc filter
     * @name ng.filter:lowercase
     * @function
     * @description
     * Converts string to lowercase.
     * @see angular.lowercase
     */
    var lowercaseFilter = valueFn(lowercase);


    /**
     * @ngdoc filter
     * @name ng.filter:uppercase
     * @function
     * @description
     * Converts string to uppercase.
     * @see angular.uppercase
     */
    var uppercaseFilter = valueFn(uppercase);

    /**
     * @ngdoc function
     * @name ng.filter:limitTo
     * @function
     *
     * @description
     * Creates a new array containing only a specified number of elements in an array. The elements
     * are taken from either the beginning or the end of the source array, as specified by the
     * value and sign (positive or negative) of `limit`.
     *
     * Note: This function is used to augment the `Array` type in Angular expressions. See
     * {@link ng.$filter} for more information about Angular arrays.
     *
     * @param {Array} array Source array to be limited.
     * @param {string|Number} limit The length of the returned array. If the `limit` number is
     *     positive, `limit` number of items from the beginning of the source array are copied.
     *     If the number is negative, `limit` number  of items from the end of the source array are
     *     copied. The `limit` will be trimmed if it exceeds `array.length`
     * @returns {Array} A new sub-array of length `limit` or less if input array had less than `limit`
     *     elements.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.numbers = [1,2,3,4,5,6,7,8,9];
     $scope.limit = 3;
     }
     </script>
     <div ng-controller="Ctrl">
     Limit {{numbers}} to: <input type="integer" ng-model="limit">
     <p>Output: {{ numbers | limitTo:limit }}</p>
     </div>
     </doc:source>
     <doc:scenario>
     it('should limit the numer array to first three items', function() {
     expect(element('.doc-example-live input[ng-model=limit]').val()).toBe('3');
     expect(binding('numbers | limitTo:limit')).toEqual('[1,2,3]');
     });

     it('should update the output when -3 is entered', function() {
     input('limit').enter(-3);
     expect(binding('numbers | limitTo:limit')).toEqual('[7,8,9]');
     });

     it('should not exceed the maximum size of input array', function() {
     input('limit').enter(100);
     expect(binding('numbers | limitTo:limit')).toEqual('[1,2,3,4,5,6,7,8,9]');
     });
     </doc:scenario>
     </doc:example>
     */
    function limitToFilter(){
        return function(array, limit) {
            if (!(array instanceof Array)) return array;
            limit = int(limit);
            var out = [],
                i, n;

            // check that array is iterable
            if (!array || !(array instanceof Array))
                return out;

            // if abs(limit) exceeds maximum length, trim it
            if (limit > array.length)
                limit = array.length;
            else if (limit < -array.length)
                limit = -array.length;

            if (limit > 0) {
                i = 0;
                n = limit;
            } else {
                i = array.length + limit;
                n = array.length;
            }

            for (; i<n; i++) {
                out.push(array[i]);
            }

            return out;
        }
    }

    /**
     * @ngdoc function
     * @name ng.filter:orderBy
     * @function
     *
     * @description
     * Orders a specified `array` by the `expression` predicate.
     *
     * Note: this function is used to augment the `Array` type in Angular expressions. See
     * {@link ng.$filter} for more informaton about Angular arrays.
     *
     * @param {Array} array The array to sort.
     * @param {function(*)|string|Array.<(function(*)|string)>} expression A predicate to be
     *    used by the comparator to determine the order of elements.
     *
     *    Can be one of:
     *
     *    - `function`: Getter function. The result of this function will be sorted using the
     *      `<`, `=`, `>` operator.
     *    - `string`: An Angular expression which evaluates to an object to order by, such as 'name'
     *      to sort by a property called 'name'. Optionally prefixed with `+` or `-` to control
     *      ascending or descending sort order (for example, +name or -name).
     *    - `Array`: An array of function or string predicates. The first predicate in the array
     *      is used for sorting, but when two items are equivalent, the next predicate is used.
     *
     * @param {boolean=} reverse Reverse the order the array.
     * @returns {Array} Sorted copy of the source array.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.friends =
     [{name:'John', phone:'555-1212', age:10},
     {name:'Mary', phone:'555-9876', age:19},
     {name:'Mike', phone:'555-4321', age:21},
     {name:'Adam', phone:'555-5678', age:35},
     {name:'Julie', phone:'555-8765', age:29}]
     $scope.predicate = '-age';
     }
     </script>
     <div ng-controller="Ctrl">
     <pre>Sorting predicate = {{predicate}}; reverse = {{reverse}}</pre>
     <hr/>
     [ <a href="" ng-click="predicate=''">unsorted</a> ]
     <table class="friend">
     <tr>
     <th><a href="" ng-click="predicate = 'name'; reverse=false">Name</a>
     (<a href ng-click="predicate = '-name'; reverse=false">^</a>)</th>
     <th><a href="" ng-click="predicate = 'phone'; reverse=!reverse">Phone Number</a></th>
     <th><a href="" ng-click="predicate = 'age'; reverse=!reverse">Age</a></th>
     <tr>
     <tr ng-repeat="friend in friends | orderBy:predicate:reverse">
     <td>{{friend.name}}</td>
     <td>{{friend.phone}}</td>
     <td>{{friend.age}}</td>
     <tr>
     </table>
     </div>
     </doc:source>
     <doc:scenario>
     it('should be reverse ordered by aged', function() {
     expect(binding('predicate')).toBe('-age');
     expect(repeater('table.friend', 'friend in friends').column('friend.age')).
     toEqual(['35', '29', '21', '19', '10']);
     expect(repeater('table.friend', 'friend in friends').column('friend.name')).
     toEqual(['Adam', 'Julie', 'Mike', 'Mary', 'John']);
     });

     it('should reorder the table when user selects different predicate', function() {
     element('.doc-example-live a:contains("Name")').click();
     expect(repeater('table.friend', 'friend in friends').column('friend.name')).
     toEqual(['Adam', 'John', 'Julie', 'Mary', 'Mike']);
     expect(repeater('table.friend', 'friend in friends').column('friend.age')).
     toEqual(['35', '10', '29', '19', '21']);

     element('.doc-example-live a:contains("Phone")').click();
     expect(repeater('table.friend', 'friend in friends').column('friend.phone')).
     toEqual(['555-9876', '555-8765', '555-5678', '555-4321', '555-1212']);
     expect(repeater('table.friend', 'friend in friends').column('friend.name')).
     toEqual(['Mary', 'Julie', 'Adam', 'Mike', 'John']);
     });
     </doc:scenario>
     </doc:example>
     */
    orderByFilter.$inject = ['$parse'];
    function orderByFilter($parse){
        return function(array, sortPredicate, reverseOrder) {
            if (!(array instanceof 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();
                    if (t1 == "string") 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);
    }

    /**
     * @ngdoc directive
     * @name ng.directive:a
     * @restrict E
     *
     * @description
     * Modifies the default behavior of html A tag, so that the default action is prevented when href
     * attribute is empty.
     *
     * The reasoning for this change is to allow easy creation of action links with `ngClick` directive
     * without changing the location or causing page reloads, e.g.:
     * <a href="" ng-click="model.$save()">Save</a>
     */
    var htmlAnchorDirective = valueFn({
        restrict: 'E',
        compile: function(element, attr) {
            // turn <a href ng-click="..">link</a> into a link in IE
            // but only if it doesn't have name attribute, in which case it's an anchor
            if (!attr.href) {
                attr.$set('href', '');
            }

            return function(scope, element) {
                element.bind('click', function(event){
                    // if we have no href url, then don't navigate anywhere.
                    if (!element.attr('href')) {
                        event.preventDefault();
                    }
                });
            }
        }
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngHref
     * @restrict A
     *
     * @description
     * Using Angular markup like {{hash}} in an href attribute makes
     * the page open to a wrong URL, if the user clicks that link before
     * angular has a chance to replace the {{hash}} with actual URL, the
     * link will be broken and will most likely return a 404 error.
     * The `ngHref` directive solves this problem.
     *
     * The buggy way to write it:
     * <pre>
     * <a href="http://www.gravatar.com/avatar/{{hash}}"/>
     * </pre>
     *
     * The correct way to write it:
     * <pre>
     * <a ng-href="http://www.gravatar.com/avatar/{{hash}}"/>
     * </pre>
     *
     * @element A
     * @param {template} ngHref any string which can contain `{{}}` markup.
     *
     * @example
     * This example uses `link` variable inside `href` attribute:
     <doc:example>
     <doc:source>
     <input ng-model="value" /><br />
     <a id="link-1" href ng-click="value = 1">link 1</a> (link, don't reload)<br />
     <a id="link-2" href="" ng-click="value = 2">link 2</a> (link, don't reload)<br />
     <a id="link-3" ng-href="/{{'123'}}">link 3</a> (link, reload!)<br />
     <a id="link-4" href="" name="xx" ng-click="value = 4">anchor</a> (link, don't reload)<br />
     <a id="link-5" name="xxx" ng-click="value = 5">anchor</a> (no link)<br />
     <a id="link-6" ng-href="{{value}}">link</a> (link, change location)
     </doc:source>
     <doc:scenario>
     it('should execute ng-click but not reload when href without value', function() {
     element('#link-1').click();
     expect(input('value').val()).toEqual('1');
     expect(element('#link-1').attr('href')).toBe("");
     });

     it('should execute ng-click but not reload when href empty string', function() {
     element('#link-2').click();
     expect(input('value').val()).toEqual('2');
     expect(element('#link-2').attr('href')).toBe("");
     });

     it('should execute ng-click and change url when ng-href specified', function() {
     expect(element('#link-3').attr('href')).toBe("/123");

     element('#link-3').click();
     expect(browser().window().path()).toEqual('/123');
     });

     it('should execute ng-click but not reload when href empty string and name specified', function() {
     element('#link-4').click();
     expect(input('value').val()).toEqual('4');
     expect(element('#link-4').attr('href')).toBe('');
     });

     it('should execute ng-click but not reload when no href but name specified', function() {
     element('#link-5').click();
     expect(input('value').val()).toEqual('5');
     expect(element('#link-5').attr('href')).toBe('');
     });

     it('should only change url when only ng-href', function() {
     input('value').enter('6');
     expect(element('#link-6').attr('href')).toBe('6');

     element('#link-6').click();
     expect(browser().location().url()).toEqual('/6');
     });
     </doc:scenario>
     </doc:example>
     */

    /**
     * @ngdoc directive
     * @name ng.directive:ngSrc
     * @restrict A
     *
     * @description
     * Using Angular markup like `{{hash}}` in a `src` attribute doesn't
     * work right: The browser will fetch from the URL with the literal
     * text `{{hash}}` until Angular replaces the expression inside
     * `{{hash}}`. The `ngSrc` directive solves this problem.
     *
     * The buggy way to write it:
     * <pre>
     * <img src="http://www.gravatar.com/avatar/{{hash}}"/>
     * </pre>
     *
     * The correct way to write it:
     * <pre>
     * <img ng-src="http://www.gravatar.com/avatar/{{hash}}"/>
     * </pre>
     *
     * @element IMG
     * @param {template} ngSrc any string which can contain `{{}}` markup.
     */

    /**
     * @ngdoc directive
     * @name ng.directive:ngDisabled
     * @restrict A
     *
     * @description
     *
     * The following markup will make the button enabled on Chrome/Firefox but not on IE8 and older IEs:
     * <pre>
     * <div ng-init="scope = { isDisabled: false }">
     *  <button disabled="{{scope.isDisabled}}">Disabled</button>
     * </div>
     * </pre>
     *
     * The HTML specs do not require browsers to preserve the special attributes such as disabled.
     * (The presence of them means true and absence means false)
     * This prevents the angular compiler from correctly retrieving the binding expression.
     * To solve this problem, we introduce the `ngDisabled` directive.
     *
     * @example
     <doc:example>
     <doc:source>
     Click me to toggle: <input type="checkbox" ng-model="checked"><br/>
     <button ng-model="button" ng-disabled="checked">Button</button>
     </doc:source>
     <doc:scenario>
     it('should toggle button', function() {
     expect(element('.doc-example-live :button').prop('disabled')).toBeFalsy();
     input('checked').check();
     expect(element('.doc-example-live :button').prop('disabled')).toBeTruthy();
     });
     </doc:scenario>
     </doc:example>
     *
     * @element INPUT
     * @param {expression} ngDisabled Angular expression that will be evaluated.
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngChecked
     * @restrict A
     *
     * @description
     * The HTML specs do not require browsers to preserve the special attributes such as checked.
     * (The presence of them means true and absence means false)
     * This prevents the angular compiler from correctly retrieving the binding expression.
     * To solve this problem, we introduce the `ngChecked` directive.
     * @example
     <doc:example>
     <doc:source>
     Check me to check both: <input type="checkbox" ng-model="master"><br/>
     <input id="checkSlave" type="checkbox" ng-checked="master">
     </doc:source>
     <doc:scenario>
     it('should check both checkBoxes', function() {
     expect(element('.doc-example-live #checkSlave').prop('checked')).toBeFalsy();
     input('master').check();
     expect(element('.doc-example-live #checkSlave').prop('checked')).toBeTruthy();
     });
     </doc:scenario>
     </doc:example>
     *
     * @element INPUT
     * @param {expression} ngChecked Angular expression that will be evaluated.
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngMultiple
     * @restrict A
     *
     * @description
     * The HTML specs do not require browsers to preserve the special attributes such as multiple.
     * (The presence of them means true and absence means false)
     * This prevents the angular compiler from correctly retrieving the binding expression.
     * To solve this problem, we introduce the `ngMultiple` directive.
     *
     * @example
     <doc:example>
     <doc:source>
     Check me check multiple: <input type="checkbox" ng-model="checked"><br/>
     <select id="select" ng-multiple="checked">
     <option>Misko</option>
     <option>Igor</option>
     <option>Vojta</option>
     <option>Di</option>
     </select>
     </doc:source>
     <doc:scenario>
     it('should toggle multiple', function() {
     expect(element('.doc-example-live #select').prop('multiple')).toBeFalsy();
     input('checked').check();
     expect(element('.doc-example-live #select').prop('multiple')).toBeTruthy();
     });
     </doc:scenario>
     </doc:example>
     *
     * @element SELECT
     * @param {expression} ngMultiple Angular expression that will be evaluated.
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngReadonly
     * @restrict A
     *
     * @description
     * The HTML specs do not require browsers to preserve the special attributes such as readonly.
     * (The presence of them means true and absence means false)
     * This prevents the angular compiler from correctly retrieving the binding expression.
     * To solve this problem, we introduce the `ngReadonly` directive.
     * @example
     <doc:example>
     <doc:source>
     Check me to make text readonly: <input type="checkbox" ng-model="checked"><br/>
     <input type="text" ng-readonly="checked" value="I'm Angular"/>
     </doc:source>
     <doc:scenario>
     it('should toggle readonly attr', function() {
     expect(element('.doc-example-live :text').prop('readonly')).toBeFalsy();
     input('checked').check();
     expect(element('.doc-example-live :text').prop('readonly')).toBeTruthy();
     });
     </doc:scenario>
     </doc:example>
     *
     * @element INPUT
     * @param {string} expression Angular expression that will be evaluated.
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngSelected
     * @restrict A
     *
     * @description
     * The HTML specs do not require browsers to preserve the special attributes such as selected.
     * (The presence of them means true and absence means false)
     * This prevents the angular compiler from correctly retrieving the binding expression.
     * To solve this problem, we introduced the `ngSelected` directive.
     * @example
     <doc:example>
     <doc:source>
     Check me to select: <input type="checkbox" ng-model="selected"><br/>
     <select>
     <option>Hello!</option>
     <option id="greet" ng-selected="selected">Greetings!</option>
     </select>
     </doc:source>
     <doc:scenario>
     it('should select Greetings!', function() {
     expect(element('.doc-example-live #greet').prop('selected')).toBeFalsy();
     input('selected').check();
     expect(element('.doc-example-live #greet').prop('selected')).toBeTruthy();
     });
     </doc:scenario>
     </doc:example>
     *
     * @element OPTION
     * @param {string} expression Angular expression that will be evaluated.
     */


    var ngAttributeAliasDirectives = {};


// boolean attrs are evaluated
    forEach(BOOLEAN_ATTR, function(propName, attrName) {
        var normalized = directiveNormalize('ng-' + attrName);
        ngAttributeAliasDirectives[normalized] = function() {
            return {
                priority: 100,
                compile: function() {
                    return function(scope, element, attr) {
                        scope.$watch(attr[normalized], function(value) {
                            attr.$set(attrName, !!value);
                        });
                    };
                }
            };
        };
    });


// ng-src, ng-href are interpolated
    forEach(['src', 'href'], function(attrName) {
        var normalized = directiveNormalize('ng-' + attrName);
        ngAttributeAliasDirectives[normalized] = function() {
            return {
                priority: 99, // it needs to run after the attributes are interpolated
                link: function(scope, element, attr) {
                    attr.$observe(normalized, function(value) {
                        attr.$set(attrName, value);

                        // on IE, if "ng:src" directive declaration is used and "src" attribute doesn't exist
                        // then calling element.setAttribute('src', 'foo') doesn't do anything, so we need
                        // to set the property as well to achieve the desired effect
                        if (msie) element.prop(attrName, value);
                    });
                }
            };
        };
    });

    var nullFormCtrl = {
        $addControl: noop,
        $removeControl: noop,
        $setValidity: noop,
        $setDirty: noop
    };

    /**
     * @ngdoc object
     * @name ng.directive:form.FormController
     *
     * @property {boolean} $pristine True if user has not interacted with the form yet.
     * @property {boolean} $dirty True if user has already interacted with the form.
     * @property {boolean} $valid True if all of the containg forms and controls are valid.
     * @property {boolean} $invalid True if at least one containing control or form is invalid.
     *
     * @property {Object} $error Is an object hash, containing references to all invalid controls or
     *  forms, where:
     *
     *  - keys are validation tokens (error names) — such as `REQUIRED`, `URL` or `EMAIL`),
     *  - values are arrays of controls or forms that are invalid with given error.
     *
     * @description
     * `FormController` keeps track of all its controls and nested forms as well as state of them,
     * such as being valid/invalid or dirty/pristine.
     *
     * Each {@link ng.directive:form form} directive creates an instance
     * of `FormController`.
     *
     */
//asks for $scope to fool the BC controller module
    FormController.$inject = ['$element', '$attrs', '$scope'];
    function FormController(element, attrs) {
        var form = this,
            parentForm = element.parent().controller('form') || nullFormCtrl,
            invalidCount = 0, // used to easily determine if we are valid
            errors = form.$error = {};

        // init state
        form.$name = attrs.name;
        form.$dirty = false;
        form.$pristine = true;
        form.$valid = true;
        form.$invalid = false;

        parentForm.$addControl(form);

        // Setup initial state of the control
        element.addClass(PRISTINE_CLASS);
        toggleValidCss(true);

        // convenience method for easy toggling of classes
        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) {
            if (control.$name && !form.hasOwnProperty(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);
            });
        };

        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;
        };

    }


    /**
     * @ngdoc directive
     * @name ng.directive:ngForm
     * @restrict EAC
     *
     * @description
     * Nestable alias of {@link ng.directive:form `form`} directive. HTML
     * does not allow nesting of form elements. It is useful to nest forms, for example if the validity of a
     * sub-group of controls needs to be determined.
     *
     * @param {string=} ngForm|name Name of the form. If specified, the form controller will be published into
     *                       related scope, under this name.
     *
     */

    /**
     * @ngdoc directive
     * @name ng.directive:form
     * @restrict E
     *
     * @description
     * Directive that instantiates
     * {@link ng.directive:form.FormController FormController}.
     *
     * If `name` attribute is specified, the form controller is published onto the current scope under
     * this name.
     *
     * # Alias: {@link ng.directive:ngForm `ngForm`}
     *
     * In angular forms can be nested. This means that the outer form is valid when all of the child
     * forms are valid as well. However browsers do not allow nesting of `<form>` elements, for this
     * reason angular provides {@link ng.directive:ngForm `ngForm`} alias
     * which behaves identical to `<form>` but allows form nesting.
     *
     *
     * # CSS classes
     *  - `ng-valid` Is set if the form is valid.
     *  - `ng-invalid` Is set if the form is invalid.
     *  - `ng-pristine` Is set if the form is pristine.
     *  - `ng-dirty` Is set if the form is dirty.
     *
     *
     * # Submitting a form and preventing default action
     *
     * Since the role of forms in client-side Angular applications is different than in classical
     * roundtrip apps, it is desirable for the browser not to translate the form submission into a full
     * page reload that sends the data to the server. Instead some javascript logic should be triggered
     * to handle the form submission in application specific way.
     *
     * For this reason, Angular prevents the default action (form submission to the server) unless the
     * `<form>` element has an `action` attribute specified.
     *
     * You can use one of the following two ways to specify what javascript method should be called when
     * a form is submitted:
     *
     * - {@link ng.directive:ngSubmit ngSubmit} directive on the form element
     * - {@link ng.directive:ngClick ngClick} directive on the first
     *  button or input field of type submit (input[type=submit])
     *
     * To prevent double execution of the handler, use only one of ngSubmit or ngClick directives. This
     * is because of the following form submission rules coming from the html spec:
     *
     * - If a form has only one input field then hitting enter in this field triggers form submit
     * (`ngSubmit`)
     * - if a form has has 2+ input fields and no buttons or input[type=submit] then hitting enter
     * doesn't trigger submit
     * - if a form has one or more input fields and one or more buttons or input[type=submit] then
     * hitting enter in any of the input fields will trigger the click handler on the *first* button or
     * input[type=submit] (`ngClick`) *and* a submit handler on the enclosing form (`ngSubmit`)
     *
     * @param {string=} name Name of the form. If specified, the form controller will be published into
     *                       related scope, under this name.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.userType = 'guest';
     }
     </script>
     <form name="myForm" ng-controller="Ctrl">
     userType: <input name="input" ng-model="userType" required>
     <span class="error" ng-show="myForm.input.$error.REQUIRED">Required!</span><br>
     <tt>userType = {{userType}}</tt><br>
     <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br>
     <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br>
     <tt>myForm.$valid = {{myForm.$valid}}</tt><br>
     <tt>myForm.$error.REQUIRED = {{!!myForm.$error.REQUIRED}}</tt><br>
     </form>
     </doc:source>
     <doc:scenario>
     it('should initialize to model', function() {
     expect(binding('userType')).toEqual('guest');
     expect(binding('myForm.input.$valid')).toEqual('true');
     });

     it('should be invalid if empty', function() {
     input('userType').enter('');
     expect(binding('userType')).toEqual('');
     expect(binding('myForm.input.$valid')).toEqual('false');
     });
     </doc:scenario>
     </doc:example>
     */
    var formDirectiveFactory = function(isNgForm) {
        return ['$timeout', function($timeout) {
            var formDirective = {
                name: 'form',
                restrict: 'E',
                controller: FormController,
                compile: function() {
                    return {
                        pre: function(scope, formElement, attr, controller) {
                            if (!attr.action) {
                                // we can't use jq events because if a form is destroyed during submission the default
                                // action is not prevented. see #1238
                                //
                                // IE 9 is not affected because it doesn't fire a submit event and try to do a full
                                // page reload if the form was destroyed by submission of the form via a click handler
                                // on a button in the form. Looks like an IE9 specific bug.
                                var preventDefaultListener = function(event) {
                                    event.preventDefault
                                        ? event.preventDefault()
                                        : event.returnValue = false; // IE
                                };

                                addEventListenerFn(formElement[0], 'submit', preventDefaultListener);

                                // unregister the preventDefault listener so that we don't not leak memory but in a
                                // way that will achieve the prevention of the default action.
                                formElement.bind('$destroy', function() {
                                    $timeout(function() {
                                        removeEventListenerFn(formElement[0], 'submit', preventDefaultListener);
                                    }, 0, false);
                                });
                            }

                            var parentFormCtrl = formElement.parent().controller('form'),
                                alias = attr.name || attr.ngForm;

                            if (alias) {
                                scope[alias] = controller;
                            }
                            if (parentFormCtrl) {
                                formElement.bind('$destroy', function() {
                                    parentFormCtrl.$removeControl(controller);
                                    if (alias) {
                                        scope[alias] = undefined;
                                    }
                                    extend(controller, nullFormCtrl); //stop propagating child destruction handlers upwards
                                });
                            }
                        }
                    };
                }
            };

            return isNgForm ? extend(copy(formDirective), {restrict: 'EAC'}) : 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,4}$/;
    var NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))\s*$/;

    var inputType = {

        /**
         * @ngdoc inputType
         * @name ng.directive:input.text
         *
         * @description
         * Standard HTML text input with angular data binding.
         *
         * @param {string} ngModel Assignable angular expression to data-bind to.
         * @param {string=} name Property name of the form under which the control is published.
         * @param {string=} required Sets `required` validation error key if the value is not entered.
         * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
         *    minlength.
         * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
         *    maxlength.
         * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
         *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
         *    patterns defined as scope expressions.
         * @param {string=} ngChange Angular expression to be executed when input changes due to user
         *    interaction with the input element.
         *
         * @example
         <doc:example>
         <doc:source>
         <script>
         function Ctrl($scope) {
         $scope.text = 'guest';
         $scope.word = /^\w*$/;
         }
         </script>
         <form name="myForm" ng-controller="Ctrl">
         Single word: <input type="text" name="input" ng-model="text"
         ng-pattern="word" required>
         <span class="error" ng-show="myForm.input.$error.required">
         Required!</span>
         <span class="error" ng-show="myForm.input.$error.pattern">
         Single word only!</span>

         <tt>text = {{text}}</tt><br/>
         <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
         <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
         <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
         </form>
         </doc:source>
         <doc:scenario>
         it('should initialize to model', function() {
         expect(binding('text')).toEqual('guest');
         expect(binding('myForm.input.$valid')).toEqual('true');
         });

         it('should be invalid if empty', function() {
         input('text').enter('');
         expect(binding('text')).toEqual('');
         expect(binding('myForm.input.$valid')).toEqual('false');
         });

         it('should be invalid if multi word', function() {
         input('text').enter('hello world');
         expect(binding('myForm.input.$valid')).toEqual('false');
         });
         </doc:scenario>
         </doc:example>
         */
        'text': textInputType,


        /**
         * @ngdoc inputType
         * @name ng.directive:input.number
         *
         * @description
         * Text input with number validation and transformation. Sets the `number` validation
         * error if not a valid number.
         *
         * @param {string} ngModel Assignable angular expression to data-bind to.
         * @param {string=} name Property name of the form under which the control is published.
         * @param {string=} min Sets the `min` validation error key if the value entered is less then `min`.
         * @param {string=} max Sets the `max` validation error key if the value entered is greater then `min`.
         * @param {string=} required Sets `required` validation error key if the value is not entered.
         * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
         *    minlength.
         * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
         *    maxlength.
         * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
         *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
         *    patterns defined as scope expressions.
         * @param {string=} ngChange Angular expression to be executed when input changes due to user
         *    interaction with the input element.
         *
         * @example
         <doc:example>
         <doc:source>
         <script>
         function Ctrl($scope) {
         $scope.value = 12;
         }
         </script>
         <form name="myForm" ng-controller="Ctrl">
         Number: <input type="number" name="input" ng-model="value"
         min="0" max="99" required>
         <span class="error" ng-show="myForm.list.$error.required">
         Required!</span>
         <span class="error" ng-show="myForm.list.$error.number">
         Not valid number!</span>
         <tt>value = {{value}}</tt><br/>
         <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
         <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
         <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
         </form>
         </doc:source>
         <doc:scenario>
         it('should initialize to model', function() {
         expect(binding('value')).toEqual('12');
         expect(binding('myForm.input.$valid')).toEqual('true');
         });

         it('should be invalid if empty', function() {
         input('value').enter('');
         expect(binding('value')).toEqual('');
         expect(binding('myForm.input.$valid')).toEqual('false');
         });

         it('should be invalid if over max', function() {
         input('value').enter('123');
         expect(binding('value')).toEqual('');
         expect(binding('myForm.input.$valid')).toEqual('false');
         });
         </doc:scenario>
         </doc:example>
         */
        'number': numberInputType,


        /**
         * @ngdoc inputType
         * @name ng.directive:input.url
         *
         * @description
         * Text input with URL validation. Sets the `url` validation error key if the content is not a
         * valid URL.
         *
         * @param {string} ngModel Assignable angular expression to data-bind to.
         * @param {string=} name Property name of the form under which the control is published.
         * @param {string=} required Sets `required` validation error key if the value is not entered.
         * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
         *    minlength.
         * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
         *    maxlength.
         * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
         *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
         *    patterns defined as scope expressions.
         * @param {string=} ngChange Angular expression to be executed when input changes due to user
         *    interaction with the input element.
         *
         * @example
         <doc:example>
         <doc:source>
         <script>
         function Ctrl($scope) {
         $scope.text = 'http://google.com';
         }
         </script>
         <form name="myForm" ng-controller="Ctrl">
         URL: <input type="url" name="input" ng-model="text" required>
         <span class="error" ng-show="myForm.input.$error.required">
         Required!</span>
         <span class="error" ng-show="myForm.input.$error.url">
         Not valid url!</span>
         <tt>text = {{text}}</tt><br/>
         <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
         <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
         <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
         <tt>myForm.$error.url = {{!!myForm.$error.url}}</tt><br/>
         </form>
         </doc:source>
         <doc:scenario>
         it('should initialize to model', function() {
         expect(binding('text')).toEqual('http://google.com');
         expect(binding('myForm.input.$valid')).toEqual('true');
         });

         it('should be invalid if empty', function() {
         input('text').enter('');
         expect(binding('text')).toEqual('');
         expect(binding('myForm.input.$valid')).toEqual('false');
         });

         it('should be invalid if not url', function() {
         input('text').enter('xxx');
         expect(binding('myForm.input.$valid')).toEqual('false');
         });
         </doc:scenario>
         </doc:example>
         */
        'url': urlInputType,


        /**
         * @ngdoc inputType
         * @name ng.directive:input.email
         *
         * @description
         * Text input with email validation. Sets the `email` validation error key if not a valid email
         * address.
         *
         * @param {string} ngModel Assignable angular expression to data-bind to.
         * @param {string=} name Property name of the form under which the control is published.
         * @param {string=} required Sets `required` validation error key if the value is not entered.
         * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
         *    minlength.
         * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
         *    maxlength.
         * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
         *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
         *    patterns defined as scope expressions.
         *
         * @example
         <doc:example>
         <doc:source>
         <script>
         function Ctrl($scope) {
         $scope.text = 'me@example.com';
         }
         </script>
         <form name="myForm" ng-controller="Ctrl">
         Email: <input type="email" name="input" ng-model="text" required>
         <span class="error" ng-show="myForm.input.$error.required">
         Required!</span>
         <span class="error" ng-show="myForm.input.$error.email">
         Not valid email!</span>
         <tt>text = {{text}}</tt><br/>
         <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
         <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
         <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
         <tt>myForm.$error.email = {{!!myForm.$error.email}}</tt><br/>
         </form>
         </doc:source>
         <doc:scenario>
         it('should initialize to model', function() {
         expect(binding('text')).toEqual('me@example.com');
         expect(binding('myForm.input.$valid')).toEqual('true');
         });

         it('should be invalid if empty', function() {
         input('text').enter('');
         expect(binding('text')).toEqual('');
         expect(binding('myForm.input.$valid')).toEqual('false');
         });

         it('should be invalid if not email', function() {
         input('text').enter('xxx');
         expect(binding('myForm.input.$valid')).toEqual('false');
         });
         </doc:scenario>
         </doc:example>
         */
        'email': emailInputType,


        /**
         * @ngdoc inputType
         * @name ng.directive:input.radio
         *
         * @description
         * HTML radio button.
         *
         * @param {string} ngModel Assignable angular expression to data-bind to.
         * @param {string} value The value to which the expression should be set when selected.
         * @param {string=} name Property name of the form under which the control is published.
         * @param {string=} ngChange Angular expression to be executed when input changes due to user
         *    interaction with the input element.
         *
         * @example
         <doc:example>
         <doc:source>
         <script>
         function Ctrl($scope) {
         $scope.color = 'blue';
         }
         </script>
         <form name="myForm" ng-controller="Ctrl">
         <input type="radio" ng-model="color" value="red">  Red <br/>
         <input type="radio" ng-model="color" value="green"> Green <br/>
         <input type="radio" ng-model="color" value="blue"> Blue <br/>
         <tt>color = {{color}}</tt><br/>
         </form>
         </doc:source>
         <doc:scenario>
         it('should change state', function() {
         expect(binding('color')).toEqual('blue');

         input('color').select('red');
         expect(binding('color')).toEqual('red');
         });
         </doc:scenario>
         </doc:example>
         */
        'radio': radioInputType,


        /**
         * @ngdoc inputType
         * @name ng.directive:input.checkbox
         *
         * @description
         * HTML checkbox.
         *
         * @param {string} ngModel Assignable angular expression to data-bind to.
         * @param {string=} name Property name of the form under which the control is published.
         * @param {string=} ngTrueValue The value to which the expression should be set when selected.
         * @param {string=} ngFalseValue The value to which the expression should be set when not selected.
         * @param {string=} ngChange Angular expression to be executed when input changes due to user
         *    interaction with the input element.
         *
         * @example
         <doc:example>
         <doc:source>
         <script>
         function Ctrl($scope) {
         $scope.value1 = true;
         $scope.value2 = 'YES'
         }
         </script>
         <form name="myForm" ng-controller="Ctrl">
         Value1: <input type="checkbox" ng-model="value1"> <br/>
         Value2: <input type="checkbox" ng-model="value2"
         ng-true-value="YES" ng-false-value="NO"> <br/>
         <tt>value1 = {{value1}}</tt><br/>
         <tt>value2 = {{value2}}</tt><br/>
         </form>
         </doc:source>
         <doc:scenario>
         it('should change state', function() {
         expect(binding('value1')).toEqual('true');
         expect(binding('value2')).toEqual('YES');

         input('value1').check();
         input('value2').check();
         expect(binding('value1')).toEqual('false');
         expect(binding('value2')).toEqual('NO');
         });
         </doc:scenario>
         </doc:example>
         */
        'checkbox': checkboxInputType,

        'hidden': noop,
        'button': noop,
        'submit': noop,
        'reset': noop
    };


    function isEmpty(value) {
        return isUndefined(value) || value === '' || value === null || value !== value;
    }


    function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {

        var listener = function() {
            var value = trim(element.val());

            if (ctrl.$viewValue !== value) {
                scope.$apply(function() {
                    ctrl.$setViewValue(value);
                });
            }
        };

        // if the browser does support "input" event, we are fine - except on IE9 which doesn't fire the
        // input event on backspace, delete or cut
        if ($sniffer.hasEvent('input')) {
            element.bind('input', listener);
        } else {
            var timeout;

            element.bind('keydown', function(event) {
                var key = event.keyCode;

                // ignore
                //    command            modifiers                   arrows
                if (key === 91 || (15 < key && key < 19) || (37 <= key && key <= 40)) return;

                if (!timeout) {
                    timeout = $browser.defer(function() {
                        listener();
                        timeout = null;
                    });
                }
            });

            // if user paste into input using mouse, we need "change" event to catch it
            element.bind('change', listener);
        }


        ctrl.$render = function() {
            element.val(isEmpty(ctrl.$viewValue) ? '' : ctrl.$viewValue);
        };

        // pattern validator
        var pattern = attr.ngPattern,
            patternValidator;

        var validate = function(regexp, value) {
            if (isEmpty(value) || regexp.test(value)) {
                ctrl.$setValidity('pattern', true);
                return value;
            } else {
                ctrl.$setValidity('pattern', false);
                return undefined;
            }
        };

        if (pattern) {
            if (pattern.match(/^\/(.*)\/$/)) {
                pattern = new RegExp(pattern.substr(1, pattern.length - 2));
                patternValidator = function(value) {
                    return validate(pattern, value)
                };
            } else {
                patternValidator = function(value) {
                    var patternObj = scope.$eval(pattern);

                    if (!patternObj || !patternObj.test) {
                        throw new Error('Expected ' + pattern + ' to be a RegExp but was ' + patternObj);
                    }
                    return validate(patternObj, value);
                };
            }

            ctrl.$formatters.push(patternValidator);
            ctrl.$parsers.push(patternValidator);
        }

        // min length validator
        if (attr.ngMinlength) {
            var minlength = int(attr.ngMinlength);
            var minLengthValidator = function(value) {
                if (!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);
        }

        // max length validator
        if (attr.ngMaxlength) {
            var maxlength = int(attr.ngMaxlength);
            var maxLengthValidator = function(value) {
                if (!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 = 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 isEmpty(value) ? '' : '' + value;
        });

        if (attr.min) {
            var min = parseFloat(attr.min);
            var minValidator = function(value) {
                if (!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 max = parseFloat(attr.max);
            var maxValidator = function(value) {
                if (!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 (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 (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 (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) {
        // make the name unique, if not defined
        if (isUndefined(attr.name)) {
            element.attr('name', nextUid());
        }

        element.bind('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.bind('click', function() {
            scope.$apply(function() {
                ctrl.$setViewValue(element[0].checked);
            });
        });

        ctrl.$render = function() {
            element[0].checked = ctrl.$viewValue;
        };

        ctrl.$formatters.push(function(value) {
            return value === trueValue;
        });

        ctrl.$parsers.push(function(value) {
            return value ? trueValue : falseValue;
        });
    }


    /**
     * @ngdoc directive
     * @name ng.directive:textarea
     * @restrict E
     *
     * @description
     * HTML textarea element control with angular data-binding. The data-binding and validation
     * properties of this element are exactly the same as those of the
     * {@link ng.directive:input input element}.
     *
     * @param {string} ngModel Assignable angular expression to data-bind to.
     * @param {string=} name Property name of the form under which the control is published.
     * @param {string=} required Sets `required` validation error key if the value is not entered.
     * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
     *    minlength.
     * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
     *    maxlength.
     * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
     *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
     *    patterns defined as scope expressions.
     * @param {string=} ngChange Angular expression to be executed when input changes due to user
     *    interaction with the input element.
     */


    /**
     * @ngdoc directive
     * @name ng.directive:input
     * @restrict E
     *
     * @description
     * HTML input element control with angular data-binding. Input control follows HTML5 input types
     * and polyfills the HTML5 validation behavior for older browsers.
     *
     * @param {string} ngModel Assignable angular expression to data-bind to.
     * @param {string=} name Property name of the form under which the control is published.
     * @param {string=} required Sets `required` validation error key if the value is not entered.
     * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
     *    minlength.
     * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
     *    maxlength.
     * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
     *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
     *    patterns defined as scope expressions.
     * @param {string=} ngChange Angular expression to be executed when input changes due to user
     *    interaction with the input element.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.user = {name: 'guest', last: 'visitor'};
     }
     </script>
     <div ng-controller="Ctrl">
     <form name="myForm">
     User name: <input type="text" name="userName" ng-model="user.name" required>
     <span class="error" ng-show="myForm.userName.$error.required">
     Required!</span><br>
     Last name: <input type="text" name="lastName" ng-model="user.last"
     ng-minlength="3" ng-maxlength="10">
     <span class="error" ng-show="myForm.lastName.$error.minlength">
     Too short!</span>
     <span class="error" ng-show="myForm.lastName.$error.maxlength">
     Too long!</span><br>
     </form>
     <hr>
     <tt>user = {{user}}</tt><br/>
     <tt>myForm.userName.$valid = {{myForm.userName.$valid}}</tt><br>
     <tt>myForm.userName.$error = {{myForm.userName.$error}}</tt><br>
     <tt>myForm.lastName.$valid = {{myForm.lastName.$valid}}</tt><br>
     <tt>myForm.userName.$error = {{myForm.lastName.$error}}</tt><br>
     <tt>myForm.$valid = {{myForm.$valid}}</tt><br>
     <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br>
     <tt>myForm.$error.minlength = {{!!myForm.$error.minlength}}</tt><br>
     <tt>myForm.$error.maxlength = {{!!myForm.$error.maxlength}}</tt><br>
     </div>
     </doc:source>
     <doc:scenario>
     it('should initialize to model', function() {
     expect(binding('user')).toEqual('{"name":"guest","last":"visitor"}');
     expect(binding('myForm.userName.$valid')).toEqual('true');
     expect(binding('myForm.$valid')).toEqual('true');
     });

     it('should be invalid if empty when required', function() {
     input('user.name').enter('');
     expect(binding('user')).toEqual('{"last":"visitor"}');
     expect(binding('myForm.userName.$valid')).toEqual('false');
     expect(binding('myForm.$valid')).toEqual('false');
     });

     it('should be valid if empty when min length is set', function() {
     input('user.last').enter('');
     expect(binding('user')).toEqual('{"name":"guest","last":""}');
     expect(binding('myForm.lastName.$valid')).toEqual('true');
     expect(binding('myForm.$valid')).toEqual('true');
     });

     it('should be invalid if less than required min length', function() {
     input('user.last').enter('xx');
     expect(binding('user')).toEqual('{"name":"guest"}');
     expect(binding('myForm.lastName.$valid')).toEqual('false');
     expect(binding('myForm.lastName.$error')).toMatch(/minlength/);
     expect(binding('myForm.$valid')).toEqual('false');
     });

     it('should be invalid if longer than max length', function() {
     input('user.last').enter('some ridiculously long name');
     expect(binding('user'))
     .toEqual('{"name":"guest"}');
     expect(binding('myForm.lastName.$valid')).toEqual('false');
     expect(binding('myForm.lastName.$error')).toMatch(/maxlength/);
     expect(binding('myForm.$valid')).toEqual('false');
     });
     </doc:scenario>
     </doc:example>
     */
    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';

    /**
     * @ngdoc object
     * @name ng.directive:ngModel.NgModelController
     *
     * @property {string} $viewValue Actual string value in the view.
     * @property {*} $modelValue The value in the model, that the control is bound to.
     * @property {Array.<Function>} $parsers Whenever the control reads value from the DOM, it executes
     *     all of these functions to sanitize / convert the value as well as validate.
     *
     * @property {Array.<Function>} $formatters Whenever the model value changes, it executes all of
     *     these functions to convert the value as well as validate.
     *
     * @property {Object} $error An bject hash with all errors as keys.
     *
     * @property {boolean} $pristine True if user has not interacted with the control yet.
     * @property {boolean} $dirty True if user has already interacted with the control.
     * @property {boolean} $valid True if there is no error.
     * @property {boolean} $invalid True if at least one error on the control.
     *
     * @description
     *
     * `NgModelController` provides API for the `ng-model` directive. The controller contains
     * services for data-binding, validation, CSS update, value formatting and parsing. It
     * specifically does not contain any logic which deals with DOM rendering or listening to
     * DOM events. The `NgModelController` is meant to be extended by other directives where, the
     * directive provides DOM manipulation and the `NgModelController` provides the data-binding.
     *
     * This example shows how to use `NgModelController` with a custom control to achieve
     * data-binding. Notice how different directives (`contenteditable`, `ng-model`, and `required`)
     * collaborate together to achieve the desired result.
     *
     * <example module="customControl">
     <file name="style.css">
     [contenteditable] {
     border: 1px solid black;
     background-color: white;
     min-height: 20px;
     }

     .ng-invalid {
     border: 1px solid red;
     }

     </file>
     <file name="script.js">
     angular.module('customControl', []).
     directive('contenteditable', function() {
     return {
     restrict: 'A', // only activate on element attribute
     require: '?ngModel', // get a hold of NgModelController
     link: function(scope, element, attrs, ngModel) {
     if(!ngModel) return; // do nothing if no ng-model

     // Specify how UI should be updated
     ngModel.$render = function() {
     element.html(ngModel.$viewValue || '');
     };

     // Listen for change events to enable binding
     element.bind('blur keyup change', function() {
     scope.$apply(read);
     });
     read(); // initialize

     // Write data to the model
     function read() {
     ngModel.$setViewValue(element.html());
     }
     }
     };
     });
     </file>
     <file name="index.html">
     <form name="myForm">
     <div contenteditable
     name="myWidget" ng-model="userContent"
     required>Change me!</div>
     <span ng-show="myForm.myWidget.$error.required">Required!</span>
     <hr>
     <textarea ng-model="userContent"></textarea>
     </form>
     </file>
     <file name="scenario.js">
     it('should data-bind and become invalid', function() {
     var contentEditable = element('[contenteditable]');

     expect(contentEditable.text()).toEqual('Change me!');
     input('userContent').enter('');
     expect(contentEditable.text()).toEqual('');
     expect(contentEditable.prop('className')).toMatch(/ng-invalid-required/);
     });
     </file>
     * </example>
     *
     */
    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 Error(NON_ASSIGNABLE_MODEL_EXPRESSION + $attr.ngModel +
                    ' (' + startingTag($element) + ')');
            }

            /**
             * @ngdoc function
             * @name ng.directive:ngModel.NgModelController#$render
             * @methodOf ng.directive:ngModel.NgModelController
             *
             * @description
             * Called when the view needs to be updated. It is expected that the user of the ng-model
             * directive will implement this method.
             */
            this.$render = noop;

            var parentForm = $element.inheritedData('$formController') || nullFormCtrl,
                invalidCount = 0, // used to easily determine if we are valid
                $error = this.$error = {}; // keep invalid keys here


            // Setup initial state of the control
            $element.addClass(PRISTINE_CLASS);
            toggleValidCss(true);

            // convenience method for easy toggling of classes
            function toggleValidCss(isValid, validationErrorKey) {
                validationErrorKey = validationErrorKey ? '-' + snake_case(validationErrorKey, '-') : '';
                $element.
                    removeClass((isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey).
                    addClass((isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey);
            }

            /**
             * @ngdoc function
             * @name ng.directive:ngModel.NgModelController#$setValidity
             * @methodOf ng.directive:ngModel.NgModelController
             *
             * @description
             * Change the validity state, and notifies the form when the control changes validity. (i.e. it
             * does not notify form if given validator is already marked as invalid).
             *
             * This method should be called by validators - i.e. the parser or formatter functions.
             *
             * @param {string} validationErrorKey Name of the validator. the `validationErrorKey` will assign
             *        to `$error[validationErrorKey]=isValid` so that it is available for data-binding.
             *        The `validationErrorKey` should be in camelCase and will get converted into dash-case
             *        for class name. Example: `myError` will result in `ng-valid-my-error` and `ng-invalid-my-error`
             *        class and can be bound to as  `{{someForm.someControl.$error.myError}}` .
             * @param {boolean} isValid Whether the current state is valid (true) or invalid (false).
             */
            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);
            };


            /**
             * @ngdoc function
             * @name ng.directive:ngModel.NgModelController#$setViewValue
             * @methodOf ng.directive:ngModel.NgModelController
             *
             * @description
             * Read a value from view.
             *
             * This method should be called from within a DOM event handler.
             * For example {@link ng.directive:input input} or
             * {@link ng.directive:select select} directives call it.
             *
             * It internally calls all `formatters` and if resulted value is valid, updates the model and
             * calls all registered change listeners.
             *
             * @param {string} value Value from the view.
             */
            this.$setViewValue = function(value) {
                this.$viewValue = value;

                // change to dirty
                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);
                        }
                    })
                }
            };

            // model -> value
            var ctrl = this;
            $scope.$watch(ngModelGet, function(value) {

                // ignore change from view
                if (ctrl.$modelValue === value) return;

                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();
                }
            });
        }];


    /**
     * @ngdoc directive
     * @name ng.directive:ngModel
     *
     * @element input
     *
     * @description
     * Is directive that tells Angular to do two-way data binding. It works together with `input`,
     * `select`, `textarea`. You can easily write your own directives to use `ngModel` as well.
     *
     * `ngModel` is responsible for:
     *
     * - binding the view into the model, which other directives such as `input`, `textarea` or `select`
     *   require,
     * - providing validation behavior (i.e. required, number, email, url),
     * - keeping state of the control (valid/invalid, dirty/pristine, validation errors),
     * - setting related css class onto the element (`ng-valid`, `ng-invalid`, `ng-dirty`, `ng-pristine`),
     * - register the control with parent {@link ng.directive:form form}.
     *
     * For basic examples, how to use `ngModel`, see:
     *
     *  - {@link ng.directive:input input}
     *    - {@link ng.directive:input.text text}
     *    - {@link ng.directive:input.checkbox checkbox}
     *    - {@link ng.directive:input.radio radio}
     *    - {@link ng.directive:input.number number}
     *    - {@link ng.directive:input.email email}
     *    - {@link ng.directive:input.url url}
     *  - {@link ng.directive:select select}
     *  - {@link ng.directive:textarea textarea}
     *
     */
    var ngModelDirective = function() {
        return {
            require: ['ngModel', '^?form'],
            controller: NgModelController,
            link: function(scope, element, attr, ctrls) {
                // notify others, especially parent forms

                var modelCtrl = ctrls[0],
                    formCtrl = ctrls[1] || nullFormCtrl;

                formCtrl.$addControl(modelCtrl);

                element.bind('$destroy', function() {
                    formCtrl.$removeControl(modelCtrl);
                });
            }
        };
    };


    /**
     * @ngdoc directive
     * @name ng.directive:ngChange
     * @restrict E
     *
     * @description
     * Evaluate given expression when user changes the input.
     * The expression is not evaluated when the value change is coming from the model.
     *
     * Note, this directive requires `ngModel` to be present.
     *
     * @element input
     *
     * @example
     * <doc:example>
     *   <doc:source>
     *     <script>
     *       function Controller($scope) {
     *         $scope.counter = 0;
     *         $scope.change = function() {
     *           $scope.counter++;
     *         };
     *       }
     *     </script>
     *     <div ng-controller="Controller">
     *       <input type="checkbox" ng-model="confirmed" ng-change="change()" id="ng-change-example1" />
     *       <input type="checkbox" ng-model="confirmed" id="ng-change-example2" />
     *       <label for="ng-change-example2">Confirmed</label><br />
     *       debug = {{confirmed}}<br />
     *       counter = {{counter}}
     *     </div>
     *   </doc:source>
     *   <doc:scenario>
     *     it('should evaluate the expression if changing from view', function() {
     *       expect(binding('counter')).toEqual('0');
     *       element('#ng-change-example1').click();
     *       expect(binding('counter')).toEqual('1');
     *       expect(binding('confirmed')).toEqual('true');
     *     });
     *
     *     it('should not evaluate the expression if changing from model', function() {
     *       element('#ng-change-example2').click();
     *       expect(binding('counter')).toEqual('0');
     *       expect(binding('confirmed')).toEqual('true');
     *     });
     *   </doc:scenario>
     * </doc:example>
     */
    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; // force truthy in case we are on non input element

                var validator = function(value) {
                    if (attr.required && (isEmpty(value) || value === false)) {
                        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);
                });
            }
        };
    };


    /**
     * @ngdoc directive
     * @name ng.directive:ngList
     *
     * @description
     * Text input that converts between comma-seperated string into an array of strings.
     *
     * @element input
     * @param {string=} ngList optional delimiter that should be used to split the value. If
     *   specified in form `/something/` then the value will be converted into a regular expression.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.names = ['igor', 'misko', 'vojta'];
     }
     </script>
     <form name="myForm" ng-controller="Ctrl">
     List: <input name="namesInput" ng-model="names" ng-list required>
     <span class="error" ng-show="myForm.list.$error.required">
     Required!</span>
     <tt>names = {{names}}</tt><br/>
     <tt>myForm.namesInput.$valid = {{myForm.namesInput.$valid}}</tt><br/>
     <tt>myForm.namesInput.$error = {{myForm.namesInput.$error}}</tt><br/>
     <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
     <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
     </form>
     </doc:source>
     <doc:scenario>
     it('should initialize to model', function() {
     expect(binding('names')).toEqual('["igor","misko","vojta"]');
     expect(binding('myForm.namesInput.$valid')).toEqual('true');
     });

     it('should be invalid if empty', function() {
     input('names').enter('');
     expect(binding('names')).toEqual('[]');
     expect(binding('myForm.namesInput.$valid')).toEqual('false');
     });
     </doc:scenario>
     </doc:example>
     */
    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) {
                    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;
                });
            }
        };
    };


    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(scope, elm, attr) {
                        attr.$set('value', scope.$eval(attr.ngValue));
                    };
                } else {
                    return function(scope, elm, attr) {
                        scope.$watch(attr.ngValue, function(value) {
                            attr.$set('value', value, false);
                        });
                    };
                }
            }
        };
    };

    /**
     * @ngdoc directive
     * @name ng.directive:ngBind
     *
     * @description
     * The `ngBind` attribute tells Angular to replace the text content of the specified HTML element
     * with the value of a given expression, and to update the text content when the value of that
     * expression changes.
     *
     * Typically, you don't use `ngBind` directly, but instead you use the double curly markup like
     * `{{ expression }}` which is similar but less verbose.
     *
     * Once scenario in which the use of `ngBind` is prefered over `{{ expression }}` binding is when
     * it's desirable to put bindings into template that is momentarily displayed by the browser in its
     * raw state before Angular compiles it. Since `ngBind` is an element attribute, it makes the
     * bindings invisible to the user while the page is loading.
     *
     * An alternative solution to this problem would be using the
     * {@link ng.directive:ngCloak ngCloak} directive.
     *
     *
     * @element ANY
     * @param {expression} ngBind {@link guide/expression Expression} to evaluate.
     *
     * @example
     * Enter a name in the Live Preview text box; the greeting below the text box changes instantly.
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.name = 'Whirled';
     }
     </script>
     <div ng-controller="Ctrl">
     Enter name: <input type="text" ng-model="name"><br>
     Hello <span ng-bind="name"></span>!
     </div>
     </doc:source>
     <doc:scenario>
     it('should check ng-bind', function() {
     expect(using('.doc-example-live').binding('name')).toBe('Whirled');
     using('.doc-example-live').input('name').enter('world');
     expect(using('.doc-example-live').binding('name')).toBe('world');
     });
     </doc:scenario>
     </doc:example>
     */
    var ngBindDirective = ngDirective(function(scope, element, attr) {
        element.addClass('ng-binding').data('$binding', attr.ngBind);
        scope.$watch(attr.ngBind, function(value) {
            element.text(value == undefined ? '' : value);
        });
    });


    /**
     * @ngdoc directive
     * @name ng.directive:ngBindTemplate
     *
     * @description
     * The `ngBindTemplate` directive specifies that the element
     * text should be replaced with the template in ngBindTemplate.
     * Unlike ngBind the ngBindTemplate can contain multiple `{{` `}}`
     * expressions. (This is required since some HTML elements
     * can not have SPAN elements such as TITLE, or OPTION to name a few.)
     *
     * @element ANY
     * @param {string} ngBindTemplate template of form
     *   <tt>{{</tt> <tt>expression</tt> <tt>}}</tt> to eval.
     *
     * @example
     * Try it here: enter text in text box and watch the greeting change.
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.salutation = 'Hello';
     $scope.name = 'World';
     }
     </script>
     <div ng-controller="Ctrl">
     Salutation: <input type="text" ng-model="salutation"><br>
     Name: <input type="text" ng-model="name"><br>
     <pre ng-bind-template="{{salutation}} {{name}}!"></pre>
     </div>
     </doc:source>
     <doc:scenario>
     it('should check ng-bind', function() {
     expect(using('.doc-example-live').binding('salutation')).
     toBe('Hello');
     expect(using('.doc-example-live').binding('name')).
     toBe('World');
     using('.doc-example-live').input('salutation').enter('Greetings');
     using('.doc-example-live').input('name').enter('user');
     expect(using('.doc-example-live').binding('salutation')).
     toBe('Greetings');
     expect(using('.doc-example-live').binding('name')).
     toBe('user');
     });
     </doc:scenario>
     </doc:example>
     */
    var ngBindTemplateDirective = ['$interpolate', function($interpolate) {
        return function(scope, element, attr) {
            // TODO: move this to scenario runner
            var interpolateFn = $interpolate(element.attr(attr.$attr.ngBindTemplate));
            element.addClass('ng-binding').data('$binding', interpolateFn);
            attr.$observe('ngBindTemplate', function(value) {
                element.text(value);
            });
        }
    }];


    /**
     * @ngdoc directive
     * @name ng.directive:ngBindHtmlUnsafe
     *
     * @description
     * Creates a binding that will innerHTML the result of evaluating the `expression` into the current
     * element. *The innerHTML-ed content will not be sanitized!* You should use this directive only if
     * {@link ngSanitize.directive:ngBindHtml ngBindHtml} directive is too
     * restrictive and when you absolutely trust the source of the content you are binding to.
     *
     * See {@link ngSanitize.$sanitize $sanitize} docs for examples.
     *
     * @element ANY
     * @param {expression} ngBindHtmlUnsafe {@link guide/expression Expression} to evaluate.
     */
    var ngBindHtmlUnsafeDirective = [function() {
        return function(scope, element, attr) {
            element.addClass('ng-binding').data('$binding', attr.ngBindHtmlUnsafe);
            scope.$watch(attr.ngBindHtmlUnsafe, function(value) {
                element.html(value || '');
            });
        };
    }];

    function classDirective(name, selector) {
        name = 'ngClass' + name;
        return ngDirective(function(scope, element, attr) {
            scope.$watch(attr[name], function(newVal, oldVal) {
                if (selector === true || scope.$index % 2 === selector) {
                    if (oldVal && (newVal !== oldVal)) {
                        if (isObject(oldVal) && !isArray(oldVal))
                            oldVal = map(oldVal, function(v, k) { if (v) return k });
                        element.removeClass(isArray(oldVal) ? oldVal.join(' ') : oldVal);
                    }
                    if (isObject(newVal) && !isArray(newVal))
                        newVal = map(newVal, function(v, k) { if (v) return k });
                    if (newVal) element.addClass(isArray(newVal) ? newVal.join(' ') : newVal);      }
            }, true);
        });
    }

    /**
     * @ngdoc directive
     * @name ng.directive:ngClass
     *
     * @description
     * The `ngClass` allows you to set CSS class on HTML element dynamically by databinding an
     * expression that represents all classes to be added.
     *
     * The directive won't add duplicate classes if a particular class was already set.
     *
     * When the expression changes, the previously added classes are removed and only then the classes
     * new classes are added.
     *
     * @element ANY
     * @param {expression} ngClass {@link guide/expression Expression} to eval. The result
     *   of the evaluation can be a string representing space delimited class
     *   names, an array, or a map of class names to boolean values.
     *
     * @example
     <example>
     <file name="index.html">
     <input type="button" value="set" ng-click="myVar='my-class'">
     <input type="button" value="clear" ng-click="myVar=''">
     <br>
     <span ng-class="myVar">Sample Text</span>
     </file>
     <file name="style.css">
     .my-class {
     color: red;
     }
     </file>
     <file name="scenario.js">
     it('should check ng-class', function() {
     expect(element('.doc-example-live span').prop('className')).not().
     toMatch(/my-class/);

     using('.doc-example-live').element(':button:first').click();

     expect(element('.doc-example-live span').prop('className')).
     toMatch(/my-class/);

     using('.doc-example-live').element(':button:last').click();

     expect(element('.doc-example-live span').prop('className')).not().
     toMatch(/my-class/);
     });
     </file>
     </example>
     */
    var ngClassDirective = classDirective('', true);

    /**
     * @ngdoc directive
     * @name ng.directive:ngClassOdd
     *
     * @description
     * The `ngClassOdd` and `ngClassEven` directives work exactly as
     * {@link ng.directive:ngClass ngClass}, except it works in
     * conjunction with `ngRepeat` and takes affect only on odd (even) rows.
     *
     * This directive can be applied only within a scope of an
     * {@link ng.directive:ngRepeat ngRepeat}.
     *
     * @element ANY
     * @param {expression} ngClassOdd {@link guide/expression Expression} to eval. The result
     *   of the evaluation can be a string representing space delimited class names or an array.
     *
     * @example
     <example>
     <file name="index.html">
     <ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']">
     <li ng-repeat="name in names">
     <span ng-class-odd="'odd'" ng-class-even="'even'">
     {{name}}
     </span>
     </li>
     </ol>
     </file>
     <file name="style.css">
     .odd {
     color: red;
     }
     .even {
     color: blue;
     }
     </file>
     <file name="scenario.js">
     it('should check ng-class-odd and ng-class-even', function() {
     expect(element('.doc-example-live li:first span').prop('className')).
     toMatch(/odd/);
     expect(element('.doc-example-live li:last span').prop('className')).
     toMatch(/even/);
     });
     </file>
     </example>
     */
    var ngClassOddDirective = classDirective('Odd', 0);

    /**
     * @ngdoc directive
     * @name ng.directive:ngClassEven
     *
     * @description
     * The `ngClassOdd` and `ngClassEven` works exactly as
     * {@link ng.directive:ngClass ngClass}, except it works in
     * conjunction with `ngRepeat` and takes affect only on odd (even) rows.
     *
     * This directive can be applied only within a scope of an
     * {@link ng.directive:ngRepeat ngRepeat}.
     *
     * @element ANY
     * @param {expression} ngClassEven {@link guide/expression Expression} to eval. The
     *   result of the evaluation can be a string representing space delimited class names or an array.
     *
     * @example
     <example>
     <file name="index.html">
     <ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']">
     <li ng-repeat="name in names">
     <span ng-class-odd="'odd'" ng-class-even="'even'">
     {{name}} &nbsp; &nbsp; &nbsp;
     </span>
     </li>
     </ol>
     </file>
     <file name="style.css">
     .odd {
     color: red;
     }
     .even {
     color: blue;
     }
     </file>
     <file name="scenario.js">
     it('should check ng-class-odd and ng-class-even', function() {
     expect(element('.doc-example-live li:first span').prop('className')).
     toMatch(/odd/);
     expect(element('.doc-example-live li:last span').prop('className')).
     toMatch(/even/);
     });
     </file>
     </example>
     */
    var ngClassEvenDirective = classDirective('Even', 1);

    /**
     * @ngdoc directive
     * @name ng.directive:ngCloak
     *
     * @description
     * The `ngCloak` directive is used to prevent the Angular html template from being briefly
     * displayed by the browser in its raw (uncompiled) form while your application is loading. Use this
     * directive to avoid the undesirable flicker effect caused by the html template display.
     *
     * The directive can be applied to the `<body>` element, but typically a fine-grained application is
     * prefered in order to benefit from progressive rendering of the browser view.
     *
     * `ngCloak` works in cooperation with a css rule that is embedded within `angular.js` and
     *  `angular.min.js` files. Following is the css rule:
     *
     * <pre>
     * [ng\:cloak], [ng-cloak], .ng-cloak {
     *   display: none;
     * }
     * </pre>
     *
     * When this css rule is loaded by the browser, all html elements (including their children) that
     * are tagged with the `ng-cloak` directive are hidden. When Angular comes across this directive
     * during the compilation of the template it deletes the `ngCloak` element attribute, which
     * makes the compiled element visible.
     *
     * For the best result, `angular.js` script must be loaded in the head section of the html file;
     * alternatively, the css rule (above) must be included in the external stylesheet of the
     * application.
     *
     * Legacy browsers, like IE7, do not provide attribute selector support (added in CSS 2.1) so they
     * cannot match the `[ng\:cloak]` selector. To work around this limitation, you must add the css
     * class `ngCloak` in addition to `ngCloak` directive as shown in the example below.
     *
     * @element ANY
     *
     * @example
     <doc:example>
     <doc:source>
     <div id="template1" ng-cloak>{{ 'hello' }}</div>
     <div id="template2" ng-cloak class="ng-cloak">{{ 'hello IE7' }}</div>
     </doc:source>
     <doc:scenario>
     it('should remove the template directive and css class', function() {
     expect(element('.doc-example-live #template1').attr('ng-cloak')).
     not().toBeDefined();
     expect(element('.doc-example-live #template2').attr('ng-cloak')).
     not().toBeDefined();
     });
     </doc:scenario>
     </doc:example>
     *
     */
    var ngCloakDirective = ngDirective({
        compile: function(element, attr) {
            attr.$set('ngCloak', undefined);
            element.removeClass('ng-cloak');
        }
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngController
     *
     * @description
     * The `ngController` directive assigns behavior to a scope. This is a key aspect of how angular
     * supports the principles behind the Model-View-Controller design pattern.
     *
     * MVC components in angular:
     *
     * * Model — The Model is data in scope properties; scopes are attached to the DOM.
     * * View — The template (HTML with data bindings) is rendered into the View.
     * * Controller — The `ngController` directive specifies a Controller class; the class has
     *   methods that typically express the business logic behind the application.
     *
     * Note that an alternative way to define controllers is via the `{@link ng.$route}`
     * service.
     *
     * @element ANY
     * @scope
     * @param {expression} ngController Name of a globally accessible constructor function or an
     *     {@link guide/expression expression} that on the current scope evaluates to a
     *     constructor function.
     *
     * @example
     * Here is a simple form for editing user contact information. Adding, removing, clearing, and
     * greeting are methods declared on the controller (see source tab). These methods can
     * easily be called from the angular markup. Notice that the scope becomes the `this` for the
     * controller's instance. This allows for easy access to the view data from the controller. Also
     * notice that any changes to the data are automatically reflected in the View without the need
     * for a manual update.
     <doc:example>
     <doc:source>
     <script>
     function SettingsController($scope) {
     $scope.name = "John Smith";
     $scope.contacts = [
     {type:'phone', value:'408 555 1212'},
     {type:'email', value:'john.smith@example.org'} ];

     $scope.greet = function() {
     alert(this.name);
     };

     $scope.addContact = function() {
     this.contacts.push({type:'email', value:'yourname@example.org'});
     };

     $scope.removeContact = function(contactToRemove) {
     var index = this.contacts.indexOf(contactToRemove);
     this.contacts.splice(index, 1);
     };

     $scope.clearContact = function(contact) {
     contact.type = 'phone';
     contact.value = '';
     };
     }
     </script>
     <div ng-controller="SettingsController">
     Name: <input type="text" ng-model="name"/>
     [ <a href="" ng-click="greet()">greet</a> ]<br/>
     Contact:
     <ul>
     <li ng-repeat="contact in contacts">
     <select ng-model="contact.type">
     <option>phone</option>
     <option>email</option>
     </select>
     <input type="text" ng-model="contact.value"/>
     [ <a href="" ng-click="clearContact(contact)">clear</a>
     | <a href="" ng-click="removeContact(contact)">X</a> ]
     </li>
     <li>[ <a href="" ng-click="addContact()">add</a> ]</li>
     </ul>
     </div>
     </doc:source>
     <doc:scenario>
     it('should check controller', function() {
     expect(element('.doc-example-live div>:input').val()).toBe('John Smith');
     expect(element('.doc-example-live li:nth-child(1) input').val())
     .toBe('408 555 1212');
     expect(element('.doc-example-live li:nth-child(2) input').val())
     .toBe('john.smith@example.org');

     element('.doc-example-live li:first a:contains("clear")').click();
     expect(element('.doc-example-live li:first input').val()).toBe('');

     element('.doc-example-live li:last a:contains("add")').click();
     expect(element('.doc-example-live li:nth-child(3) input').val())
     .toBe('yourname@example.org');
     });
     </doc:scenario>
     </doc:example>
     */
    var ngControllerDirective = [function() {
        return {
            scope: true,
            controller: '@'
        };
    }];

    /**
     * @ngdoc directive
     * @name ng.directive:ngCsp
     * @priority 1000
     *
     * @description
     * Enables [CSP (Content Security Policy)](https://developer.mozilla.org/en/Security/CSP) support.
     * This directive should be used on the root element of the application (typically the `<html>`
     * element or other element with the {@link ng.directive:ngApp ngApp}
     * directive).
     *
     * If enabled the performance of template expression evaluator will suffer slightly, so don't enable
     * this mode unless you need it.
     *
     * @element html
     */

    var ngCspDirective = ['$sniffer', function($sniffer) {
        return {
            priority: 1000,
            compile: function() {
                $sniffer.csp = true;
            }
        };
    }];

    /**
     * @ngdoc directive
     * @name ng.directive:ngClick
     *
     * @description
     * The ngClick allows you to specify custom behavior when
     * element is clicked.
     *
     * @element ANY
     * @param {expression} ngClick {@link guide/expression Expression} to evaluate upon
     * click. (Event object is available as `$event`)
     *
     * @example
     <doc:example>
     <doc:source>
     <button ng-click="count = count + 1" ng-init="count=0">
     Increment
     </button>
     count: {{count}}
     </doc:source>
     <doc:scenario>
     it('should check ng-click', function() {
     expect(binding('count')).toBe('0');
     element('.doc-example-live :button').click();
     expect(binding('count')).toBe('1');
     });
     </doc:scenario>
     </doc:example>
     */
    /*
     * A directive that allows creation of custom onclick handlers that are defined as angular
     * expressions and are compiled and executed within the current scope.
     *
     * Events that are handled via these handler are always configured not to propagate further.
     */
    var ngEventDirectives = {};
    forEach(
        'click dblclick mousedown mouseup mouseover mouseout mousemove mouseenter mouseleave'.split(' '),
        function(name) {
            var directiveName = directiveNormalize('ng-' + name);
            ngEventDirectives[directiveName] = ['$parse', function($parse) {
                return function(scope, element, attr) {
                    var fn = $parse(attr[directiveName]);
                    element.bind(lowercase(name), function(event) {
                        scope.$apply(function() {
                            fn(scope, {$event:event});
                        });
                    });
                };
            }];
        }
    );

    /**
     * @ngdoc directive
     * @name ng.directive:ngDblclick
     *
     * @description
     * The `ngDblclick` directive allows you to specify custom behavior on dblclick event.
     *
     * @element ANY
     * @param {expression} ngDblclick {@link guide/expression Expression} to evaluate upon
     * dblclick. (Event object is available as `$event`)
     *
     * @example
     * See {@link ng.directive:ngClick ngClick}
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngMousedown
     *
     * @description
     * The ngMousedown directive allows you to specify custom behavior on mousedown event.
     *
     * @element ANY
     * @param {expression} ngMousedown {@link guide/expression Expression} to evaluate upon
     * mousedown. (Event object is available as `$event`)
     *
     * @example
     * See {@link ng.directive:ngClick ngClick}
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngMouseup
     *
     * @description
     * Specify custom behavior on mouseup event.
     *
     * @element ANY
     * @param {expression} ngMouseup {@link guide/expression Expression} to evaluate upon
     * mouseup. (Event object is available as `$event`)
     *
     * @example
     * See {@link ng.directive:ngClick ngClick}
     */

    /**
     * @ngdoc directive
     * @name ng.directive:ngMouseover
     *
     * @description
     * Specify custom behavior on mouseover event.
     *
     * @element ANY
     * @param {expression} ngMouseover {@link guide/expression Expression} to evaluate upon
     * mouseover. (Event object is available as `$event`)
     *
     * @example
     * See {@link ng.directive:ngClick ngClick}
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngMouseenter
     *
     * @description
     * Specify custom behavior on mouseenter event.
     *
     * @element ANY
     * @param {expression} ngMouseenter {@link guide/expression Expression} to evaluate upon
     * mouseenter. (Event object is available as `$event`)
     *
     * @example
     * See {@link ng.directive:ngClick ngClick}
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngMouseleave
     *
     * @description
     * Specify custom behavior on mouseleave event.
     *
     * @element ANY
     * @param {expression} ngMouseleave {@link guide/expression Expression} to evaluate upon
     * mouseleave. (Event object is available as `$event`)
     *
     * @example
     * See {@link ng.directive:ngClick ngClick}
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngMousemove
     *
     * @description
     * Specify custom behavior on mousemove event.
     *
     * @element ANY
     * @param {expression} ngMousemove {@link guide/expression Expression} to evaluate upon
     * mousemove. (Event object is available as `$event`)
     *
     * @example
     * See {@link ng.directive:ngClick ngClick}
     */


    /**
     * @ngdoc directive
     * @name ng.directive:ngSubmit
     *
     * @description
     * Enables binding angular expressions to onsubmit events.
     *
     * Additionally it prevents the default action (which for form means sending the request to the
     * server and reloading the current page).
     *
     * @element form
     * @param {expression} ngSubmit {@link guide/expression Expression} to eval.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.list = [];
     $scope.text = 'hello';
     $scope.submit = function() {
     if (this.text) {
     this.list.push(this.text);
     this.text = '';
     }
     };
     }
     </script>
     <form ng-submit="submit()" ng-controller="Ctrl">
     Enter text and hit enter:
     <input type="text" ng-model="text" name="text" />
     <input type="submit" id="submit" value="Submit" />
     <pre>list={{list}}</pre>
     </form>
     </doc:source>
     <doc:scenario>
     it('should check ng-submit', function() {
     expect(binding('list')).toBe('[]');
     element('.doc-example-live #submit').click();
     expect(binding('list')).toBe('["hello"]');
     expect(input('text').val()).toBe('');
     });
     it('should ignore empty strings', function() {
     expect(binding('list')).toBe('[]');
     element('.doc-example-live #submit').click();
     element('.doc-example-live #submit').click();
     expect(binding('list')).toBe('["hello"]');
     });
     </doc:scenario>
     </doc:example>
     */
    var ngSubmitDirective = ngDirective(function(scope, element, attrs) {
        element.bind('submit', function() {
            scope.$apply(attrs.ngSubmit);
        });
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngInclude
     * @restrict ECA
     *
     * @description
     * Fetches, compiles and includes an external HTML fragment.
     *
     * Keep in mind that Same Origin Policy applies to included resources
     * (e.g. ngInclude won't work for cross-domain requests on all browsers and for
     *  file:// access on some browsers).
     *
     * @scope
     *
     * @param {string} ngInclude|src angular expression evaluating to URL. If the source is a string constant,
     *                 make sure you wrap it in quotes, e.g. `src="'myPartialTemplate.html'"`.
     * @param {string=} onload Expression to evaluate when a new partial is loaded.
     *
     * @param {string=} autoscroll Whether `ngInclude` should call {@link ng.$anchorScroll
     *                  $anchorScroll} to scroll the viewport after the content is loaded.
     *
     *                  - If the attribute is not set, disable scrolling.
     *                  - If the attribute is set without value, enable scrolling.
     *                  - Otherwise enable scrolling only if the expression evaluates to truthy value.
     *
     * @example
     <example>
     <file name="index.html">
     <div ng-controller="Ctrl">
     <select ng-model="template" ng-options="t.name for t in templates">
     <option value="">(blank)</option>
     </select>
     url of the template: <tt>{{template.url}}</tt>
     <hr/>
     <div ng-include src="template.url"></div>
     </div>
     </file>
     <file name="script.js">
     function Ctrl($scope) {
     $scope.templates =
     [ { name: 'template1.html', url: 'template1.html'}
     , { name: 'template2.html', url: 'template2.html'} ];
     $scope.template = $scope.templates[0];
     }
     </file>
     <file name="template1.html">
     Content of template1.html
     </file>
     <file name="template2.html">
     Content of template2.html
     </file>
     <file name="scenario.js">
     it('should load template1.html', function() {
     expect(element('.doc-example-live [ng-include]').text()).
     toMatch(/Content of template1.html/);
     });
     it('should load template2.html', function() {
     select('template').option('1');
     expect(element('.doc-example-live [ng-include]').text()).
     toMatch(/Content of template2.html/);
     });
     it('should change to blank', function() {
     select('template').option('');
     expect(element('.doc-example-live [ng-include]').text()).toEqual('');
     });
     </file>
     </example>
     */


    /**
     * @ngdoc event
     * @name ng.directive:ngInclude#$includeContentLoaded
     * @eventOf ng.directive:ngInclude
     * @eventType emit on the current ngInclude scope
     * @description
     * Emitted every time the ngInclude content is reloaded.
     */
    var ngIncludeDirective = ['$http', '$templateCache', '$anchorScroll', '$compile',
        function($http,   $templateCache,   $anchorScroll,   $compile) {
            return {
                restrict: 'ECA',
                terminal: true,
                compile: function(element, attr) {
                    var srcExp = attr.ngInclude || attr.src,
                        onloadExp = attr.onload || '',
                        autoScrollExp = attr.autoscroll;

                    return function(scope, element) {
                        var changeCounter = 0,
                            childScope;

                        var clearContent = function() {
                            if (childScope) {
                                childScope.$destroy();
                                childScope = null;
                            }

                            element.html('');
                        };

                        scope.$watch(srcExp, function(src) {
                            var thisChangeId = ++changeCounter;

                            if (src) {
                                $http.get(src, {cache: $templateCache}).success(function(response) {
                                    if (thisChangeId !== changeCounter) return;

                                    if (childScope) childScope.$destroy();
                                    childScope = scope.$new();

                                    element.html(response);
                                    $compile(element.contents())(childScope);

                                    if (isDefined(autoScrollExp) && (!autoScrollExp || scope.$eval(autoScrollExp))) {
                                        $anchorScroll();
                                    }

                                    childScope.$emit('$includeContentLoaded');
                                    scope.$eval(onloadExp);
                                }).error(function() {
                                        if (thisChangeId === changeCounter) clearContent();
                                    });
                            } else clearContent();
                        });
                    };
                }
            };
        }];

    /**
     * @ngdoc directive
     * @name ng.directive:ngInit
     *
     * @description
     * The `ngInit` directive specifies initialization tasks to be executed
     *  before the template enters execution mode during bootstrap.
     *
     * @element ANY
     * @param {expression} ngInit {@link guide/expression Expression} to eval.
     *
     * @example
     <doc:example>
     <doc:source>
     <div ng-init="greeting='Hello'; person='World'">
     {{greeting}} {{person}}!
     </div>
     </doc:source>
     <doc:scenario>
     it('should check greeting', function() {
     expect(binding('greeting')).toBe('Hello');
     expect(binding('person')).toBe('World');
     });
     </doc:scenario>
     </doc:example>
     */
    var ngInitDirective = ngDirective({
        compile: function() {
            return {
                pre: function(scope, element, attrs) {
                    scope.$eval(attrs.ngInit);
                }
            }
        }
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngNonBindable
     * @priority 1000
     *
     * @description
     * Sometimes it is necessary to write code which looks like bindings but which should be left alone
     * by angular. Use `ngNonBindable` to make angular ignore a chunk of HTML.
     *
     * @element ANY
     *
     * @example
     * In this example there are two location where a simple binding (`{{}}`) is present, but the one
     * wrapped in `ngNonBindable` is left alone.
     *
     * @example
     <doc:example>
     <doc:source>
     <div>Normal: {{1 + 2}}</div>
     <div ng-non-bindable>Ignored: {{1 + 2}}</div>
     </doc:source>
     <doc:scenario>
     it('should check ng-non-bindable', function() {
     expect(using('.doc-example-live').binding('1 + 2')).toBe('3');
     expect(using('.doc-example-live').element('div:last').text()).
     toMatch(/1 \+ 2/);
     });
     </doc:scenario>
     </doc:example>
     */
    var ngNonBindableDirective = ngDirective({ terminal: true, priority: 1000 });

    /**
     * @ngdoc directive
     * @name ng.directive:ngPluralize
     * @restrict EA
     *
     * @description
     * # Overview
     * `ngPluralize` is a directive that displays messages according to en-US localization rules.
     * These rules are bundled with angular.js and the rules can be overridden
     * (see {@link guide/i18n Angular i18n} dev guide). You configure ngPluralize directive
     * by specifying the mappings between
     * {@link http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
     * plural categories} and the strings to be displayed.
     *
     * # Plural categories and explicit number rules
     * There are two
     * {@link http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
     * plural categories} in Angular's default en-US locale: "one" and "other".
     *
     * While a pural category may match many numbers (for example, in en-US locale, "other" can match
     * any number that is not 1), an explicit number rule can only match one number. For example, the
     * explicit number rule for "3" matches the number 3. You will see the use of plural categories
     * and explicit number rules throughout later parts of this documentation.
     *
     * # Configuring ngPluralize
     * You configure ngPluralize by providing 2 attributes: `count` and `when`.
     * You can also provide an optional attribute, `offset`.
     *
     * The value of the `count` attribute can be either a string or an {@link guide/expression
     * Angular expression}; these are evaluated on the current scope for its bound value.
     *
     * The `when` attribute specifies the mappings between plural categories and the actual
     * string to be displayed. The value of the attribute should be a JSON object so that Angular
     * can interpret it correctly.
     *
     * The following example shows how to configure ngPluralize:
     *
     * <pre>
     * <ng-pluralize count="personCount"
     when="{'0': 'Nobody is viewing.',
     *                      'one': '1 person is viewing.',
     *                      'other': '{} people are viewing.'}">
     * </ng-pluralize>
     *</pre>
     *
     * In the example, `"0: Nobody is viewing."` is an explicit number rule. If you did not
     * specify this rule, 0 would be matched to the "other" category and "0 people are viewing"
     * would be shown instead of "Nobody is viewing". You can specify an explicit number rule for
     * other numbers, for example 12, so that instead of showing "12 people are viewing", you can
     * show "a dozen people are viewing".
     *
     * You can use a set of closed braces(`{}`) as a placeholder for the number that you want substituted
     * into pluralized strings. In the previous example, Angular will replace `{}` with
     * <span ng-non-bindable>`{{personCount}}`</span>. The closed braces `{}` is a placeholder
     * for <span ng-non-bindable>{{numberExpression}}</span>.
     *
     * # Configuring ngPluralize with offset
     * The `offset` attribute allows further customization of pluralized text, which can result in
     * a better user experience. For example, instead of the message "4 people are viewing this document",
     * you might display "John, Kate and 2 others are viewing this document".
     * The offset attribute allows you to offset a number by any desired value.
     * Let's take a look at an example:
     *
     * <pre>
     * <ng-pluralize count="personCount" offset=2
     *               when="{'0': 'Nobody is viewing.',
     *                      '1': '{{person1}} is viewing.',
     *                      '2': '{{person1}} and {{person2}} are viewing.',
     *                      'one': '{{person1}}, {{person2}} and one other person are viewing.',
     *                      'other': '{{person1}}, {{person2}} and {} other people are viewing.'}">
     * </ng-pluralize>
     * </pre>
     *
     * Notice that we are still using two plural categories(one, other), but we added
     * three explicit number rules 0, 1 and 2.
     * When one person, perhaps John, views the document, "John is viewing" will be shown.
     * When three people view the document, no explicit number rule is found, so
     * an offset of 2 is taken off 3, and Angular uses 1 to decide the plural category.
     * In this case, plural category 'one' is matched and "John, Marry and one other person are viewing"
     * is shown.
     *
     * Note that when you specify offsets, you must provide explicit number rules for
     * numbers from 0 up to and including the offset. If you use an offset of 3, for example,
     * you must provide explicit number rules for 0, 1, 2 and 3. You must also provide plural strings for
     * plural categories "one" and "other".
     *
     * @param {string|expression} count The variable to be bounded to.
     * @param {string} when The mapping between plural category to its correspoding strings.
     * @param {number=} offset Offset to deduct from the total number.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.person1 = 'Igor';
     $scope.person2 = 'Misko';
     $scope.personCount = 1;
     }
     </script>
     <div ng-controller="Ctrl">
     Person 1:<input type="text" ng-model="person1" value="Igor" /><br/>
     Person 2:<input type="text" ng-model="person2" value="Misko" /><br/>
     Number of People:<input type="text" ng-model="personCount" value="1" /><br/>

     <!--- Example with simple pluralization rules for en locale --->
     Without Offset:
     <ng-pluralize count="personCount"
     when="{'0': 'Nobody is viewing.',
     'one': '1 person is viewing.',
     'other': '{} people are viewing.'}">
     </ng-pluralize><br>

     <!--- Example with offset --->
     With Offset(2):
     <ng-pluralize count="personCount" offset=2
     when="{'0': 'Nobody is viewing.',
     '1': '{{person1}} is viewing.',
     '2': '{{person1}} and {{person2}} are viewing.',
     'one': '{{person1}}, {{person2}} and one other person are viewing.',
     'other': '{{person1}}, {{person2}} and {} other people are viewing.'}">
     </ng-pluralize>
     </div>
     </doc:source>
     <doc:scenario>
     it('should show correct pluralized string', function() {
     expect(element('.doc-example-live ng-pluralize:first').text()).
     toBe('1 person is viewing.');
     expect(element('.doc-example-live ng-pluralize:last').text()).
     toBe('Igor is viewing.');

     using('.doc-example-live').input('personCount').enter('0');
     expect(element('.doc-example-live ng-pluralize:first').text()).
     toBe('Nobody is viewing.');
     expect(element('.doc-example-live ng-pluralize:last').text()).
     toBe('Nobody is viewing.');

     using('.doc-example-live').input('personCount').enter('2');
     expect(element('.doc-example-live ng-pluralize:first').text()).
     toBe('2 people are viewing.');
     expect(element('.doc-example-live ng-pluralize:last').text()).
     toBe('Igor and Misko are viewing.');

     using('.doc-example-live').input('personCount').enter('3');
     expect(element('.doc-example-live ng-pluralize:first').text()).
     toBe('3 people are viewing.');
     expect(element('.doc-example-live ng-pluralize:last').text()).
     toBe('Igor, Misko and one other person are viewing.');

     using('.doc-example-live').input('personCount').enter('4');
     expect(element('.doc-example-live ng-pluralize:first').text()).
     toBe('4 people are viewing.');
     expect(element('.doc-example-live ng-pluralize:last').text()).
     toBe('Igor, Misko and 2 other people are viewing.');
     });

     it('should show data-binded names', function() {
     using('.doc-example-live').input('personCount').enter('4');
     expect(element('.doc-example-live ng-pluralize:last').text()).
     toBe('Igor, Misko and 2 other people are viewing.');

     using('.doc-example-live').input('person1').enter('Di');
     using('.doc-example-live').input('person2').enter('Vojta');
     expect(element('.doc-example-live ng-pluralize:last').text()).
     toBe('Di, Vojta and 2 other people are viewing.');
     });
     </doc:scenario>
     </doc:example>
     */
    var ngPluralizeDirective = ['$locale', '$interpolate', function($locale, $interpolate) {
        var BRACE = /{}/g;
        return {
            restrict: 'EA',
            link: function(scope, element, attr) {
                var numberExp = attr.count,
                    whenExp = element.attr(attr.$attr.when), // this is because we have {{}} in attrs
                    offset = attr.offset || 0,
                    whens = scope.$eval(whenExp),
                    whensExpFns = {},
                    startSymbol = $interpolate.startSymbol(),
                    endSymbol = $interpolate.endSymbol();

                forEach(whens, function(expression, key) {
                    whensExpFns[key] =
                        $interpolate(expression.replace(BRACE, startSymbol + numberExp + '-' +
                            offset + endSymbol));
                });

                scope.$watch(function() {
                    var value = parseFloat(scope.$eval(numberExp));

                    if (!isNaN(value)) {
                        //if explicit number rule such as 1, 2, 3... is defined, just use it. Otherwise,
                        //check it against pluralization rules in $locale service
                        if (!whens[value]) value = $locale.pluralCat(value - offset);
                        return whensExpFns[value](scope, element, true);
                    } else {
                        return '';
                    }
                }, function(newVal) {
                    element.text(newVal);
                });
            }
        };
    }];

    /**
     * @ngdoc directive
     * @name ng.directive:ngRepeat
     *
     * @description
     * The `ngRepeat` directive instantiates a template once per item from a collection. Each template
     * instance gets its own scope, where the given loop variable is set to the current collection item,
     * and `$index` is set to the item index or key.
     *
     * Special properties are exposed on the local scope of each template instance, including:
     *
     *   * `$index` – `{number}` – iterator offset of the repeated element (0..length-1)
     *   * `$first` – `{boolean}` – true if the repeated element is first in the iterator.
     *   * `$middle` – `{boolean}` – true if the repeated element is between the first and last in the iterator.
     *   * `$last` – `{boolean}` – true if the repeated element is last in the iterator.
     *
     *
     * @element ANY
     * @scope
     * @priority 1000
     * @param {repeat_expression} ngRepeat The expression indicating how to enumerate a collection. Two
     *   formats are currently supported:
     *
     *   * `variable in expression` – where variable is the user defined loop variable and `expression`
     *     is a scope expression giving the collection to enumerate.
     *
     *     For example: `track in cd.tracks`.
     *
     *   * `(key, value) in expression` – where `key` and `value` can be any user defined identifiers,
     *     and `expression` is the scope expression giving the collection to enumerate.
     *
     *     For example: `(name, age) in {'adam':10, 'amalie':12}`.
     *
     * @example
     * This example initializes the scope to a list of names and
     * then uses `ngRepeat` to display every person:
     <doc:example>
     <doc:source>
     <div ng-init="friends = [{name:'John', age:25}, {name:'Mary', age:28}]">
     I have {{friends.length}} friends. They are:
     <ul>
     <li ng-repeat="friend in friends">
     [{{$index + 1}}] {{friend.name}} who is {{friend.age}} years old.
     </li>
     </ul>
     </div>
     </doc:source>
     <doc:scenario>
     it('should check ng-repeat', function() {
     var r = using('.doc-example-live').repeater('ul li');
     expect(r.count()).toBe(2);
     expect(r.row(0)).toEqual(["1","John","25"]);
     expect(r.row(1)).toEqual(["2","Mary","28"]);
     });
     </doc:scenario>
     </doc:example>
     */
    var ngRepeatDirective = ngDirective({
        transclude: 'element',
        priority: 1000,
        terminal: true,
        compile: function(element, attr, linker) {
            return function(scope, iterStartElement, attr){
                var expression = attr.ngRepeat;
                var match = expression.match(/^\s*(.+)\s+in\s+(.*)\s*$/),
                    lhs, rhs, valueIdent, keyIdent;
                if (! match) {
                    throw Error("Expected ngRepeat in form of '_item_ in _collection_' but got '" +
                        expression + "'.");
                }
                lhs = match[1];
                rhs = match[2];
                match = lhs.match(/^(?:([\$\w]+)|\(([\$\w]+)\s*,\s*([\$\w]+)\))$/);
                if (!match) {
                    throw Error("'item' in 'item in collection' should be identifier or (key, value) but got '" +
                        lhs + "'.");
                }
                valueIdent = match[3] || match[1];
                keyIdent = match[2];

                // Store a list of elements from previous run. This is a hash where key is the item from the
                // iterator, and the value is an array of objects with following properties.
                //   - scope: bound scope
                //   - element: previous element.
                //   - index: position
                // We need an array of these objects since the same object can be returned from the iterator.
                // We expect this to be a rare case.
                var lastOrder = new HashQueueMap();
                scope.$watch(function(scope){
                    var index, length,
                        collection = scope.$eval(rhs),
                        collectionLength = size(collection, true),
                        childScope,
                    // Same as lastOrder but it has the current state. It will become the
                    // lastOrder on the next iteration.
                        nextOrder = new HashQueueMap(),
                        key, value, // key/value of iteration
                        array, last,       // last object information {scope, element, index}
                        cursor = iterStartElement;     // current position of the node

                    if (!isArray(collection)) {
                        // if object, extract keys, sort them and use to determine order of iteration over obj props
                        array = [];
                        for(key in collection) {
                            if (collection.hasOwnProperty(key) && key.charAt(0) != '$') {
                                array.push(key);
                            }
                        }
                        array.sort();
                    } else {
                        array = collection || [];
                    }

                    // we are not using forEach for perf reasons (trying to avoid #call)
                    for (index = 0, length = array.length; index < length; index++) {
                        key = (collection === array) ? index : array[index];
                        value = collection[key];
                        last = lastOrder.shift(value);
                        if (last) {
                            // if we have already seen this object, then we need to reuse the
                            // associated scope/element
                            childScope = last.scope;
                            nextOrder.push(value, last);

                            if (index === last.index) {
                                // do nothing
                                cursor = last.element;
                            } else {
                                // existing item which got moved
                                last.index = index;
                                // This may be a noop, if the element is next, but I don't know of a good way to
                                // figure this out,  since it would require extra DOM access, so let's just hope that
                                // the browsers realizes that it is noop, and treats it as such.
                                cursor.after(last.element);
                                cursor = last.element;
                            }
                        } else {
                            // new item which we don't know about
                            childScope = scope.$new();
                        }

                        childScope[valueIdent] = value;
                        if (keyIdent) childScope[keyIdent] = key;
                        childScope.$index = index;

                        childScope.$first = (index === 0);
                        childScope.$last = (index === (collectionLength - 1));
                        childScope.$middle = !(childScope.$first || childScope.$last);

                        if (!last) {
                            linker(childScope, function(clone){
                                cursor.after(clone);
                                last = {
                                    scope: childScope,
                                    element: (cursor = clone),
                                    index: index
                                };
                                nextOrder.push(value, last);
                            });
                        }
                    }

                    //shrink children
                    for (key in lastOrder) {
                        if (lastOrder.hasOwnProperty(key)) {
                            array = lastOrder[key];
                            while(array.length) {
                                value = array.pop();
                                value.element.remove();
                                value.scope.$destroy();
                            }
                        }
                    }

                    lastOrder = nextOrder;
                });
            };
        }
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngShow
     *
     * @description
     * The `ngShow` and `ngHide` directives show or hide a portion of the DOM tree (HTML)
     * conditionally.
     *
     * @element ANY
     * @param {expression} ngShow If the {@link guide/expression expression} is truthy
     *     then the element is shown or hidden respectively.
     *
     * @example
     <doc:example>
     <doc:source>
     Click me: <input type="checkbox" ng-model="checked"><br/>
     Show: <span ng-show="checked">I show up when your checkbox is checked.</span> <br/>
     Hide: <span ng-hide="checked">I hide when your checkbox is checked.</span>
     </doc:source>
     <doc:scenario>
     it('should check ng-show / ng-hide', function() {
     expect(element('.doc-example-live span:first:hidden').count()).toEqual(1);
     expect(element('.doc-example-live span:last:visible').count()).toEqual(1);

     input('checked').check();

     expect(element('.doc-example-live span:first:visible').count()).toEqual(1);
     expect(element('.doc-example-live span:last:hidden').count()).toEqual(1);
     });
     </doc:scenario>
     </doc:example>
     */
//TODO(misko): refactor to remove element from the DOM
    var ngShowDirective = ngDirective(function(scope, element, attr){
        scope.$watch(attr.ngShow, function(value){
            element.css('display', toBoolean(value) ? '' : 'none');
        });
    });


    /**
     * @ngdoc directive
     * @name ng.directive:ngHide
     *
     * @description
     * The `ngHide` and `ngShow` directives hide or show a portion
     * of the HTML conditionally.
     *
     * @element ANY
     * @param {expression} ngHide If the {@link guide/expression expression} truthy then
     *     the element is shown or hidden respectively.
     *
     * @example
     <doc:example>
     <doc:source>
     Click me: <input type="checkbox" ng-model="checked"><br/>
     Show: <span ng-show="checked">I show up when you checkbox is checked?</span> <br/>
     Hide: <span ng-hide="checked">I hide when you checkbox is checked?</span>
     </doc:source>
     <doc:scenario>
     it('should check ng-show / ng-hide', function() {
     expect(element('.doc-example-live span:first:hidden').count()).toEqual(1);
     expect(element('.doc-example-live span:last:visible').count()).toEqual(1);

     input('checked').check();

     expect(element('.doc-example-live span:first:visible').count()).toEqual(1);
     expect(element('.doc-example-live span:last:hidden').count()).toEqual(1);
     });
     </doc:scenario>
     </doc:example>
     */
//TODO(misko): refactor to remove element from the DOM
    var ngHideDirective = ngDirective(function(scope, element, attr){
        scope.$watch(attr.ngHide, function(value){
            element.css('display', toBoolean(value) ? 'none' : '');
        });
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngStyle
     *
     * @description
     * The `ngStyle` directive allows you to set CSS style on an HTML element conditionally.
     *
     * @element ANY
     * @param {expression} ngStyle {@link guide/expression Expression} which evals to an
     *      object whose keys are CSS style names and values are corresponding values for those CSS
     *      keys.
     *
     * @example
     <example>
     <file name="index.html">
     <input type="button" value="set" ng-click="myStyle={color:'red'}">
     <input type="button" value="clear" ng-click="myStyle={}">
     <br/>
     <span ng-style="myStyle">Sample Text</span>
     <pre>myStyle={{myStyle}}</pre>
     </file>
     <file name="style.css">
     span {
     color: black;
     }
     </file>
     <file name="scenario.js">
     it('should check ng-style', function() {
     expect(element('.doc-example-live span').css('color')).toBe('rgb(0, 0, 0)');
     element('.doc-example-live :button[value=set]').click();
     expect(element('.doc-example-live span').css('color')).toBe('rgb(255, 0, 0)');
     element('.doc-example-live :button[value=clear]').click();
     expect(element('.doc-example-live span').css('color')).toBe('rgb(0, 0, 0)');
     });
     </file>
     </example>
     */
    var ngStyleDirective = ngDirective(function(scope, element, attr) {
        scope.$watch(attr.ngStyle, function(newStyles, oldStyles) {
            if (oldStyles && (newStyles !== oldStyles)) {
                forEach(oldStyles, function(val, style) { element.css(style, '');});
            }
            if (newStyles) element.css(newStyles);
        }, true);
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngSwitch
     * @restrict EA
     *
     * @description
     * Conditionally change the DOM structure.
     *
     * @usageContent
     * <ANY ng-switch-when="matchValue1">...</ANY>
     *   <ANY ng-switch-when="matchValue2">...</ANY>
     *   ...
     *   <ANY ng-switch-default>...</ANY>
     *
     * @scope
     * @param {*} ngSwitch|on expression to match against <tt>ng-switch-when</tt>.
     * @paramDescription
     * On child elments add:
     *
     * * `ngSwitchWhen`: the case statement to match against. If match then this
     *   case will be displayed.
     * * `ngSwitchDefault`: the default case when no other casses match.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.items = ['settings', 'home', 'other'];
     $scope.selection = $scope.items[0];
     }
     </script>
     <div ng-controller="Ctrl">
     <select ng-model="selection" ng-options="item for item in items">
     </select>
     <tt>selection={{selection}}</tt>
     <hr/>
     <div ng-switch on="selection" >
     <div ng-switch-when="settings">Settings Div</div>
     <span ng-switch-when="home">Home Span</span>
     <span ng-switch-default>default</span>
     </div>
     </div>
     </doc:source>
     <doc:scenario>
     it('should start in settings', function() {
     expect(element('.doc-example-live [ng-switch]').text()).toMatch(/Settings Div/);
     });
     it('should change to home', function() {
     select('selection').option('home');
     expect(element('.doc-example-live [ng-switch]').text()).toMatch(/Home Span/);
     });
     it('should select deafault', function() {
     select('selection').option('other');
     expect(element('.doc-example-live [ng-switch]').text()).toMatch(/default/);
     });
     </doc:scenario>
     </doc:example>
     */
    var NG_SWITCH = 'ng-switch';
    var ngSwitchDirective = valueFn({
        restrict: 'EA',
        compile: function(element, attr) {
            var watchExpr = attr.ngSwitch || attr.on,
                cases = {};

            element.data(NG_SWITCH, cases);
            return function(scope, element){
                var selectedTransclude,
                    selectedElement,
                    selectedScope;

                scope.$watch(watchExpr, function(value) {
                    if (selectedElement) {
                        selectedScope.$destroy();
                        selectedElement.remove();
                        selectedElement = selectedScope = null;
                    }
                    if ((selectedTransclude = cases['!' + value] || cases['?'])) {
                        scope.$eval(attr.change);
                        selectedScope = scope.$new();
                        selectedTransclude(selectedScope, function(caseElement) {
                            selectedElement = caseElement;
                            element.append(caseElement);
                        });
                    }
                });
            };
        }
    });

    var ngSwitchWhenDirective = ngDirective({
        transclude: 'element',
        priority: 500,
        compile: function(element, attrs, transclude) {
            var cases = element.inheritedData(NG_SWITCH);
            assertArg(cases);
            cases['!' + attrs.ngSwitchWhen] = transclude;
        }
    });

    var ngSwitchDefaultDirective = ngDirective({
        transclude: 'element',
        priority: 500,
        compile: function(element, attrs, transclude) {
            var cases = element.inheritedData(NG_SWITCH);
            assertArg(cases);
            cases['?'] = transclude;
        }
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngTransclude
     *
     * @description
     * Insert the transcluded DOM here.
     *
     * @element ANY
     *
     * @example
     <doc:example module="transclude">
     <doc:source>
     <script>
     function Ctrl($scope) {
     $scope.title = 'Lorem Ipsum';
     $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
     }

     angular.module('transclude', [])
     .directive('pane', function(){
     return {
     restrict: 'E',
     transclude: true,
     scope: 'isolate',
     locals: { title:'bind' },
     template: '<div style="border: 1px solid black;">' +
     '<div style="background-color: gray">{{title}}</div>' +
     '<div ng-transclude></div>' +
     '</div>'
     };
     });
     </script>
     <div ng-controller="Ctrl">
     <input ng-model="title"><br>
     <textarea ng-model="text"></textarea> <br/>
     <pane title="{{title}}">{{text}}</pane>
     </div>
     </doc:source>
     <doc:scenario>
     it('should have transcluded', function() {
     input('title').enter('TITLE');
     input('text').enter('TEXT');
     expect(binding('title')).toEqual('TITLE');
     expect(binding('text')).toEqual('TEXT');
     });
     </doc:scenario>
     </doc:example>
     *
     */
    var ngTranscludeDirective = ngDirective({
        controller: ['$transclude', '$element', function($transclude, $element) {
            $transclude(function(clone) {
                $element.append(clone);
            });
        }]
    });

    /**
     * @ngdoc directive
     * @name ng.directive:ngView
     * @restrict ECA
     *
     * @description
     * # Overview
     * `ngView` is a directive that complements the {@link ng.$route $route} service by
     * including the rendered template of the current route into the main layout (`index.html`) file.
     * Every time the current route changes, the included view changes with it according to the
     * configuration of the `$route` service.
     *
     * @scope
     * @example
     <example module="ngView">
     <file name="index.html">
     <div ng-controller="MainCntl">
     Choose:
     <a href="Book/Moby">Moby</a> |
     <a href="Book/Moby/ch/1">Moby: Ch1</a> |
     <a href="Book/Gatsby">Gatsby</a> |
     <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> |
     <a href="Book/Scarlet">Scarlet Letter</a><br/>

     <div ng-view></div>
     <hr />

     <pre>$location.path() = {{$location.path()}}</pre>
     <pre>$route.current.template = {{$route.current.template}}</pre>
     <pre>$route.current.params = {{$route.current.params}}</pre>
     <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre>
     <pre>$routeParams = {{$routeParams}}</pre>
     </div>
     </file>

     <file name="book.html">
     controller: {{name}}<br />
     Book Id: {{params.bookId}}<br />
     </file>

     <file name="chapter.html">
     controller: {{name}}<br />
     Book Id: {{params.bookId}}<br />
     Chapter Id: {{params.chapterId}}
     </file>

     <file name="script.js">
     angular.module('ngView', [], function($routeProvider, $locationProvider) {
     $routeProvider.when('/Book/:bookId', {
     templateUrl: 'book.html',
     controller: BookCntl
     });
     $routeProvider.when('/Book/:bookId/ch/:chapterId', {
     templateUrl: 'chapter.html',
     controller: ChapterCntl
     });

     // configure html5 to get links working on jsfiddle
     $locationProvider.html5Mode(true);
     });

     function MainCntl($scope, $route, $routeParams, $location) {
     $scope.$route = $route;
     $scope.$location = $location;
     $scope.$routeParams = $routeParams;
     }

     function BookCntl($scope, $routeParams) {
     $scope.name = "BookCntl";
     $scope.params = $routeParams;
     }

     function ChapterCntl($scope, $routeParams) {
     $scope.name = "ChapterCntl";
     $scope.params = $routeParams;
     }
     </file>

     <file name="scenario.js">
     it('should load and compile correct template', function() {
     element('a:contains("Moby: Ch1")').click();
     var content = element('.doc-example-live [ng-view]').text();
     expect(content).toMatch(/controller\: ChapterCntl/);
     expect(content).toMatch(/Book Id\: Moby/);
     expect(content).toMatch(/Chapter Id\: 1/);

     element('a:contains("Scarlet")').click();
     content = element('.doc-example-live [ng-view]').text();
     expect(content).toMatch(/controller\: BookCntl/);
     expect(content).toMatch(/Book Id\: Scarlet/);
     });
     </file>
     </example>
     */


    /**
     * @ngdoc event
     * @name ng.directive:ngView#$viewContentLoaded
     * @eventOf ng.directive:ngView
     * @eventType emit on the current ngView scope
     * @description
     * Emitted every time the ngView content is reloaded.
     */
    var ngViewDirective = ['$http', '$templateCache', '$route', '$anchorScroll', '$compile',
        '$controller',
        function($http,   $templateCache,   $route,   $anchorScroll,   $compile,
                 $controller) {
            return {
                restrict: 'ECA',
                terminal: true,
                link: function(scope, element, attr) {
                    var lastScope,
                        onloadExp = attr.onload || '';

                    scope.$on('$routeChangeSuccess', update);
                    update();


                    function destroyLastScope() {
                        if (lastScope) {
                            lastScope.$destroy();
                            lastScope = null;
                        }
                    }

                    function clearContent() {
                        element.html('');
                        destroyLastScope();
                    }

                    function update() {
                        var locals = $route.current && $route.current.locals,
                            template = locals && locals.$template;

                        if (template) {
                            element.html(template);
                            destroyLastScope();

                            var link = $compile(element.contents()),
                                current = $route.current,
                                controller;

                            lastScope = current.scope = scope.$new();
                            if (current.controller) {
                                locals.$scope = lastScope;
                                controller = $controller(current.controller, locals);
                                element.contents().data('$ngControllerController', controller);
                            }

                            link(lastScope);
                            lastScope.$emit('$viewContentLoaded');
                            lastScope.$eval(onloadExp);

                            // $anchorScroll might listen on event...
                            $anchorScroll();
                        } else {
                            clearContent();
                        }
                    }
                }
            };
        }];

    /**
     * @ngdoc directive
     * @name ng.directive:script
     *
     * @description
     * Load content of a script tag, with type `text/ng-template`, into `$templateCache`, so that the
     * template can be used by `ngInclude`, `ngView` or directive templates.
     *
     * @restrict E
     * @param {'text/ng-template'} type must be set to `'text/ng-template'`
     *
     * @example
     <doc:example>
     <doc:source>
     <script type="text/ng-template" id="/tpl.html">
     Content of the template.
     </script>

     <a ng-click="currentTpl='/tpl.html'" id="tpl-link">Load inlined template</a>
     <div id="tpl-content" ng-include src="currentTpl"></div>
     </doc:source>
     <doc:scenario>
     it('should load template defined inside script tag', function() {
     element('#tpl-link').click();
     expect(element('#tpl-content').text()).toMatch(/Content of the template/);
     });
     </doc:scenario>
     </doc:example>
     */
    var scriptDirective = ['$templateCache', function($templateCache) {
        return {
            restrict: 'E',
            terminal: true,
            compile: function(element, attr) {
                if (attr.type == 'text/ng-template') {
                    var templateUrl = attr.id,
                    // IE is not consistent, in scripts we have to read .text but in other nodes we have to read .textContent
                        text = element[0].text;

                    $templateCache.put(templateUrl, text);
                }
            }
        };
    }];

    /**
     * @ngdoc directive
     * @name ng.directive:select
     * @restrict E
     *
     * @description
     * HTML `SELECT` element with angular data-binding.
     *
     * # `ngOptions`
     *
     * Optionally `ngOptions` attribute can be used to dynamically generate a list of `<option>`
     * elements for a `<select>` element using an array or an object obtained by evaluating the
     * `ngOptions` expression.
     *˝˝
     * When an item in the select menu is select, the value of array element or object property
     * represented by the selected option will be bound to the model identified by the `ngModel`
     * directive of the parent select element.
     *
     * Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
     * be nested into the `<select>` element. This element will then represent `null` or "not selected"
     * option. See example below for demonstration.
     *
     * Note: `ngOptions` provides iterator facility for `<option>` element which should be used instead
     * of {@link ng.directive:ngRepeat ngRepeat} when you want the
     * `select` model to be bound to a non-string value. This is because an option element can currently
     * be bound to string values only.
     *
     * @param {string} name assignable expression to data-bind to.
     * @param {string=} required The control is considered valid only if value is entered.
     * @param {comprehension_expression=} ngOptions in one of the following forms:
     *
     *   * for array data sources:
     *     * `label` **`for`** `value` **`in`** `array`
     *     * `select` **`as`** `label` **`for`** `value` **`in`** `array`
     *     * `label`  **`group by`** `group` **`for`** `value` **`in`** `array`
     *     * `select` **`as`** `label` **`group by`** `group` **`for`** `value` **`in`** `array`
     *   * for object data sources:
     *     * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
     *     * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
     *     * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object`
     *     * `select` **`as`** `label` **`group by`** `group`
     *         **`for` `(`**`key`**`,`** `value`**`) in`** `object`
     *
     * Where:
     *
     *   * `array` / `object`: an expression which evaluates to an array / object to iterate over.
     *   * `value`: local variable which will refer to each item in the `array` or each property value
     *      of `object` during iteration.
     *   * `key`: local variable which will refer to a property name in `object` during iteration.
     *   * `label`: The result of this expression will be the label for `<option>` element. The
     *     `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`).
     *   * `select`: The result of this expression will be bound to the model of the parent `<select>`
     *      element. If not specified, `select` expression will default to `value`.
     *   * `group`: The result of this expression will be used to group options using the `<optgroup>`
     *      DOM element.
     *
     * @example
     <doc:example>
     <doc:source>
     <script>
     function MyCntrl($scope) {
     $scope.colors = [
     {name:'black', shade:'dark'},
     {name:'white', shade:'light'},
     {name:'red', shade:'dark'},
     {name:'blue', shade:'dark'},
     {name:'yellow', shade:'light'}
     ];
     $scope.color = $scope.colors[2]; // red
     }
     </script>
     <div ng-controller="MyCntrl">
     <ul>
     <li ng-repeat="color in colors">
     Name: <input ng-model="color.name">
     [<a href ng-click="colors.splice($index, 1)">X</a>]
     </li>
     <li>
     [<a href ng-click="colors.push({})">add</a>]
     </li>
     </ul>
     <hr/>
     Color (null not allowed):
     <select ng-model="color" ng-options="c.name for c in colors"></select><br>

     Color (null allowed):
     <span  class="nullable">
     <select ng-model="color" ng-options="c.name for c in colors">
     <option value="">-- chose color --</option>
     </select>
     </span><br/>

     Color grouped by shade:
     <select ng-model="color" ng-options="c.name group by c.shade for c in colors">
     </select><br/>


     Select <a href ng-click="color={name:'not in list'}">bogus</a>.<br>
     <hr/>
     Currently selected: {{ {selected_color:color}  }}
     <div style="border:solid 1px black; height:20px"
     ng-style="{'background-color':color.name}">
     </div>
     </div>
     </doc:source>
     <doc:scenario>
     it('should check ng-options', function() {
     expect(binding('{selected_color:color}')).toMatch('red');
     select('color').option('0');
     expect(binding('{selected_color:color}')).toMatch('black');
     using('.nullable').select('color').option('');
     expect(binding('{selected_color:color}')).toMatch('null');
     });
     </doc:scenario>
     </doc:example>
     */

    var ngOptionsDirective = valueFn({ terminal: true });
    var selectDirective = ['$compile', '$parse', function($compile,   $parse) {
        //00001111100000000000222200000000000000000000003333000000000000044444444444444444000000000555555555555555550000000666666666666666660000000000000007777
        var NG_OPTIONS_REGEXP = /^\s*(.*?)(?:\s+as\s+(.*?))?(?:\s+group\s+by\s+(.*))?\s+for\s+(?:([\$\w][\$\w\d]*)|(?:\(\s*([\$\w][\$\w\d]*)\s*,\s*([\$\w][\$\w\d]*)\s*\)))\s+in\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) {
                    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); // needed for IE
                }


                self.hasOption = function(value) {
                    return optionsMap.hasOwnProperty(value);
                }

                $scope.$on('$destroy', function() {
                    // disable unknown option so that we don't do work when the whole select is being destroyed
                    self.renderUnknownOption = noop;
                });
            }],

            link: function(scope, element, attr, ctrls) {
                // if ngModel is not defined, we don't need to do anything
                if (!ctrls[1]) return;

                var selectCtrl = ctrls[0],
                    ngModelCtrl = ctrls[1],
                    multiple = attr.multiple,
                    optionsExp = attr.ngOptions,
                    nullOption = false, // if false, user will not be able to select it (used by ngOptions)
                    emptyOption,
                // we can't just jqLite('<option>') since jqLite is not smart enough
                // to create it in <select> and IE barfs otherwise.
                    optionTemplate = jqLite(document.createElement('option')),
                    optGroupTemplate =jqLite(document.createElement('optgroup')),
                    unknownOption = optionTemplate.clone();

                // find "null" option
                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);

                // required validator
                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) Options(scope, element, ngModelCtrl);
                else if (multiple) Multiple(scope, element, ngModelCtrl);
                else Single(scope, element, ngModelCtrl, selectCtrl);


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



                function Single(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); // to make IE9 happy
                        } else {
                            if (isUndefined(viewValue) && emptyOption) {
                                selectElement.val('');
                            } else {
                                selectCtrl.renderUnknownOption(viewValue);
                            }
                        }
                    };

                    selectElement.bind('change', function() {
                        scope.$apply(function() {
                            if (unknownOption.parent()) unknownOption.remove();
                            ngModelCtrl.$setViewValue(selectElement.val());
                        });
                    });
                }

                function Multiple(scope, selectElement, ctrl) {
                    var lastView;
                    ctrl.$render = function() {
                        var items = new HashMap(ctrl.$viewValue);
                        forEach(selectElement.children(), function(option) {
                            option.selected = isDefined(items.get(option.value));
                        });
                    };

                    // we have to do it on each watch since ngModel watches reference, but
                    // we need to work of an array, so we need to see if anything was inserted/removed
                    scope.$watch(function() {
                        if (!equals(lastView, ctrl.$viewValue)) {
                            lastView = copy(ctrl.$viewValue);
                            ctrl.$render();
                        }
                    });

                    selectElement.bind('change', function() {
                        scope.$apply(function() {
                            var array = [];
                            forEach(selectElement.children(), function(option) {
                                if (option.selected) {
                                    array.push(option.value);
                                }
                            });
                            ctrl.$setViewValue(array);
                        });
                    });
                }

                function Options(scope, selectElement, ctrl) {
                    var match;

                    if (! (match = optionsExp.match(NG_OPTIONS_REGEXP))) {
                        throw Error(
                            "Expected ngOptions in form of '_select_ (as _label_)? for (_key_,)?_value_ in _collection_'" +
                                " but got '" + optionsExp + "'.");
                    }

                    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]),
                    // This is an array of array of existing option groups in DOM. We try to reuse these if possible
                    // optionGroupsCache[0] is the options with no option group
                    // optionGroupsCache[?][0] is the parent: either the SELECT or OPTGROUP element
                        optionGroupsCache = [[{element: selectElement, label:''}]];

                    if (nullOption) {
                        // compile the element since there might be bindings in it
                        $compile(nullOption)(scope);

                        // remove the class, which is added automatically because we recompile the element and it
                        // becomes the compilation root
                        nullOption.removeClass('ng-scope');

                        // we need to remove it before calling selectElement.html('') because otherwise IE will
                        // remove the label from the element. wtf?
                        nullOption.remove();
                    }

                    // clear contents, we'll add what's needed based on the model
                    selectElement.html('');

                    selectElement.bind('change', function() {
                        scope.$apply(function() {
                            var optionGroup,
                                collection = valuesFn(scope) || [],
                                locals = {},
                                key, value, optionElement, index, groupIndex, length, groupLength;

                            if (multiple) {
                                value = [];
                                for (groupIndex = 0, groupLength = optionGroupsCache.length;
                                     groupIndex < groupLength;
                                     groupIndex++) {
                                    // list of options for that group. (first item has the parent)
                                    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;
                                            locals[valueName] = collection[key];
                                            value.push(valueFn(scope, locals));
                                        }
                                    }
                                }
                            } else {
                                key = selectElement.val();
                                if (key == '?') {
                                    value = undefined;
                                } else if (key == ''){
                                    value = null;
                                } else {
                                    locals[valueName] = collection[key];
                                    if (keyName) locals[keyName] = key;
                                    value = valueFn(scope, locals);
                                }
                            }
                            ctrl.$setViewValue(value);
                        });
                    });

                    ctrl.$render = render;

                    // TODO(vojta): can't we optimize this ?
                    scope.$watch(render);

                    function render() {
                        var optionGroups = {'':[]}, // Temporary location for the option groups before we render them
                            optionGroupNames = [''],
                            optionGroupName,
                            optionGroup,
                            option,
                            existingParent, existingOptions, existingOption,
                            modelValue = ctrl.$modelValue,
                            values = valuesFn(scope) || [],
                            keys = keyName ? sortedKeys(values) : values,
                            groupLength, length,
                            groupIndex, index,
                            locals = {},
                            selected,
                            selectedSet = false, // nothing is selected yet
                            lastElement,
                            element;

                        if (multiple) {
                            selectedSet = new HashMap(modelValue);
                        } else if (modelValue === null || nullOption) {
                            // if we are not multiselect, and we are null then we have to add the nullOption
                            optionGroups[''].push({selected:modelValue === null, id:'', label:''});
                            selectedSet = true;
                        }

                        // We now build up the list of options we need (we merge later)
                        for (index = 0; length = keys.length, index < length; index++) {
                            locals[valueName] = values[keyName ? locals[keyName]=keys[index]:index];
                            optionGroupName = groupByFn(scope, locals) || '';
                            if (!(optionGroup = optionGroups[optionGroupName])) {
                                optionGroup = optionGroups[optionGroupName] = [];
                                optionGroupNames.push(optionGroupName);
                            }
                            if (multiple) {
                                selected = selectedSet.remove(valueFn(scope, locals)) != undefined;
                            } else {
                                selected = modelValue === valueFn(scope, locals);
                                selectedSet = selectedSet || selected; // see if at least one item is selected
                            }
                            optionGroup.push({
                                id: keyName ? keys[index] : index,   // either the index into array or key from object
                                label: displayFn(scope, locals) || '', // what will be seen by the user
                                selected: selected                   // determine if we should be selected
                            });
                        }
                        if (!multiple && !selectedSet) {
                            // nothing was selected, we have to insert the undefined item
                            optionGroups[''].unshift({id:'?', label:'', selected:true});
                        }

                        // Now we need to update the list of DOM nodes to match the optionGroups we computed above
                        for (groupIndex = 0, groupLength = optionGroupNames.length;
                             groupIndex < groupLength;
                             groupIndex++) {
                            // current option group name or '' if no group
                            optionGroupName = optionGroupNames[groupIndex];

                            // list of options for that group. (first item has the parent)
                            optionGroup = optionGroups[optionGroupName];

                            if (optionGroupsCache.length <= groupIndex) {
                                // we need to grow the optionGroups
                                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];  // either SELECT (no group) or OPTGROUP element

                                // update the OPTGROUP label if not the same.
                                if (existingParent.label != optionGroupName) {
                                    existingParent.element.attr('label', existingParent.label = optionGroupName);
                                }
                            }

                            lastElement = null;  // start at the beginning
                            for(index = 0, length = optionGroup.length; index < length; index++) {
                                option = optionGroup[index];
                                if ((existingOption = existingOptions[index+1])) {
                                    // reuse elements
                                    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 (existingOption.element.selected !== option.selected) {
                                        lastElement.prop('selected', (existingOption.selected = option.selected));
                                    }
                                } else {
                                    // grow elements

                                    // if it's a null option
                                    if (option.id === '' && nullOption) {
                                        // put back the pre-compiled element
                                        element = nullOption;
                                    } else {
                                        // jQuery(v1.4.2) Bug: We should be able to chain the method calls, but
                                        // in this version of jQuery on some browser the .text() returns a string
                                        // rather then the element.
                                        (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;
                                }
                            }
                            // remove any excessive OPTIONs in a group
                            index++; // increment since the existingOptions[0] is parent element not OPTION
                            while(existingOptions.length > index) {
                                existingOptions.pop().element.remove();
                            }
                        }
                        // remove any excessive OPTGROUPs from select
                        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); // in case we are in optgroup

                    if (selectCtrl && selectCtrl.databound) {
                        // For some reason Opera defaults to true and if not overridden this messes up the repeater.
                        // We don't want the view to drive the initialization of the model anyway.
                        element.prop('selected', false);
                    } else {
                        selectCtrl = nullSelectCtrl;
                    }

                    if (interpolateFn) {
                        scope.$watch(interpolateFn, function(newVal, oldVal) {
                            attr.$set('value', newVal);
                            if (newVal !== oldVal) selectCtrl.removeOption(oldVal);
                            selectCtrl.addOption(newVal);
                        });
                    } else {
                        selectCtrl.addOption(attr.value);
                    }

                    element.bind('$destroy', function() {
                        selectCtrl.removeOption(attr.value);
                    });
                };
            }
        }
    }];

    var styleDirective = valueFn({
        restrict: 'E',
        terminal: true
    });
    //try to bind to jquery now so that one can write angular.element().read()
    //but we will rebind on bootstrap again.
    bindJQuery();

    publishExternalAPI(angular);

    jqLite(document).ready(function() {
        angularInit(document, bootstrap);
    });

})(window, document);
angular.element(document).find('head').append('<style type="text/css">@charset "UTF-8";[ng\\:cloak],[ng-cloak],[data-ng-cloak],[x-ng-cloak],.ng-cloak,.x-ng-cloak{display:none;}ng\\:form{display:block;}</style>');