text: /**
   * @license AngularJS v1.2.0-rc.2
   * (c) 2010-2012 Google, Inc. http://angularjs.org
   * License: MIT
   */
  (function (window, angular, undefined) {
    'use strict';
  
    var copy = angular.copy,
        equals = angular.equals,
        extend = angular.extend,
        forEach = angular.forEach,
        isDefined = angular.isDefined,
        isFunction = angular.isFunction,
        isString = angular.isString,
        jqLite = angular.element,
        noop = angular.noop,
        toJson = angular.toJson;
  
    function inherit(parent, extra) {
      return extend(new (extend(function () {}, { prototype: parent }))(), extra);
    }
  
    /**
     * @ngdoc overview
     * @name ngRoute
     * @description
     *
     * # ngRoute
     *
     * The `ngRoute` module provides routing and deeplinking services and directives for angular apps.
     *
     * {@installModule route}
     *
     */
  
    var ngRouteModule = angular.module('ngRoute', ['ng']).provider('$route', $RouteProvider);
  
    /**
     * @ngdoc object
     * @name ngRoute.$routeProvider
     * @function
     *
     * @description
     *
     * Used for configuring routes. See {@link ngRoute.$route $route} for an example.
     *
     * Requires the {@link ngRoute `ngRoute`} module to be installed.
     */
    function $RouteProvider() {
      var routes = {};
  
      /**
       * @ngdoc method
       * @name ngRoute.$routeProvider#when
       * @methodOf ngRoute.$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 exactly match the
       *    route definition.
       *
       *      * `path` can contain named groups starting with a colon (`:name`). All characters up
       *        to the next slash are matched and stored in `$routeParams` under the given `name`
       *        when the route matches.
       *      * `path` can contain named groups starting with a colon and ending with a star (`:name*`).
       *        All characters are eagerly stored in `$routeParams` under the given `name`
       *        when the route matches.
       *      * `path` can contain optional named groups with a question mark (`:name?`).
       *
       *    For example, routes like `/color/:color/largecode/:largecode*\/edit` will match
       *    `/color/brown/largecode/code/with/slashs/edit` and extract:
       *
       *      * `color: brown`
       *      * `largecode: code/with/slashs`.
       *
       *
       * @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.
       *    - `controllerAs` – `{string=}` – A controller alias name. If present the controller will be
       *      published to scope under the `controllerAs` name.
       *    - `template` – `{string=|function()=}` – html template as a string or a function that
       *      returns an html template as a string which should be used by {@link
       *      ngRoute.directive:ngView ngView} or {@link ng.directive:ngInclude ngInclude} directives.
       *      This property takes precedence over `templateUrl`.
       *
       *      If `template` is a function, it will be called with the following parameters:
       *
       *      - `{Array.<Object>}` - route parameters extracted from the current
       *        `$location.path()` by applying the current route
       *
       *    - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
       *      template that should be used by {@link ngRoute.directive:ngView ngView}.
       *
       *      If `templateUrl` is a function, it will be called with the following parameters:
       *
       *      - `{Array.<Object>}` - route parameters extracted from the current
       *        `$location.path()` by applying the current route
       *
       *    - `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
       *      `$routeChangeSuccess` 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. Be aware that `ngRoute.$routeParams` will
       *        still refer to the previous route within these resolve functions.  Use `$route.current.params`
       *        to access the new route parameters, instead.
       *
       *    - `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.
       *
       *    - `[caseInsensitiveMatch=false]` - {boolean=} - match routes without being case sensitive
       *
       *      If the option is set to `true`, then the particular route can be matched without being
       *      case sensitive
       *
       * @returns {Object} self
       *
       * @description
       * Adds a new route definition to the `$route` service.
       */
      this.when = function (path, route) {
        routes[path] = extend({ reloadOnSearch: true }, route, path && pathRegExp(path, route));
  
        // create redirection for trailing slashes
        if (path) {
          var redirectPath = path[path.length - 1] == '/' ? path.substr(0, path.length - 1) : path + '/';
  
          routes[redirectPath] = extend({ redirectTo: path }, pathRegExp(redirectPath, route));
        }
  
        return this;
      };
  
      /**
       * @param path {string} path
       * @param opts {Object} options
       * @return {?Object}
       *
       * @description
       * Normalizes the given path, returning a regular expression
       * and the original path.
       *
       * Inspired by pathRexp in visionmedia/express/lib/utils.js.
       */
      function pathRegExp(path, opts) {
        var insensitive = opts.caseInsensitiveMatch,
            ret = {
          originalPath: path,
          regexp: path
        },
            keys = ret.keys = [];
  
        path = path.replace(/([().])/g, '\\$1').replace(/(\/)?:(\w+)([\?|\*])?/g, function (_, slash, key, option) {
          var optional = option === '?' ? option : null;
          var star = option === '*' ? option : null;
          keys.push({ name: key, optional: !!optional });
          slash = slash || '';
          return '' + (optional ? '' : slash) + '(?:' + (optional ? slash : '') + (star && '(.+)?' || '([^/]+)?') + ')' + (optional || '');
        }).replace(/([\/$\*])/g, '\\$1');
  
        ret.regexp = new RegExp('^' + path + '$', insensitive ? 'i' : '');
        return ret;
      }
  
      /**
       * @ngdoc method
       * @name ngRoute.$routeProvider#otherwise
       * @methodOf ngRoute.$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', '$sce', function ($rootScope, $location, $routeParams, $q, $injector, $http, $templateCache, $sce) {
  
        /**
         * @ngdoc object
         * @name ngRoute.$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
         * `$route` 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.
         *
         * Requires the {@link ngRoute `ngRoute`} module to be installed.
         *
         * You can define routes through {@link ngRoute.$routeProvider $routeProvider}'s API.
         *
         * The `$route` service is typically used in conjunction with the {@link ngRoute.directive:ngView `ngView`}
         * directive and the {@link ngRoute.$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" deps="angular-route.js">
           <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', ['ngRoute']).config(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 ngRoute.$route#$routeChangeStart
         * @eventOf ngRoute.$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 ngRoute.$route#$routeChangeSuccess
         * @eventOf ngRoute.$route
         * @eventType broadcast on root scope
         * @description
         * Broadcasted after a route dependencies are resolved.
         * {@link ngRoute.directive:ngView ngView} listens for the directive
         * to instantiate the controller and render the view.
         *
         * @param {Object} angularEvent Synthetic event object.
         * @param {Route} current Current route information.
         * @param {Route|Undefined} previous Previous route information, or undefined if current is first route entered.
         */
  
        /**
         * @ngdoc event
         * @name ngRoute.$route#$routeChangeError
         * @eventOf ngRoute.$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 ngRoute.$route#$routeUpdate
         * @eventOf ngRoute.$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 forceReload = false,
            $route = {
          routes: routes,
  
          /**
           * @ngdoc method
           * @name ngRoute.$route#reload
           * @methodOf ngRoute.$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 ngRoute.directive:ngView ngView}
           * creates new scope, reinstantiates the controller.
           */
          reload: function () {
            forceReload = true;
            $rootScope.$evalAsync(updateRoute);
          }
        };
  
        $rootScope.$on('$locationChangeSuccess', updateRoute);
  
        return $route;
  
        /////////////////////////////////////////////////////
  
        /**
         * @param on {string} current url
         * @param route {Object} route regexp to match the url against
         * @return {?Object}
         *
         * @description
         * Check if the route matches the current url.
         *
         * Inspired by match in
         * visionmedia/express/lib/router/router.js.
         */
        function switchRouteMatcher(on, route) {
          var keys = route.keys,
              params = {};
  
          if (!route.regexp) return null;
  
          var m = route.regexp.exec(on);
          if (!m) return null;
  
          for (var i = 1, len = m.length; i < len; ++i) {
            var key = keys[i - 1];
  
            var val = 'string' == typeof m[i] ? decodeURIComponent(m[i]) : m[i];
  
            if (key && val) {
              params[key.name] = val;
            }
          }
          return params;
        }
  
        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 locals = extend({}, next.resolve),
                    template,
                    templateUrl;
  
                forEach(locals, function (value, key) {
                  locals[key] = isString(value) ? $injector.get(value) : $injector.invoke(value);
                });
  
                if (isDefined(template = next.template)) {
                  if (isFunction(template)) {
                    template = template(next.params);
                  }
                } else if (isDefined(templateUrl = next.templateUrl)) {
                  if (isFunction(templateUrl)) {
                    templateUrl = templateUrl(next.params);
                  }
                  templateUrl = $sce.getTrustedResourceUrl(templateUrl);
                  if (isDefined(templateUrl)) {
                    next.loadedTemplateUrl = templateUrl;
                    template = $http.get(templateUrl, { cache: $templateCache }).then(function (response) {
                      return response.data;
                    });
                  }
                }
                if (isDefined(template)) {
                  locals['$template'] = template;
                }
                return $q.all(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 = switchRouteMatcher($location.path(), route))) {
              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 parameters
         */
        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('');
        }
      }];
    }
  
    ngRouteModule.provider('$routeParams', $RouteParamsProvider);
  
    /**
     * @ngdoc object
     * @name ngRoute.$routeParams
     * @requires $route
     *
     * @description
     * The `$routeParams` service allows you to retrieve the current set of route parameters.
     *
     * Requires the {@link ngRoute `ngRoute`} module to be installed.
     *
     * The route parameters are a combination of {@link ng.$location `$location`}'s
     * {@link ng.$location#search `search()`} and {@link ng.$location#path `path()`}.
     * The `path` parameters are extracted when the {@link ngRoute.$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.
     *
     * Note that the `$routeParams` are only updated *after* a route change completes successfully.
     * This means that you cannot rely on `$routeParams` being correct in route resolve functions.
     * Instead you can use `$route.current.params` to access the new route's parameters.
     *
     * @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 = function () {
        return {};
      };
    }
  
    ngRouteModule.directive('ngView', ngViewFactory);
  
    /**
     * @ngdoc directive
     * @name ngRoute.directive:ngView
     * @restrict ECA
     *
     * @description
     * # Overview
     * `ngView` is a directive that complements the {@link ngRoute.$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.
     *
     * Requires the {@link ngRoute `ngRoute`} module to be installed.
     *
     * @animations
     * enter - animation is used to bring new content into the browser.
     * leave - animation is used to animate existing content away.
     *
     * The enter and leave animation occur concurrently.
     *
     * @scope
     * @example
        <example module="ngViewExample" deps="angular-route.js" animations="true">
          <file name="index.html">
            <div ng-controller="MainCntl as main">
              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 class="example-animate-container">
                <div ng-view class="view-example"></div>
              </div>
              <hr />
    
              <pre>$location.path() = {{main.$location.path()}}</pre>
              <pre>$route.current.templateUrl = {{main.$route.current.templateUrl}}</pre>
              <pre>$route.current.params = {{main.$route.current.params}}</pre>
              <pre>$route.current.scope.name = {{main.$route.current.scope.name}}</pre>
              <pre>$routeParams = {{main.$routeParams}}</pre>
            </div>
          </file>
    
          <file name="book.html">
            <div>
              controller: {{book.name}}<br />
              Book Id: {{book.params.bookId}}<br />
            </div>
          </file>
    
          <file name="chapter.html">
            <div>
              controller: {{chapter.name}}<br />
              Book Id: {{chapter.params.bookId}}<br />
              Chapter Id: {{chapter.params.chapterId}}
            </div>
          </file>
    
          <file name="animations.css">
            .example-animate-container {
              position:relative;
              background:white;
              border:1px solid black;
              height:40px;
              overflow:hidden;
            }
    
            .example-animate-container > div {
              padding:10px;
            }
    
            .view-example.ng-enter, .view-example.ng-leave {
              -webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s;
              -moz-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s;
              -o-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s;
              transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s;
    
              display:block;
              width:100%;
              border-left:1px solid black;
    
              position:absolute;
              top:0;
              left:0;
              right:0;
              bottom:0;
              padding:10px;
            }
    
            .example-animate-container {
              position:relative;
              height:100px;
            }
    
            .view-example.ng-enter {
              left:100%;
            }
            .view-example.ng-enter.ng-enter-active {
              left:0;
            }
    
            .view-example.ng-leave { }
            .view-example.ng-leave.ng-leave-active {
              left:-100%;
            }
          </file>
    
          <file name="script.js">
            angular.module('ngViewExample', ['ngRoute', 'ngAnimate'], function($routeProvider, $locationProvider) {
              $routeProvider.when('/Book/:bookId', {
                templateUrl: 'book.html',
                controller: BookCntl,
                controllerAs: 'book'
              });
              $routeProvider.when('/Book/:bookId/ch/:chapterId', {
                templateUrl: 'chapter.html',
                controller: ChapterCntl,
                controllerAs: 'chapter'
              });
    
              // configure html5 to get links working on jsfiddle
              $locationProvider.html5Mode(true);
            });
    
            function MainCntl($route, $routeParams, $location) {
              this.$route = $route;
              this.$location = $location;
              this.$routeParams = $routeParams;
            }
    
            function BookCntl($routeParams) {
              this.name = "BookCntl";
              this.params = $routeParams;
            }
    
            function ChapterCntl($routeParams) {
              this.name = "ChapterCntl";
              this.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 ngRoute.directive:ngView#$viewContentLoaded
     * @eventOf ngRoute.directive:ngView
     * @eventType emit on the current ngView scope
     * @description
     * Emitted every time the ngView content is reloaded.
     */
    ngViewFactory.$inject = ['$route', '$anchorScroll', '$compile', '$controller', '$animate'];
    function ngViewFactory($route, $anchorScroll, $compile, $controller, $animate) {
      return {
        restrict: 'ECA',
        terminal: true,
        priority: 1000,
        transclude: 'element',
        compile: function (element, attr, linker) {
          return function (scope, $element, attr) {
            var currentScope,
                currentElement,
                onloadExp = attr.onload || '';
  
            scope.$on('$routeChangeSuccess', update);
            update();
  
            function cleanupLastView() {
              if (currentScope) {
                currentScope.$destroy();
                currentScope = null;
              }
              if (currentElement) {
                $animate.leave(currentElement);
                currentElement = null;
              }
            }
  
            function update() {
              var locals = $route.current && $route.current.locals,
                  template = locals && locals.$template;
  
              if (template) {
                var newScope = scope.$new();
                linker(newScope, function (clone) {
                  cleanupLastView();
  
                  clone.html(template);
                  $animate.enter(clone, null, $element);
  
                  var link = $compile(clone.contents()),
                      current = $route.current;
  
                  currentScope = current.scope = newScope;
                  currentElement = clone;
  
                  if (current.controller) {
                    locals.$scope = currentScope;
                    var controller = $controller(current.controller, locals);
                    if (current.controllerAs) {
                      currentScope[current.controllerAs] = controller;
                    }
                    clone.data('$ngControllerController', controller);
                    clone.contents().data('$ngControllerController', controller);
                  }
  
                  link(currentScope);
                  currentScope.$emit('$viewContentLoaded');
                  currentScope.$eval(onloadExp);
  
                  // $anchorScroll might listen on event...
                  $anchorScroll();
                });
              } else {
                cleanupLastView();
              }
            }
          };
        }
      };
    }
  })(window, window.angular);