https://keepy.me/build/js/lib.js

1/**
2 * @license AngularJS v1.2.6
3 * (c) 2010-2014 Google, Inc. http://angularjs.org
4 * License: MIT
5 */
6(function(window, angular, undefined) {'use strict';
7
8var $resourceMinErr = angular.$$minErr('$resource');
9
10// Helper functions and regex to lookup a dotted path on an object
11// stopping at undefined/null.  The path must be composed of ASCII
12// identifiers (just like $parse)
13var MEMBER_NAME_REGEX = /^(\.[a-zA-Z_$][0-9a-zA-Z_$]*)+$/;
14
15function isValidDottedPath(path) {
16  return (path != null && path !== '' && path !== 'hasOwnProperty' &&
17      MEMBER_NAME_REGEX.test('.' + path));
18}
19
20function lookupDottedPath(obj, path) {
21  if (!isValidDottedPath(path)) {
22    throw $resourceMinErr('badmember', 'Dotted member path "@{0}" is invalid.', path);
23  }
24  var keys = path.split('.');
25  for (var i = 0, ii = keys.length; i < ii && obj !== undefined; i++) {
26    var key = keys[i];
27    obj = (obj !== null) ? obj[key] : undefined;
28  }
29  return obj;
30}
31
32/**
33 * Create a shallow copy of an object and clear other fields from the destination
34 */
35function shallowClearAndCopy(src, dst) {
36  dst = dst || {};
37
38  angular.forEach(dst, function(value, key){
39    delete dst[key];
40  });
41
42  for (var key in src) {
43    if (src.hasOwnProperty(key) && key.charAt(0) !== '$' && key.charAt(1) !== '$') {
44      dst[key] = src[key];
45    }
46  }
47
48  return dst;
49}
50
51/**
52 * @ngdoc overview
53 * @name ngResource
54 * @description
55 *
56 * # ngResource
57 *
58 * The `ngResource` module provides interaction support with RESTful services
59 * via the $resource service.
60 *
61 * {@installModule resource}
62 *
63 * <div doc-module-components="ngResource"></div>
64 *
65 * See {@link ngResource.$resource `$resource`} for usage.
66 */
67
68/**
69 * @ngdoc object
70 * @name ngResource.$resource
71 * @requires $http
72 *
73 * @description
74 * A factory which creates a resource object that lets you interact with
75 * [RESTful](http://en.wikipedia.org/wiki/Representational_State_Transfer) server-side data sources.
76 *
77 * The returned resource object has action methods which provide high-level behaviors without
78 * the need to interact with the low level {@link ng.$http $http} service.
79 *
80 * Requires the {@link ngResource `ngResource`} module to be installed.
81 *
82 * @param {string} url A parametrized URL template with parameters prefixed by `:` as in
83 *   `/user/:username`. If you are using a URL with a port number (e.g.
84 *   `http://example.com:8080/api`), it will be respected.
85 *
86 *   If you are using a url with a suffix, just add the suffix, like this:
87 *   `$resource('http://example.com/resource.json')` or `$resource('http://example.com/:id.json')`
88 *   or even `$resource('http://example.com/resource/:resource_id.:format')`
89 *   If the parameter before the suffix is empty, :resource_id in this case, then the `/.` will be
90 *   collapsed down to a single `.`.  If you need this sequence to appear and not collapse then you
91 *   can escape it with `/\.`.
92 *
93 * @param {Object=} paramDefaults Default values for `url` parameters. These can be overridden in
94 *   `actions` methods. If any of the parameter value is a function, it will be executed every time
95 *   when a param value needs to be obtained for a request (unless the param was overridden).
96 *
97 *   Each key value in the parameter object is first bound to url template if present and then any
98 *   excess keys are appended to the url seapph query after the `?`.
99 *
100 *   Given a template `/path/:verb` and parameter `{verb:'greet', salutation:'Hello'}` results in
101 *   URL `/path/greet?salutation=Hello`.
102 *
103 *   If the parameter value is prefixed with `@` then the value of that parameter is extracted from
104 *   the data object (useful for non-GET operations).
105 *
106 * @param {Object.<Object>=} actions Hash with declaration of custom action that should extend the
107 *   default set of resource actions. The declaration should be created in the format of {@link
108 *   ng.$http#usage_parameters $http.config}:
109 *
110 *       {action1: {method:?, params:?, isArray:?, headers:?, ...},
111 *        action2: {method:?, params:?, isArray:?, headers:?, ...},
112 *        ...}
113 *
114 *   Where:
115 *
116 *   - **`action`** – {string} – The name of action. This name becomes the name of the method on
117 *     your resource object.
118 *   - **`method`** – {string} – HTTP request method. Valid methods are: `GET`, `POST`, `PUT`,
119 *     `DELETE`, and `JSONP`.
120 *   - **`params`** – {Object=} – Optional set of pre-bound parameters for this action. If any of
121 *     the parameter value is a function, it will be executed every time when a param value needs to
122 *     be obtained for a request (unless the param was overridden).
123 *   - **`url`** – {string} – action specific `url` override. The url templating is supported just
124 *     like for the resource-level urls.
125 *   - **`isArray`** – {boolean=} – If true then the returned object for this action is an array,
126 *     see `returns` section.
127 *   - **`transformRequest`** –
128 *     `{function(data, headersGetter)|Array.<function(data, headersGetter)>

128}` –
129 *     transform function or an array of such functions. The transform function takes the http
130 *     request body and headers and returns its transformed (typically serialized) version.
131 *   - **`transformResponse`** –
132 *     `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
133 *     transform function or an array of such functions. The transform function takes the http
134 *     response body and headers and returns its transformed (typically deserialized) version.
135 *   - **`cache`** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the
136 *     GET request, otherwise if a cache instance built with
137 *     {@link ng.$cacheFactory $cacheFactory}, this cache will be used for
138 *     caching.
139 *   - **`timeout`** – `{number|Promise}` – timeout in milliseconds, or {@link ng.$q promise} that
140 *     should abort the request when resolved.
141 *   - **`withCredentials`** - `{boolean}` - whether to set the `withCredentials` flag on the
142 *     XHR object. See {@link https://developer.mozilla.org/en/http_access_control#section_5
143 *     requests with credentials} for more information.
144 *   - **`responseType`** - `{string}` - see {@link
145 *     https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType requestType}.
146 *   - **`interceptor`** - `{Object=}` - The interceptor object has two optional methods -
147 *     `response` and `responseError`. Both `response` and `responseError` interceptors get called
148 *     with `http response` object. See {@link ng.$http $http interceptors}.
149 *
150 * @returns {Object} A resource "class" object with methods for the default set of resource actions
151 *   optionally extended with custom `actions`. The default set contains these actions:
152 *
153 *       { 'get':    {method:'GET'},
154 *         'save':   {method:'POST'},
155 *         'query':  {method:'GET', isArray:true},
156 *         'remove': {method:'DELETE'},
157 *         'delete': {method:'DELETE'} };
158 *
159 *   Calling these methods invoke an {@link ng.$http} with the specified http method,
160 *   destination and parameters. When the data is returned from the server then the object is an
161 *   instance of the resource class. The actions `save`, `remove` and `delete` are available on it
162 *   as  methods with the `$` prefix. This allows you to easily perform CRUD operations (create,
163 *   read, update, delete) on server-side data like this:
164 *   <pre>
165        var User = $resource('/user/:userId', {userId:'@id'});
166        var user = User.get({userId:123}, function() {
167          user.abc = true;
168          user.$save();
169        });
170     </pre>
171 *
172 *   It is important to realize that invoking a $resource object method immediately returns an
173 *   empty reference (object or array depending on `isArray`). Once the data is returned from the
174 *   server the existing reference is populated with the actual data. This is a useful trick since
175 *   usually the resource is assigned to a model which is then rendered by the view. Having an empty
176 *   object results in no rendering, once the data arrives from the server then the object is
177 *   populated with the data and the view automatically re-renders itself showing the new data. This
178 *   means that in most cases one never has to write a callback function for the action methods.
179 *
180 *   The action methods on the class object or instance object can be invoked with the following
181 *   parameters:
182 *
183 *   - HTTP GET "class" actions: `Resource.action([parameters], [success], [error])`
184 *   - non-GET "class" actions: `Resource.action([parameters], postData, [success], [error])`
185 *   - non-GET instance actions:  `instance.$action([parameters], [success], [error])`
186 *
187 *   Success callback is called with (value, responseHeaders) arguments. Error callback is called
188 *   with (httpResponse) argument.
189 *
190 *   Class actions return empty instance (with additional properties below).
191 *   Instance actions return promise of the action.
192 *
193 *   The Resource instances and collection have these additional properties:
194 *
195 *   - `$promise`: the {@link ng.$q promise} of the original server interaction that created this
196 *     instance or collection.
197 *
198 *     On success, the promise is resolved with the same resource instance or collection object,
199 *     updated with data from server. This makes it easy to use in
200 *     {@link ngRoute.$routeProvider resolve section of $routeProvider.when()} to defer view
201 *     rendering until the resource(s) are loaded.
202 *
203 *     On failure, the promise is resolved with the {@link ng.$http http response} object, without
204 *     the `resource` property.
205 *
206 *   - `$resolved`: `true` after first server interaction is completed (either with success or
207 *      rejection), `false` before that. Knowing if the Resource has been resolved 

207is useful in
208 *      data-binding.
209 *
210 * @example
211 *
212 * # Credit card resource
213 *
214 * <pre>
215     // Define CreditCard class
216     var CreditCard = $resource('/user/:userId/card/:cardId',
217      {userId:123, cardId:'@id'}, {
218       charge: {method:'POST', params:{charge:true}}
219      });
220
221     // We can retrieve a collection from the server
222     var cards = CreditCard.query(function() {
223       // GET: /user/123/card
224       // server returns: [ {id:456, number:'1234', name:'Smith'} ];
225
226       var card = cards[0];
227       // each item is an instance of CreditCard
228       expect(card instanceof CreditCard).toEqual(true);
229       card.name = "J. Smith";
230       // non GET methods are mapped onto the instances
231       card.$save();
232       // POST: /user/123/card/456 {id:456, number:'1234', name:'J. Smith'}
233       // server returns: {id:456, number:'1234', name: 'J. Smith'};
234
235       // our custom method is mapped as well.
236       card.$charge({amount:9.99});
237       // POST: /user/123/card/456?amount=9.99&charge=true {id:456, number:'1234', name:'J. Smith'}
238     });
239
240     // we can create an instance as well
241     var newCard = new CreditCard({number:'0123'});
242     newCard.name = "Mike Smith";
243     newCard.$save();
244     // POST: /user/123/card {number:'0123', name:'Mike Smith'}
245     // server returns: {id:789, number:'0123', name: 'Mike Smith'};
246     expect(newCard.id).toEqual(789);
247 * </pre>
248 *
249 * The object returned from this function execution is a resource "class" which has "static" method
250 * for each action in the definition.
251 *
252 * Calling these methods invoke `$http` on the `url` template with the given `method`, `params` and
253 * `headers`.
254 * When the data is returned from the server then the object is an instance of the resource type and
255 * all of the non-GET methods are available with `$` prefix. This allows you to easily support CRUD
256 * operations (create, read, update, delete) on server-side data.
257
258   <pre>
259     var User = $resource('/user/:userId', {userId:'@id'});
260     var user = User.get({userId:123}, function() {
261       user.abc = true;
262       user.$save();
263     });
264   </pre>
265 *
266 * It's worth noting that the success callback for `get`, `query` and other methods gets passed
267 * in the response that came from the server as well as $http header getter function, so one
268 * could rewrite the above example and get access to http headers as:
269 *
270   <pre>
271     var User = $resource('/user/:userId', {userId:'@id'});
272     User.get({userId:123}, function(u, getResponseHeaders){
273       u.abc = true;
274       u.$save(function(u, putResponseHeaders) {
275         //u => saved user object
276         //putResponseHeaders => $http header getter
277       });
278     });
279   </pre>
280
281 * # Creating a custom 'PUT' request
282 * In this example we create a custom method on our resource to make a PUT request
283 * <pre>
284 *		var app = angular.module('app', ['ngResource', 'ngRoute']);
285 *
286 *		// Some APIs expect a PUT request in the format URL/object/ID
287 *		// Here we are creating an 'update' method 
288 *		app.factory('Notes', ['$resource', function($resource) {
289 *    return $resource('/notes/:id', null,
290 *        {
291 *            'update': { method:'PUT' }
292 *        });
293 *		}]);
294 *
295 *		// In our controller we get the ID from the URL using ngRoute and $routeParams
296 *		// We pass in $routeParams and our Notes factory along with $scope
297 *		app.controller('NotesCtrl', ['$scope', '$routeParams', 'Notes',
298                                      function($scope, $routeParams, Notes) {
299 *    // First get a note object from the factory
300 *    var note = Notes.get({ id:$routeParams.id });
301 *    $id = note.id;
302 *
303 *    // Now call update passing in the ID first then the object you are updating
304 *    Notes.update({ id:$id }, note);
305 *
306 *    // This will PUT /notes/ID with the note object in the request payload
307 *		}]);
308 * </pre>
309 */
310angular.module('ngResource', ['ng']).
311  factory('$resource', ['$http', '$q', function($http, $q) {
312
313    var DEFAULT_ACTIONS = {
314      'get':    {method:'GET'},
315      'save':   {method:'POST'},
316      'query':  {method:'GET', isArray:true},
317      'remove': {method:'DELETE'},
318      'delete': {method:'DELETE'}
319    };
320    var noop = angular.noop,

321        forEach = angular.forEach,
322        extend = angular.extend,
323        copy = angular.copy,
324        isFunction = angular.isFunction;
325
326    /**
327     * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
328     * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
329     * segments:
330     *    segment       = *pchar
331     *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
332     *    pct-encoded   = "%" HEXDIG HEXDIG
333     *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
334     *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
335     *                     / "*" / "+" / "," / ";" / "="
336     */
337    function encodeUriSegment(val) {
338      return encodeUriQuery(val, true).
339        replace(/%26/gi, '&').
340        replace(/%3D/gi, '=').
341        replace(/%2B/gi, '+');
342    }
343
344
345    /**
346     * This method is intended for encoding *key* or *value* parts of query component. We need a
347     * custom method because encodeURIComponent is too aggressive and encodes stuff that doesn't
348     * have to be encoded per http://tools.ietf.org/html/rfc3986:
349     *    query       = *( pchar / "/" / "?" )
350     *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
351     *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
352     *    pct-encoded   = "%" HEXDIG HEXDIG
353     *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
354     *                     / "*" / "+" / "," / ";" / "="
355     */
356    function encodeUriQuery(val, pctEncodeSpaces) {
357      return encodeURIComponent(val).
358        replace(/%40/gi, '@').
359        replace(/%3A/gi, ':').
360        replace(/%24/g, '$').
361        replace(/%2C/gi, ',').
362        replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
363    }
364
365    function Route(template, defaults) {
366      this.template = template;
367      this.defaults = defaults || {};
368      this.urlParams = {};
369    }
370
371    Route.prototype = {
372      setUrlParams: function(config, params, actionUrl) {
373        var self = this,
374            url = actionUrl || self.template,
375            val,
376            encodedVal;
377
378        var urlParams = self.urlParams = {};
379        forEach(url.split(/\W/), function(param){
380          if (param === 'hasOwnProperty') {
381            throw $resourceMinErr('badname', "hasOwnProperty is not a valid parameter name.");
382          }
383          if (!(new RegExp("^\\d+$").test(param)) && param &&
384               (new RegExp("(^|[^\\\\]):" + param + "(\\W|$)").test(url))) {
385            urlParams[param] = true;
386          }
387        });
388        url = url.replace(/\\:/g, ':');
389
390        params = params || {};
391        forEach(self.urlParams, function(_, urlParam){
392          val = params.hasOwnProperty(urlParam) ? params[urlParam] : self.defaults[urlParam];
393          if (angular.isDefined(val) && val !== null) {
394            encodedVal = encodeUriSegment(val);
395            url = url.replace(new RegExp(":" + urlParam + "(\\W|$)", "g"), encodedVal + "$1");
396          } else {
397            url = url.replace(new RegExp("(\/?):" + urlParam + "(\\W|$)", "g"), function(match,
398                leadingSlashes, tail) {
399              if (tail.charAt(0) == '/') {
400                return tail;
401              } else {
402                return leadingSlashes + tail;
403              }
404            });
405          }
406        });
407
408        // strip trailing slashes and set the url
409        url = url.replace(/\/+$/, '');
410        // then replace collapse `/.` if found in the last URL path segment before the query
411        // E.g. `http://url.com/id./format?q=x` becomes `http://url.com/id.format?q=x`
412        url = url.replace(/\/\.(?=\w+($|\?))/, '.');
413        // replace escaped `/\.` with `/.`
414        config.url = url.replace(/\/\\\./, '/.');
415
416
417        // set params - delegate param encoding to $http
418        forEach(params, function(value, key){
419          if (!self.urlParams[key]) {
420            config.params = config.params || {};
421            config.params[key] = value;
422          }
423        });
424      }
425    };
426
427
428    function resourceFactory(url, paramDefaults, actions) {
429      var route = new Route(url);
430
431      actions = extend({}, DEFAULT_ACTIONS, actions);
432
433      function extractParams(data, actionParams){
434        var ids = {};
435        actionParams = extend({}, paramDefaults, actionParams);

436        forEach(actionParams, function(value, key){
437          if (isFunction(value)) { value = value(); }
438          ids[key] = value && value.charAt && value.charAt(0) == '@' ?
439            lookupDottedPath(data, value.substr(1)) : value;
440        });
441        return ids;
442      }
443
444      function defaultResponseInterceptor(response) {
445        return response.resource;
446      }
447
448      function Resource(value){
449        shallowClearAndCopy(value || {}, this);
450      }
451
452      forEach(actions, function(action, name) {
453        var hasBody = /^(POST|PUT|PATCH)$/i.test(action.method);
454
455        Resource[name] = function(a1, a2, a3, a4) {
456          var params = {}, data, success, error;
457
458          /* jshint -W086 */ /* (purposefully fall through case statements) */
459          switch(arguments.length) {
460          case 4:
461            error = a4;
462            success = a3;
463            //fallthrough
464          case 3:
465          case 2:
466            if (isFunction(a2)) {
467              if (isFunction(a1)) {
468                success = a1;
469                error = a2;
470                break;
471              }
472
473              success = a2;
474              error = a3;
475              //fallthrough
476            } else {
477              params = a1;
478              data = a2;
479              success = a3;
480              break;
481            }
482          case 1:
483            if (isFunction(a1)) success = a1;
484            else if (hasBody) data = a1;
485            else params = a1;
486            break;
487          case 0: break;
488          default:
489            throw $resourceMinErr('badargs',
490              "Expected up to 4 arguments [params, data, success, error], got {0} arguments",
491              arguments.length);
492          }
493          /* jshint +W086 */ /* (purposefully fall through case statements) */
494
495          var isInstanceCall = this instanceof Resource;
496          var value = isInstanceCall ? data : (action.isArray ? [] : new Resource(data));
497          var httpConfig = {};
498          var responseInterceptor = action.interceptor && action.interceptor.response ||
499                                    defaultResponseInterceptor;
500          var responseErrorInterceptor = action.interceptor && action.interceptor.responseError ||
501                                    undefined;
502
503          forEach(action, function(value, key) {
504            if (key != 'params' && key != 'isArray' && key != 'interceptor') {
505              httpConfig[key] = copy(value);
506            }
507          });
508
509          if (hasBody) httpConfig.data = data;
510          route.setUrlParams(httpConfig,
511                             extend({}, extractParams(data, action.params || {}), params),
512                             action.url);
513
514          var promise = $http(httpConfig).then(function(response) {
515            var data = response.data,
516                promise = value.$promise;
517
518            if (data) {
519              // Need to convert action.isArray to boolean in case it is undefined
520              // jshint -W018
521              if (angular.isArray(data) !== (!!action.isArray)) {
522                throw $resourceMinErr('badcfg', 'Error in resource configuration. Expected ' +
523                  'response to contain an {0} but got an {1}',
524                  action.isArray?'array':'object', angular.isArray(data)?'array':'object');
525              }
526              // jshint +W018
527              if (action.isArray) {
528                value.length = 0;
529                forEach(data, function(item) {
530                  value.push(new Resource(item));
531                });
532              } else {
533                shallowClearAndCopy(data, value);
534                value.$promise = promise;
535              }
536            }
537
538            value.$resolved = true;
539
540            response.resource = value;
541
542            return response;
543          }, function(response) {
544            value.$resolved = true;
545
546            (error||noop)(response);
547
548            return $q.reject(response);
549          });
550
551          promise = promise.then(
552              function(response) {
553                var value = responseInterceptor(response);
554                (success||noop)(value, response.headers);
555                return value;
556              },
557              responseErrorInterceptor);
558
559          if (!isInstanceCall) {
560            // we are creating instance / collection
561            // - set the initial promise
562            // - return the instance / collection
563            value.$promise = promise;
564            value.$resolved = false;

565
566            return value;
567          }
568
569          // instance call
570          return promise;
571        };
572
573
574        Resource.prototype['$' + name] = function(params, success, error) {
575          if (isFunction(params)) {
576            error = success; success = params; params = {};
577          }
578          var result = Resource[name].call(this, params, this, success, error);
579          return result.$promise || result;
580        };
581      });
582
583      Resource.bind = function(additionalParamDefaults){
584        return resourceFactory(url, extend({}, paramDefaults, additionalParamDefaults), actions);
585      };
586
587      return Resource;
588    }
589
590    return resourceFactory;
591  }]);
592
593
594})(window, window.angular);
595
596/**
597 * @license AngularJS v1.2.6
598 * (c) 2010-2014 Google, Inc. http://angularjs.org
599 * License: MIT
600 */
601(function(window, angular, undefined) {'use strict';
602
603var $sanitizeMinErr = angular.$$minErr('$sanitize');
604
605/**
606 * @ngdoc overview
607 * @name ngSanitize
608 * @description
609 *
610 * # ngSanitize
611 *
612 * The `ngSanitize` module provides functionality to sanitize HTML.
613 *
614 * {@installModule sanitize}
615 *
616 * <div doc-module-components="ngSanitize"></div>
617 *
618 * See {@link ngSanitize.$sanitize `$sanitize`} for usage.
619 */
620
621/*
622 * HTML Parser By Misko Hevery ([email protected])
623 * based on:  HTML Parser By John Resig (ejohn.org)
624 * Original code by Erik Arvidsson, Mozilla Public License
625 * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
626 *
627 * // Use like so:
628 * htmlParser(htmlString, {
629 *     start: function(tag, attrs, unary) {},
630 *     end: function(tag) {},
631 *     chars: function(text) {},
632 *     comment: function(text) {}
633 * });
634 *
635 */
636
637
638/**
639 * @ngdoc service
640 * @name ngSanitize.$sanitize
641 * @function
642 *
643 * @description
644 *   The input is sanitized by parsing the html into tokens. All safe tokens (from a whitelist) are
645 *   then serialized back to properly escaped html string. This means that no unsafe input can make
646 *   it into the returned string, however, since our parser is more strict than a typical browser
647 *   parser, it's possible that some obscure input, which would be recognized as valid HTML by a
648 *   browser, won't make it through the sanitizer.
649 *   The whitelist is configured using the functions `aHrefSanitizationWhitelist` and
650 *   `imgSrcSanitizationWhitelist` of {@link ng.$compileProvider `$compileProvider`}.
651 *
652 * @param {string} html Html input.
653 * @returns {string} Sanitized html.
654 *
655 * @example
656   <doc:example module="ngSanitize">
657   <doc:source>
658     <script>
659       function Ctrl($scope, $sce) {
660         $scope.snippet =
661           '<p style="color:blue">an html\n' +
662           '<em onmouseover="this.textContent=\'PWN3D!\'">click here</em>\n' +
663           'snippet</p>';
664         $scope.deliberatelyTrustDangerousSnippet = function() {
665           return $sce.trustAsHtml($scope.snippet);
666         };
667       }
668     </script>
669     <div ng-controller="Ctrl">
670        Snippet: <textarea ng-model="snippet" cols="60" rows="3"></textarea>
671       <table>
672         <tr>
673           <td>Directive</td>
674           <td>How</td>
675           <td>Source</td>
676           <td>Rendered</td>
677         </tr>
678         <tr id="bind-html-with-sanitize">
679           <td>ng-bind-html</td>
680           <td>Automatically uses $sanitize</td>
681           <td><pre>&lt;div ng-bind-html="snippet"&gt;<br/>&lt;/div&gt;</pre></td>
682           <td><div ng-bind-html="snippet"></div></td>
683         </tr>
684         <tr id="bind-html-with-trust">
685           <td>ng-bind-html</td>
686           <td>Bypass $sanitize by explicitly trusting the dangerous value</td>
687           <td>
688           <pre>&lt;div ng-bind-html="deliberatelyTrustDangerousSnippet()"&gt;
689&lt;/div&gt;</pre>
690           </td>
691           <td><div ng-bind-html="deliberatelyTrustDangerousSnippet()"></div></td>
692         </tr>
693         <tr id="bind-default">
694           <td>ng-bind</td>
695           <td>Automatically escapes</td>
696           <td><pre>&lt;div ng-bind="snippet"&gt;<br/>&lt;/div&gt;</pre></td>
697           <td><div ng-bind="snippet"></div></td>
698         </tr>
699       </table>
700       </div>
701   </doc:source>
702   <doc:scenario>
703     it('should sanitize the html snippet by default', function() {

704       expect(using('#bind-html-with-sanitize').element('div').html()).
705         toBe('<p>an html\n<em>click here</em>\nsnippet</p>');
706     });
707
708     it('should inline raw snippet if bound to a trusted value', function() {
709       expect(using('#bind-html-with-trust').element("div").html()).
710         toBe("<p style=\"color:blue\">an html\n" +
711              "<em onmouseover=\"this.textContent='PWN3D!'\">click here</em>\n" +
712              "snippet</p>");
713     });
714
715     it('should escape snippet without any filter', function() {
716       expect(using('#bind-default').element('div').html()).
717         toBe("&lt;p style=\"color:blue\"&gt;an html\n" +
718              "&lt;em onmouseover=\"this.textContent='PWN3D!'\"&gt;click here&lt;/em&gt;\n" +
719              "snippet&lt;/p&gt;");
720     });
721
722     it('should update', function() {
723       input('snippet').enter('new <b onclick="alert(1)">text</b>');
724       expect(using('#bind-html-with-sanitize').element('div').html()).toBe('new <b>text</b>');
725       expect(using('#bind-html-with-trust').element('div').html()).toBe(
726         'new <b onclick="alert(1)">text</b>');
727       expect(using('#bind-default').element('div').html()).toBe(
728         "new &lt;b onclick=\"alert(1)\"&gt;text&lt;/b&gt;");
729     });
730   </doc:scenario>
731   </doc:example>
732 */
733function $SanitizeProvider() {
734  this.$get = ['$$sanitizeUri', function($$sanitizeUri) {
735    return function(html) {
736      var buf = [];
737      htmlParser(html, htmlSanitizeWriter(buf, function(uri, isImage) {
738        return !/^unsafe/.test($$sanitizeUri(uri, isImage));
739      }));
740      return buf.join('');
741    };
742  }];
743}
744
745function sanitizeText(chars) {
746  var buf = [];
747  var writer = htmlSanitizeWriter(buf, angular.noop);
748  writer.chars(chars);
749  return buf.join('');
750}
751
752
753// Regular Expressions for parsing tags and attributes
754var START_TAG_REGEXP =
755       /^<\s*([\w:-]+)((?:\s+[\w:-]+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)\s*>/,
756  END_TAG_REGEXP = /^<\s*\/\s*([\w:-]+)[^>]*>/,
757  ATTR_REGEXP = /([\w:-]+)(?:\s*=\s*(?:(?:"((?:[^"])*)")|(?:'((?:[^'])*)')|([^>\s]+)))?/g,
758  BEGIN_TAG_REGEXP = /^</,
759  BEGING_END_TAGE_REGEXP = /^<\s*\//,
760  COMMENT_REGEXP = /<!--(.*?)-->/g,
761  DOCTYPE_REGEXP = /<!DOCTYPE([^>]*?)>/i,
762  CDATA_REGEXP = /<!\[CDATA\[(.*?)]]>/g,
763  // Match everything outside of normal chars and " (quote character)
764  NON_ALPHANUMERIC_REGEXP = /([^\#-~| |!])/g;
765
766
767// Good source of info about elements and attributes
768// http://dev.w3.org/html5/spec/Overview.html#semantics
769// http://simon.html5.org/html-elements
770
771// Safe Void Elements - HTML5
772// http://dev.w3.org/html5/spec/Overview.html#void-elements
773var voidElements = makeMap("area,br,col,hr,img,wbr");
774
775// Elements that you can, intentionally, leave open (and which close themselves)
776// http://dev.w3.org/html5/spec/Overview.html#optional-tags
777var optionalEndTagBlockElements = makeMap("colgroup,dd,dt,li,p,tbody,td,tfoot,th,thead,tr"),
778    optionalEndTagInlineElements = makeMap("rp,rt"),
779    optionalEndTagElements = angular.extend({},
780                                            optionalEndTagInlineElements,
781                                            optionalEndTagBlockElements);
782
783// Safe Block Elements - HTML5
784var blockElements = angular.extend({}, optionalEndTagBlockElements, makeMap("address,article," +
785        "aside,blockquote,caption,center,del,dir,div,dl,figure,figcaption,footer,h1,h2,h3,h4,h5," +
786        "h6,header,hgroup,hr,ins,map,menu,nav,ol,pre,script,section,table,ul"));
787
788// Inline Elements - HTML5
789var inlineElements = angular.extend({}, optionalEndTagInlineElements, makeMap("a,abbr,acronym,b," +
790        "bdi,bdo,big,br,cite,code,del,dfn,em,font,i,img,ins,kbd,label,map,mark,q,ruby,rp,rt,s," +
791        "samp,small,span,strike,strong,sub,sup,time,tt,u,var"));
792
793
794// Special Elements (can contain anything)
795var specialElements = makeMap("script,style");
796
797var validElements = angular.extend({},
798                                   voidElements,
799                                   blockElements,
800                                   inlineElements,
801                                   optionalEndTagElements);
802
803//Attributes that have href and hence need to be sanitized
804var uriAttrs = makeMap("background,cite,href,longdesc,src,usemap");
805var validAttrs = angular.extend({}, uriAttrs, makeMap(
806    'abbr,align,alt,axis,bgcolor,border,cellpadding,cellspacing,class,clear,'+

807    'color,cols,colspan,compact,coords,dir,face,headers,height,hreflang,hspace,'+
808    'ismap,lang,language,nohref,nowrap,rel,rev,rows,rowspan,rules,'+
809    'scope,scrolling,shape,span,start,summary,target,title,type,'+
810    'valign,value,vspace,width'));
811
812function makeMap(str) {
813  var obj = {}, items = str.split(','), i;
814  for (i = 0; i < items.length; i++) obj[items[i]] = true;
815  return obj;
816}
817
818
819/**
820 * @example
821 * htmlParser(htmlString, {
822 *     start: function(tag, attrs, unary) {},
823 *     end: function(tag) {},
824 *     chars: function(text) {},
825 *     comment: function(text) {}
826 * });
827 *
828 * @param {string} html string
829 * @param {object} handler
830 */
831function htmlParser( html, handler ) {
832  var index, chars, match, stack = [], last = html;
833  stack.last = function() { return stack[ stack.length - 1 ]; };
834
835  while ( html ) {
836    chars = true;
837
838    // Make sure we're not in a script or style element
839    if ( !stack.last() || !specialElements[ stack.last() ] ) {
840
841      // Comment
842      if ( html.indexOf("<!--") === 0 ) {
843        // comments containing -- are not allowed unless they terminate the comment
844        index = html.indexOf("--", 4);
845
846        if ( index >= 0 && html.lastIndexOf("-->", index) === index) {
847          if (handler.comment) handler.comment( html.substring( 4, index ) );
848          html = html.substring( index + 3 );
849          chars = false;
850        }
851      // DOCTYPE
852      } else if ( DOCTYPE_REGEXP.test(html) ) {
853        match = html.match( DOCTYPE_REGEXP );
854
855        if ( match ) {
856          html = html.replace( match[0] , '');
857          chars = false;
858        }
859      // end tag
860      } else if ( BEGING_END_TAGE_REGEXP.test(html) ) {
861        match = html.match( END_TAG_REGEXP );
862
863        if ( match ) {
864          html = html.substring( match[0].length );
865          match[0].replace( END_TAG_REGEXP, parseEndTag );
866          chars = false;
867        }
868
869      // start tag
870      } else if ( BEGIN_TAG_REGEXP.test(html) ) {
871        match = html.match( START_TAG_REGEXP );
872
873        if ( match ) {
874          html = html.substring( match[0].length );
875          match[0].replace( START_TAG_REGEXP, parseStartTag );
876          chars = false;
877        }
878      }
879
880      if ( chars ) {
881        index = html.indexOf("<");
882
883        var text = index < 0 ? html : html.substring( 0, index );
884        html = index < 0 ? "" : html.substring( index );
885
886        if (handler.chars) handler.chars( decodeEntities(text) );
887      }
888
889    } else {
890      html = html.replace(new RegExp("(.*)<\\s*\\/\\s*" + stack.last() + "[^>]*>", 'i'),
891        function(all, text){
892          text = text.replace(COMMENT_REGEXP, "$1").replace(CDATA_REGEXP, "$1");
893
894          if (handler.chars) handler.chars( decodeEntities(text) );
895
896          return "";
897      });
898
899      parseEndTag( "", stack.last() );
900    }
901
902    if ( html == last ) {
903      throw $sanitizeMinErr('badparse', "The sanitizer was unable to parse the following block " +
904                                        "of html: {0}", html);
905    }
906    last = html;
907  }
908
909  // Clean up any remaining tags
910  parseEndTag();
911
912  function parseStartTag( tag, tagName, rest, unary ) {
913    tagName = angular.lowercase(tagName);
914    if ( blockElements[ tagName ] ) {
915      while ( stack.last() && inlineElements[ stack.last() ] ) {
916        parseEndTag( "", stack.last() );
917      }
918    }
919
920    if ( optionalEndTagElements[ tagName ] && stack.last() == tagName ) {
921      parseEndTag( "", tagName );
922    }
923
924    unary = voidElements[ tagName ] || !!unary;
925
926    if ( !unary )
927      stack.push( tagName );
928
929    var attrs = {};
930
931    rest.replace(ATTR_REGEXP,
932      function(match, name, doubleQuotedValue, singleQuotedValue, unquotedValue) {
933        var value = doubleQuotedValue
934          || singleQuotedValue
935          || unquotedValue
936          || '';
937
938        attrs[name] = decodeEntities(value);
939    });
940    if (handler.start) handler.start( tagName, attrs, unary );
941  }
942
943  function parseEndTag( tag, tagName ) {
944    var pos = 0, i;
945    tagName = angular.lowercase(tagName);
946    if ( tagName )
947      // Find the closest opened tag of the same type
948      for ( pos = stack.length - 1; pos >= 0; pos-- )
949        if ( stack[ pos ] == tagName )
950          break;
951
952    if ( pos >= 0 ) {
953      // Close all the open elements, up the stack
954      for ( i = stack.length - 1; i >= pos; i-- )
955        if (handler.end) handler.end( stack[ i ] );
956
957      // Remove the open elements from the stack
958      stack.length = pos;
959    }
960  }
961}
962
963var hiddenPre=document.createElement("pre");
964var spaceRe = /^(\s*)([\s\S]*?)(\s*)$/;
965/**
966 * decodes all entities into regular string
967 * @param value
968 * @returns {string} A string with decoded entities.
969 */
970function decodeEntities(value) {
971  if (!value) { return ''; }
972

973  // Note: IE8 does not preserve spaces at the start/end of innerHTML
974  // so we must capture them and reattach them afterward
975  var parts = spaceRe.exec(value);
976  var spaceBefore = parts[1];
977  var spaceAfter = parts[3];
978  var content = parts[2];
979  if (content) {
980    hiddenPre.innerHTML=content.replace(/</g,"&lt;");
981    // innerText depends on styling as it doesn't display hidden elements.
982    // Therefore, it's better to use textContent not to cause unnecessary
983    // reflows. However, IE<9 don't support textContent so the innerText
984    // fallback is necessary.
985    content = 'textContent' in hiddenPre ?
986      hiddenPre.textContent : hiddenPre.innerText;
987  }
988  return spaceBefore + content + spaceAfter;
989}
990
991/**
992 * Escapes all potentially dangerous characters, so that the
993 * resulting string can be safely inserted into attribute or
994 * element text.
995 * @param value
996 * @returns escaped text
997 */
998function encodeEntities(value) {
999  return value.
1000    replace(/&/g, '&amp;').
1001    replace(NON_ALPHANUMERIC_REGEXP, function(value){
1002      return '&#' + value.charCodeAt(0) + ';';
1003    }).
1004    replace(/</g, '&lt;').
1005    replace(/>/g, '&gt;');
1006}
1007
1008/**
1009 * create an HTML/XML writer which writes to buffer
1010 * @param {Array} buf use buf.jain('') to get out sanitized html string
1011 * @returns {object} in the form of {
1012 *     start: function(tag, attrs, unary) {},
1013 *     end: function(tag) {},
1014 *     chars: function(text) {},
1015 *     comment: function(text) {}
1016 * }
1017 */
1018function htmlSanitizeWriter(buf, uriValidator){
1019  var ignore = false;
1020  var out = angular.bind(buf, buf.push);
1021  return {
1022    start: function(tag, attrs, unary){
1023      tag = angular.lowercase(tag);
1024      if (!ignore && specialElements[tag]) {
1025        ignore = tag;
1026      }

1027      if (!ignore && validElements[tag] === true) {
1028        out('<');
1029        out(tag);
1030        angular.forEach(attrs, function(value, key){
1031          var lkey=angular.lowercase(key);
1032          var isImage = (tag === 'img' && lkey === 'src') || (lkey === 'background');
1033          if (validAttrs[lkey] === true &&
1034            (uriAttrs[lkey] !== true || uriValidator(value, isImage))) {
1035            out(' ');
1036            out(key);
1037            out('="');
1038            out(encodeEntities(value));
1039            out('"');
1040          }
1041        });
1042        out(unary ? '/>' : '>');
1043      }
1044    },
1045    end: function(tag){
1046        tag = angular.lowercase(tag);
1047        if (!ignore && validElements[tag] === true) {
1048          out('</');
1049          out(tag);
1050          out('>');
1051        }
1052        if (tag == ignore) {
1053          ignore = false;
1054        }
1055      },
1056    chars: function(chars){
1057        if (!ignore) {
1058          out(encodeEntities(chars));
1059        }
1060      }
1061  };
1062}
1063
1064
1065// define ngSanitize module and register $sanitize service
1066angular.module('ngSanitize', []).provider('$sanitize', $SanitizeProvider);
1067
1068/* global sanitizeText: false */
1069
1070/**
1071 * @ngdoc filter
1072 * @name ngSanitize.filter:linky
1073 * @function
1074 *
1075 * @description
1076 * Finds links in text input and turns them into html links. Supports http/https/ftp/mailto and
1077 * plain email address links.
1078 *
1079 * Requires the {@link ngSanitize `ngSanitize`} module to be installed.
1080 *
1081 * @param {string} text Input text.
1082 * @param {string} target Window (_blank|_self|_parent|_top) or named frame to open links in.
1083 * @returns {string} Html-linkified text.
1084 *
1085 * @usage
1086   <span ng-bind-html="linky_expression | linky"></span>
1087 *
1088 * @example
1089   <doc:example module="ngSanitize">
1090     <doc:source>
1091       <script>
1092         function Ctrl($scope) {
1093           $scope.snippet =
1094             'Pretty text with some links:\n'+
1095             'http://angularjs.org/,\n'+
1096             'mailto:[email protected],\n'+
1097             '[email protected],\n'+
1098             'and one more: ftp://127.0.0.1/.';
1099           $scope.snippetWithTarget = 'http://angularjs.org/';
1100         }
1101       </script>
1102       <div ng-controller="Ctrl">
1103       Snippet: <textarea ng-model="snippet" cols="60" rows="3"></textarea>
1104       <table>
1105         <tr>
1106           <td>Filter</td>
1107           <td>Source</td>
1108           <td>Rendered</td>
1109         </tr>
1110         <tr id="linky-filter">
1111           <td>linky filter</td>
1112           <td>
1113             <pre>&lt;div ng-bind-html="snippet | linky"&gt;<br>&lt;/div&gt;</pre>
1114           </td>
1115           <td>
1116             <div ng-bind-html="snippet | linky"></div>
1117           </td>
1118         </tr>
1119         <tr id="linky-target">
1120          <td>linky target</td>
1121          <td>
1122            <pre>&lt;div ng-bind-html="snippetWithTarget | linky:'_blank'"&gt;<br>&lt;/div&gt;</pre>
1123          </td>
1124          <td>
1125            <div ng-bind-html="snippetWithTarget | linky:'_blank'"></div>
1126          </td>
1127         </tr>
1128         <tr id="escaped-html">
1129           <td>no filter</td>
1130           <td><pre>&lt;div ng-bind="snippet"&gt;<br>&lt;/div&gt;</pre></td>
1131           <td><div ng-bind="snippet"></div></td>
1132         </tr>
1133       </table>

1134     </doc:source>
1135     <doc:scenario>
1136       it('should linkify the snippet with urls', function() {
1137         expect(using('#linky-filter').binding('snippet | linky')).
1138           toBe('Pretty text with some links:&#10;' +
1139                '<a href="http://angularjs.org/">http://angularjs.org/</a>,&#10;' +
1140                '<a href="mailto:[email protected]">[email protected]</a>,&#10;' +
1141                '<a href="mailto:[email protected]">[email protected]</a>,&#10;' +
1142                'and one more: <a href="ftp://127.0.0.1/">ftp://127.0.0.1/</a>.');
1143       });
1144
1145       it ('should not linkify snippet without the linky filter', function() {
1146         expect(using('#escaped-html').binding('snippet')).
1147           toBe("Pretty text with some links:\n" +
1148                "http://angularjs.org/,\n" +
1149                "mailto:[email protected],\n" +
1150                "[email protected],\n" +
1151                "and one more: ftp://127.0.0.1/.");
1152       });
1153
1154       it('should update', function() {
1155         input('snippet').enter('new http://link.');
1156         expect(using('#linky-filter').binding('snippet | linky')).
1157           toBe('new <a href="http://link">http://link</a>.');
1158         expect(using('#escaped-html').binding('snippet')).toBe('new http://link.');
1159       });
1160
1161       it('should work with the target property', function() {
1162        expect(using('#linky-target').binding("snippetWithTarget | linky:'_blank'")).
1163          toBe('<a target="_blank" href="http://angularjs.org/">http://angularjs.org/</a>');
1164       });
1165     </doc:scenario>
1166   </doc:example>
1167 */
1168angular.module('ngSanitize').filter('linky', ['$sanitize', function($sanitize) {
1169  var LINKY_URL_REGEXP =
1170        /((ftp|https?):\/\/|(mailto:)?[A-Za-z0-9._%+-]+@)\S*[^\s.;,(){}<>]/,
1171      MAILTO_REGEXP = /^mailto:/;
1172
1173  return function(text, target) {
1174    if (!text) return text;
1175    var match;
1176    var raw = text;
1177    var html = [];
1178    var url;
1179    var i;
1180    while ((match = raw.match(LINKY_URL_REGEXP))) {
1181      // We can not end in these as they are sometimes found at the end of the sentence
1182      url = match[0];
1183      // if we did not match ftp/http/mailto then assume mailto
1184      if (match[2] == match[3]) url = 'mailto:' + url;
1185      i = match.index;

1186      addText(raw.substr(0, i));
1187      addLink(url, match[0].replace(MAILTO_REGEXP, ''));
1188      raw = raw.substring(i + match[0].length);
1189    }
1190    addText(raw);
1191    return $sanitize(html.join(''));
1192
1193    function addText(text) {
1194      if (!text) {
1195        return;
1196      }
1197      html.push(sanitizeText(text));
1198    }
1199
1200    function addLink(url, text) {
1201      html.push('<a ');
1202      if (angular.isDefined(target)) {
1203        html.push('target="');
1204        html.push(target);
1205        html.push('" ');
1206      }
1207      html.push('href="');
1208      html.push(url);
1209      html.push('">');
1210      addText(text);
1211      html.push('</a>');
1212    }
1213  };
1214}]);
1215
1216
1217})(window, window.angular);
1218
1219/**
1220 * @license AngularJS v1.2.6
1221 * (c) 2010-2014 Google, Inc. http://angularjs.org
1222 * License: MIT
1223 */
1224(function(window, angular, undefined) {'use strict';
1225
1226/**
1227 * @ngdoc overview
1228 * @name ngRoute
1229 * @description
1230 *
1231 * # ngRoute
1232 *
1233 * The `ngRoute` module provides routing and deeplinking services and directives for angular apps.
1234 *
1235 * ## Example
1236 * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`.
1237 * 
1238 * {@installModule route}
1239 *
1240 * <div doc-module-components="ngRoute"></div>
1241 */
1242 /* global -ngRouteModule */
1243var ngRouteModule = angular.module('ngRoute', ['ng']).
1244                        provider('$route', $RouteProvider);
1245
1246/**
1247 * @ngdoc object
1248 * @name ngRoute.$routeProvider
1249 * @function
1250 *
1251 * @description
1252 *

1253 * Used for configuring routes.
1254 * 
1255 * ## Example
1256 * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`.
1257 *
1258 * ## Dependencies
1259 * Requires the {@link ngRoute `ngRoute`} module to be installed.
1260 */
1261function $RouteProvider(){
1262  function inherit(parent, extra) {
1263    return angular.extend(new (angular.extend(function() {}, {prototype:parent}))(), extra);
1264  }
1265
1266  var routes = {};
1267
1268  /**
1269   * @ngdoc method
1270   * @name ngRoute.$routeProvider#when
1271   * @methodOf ngRoute.$routeProvider
1272   *
1273   * @param {string} path Route path (matched against `$location.path`). If `$location.path`
1274   *    contains redundant trailing slash or is missing one, the route will still match and the
1275   *    `$location.path` will be updated to add or drop the trailing slash to exactly match the
1276   *    route definition.
1277   *
1278   *      * `path` can contain named groups starting with a colon: e.g. `:name`. All characters up
1279   *        to the next slash are matched and stored in `$routeParams` under the given `name`
1280   *        when the route matches.
1281   *      * `path` can contain named groups starting with a colon and ending with a star:
1282   *        e.g.`:name*`. All characters are eagerly stored in `$routeParams` under the given `name`
1283   *        when the route matches.
1284   *      * `path` can contain optional named groups with a question mark: e.g.`:name?`.
1285   *
1286   *    For example, routes like `/color/:color/largecode/:largecode*\/edit` will match
1287   *    `/color/brown/largecode/code/with/slashs/edit` and extract:
1288   *
1289   *      * `color: brown`
1290   *      * `largecode: code/with/slashs`.
1291   *
1292   *
1293   * @param {Object} route Mapping information to be assigned to `$route.current` on route
1294   *    match.
1295   *
1296   *    Object properties:
1297   *
1298   *    - `controller` – `{(string|function()=}` – Controller fn that should be associated with
1299   *      newly created scope or the name of a {@link angular.Module#controller registered
1300   *      controller} if passed as a string.
1301   *    - `controllerAs` – `{string=}` – A controller alias name. If present the controller will be
1302   *      published to scope under the `controllerAs` name.
1303   *    - `template` – `{string=|function()=}` – html template as a string or a function that
1304   *      returns an html template as a string which should be used by {@link
1305   *      ngRoute.directive:ngView ngView} or {@link ng.directive:ngInclude ngInclude} directives.
1306   *      This property takes precedence over `templateUrl`.
1307   *
1308   *      If `template` is a function, it will be called with the following parameters:
1309   *
1310   *      - `{Array.<Object>}` - route parameters extracted from the current
1311   *        `$location.path()` by applying the current route
1312   *
1313   *    - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
1314   *      template that should be used by {@link ngRoute.directive:ngView ngView}.
1315   *
1316   *      If `templateUrl` is a function, it will be called with the following parameters:
1317   *
1318   *      - `{Array.<Object>}` - route parameters extracted from the current
1319   *        `$location.path()` by applying the current route
1320   *
1321   *    - `resolve` - `{Object.<string, function>=}` - An optional map of dependencies which should
1322   *      be injected into the controller. If any of these dependencies are promises, the router
1323   *      will wait for them all to be resolved or one to be rejected before the controller is
1324   *      instantiated.
1325   *      If all the promises are resolved successfully, the values of the resolved promises are
1326   *      injected and {@link ngRoute.$route#$routeChangeSuccess $routeChangeSuccess} event is
1327   *      fired. If any of the promises are rejected the
1328   *      {@link ngRoute.$route#$routeChangeError $routeChangeError} event is fired. The map object
1329   *      is:
1330   *
1331   *      - `key` – `{string}`: a name of a dependency to be injected into the controller.
1332   *      - `factory` - `{string|function}`: If `string` then it is an alias for a service.
1333   *        Otherwise if function, then it is {@link api/AUTO.$injector#invoke injected}
1334   *        and the return value is treated as the dependency. If the result is a promise, it is
1335   *        resolved before its value is injected into the controller. Be aware that

1336   *        `ngRoute.$routeParams` will still refer to the previous route within these resolve
1337   *        functions.  Use `$route.current.params` to access the new route parameters, instead.
1338   *
1339   *    - `redirectTo` – {(string|function())=} – value to update
1340   *      {@link ng.$location $location} path with and trigger route redirection.
1341   *
1342   *      If `redirectTo` is a function, it will be called with the following parameters:
1343   *
1344   *      - `{Object.<string>}` - route parameters extracted from the current
1345   *        `$location.path()` by applying the current route templateUrl.
1346   *      - `{string}` - current `$location.path()`
1347   *      - `{Object}` - current `$location.search()`
1348   *
1349   *      The custom `redirectTo` function is expected to return a string which will be used
1350   *      to update `$location.path()` and `$location.search()`.
1351   *
1352   *    - `[reloadOnSearch=true]` - {boolean=} - reload route when only `$location.search()`
1353   *      or `$location.hash()` changes.
1354   *
1355   *      If the option is set to `false` and url in the browser changes, then
1356   *      `$routeUpdate` event is broadcasted on the root scope.
1357   *
1358   *    - `[caseInsensitiveMatch=false]` - {boolean=} - match routes without being case sensitive
1359   *
1360   *      If the option is set to `true`, then the particular route can be matched without being
1361   *      case sensitive
1362   *
1363   * @returns {Object} self
1364   *
1365   * @description
1366   * Adds a new route definition to the `$route` service.
1367   */
1368  this.when = function(path, route) {
1369    routes[path] = angular.extend(
1370      {reloadOnSearch: true},
1371      route,
1372      path && pathRegExp(path, route)
1373    );
1374
1375    // create redirection for trailing slashes
1376    if (path) {
1377      var redirectPath = (path[path.length-1] == '/')
1378            ? path.substr(0, path.length-1)
1379            : path +'/';
1380
1381      routes[redirectPath] = angular.extend(
1382        {redirectTo: path},
1383        pathRegExp(redirectPath, route)
1384      );
1385    }
1386
1387    return this;
1388  };
1389
1390   /**
1391    * @param path {string} path
1392    * @param opts {Object} options
1393    * @return {?Object}
1394    *
1395    * @description
1396    * Normalizes the given path, returning a regular expression
1397    * and the original path.
1398    *
1399    * Inspired by pathRexp in visionmedia/express/lib/utils.js.
1400    */
1401  function pathRegExp(path, opts) {
1402    var insensitive = opts.caseInsensitiveMatch,
1403        ret = {
1404          originalPath: path,
1405          regexp: path
1406        },
1407        keys = ret.keys = [];
1408
1409    path = path
1410      .replace(/([().])/g, '\\$1')
1411      .replace(/(\/)?:(\w+)([\?|\*])?/g, function(_, slash, key, option){
1412        var optional = option === '?' ? option : null;
1413        var star = option === '*' ? option : null;
1414        keys.push({ name: key, optional: !!optional });
1415        slash = slash || '';
1416        return ''
1417          + (optional ? '' : slash)
1418          + '(?:'
1419          + (optional ? slash : '')
1420          + (star && '(.+?)' || '([^/]+)')
1421          + (optional || '')
1422          + ')'
1423          + (optional || '');
1424      })
1425      .replace(/([\/$\*])/g, '\\$1');
1426
1427    ret.regexp = new RegExp('^' + path + '$', insensitive ? 'i' : '');
1428    return ret;
1429  }
1430
1431  /**
1432   * @ngdoc method
1433   * @name ngRoute.$routeProvider#otherwise
1434   * @methodOf ngRoute.$routeProvider
1435   *
1436   * @description
1437   * Sets route definition that will be used on route change when no other route definition
1438   * is matched.
1439   *
1440   * @param {Object} params Mapping information to be assigned to `$route.current`.
1441   * @returns {Object} self
1442   */
1443  this.otherwise = function(params) {
1444    this.when(null, params);
1445    return this;
1446  };
1447
1448
1449  this.$get = ['$rootScope',
1450               '$location',
1451               '$routeParams',
1452               '$q',
1453               '$injector',
1454               '$http',
1455               '$templateCache',
1456               '$sce',
1457      function($rootScope, $location, $routeParams, $q, $injector, $http, $templateCache, $sce) {
1458
1459    /**
1460     * @ngdoc object
1461     * @name ngRoute.$route
1462     * @requires $location
1463     * @requires $routeParams
1464     *
1465     * @property {Object} current Reference to the current route definition.
1466     * The route definition contains:
1467     *
1468     *   - `controller`: The controller constructor as define in route definition.
1469     *   - `locals`: A map of locals which is used by {@link ng.$controller $controller} service for
1470     *     controller instantiation. The `locals` contain
1471     *     the resolved values of the `resolve` map. Additionally the `locals` also contain:
1472     *
1473     *     - `$scope` - The current route scope.
1474     *     - `$template` - The current route template HTML.
1475     *
1476     * @property {Array.<Object>} routes Array of all configured routes.
1477     *

1478     * @description
1479     * `$route` is used for deep-linking URLs to controllers and views (HTML partials).
1480     * It watches `$location.url()` and tries to map the path to an existing route definition.
1481     *
1482     * Requires the {@link ngRoute `ngRoute`} module to be installed.
1483     *
1484     * You can define routes through {@link ngRoute.$routeProvider $routeProvider}'s API.
1485     *
1486     * The `$route` service is typically used in conjunction with the
1487     * {@link ngRoute.directive:ngView `ngView`} directive and the
1488     * {@link ngRoute.$routeParams `$routeParams`} service.
1489     *
1490     * @example
1491       This example shows how changing the URL hash causes the `$route` to match a route against the
1492       URL, and the `ngView` pulls in the partial.
1493
1494       Note that this example is using {@link ng.directive:script inlined templates}
1495       to get it working on jsfiddle as well.
1496
1497     <example module="ngViewExample" deps="angular-route.js">
1498       <file name="index.html">
1499         <div ng-controller="MainCntl">
1500           Choose:
1501           <a href="Book/Moby">Moby</a> |
1502           <a href="Book/Moby/ch/1">Moby: Ch1</a> |
1503           <a href="Book/Gatsby">Gatsby</a> |
1504           <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> |
1505           <a href="Book/Scarlet">Scarlet Letter</a><br/>
1506
1507           <div ng-view></div>
1508           <hr />
1509
1510           <pre>$location.path() = {{$location.path()}}</pre>
1511           <pre>$route.current.templateUrl = {{$route.current.templateUrl}}</pre>
1512           <pre>$route.current.params = {{$route.current.params}}</pre>
1513           <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre>
1514           <pre>$routeParams = {{$routeParams}}</pre>
1515         </div>
1516       </file>
1517
1518       <file name="book.html">
1519         controller: {{name}}<br />
1520         Book Id: {{params.bookId}}<br />
1521       </file>
1522
1523       <file name="chapter.html">
1524         controller: {{name}}<br />
1525         Book Id: {{params.bookId}}<br />
1526         Chapter Id: {{params.chapterId}}
1527       </file>
1528
1529       <file name="script.js">
1530         angular.module('ngViewExample', ['ngRoute'])
1531
1532         .config(function($routeProvider, $locationProvider) {
1533           $routeProvider.when('/Book/:bookId', {
1534             templateUrl: 'book.html',
1535             controller: BookCntl,
1536             resolve: {
1537               // I will cause a 1 second delay
1538               delay: function($q, $timeout) {
1539                 var delay = $q.defer();
1540                 $timeout(delay.resolve, 1000);
1541                 return delay.promise;
1542               }
1543             }
1544           });
1545           $routeProvider.when('/Book/:bookId/ch/:chapterId', {
1546             templateUrl: 'chapter.html',
1547             controller: ChapterCntl
1548           });
1549
1550           // configure html5 to get links working on jsfiddle
1551           $locationProvider.html5Mode(true);
1552         });
1553
1554         function MainCntl($scope, $route, $routeParams, $location) {
1555           $scope.$route = $route;
1556           $scope.$location = $location;
1557           $scope.$routeParams = $routeParams;
1558         }
1559
1560         function BookCntl($scope, $routeParams) {
1561           $scope.name = "BookCntl";
1562           $scope.params = $routeParams;
1563         }
1564
1565         function ChapterCntl($scope, $routeParams) {
1566           $scope.name = "ChapterCntl";
1567           $scope.params = $routeParams;
1568         }
1569       </file>
1570
1571       <file name="scenario.js">
1572         it('should load and compile correct template', function() {
1573           element('a:contains("Moby: Ch1")').click();
1574           var content = element('.doc-example-live [ng-view]').text();
1575           expect(content).toMatch(/controller\: ChapterCntl/);
1576           expect(content).toMatch(/Book Id\: Moby/);
1577           expect(content).toMatch(/Chapter Id\: 1/);
1578
1579           element('a:contains("Scarlet")').click();
1580           sleep(2); // promises are not part of scenario waiting
1581           content = element('.doc-example-live [ng-view]').text();
1582           expect(content).toMatch(/controller\: BookCntl/);
1583           expect(content).toMatch(/Book Id\: Scarlet/);
1584         });
1585       </file>
1586     </example>
1587     */
1588
1589    /**
1590     * @ngdoc event
1591     * @name ngRoute.$route#$routeChangeStart
1592     * @eventOf ngRoute.$route
1593     * @eventType broadcast on root scope

1594     * @description
1595     * Broadcasted before a route change. At this  point the route services starts
1596     * resolving all of the dependencies needed for the route change to occurs.
1597     * Typically this involves fetching the view template as well as any dependencies
1598     * defined in `resolve` route property. Once  all of the dependencies are resolved
1599     * `$routeChangeSuccess` is fired.
1600     *
1601     * @param {Object} angularEvent Synthetic event object.
1602     * @param {Route} next Future route information.
1603     * @param {Route} current Current route information.
1604     */
1605
1606    /**
1607     * @ngdoc event
1608     * @name ngRoute.$route#$routeChangeSuccess
1609     * @eventOf ngRoute.$route
1610     * @eventType broadcast on root scope
1611     * @description
1612     * Broadcasted after a route dependencies are resolved.
1613     * {@link ngRoute.directive:ngView ngView} listens for the directive
1614     * to instantiate the controller and render the view.
1615     *
1616     * @param {Object} angularEvent Synthetic event object.
1617     * @param {Route} current Current route information.
1618     * @param {Route|Undefined} previous Previous route information, or undefined if current is
1619     * first route entered.
1620     */
1621
1622    /**
1623     * @ngdoc event
1624     * @name ngRoute.$route#$routeChangeError
1625     * @eventOf ngRoute.$route
1626     * @eventType broadcast on root scope
1627     * @description
1628     * Broadcasted if any of the resolve promises are rejected.
1629     *
1630     * @param {Object} angularEvent Synthetic event object
1631     * @param {Route} current Current route information.
1632     * @param {Route} previous Previous route information.
1633     * @param {Route} rejection Rejection of the promise. Usually the error of the failed promise.
1634     */
1635
1636    /**
1637     * @ngdoc event
1638     * @name ngRoute.$route#$routeUpdate
1639     * @eventOf ngRoute.$route
1640     * @eventType broadcast on root scope
1641     * @description
1642     *
1643     * The `reloadOnSearch` property has been set to false, and we are reusing the same
1644     * instance of the Controller.
1645     */
1646
1647    var forceReload = false,
1648        $route = {
1649          routes: routes,
1650
1651          /**
1652           * @ngdoc method
1653           * @name ngRoute.$route#reload
1654           * @methodOf ngRoute.$route
1655           *
1656           * @description
1657           * Causes `$route` service to reload the current route even if
1658           * {@link ng.$location $location} hasn't changed.
1659           *
1660           * As a result of that, {@link ngRoute.directive:ngView ngView}
1661           * creates new scope, reinstantiates the controller.
1662           */
1663          reload: function() {
1664            forceReload = true;
1665            $rootScope.$evalAsync(updateRoute);
1666          }
1667        };
1668
1669    $rootScope.$on('$locationChangeSuccess', updateRoute);
1670
1671    return $route;
1672
1673    /////////////////////////////////////////////////////
1674
1675    /**
1676     * @param on {string} current url
1677     * @param route {Object} route regexp to match the url against
1678     * @return {?Object}
1679     *
1680     * @description
1681     * Check if the route matches the current url.
1682     *
1683     * Inspired by match in
1684     * visionmedia/express/lib/router/router.js.
1685     */
1686    function switchRouteMatcher(on, route) {
1687      var keys = route.keys,
1688          params = {};
1689
1690      if (!route.regexp) return null;
1691
1692      var m = route.regexp.exec(on);
1693      if (!m) return null;
1694
1695      for (var i = 1, len = m.length; i < len; ++i) {
1696        var key = keys[i - 1];
1697
1698        var val = 'string' == typeof m[i]
1699              ? decodeURIComponent(m[i])
1700              : m[i];
1701
1702        if (key && val) {
1703          params[key.name] = val;
1704        }
1705      }
1706      return params;
1707    }
1708
1709    function updateRoute() {
1710      var next = parseRoute(),
1711          last = $route.current;
1712
1713      if (next && last && next.$$route === last.$$route
1714          && angular.equals(next.pathParams, last.pathParams)
1715          && !next.reloadOnSearch && !forceReload) {
1716        last.params = next.params;
1717        angular.copy(last.params, $routeParams);
1718        $rootScope.$broadcast('$routeUpdate', last);
1719      } else if (next || last) {
1720        forceReload = false;

1721        $rootScope.$broadcast('$routeChangeStart', next, last);
1722        $route.current = next;
1723        if (next) {
1724          if (next.redirectTo) {
1725            if (angular.isString(next.redirectTo)) {
1726              $location.path(interpolate(next.redirectTo, next.params)).search(next.params)
1727                       .replace();
1728            } else {
1729              $location.url(next.redirectTo(next.pathParams, $location.path(), $location.search()))
1730                       .replace();
1731            }
1732          }
1733        }
1734
1735        $q.when(next).
1736          then(function() {
1737            if (next) {
1738              var locals = angular.extend({}, next.resolve),
1739                  template, templateUrl;
1740
1741              angular.forEach(locals, function(value, key) {
1742                locals[key] = angular.isString(value) ?
1743                    $injector.get(value) : $injector.invoke(value);
1744              });
1745
1746              if (angular.isDefined(template = next.template)) {
1747                if (angular.isFunction(template)) {
1748                  template = template(next.params);
1749                }
1750              } else if (angular.isDefined(templateUrl = next.templateUrl)) {
1751                if (angular.isFunction(templateUrl)) {
1752                  templateUrl = templateUrl(next.params);
1753                }
1754                templateUrl = $sce.getTrustedResourceUrl(templateUrl);
1755                if (angular.isDefined(templateUrl)) {
1756                  next.loadedTemplateUrl = templateUrl;
1757                  template = $http.get(templateUrl, {cache: $templateCache}).
1758                      then(function(response) { return response.data; });
1759                }
1760              }
1761              if (angular.isDefined(template)) {
1762                locals['$template'] = template;
1763              }
1764              return $q.all(locals);
1765            }
1766          }).
1767          // after route change
1768          then(function(locals) {
1769            if (next == $route.current) {
1770              if (next) {
1771                next.locals = locals;
1772                angular.copy(next.params, $routeParams);
1773              }
1774              $rootScope.$broadcast('$routeChangeSuccess', next, last);
1775            }
1776          }, function(error) {
1777            if (next == $route.current) {
1778              $rootScope.$broadcast('$routeChangeError', next, last, error);
1779            }
1780          });
1781      }
1782    }
1783
1784
1785    /**
1786     * @returns the current active route, by matching it against the URL
1787     */
1788    function parseRoute() {
1789      // Match a route
1790      var params, match;
1791      angular.forEach(routes, function(route, path) {
1792        if (!match && (params = switchRouteMatcher($location.path(), route))) {
1793          match = inherit(route, {
1794            params: angular.extend({}, $location.search(), params),
1795            pathParams: params});
1796          match.$$route = route;
1797        }
1798      });
1799      // No route matched; fallback to "otherwise" route
1800      return match || routes[null] && inherit(routes[null], {params: {}, pathParams:{}});
1801    }
1802
1803    /**
1804     * @returns interpolation of the redirect path with the parameters
1805     */
1806    function interpolate(string, params) {
1807      var result = [];
1808      angular.forEach((string||'').split(':'), function(segment, i) {
1809        if (i === 0) {
1810          result.push(segment);
1811        } else {
1812          var segmentMatch = segment.match(/(\w+)(.*)/);
1813          var key = segmentMatch[1];
1814          result.push(params[key]);
1815          result.push(segmentMatch[2] || '');
1816          delete params[key];
1817        }
1818      });
1819      return result.join('');
1820    }
1821  }];
1822}
1823
1824ngRouteModule.provider('$routeParams', $RouteParamsProvider);
1825
1826
1827/**
1828 * @ngdoc object
1829 * @name ngRoute.$routeParams
1830 * @requires $route
1831 *
1832 * @description
1833 * The `$routeParams` service allows you to retrieve the current set of route parameters.
1834 *
1835 * Requires the {@link ngRoute `ngRoute`} module to be installed.
1836 *
1837 * The route parameters are a combination of {@link ng.$location `$location`}'s
1838 * {@link ng.$location#methods_search `search()`} and {@link ng.$location#methods_path `path()`}.
1839 * The `path` parameters are extracted when the {@link ngRoute.$route `$route`} path is matched.
1840 *
1841 * In case of parameter name collision, `path` params take precedence over `search` params.
1842 *

1843 * The service guarantees that the identity of the `$routeParams` object will remain unchanged
1844 * (but its properties will likely change) even when a route change occurs.
1845 *
1846 * Note that the `$routeParams` are only updated *after* a route change completes successfully.
1847 * This means that you cannot rely on `$routeParams` being correct in route resolve functions.
1848 * Instead you can use `$route.current.params` to access the new route's parameters.
1849 *
1850 * @example
1851 * <pre>
1852 *  // Given:
1853 *  // URL: http://server.com/index.html#/Chapter/1/Section/2?search=moby
1854 *  // Route: /Chapter/:chapterId/Section/:sectionId
1855 *  //
1856 *  // Then
1857 *  $routeParams ==> {chapterId:1, sectionId:2, search:'moby'}
1858 * </pre>
1859 */
1860function $RouteParamsProvider() {
1861  this.$get = function() { return {}; };
1862}
1863
1864ngRouteModule.directive('ngView', ngViewFactory);
1865ngRouteModule.directive('ngView', ngViewFillContentFactory);
1866
1867
1868/**
1869 * @ngdoc directive
1870 * @name ngRoute.directive:ngView
1871 * @restrict ECA
1872 *
1873 * @description
1874 * # Overview
1875 * `ngView` is a directive that complements the {@link ngRoute.$route $route} service by
1876 * including the rendered template of the current route into the main layout (`index.html`) file.
1877 * Every time the current route changes, the included view changes with it according to the
1878 * configuration of the `$route` service.
1879 *
1880 * Requires the {@link ngRoute `ngRoute`} module to be installed.
1881 *
1882 * @animations
1883 * enter - animation is used to bring new content into the browser.
1884 * leave - animation is used to animate existing content away.
1885 *
1886 * The enter and leave animation occur concurrently.
1887 *
1888 * @scope
1889 * @priority 400
1890 * @example
1891    <example module="ngViewExample" deps="angular-route.js" animations="true">
1892      <file name="index.html">
1893        <div ng-controller="MainCntl as main">
1894          Choose:
1895          <a href="Book/Moby">Moby</a> |
1896          <a href="Book/Moby/ch/1">Moby: Ch1</a> |
1897          <a href="Book/Gatsby">Gatsby</a> |
1898          <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> |
1899          <a href="Book/Scarlet">Scarlet Letter</a><br/>
1900
1901          <div class="view-animate-container">
1902            <div ng-view class="view-animate"></div>
1903          </div>
1904          <hr />
1905
1906          <pre>$location.path() = {{main.$location.path()}}</pre>
1907          <pre>$route.current.templateUrl = {{main.$route.current.templateUrl}}</pre>
1908          <pre>$route.current.params = {{main.$route.current.params}}</pre>
1909          <pre>$route.current.scope.name = {{main.$route.current.scope.name}}</pre>
1910          <pre>$routeParams = {{main.$routeParams}}</pre>
1911        </div>
1912      </file>
1913
1914      <file name="book.html">
1915        <div>
1916          controller: {{book.name}}<br />
1917          Book Id: {{book.params.bookId}}<br />
1918        </div>
1919      </file>
1920
1921      <file name="chapter.html">
1922        <div>
1923          controller: {{chapter.name}}<br />
1924          Book Id: {{chapter.params.bookId}}<br />
1925          Chapter Id: {{chapter.params.chapterId}}
1926        </div>
1927      </file>
1928
1929      <file name="animations.css">
1930        .view-animate-container {
1931          position:relative;
1932          height:100px!important;
1933          position:relative;
1934          background:white;
1935          border:1px solid black;
1936          height:40px;
1937          overflow:hidden;
1938        }
1939
1940        .view-animate {
1941          padding:10px;
1942        }
1943
1944        .view-animate.ng-enter, .view-animate.ng-leave {
1945          -webkit-transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s;
1946          transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s;
1947
1948          display:block;
1949          width:100%;
1950          border-left:1px solid black;
1951
1952          position:absolute;
1953          top:0;
1954          left:0;
1955          right:0;
1956          bottom:0;
1957          padding:10px;
1958        }
1959
1960        .view-animate.ng-enter {
1961          left:100%;
1962        }
1963        .view-animate.ng-enter.ng-enter-active {
1964          left:0;
1965        }
1966        .view-animate.ng-leave.ng-leave-active {
1967          left:-100%;
1968        }
1969      </file>
1970
1971      <file name="script.js">
1972        angular.module('ngViewExample', ['ngRoute', 'ngAnimate'],
1973          function($routeProvider, $locationProvider) {
1974            $routeProvider.when('/Book/:bookId', {
1975              templateUrl: 'book.html',
1976              controller: BookCntl,
1977              controllerAs: 'book'
1978            });
1979            $routeProvider.when('/Book/:bookId/ch/:chapterId', {
1980              templateUrl: 'chapter.html',
1981              controller: ChapterCntl,
1982              controllerAs: 'chapter'
1983            });
1984
1985            // configure html5 to get links working on jsfiddle
1986            $locationProvider.html5Mode(true);
1987        });
1988

1989        function MainCntl($route, $routeParams, $location) {
1990          this.$route = $route;
1991          this.$location = $location;
1992          this.$routeParams = $routeParams;
1993        }
1994
1995        function BookCntl($routeParams) {
1996          this.name = "BookCntl";
1997          this.params = $routeParams;
1998        }
1999
2000        function ChapterCntl($routeParams) {
2001          this.name = "ChapterCntl";
2002          this.params = $routeParams;
2003        }
2004      </file>
2005
2006      <file name="scenario.js">
2007        it('should load and compile correct template', function() {
2008          element('a:contains("Moby: Ch1")').click();
2009          var content = element('.doc-example-live [ng-view]').text();
2010          expect(content).toMatch(/controller\: ChapterCntl/);
2011          expect(content).toMatch(/Book Id\: Moby/);
2012          expect(content).toMatch(/Chapter Id\: 1/);
2013
2014          element('a:contains("Scarlet")').click();
2015          content = element('.doc-example-live [ng-view]').text();
2016          expect(content).toMatch(/controller\: BookCntl/);
2017          expect(content).toMatch(/Book Id\: Scarlet/);
2018        });
2019      </file>
2020    </example>
2021 */
2022
2023
2024/**
2025 * @ngdoc event
2026 * @name ngRoute.directive:ngView#$viewContentLoaded
2027 * @eventOf ngRoute.directive:ngView
2028 * @eventType emit on the current ngView scope
2029 * @description
2030 * Emitted every time the ngView content is reloaded.
2031 */
2032ngViewFactory.$inject = ['$route', '$anchorScroll', '$animate'];
2033function ngViewFactory(   $route,   $anchorScroll,   $animate) {
2034  return {
2035    restrict: 'ECA',
2036    terminal: true,
2037    priority: 400,
2038    transclude: 'element',
2039    link: function(scope, $element, attr, ctrl, $transclude) {
2040        var currentScope,
2041            currentElement,
2042            autoScrollExp = attr.autoscroll,
2043            onloadExp = attr.onload || '';
2044
2045        scope.$on('$routeChangeSuccess', update);
2046        update();
2047
2048        function cleanupLastView() {
2049          if (currentScope) {
2050            currentScope.$destroy();
2051            currentScope = null;
2052          }
2053          if(currentElement) {
2054            $animate.leave(currentElement);
2055            currentElement = null;
2056          }
2057        }
2058
2059        function update() {
2060          var locals = $route.current && $route.current.locals,
2061              template = locals && locals.$template;
2062
2063          if (template) {
2064            var newScope = scope.$new();
2065            var current = $route.current;
2066
2067            // Note: This will also link all children of ng-view that were contained in the original
2068            // html. If that content contains controllers, ... they could pollute/change the scope.
2069            // However, using ng-view on an element with additional content does not make sense...
2070            // Note: We can't remove them in the cloneAttchFn of $transclude as that
2071            // function is called before linking the content, which would apply child
2072            // directives to non existing elements.
2073            var clone = $transclude(newScope, function(clone) {
2074              $animate.enter(clone, null, currentElement || $element, function onNgViewEnter () {
2075                if (angular.isDefined(autoScrollExp)
2076                  && (!autoScrollExp || scope.$eval(autoScrollExp))) {
2077                  $anchorScroll();
2078                }
2079              });
2080              cleanupLastView();
2081            });
2082
2083            currentElement = clone;
2084            currentScope = current.scope = newScope;
2085            currentScope.$emit('$viewContentLoaded');
2086            currentScope.$eval(onloadExp);
2087          } else {
2088            cleanupLastView();
2089          }
2090        }
2091    }
2092  };
2093}
2094
2095// This directive is called during the $transclude call of the first `ngView` directive.
2096// It will replace and compile the content of the element with the loaded template.
2097// We need this directive so that the element content is already filled when
2098// the link function of another directive on the same element as ngView
2099// is called.
2100ngViewFillContentFactory.$inject = ['$compile', '$controller', '$route'];
2101function ngViewFillContentFactory($compile, $controller, $route) {
2102  return {
2103    restrict: 'ECA',
2104    priority: -400,
2105    link: function(scope, $element) {
2106      var current = $route.current,
2107          locals = current.locals;
2108
2109      $element.html(locals.$template);
2110
2111      var link = $compile($element.contents());
2112
2113      if (current.controller) {
2114        locals.$scope = scope;
2115        var controller = $controller(current.controller, locals);
2116        if (current.controllerAs) {
2117          scope[current.controllerAs] = controller;
2118        }
2119        $element.data('$ngControllerController', controller);
2120        $element.children().data('$ngControllerController', controller);
2121      }
2122
2123      link(scope);
2124    }
2125  };
2126}
2127
2128
2129})(window, window.angular);
2130
2131angular.module("ui.bootstrap", ["ui.bootstrap.tpls", "ui.bootstrap.transition","ui.bootstrap.collapse","ui.bootstrap.accordion","ui.bootstrap.alert","ui.bootstrap.bindHtml","ui.bootstrap.buttons","ui.bootstrap.carousel","ui.bootstrap.position","ui.bootstrap.datepicker","ui.bootstrap.dropdownToggle","ui.bootstrap.modal","ui.bootstrap.pagination","ui.bootstrap.tooltip","ui.bootstrap.popover","ui.bootstrap.progressbar","ui.bootstrap.rating","ui.bootstrap.tabs","ui.bootstrap.timepicker","ui.bootstrap.typeahead"]);
2132angular.module("ui.bootstrap.tpls", ["template/accordion/accordion-group.html","template/accordion/accordion.html","template/alert/alert.html","template/carousel/carousel.html","template/carousel/slide.html","template/datepicker/datepicker.html","template/datepicker/popup.html","template/modal/backdrop.html","template/modal/window.html","template/pagination/pager.html","template/pagination/pagination.html","template/tooltip/tooltip-html-unsafe-popup.html","template/tooltip/tooltip-popup.html","template/popover/popover.html","template/progressbar/bar.html","template/progressbar/progress.html","template/rating/rating.html","template/tabs/tab.html","template/tabs/tabset-titles.html","template/tabs/tabset.html","template/timepicker/timepicker.html","template/typeahead/typeahead-match.html","template/typeahead/typeahead-popup.html"]);
2133angular.module('ui.bootstrap.transition', [])
2134
2135/**
2136 * $transition service provides a consistent interface to trigger CSS 3 transitions and to be informed when they complete.
2137 * @param  {DOMElement} element  The DOMElement that will be animated.
2138 * @param  {string|object|function} trigger  The thing that will cause the transition to start:
2139 *   - As a string, it represents the css class to be added to the element.
2140 *   - As an object, it represents a hash of style attributes to be applied to the element.
2141 *   - As a function, it represents a function to be called that will cause the transition to occur.
2142 * @return {Promise}  A promise that is resolved when the transition finishes.
2143 */
2144.factory('$transition', ['$q', '$timeout', '$rootScope', function($q, $timeout, $rootScope) {
2145
2146  var $transition = function(element, trigger, options) {
2147    options = options || {};
2148    var deferred = $q.defer();
2149    var endEventName = $transition[options.animation ? "animationEndEventName" : "transitionEndEventName"];
2150
2151    var transitionEndHandler = function(event) {
2152      $rootScope.$apply(function() {
2153        element.unbind(endEventName, transitionEndHandler);
2154        deferred.resolve(element);
2155      });
2156    };
2157
2158    if (endEventName) {
2159      element.bind(endEventName, transitionEndHandler);
2160    }
2161
2162    // Wrap in a timeout to allow the browser time to update the DOM before the transition is to occur
2163    $timeout(function() {
2164      if ( angular.isString(trigger) ) {
2165        element.addClass(trigger);
2166      } else if ( angular.isFunction(trigger) ) {
2167        trigger(element);
2168      } else if ( angular.isObject(trigger) ) {
2169        element.css(trigger);
2170      }
2171      //If browser does not support transitions, instantly resolve
2172      if ( !endEventName ) {
2173        deferred.resolve(element);
2174      }
2175    });
2176
2177    // Add our custom cancel function to the promise that is returned
2178    // We can call this if we are about to run a new transition, which we know 

2178will prevent this transition from ending,
2179    // i.e. it will therefore never raise a transitionEnd event for that transition
2180    deferred.promise.cancel = function() {
2181      if ( endEventName ) {
2182        element.unbind(endEventName, transitionEndHandler);
2183      }
2184      deferred.reject('Transition cancelled');
2185    };
2186
2187    return deferred.promise;
2188  };
2189
2190  // Work out the name of the transitionEnd event
2191  var transElement = document.createElement('trans');
2192  var transitionEndEventNames = {
2193    'WebkitTransition': 'webkitTransitionEnd',
2194    'MozTransition': 'transitionend',
2195    'OTransition': 'oTransitionEnd',
2196    'transition': 'transitionend'
2197  };
2198  var animationEndEventNames = {
2199    'WebkitTransition': 'webkitAnimationEnd',
2200    'MozTransition': 'animationend',
2201    'OTransition': 'oAnimationEnd',
2202    'transition': 'animationend'
2203  };
2204  function findEndEventName(endEventNames) {
2205    for (var name in endEventNames){
2206      if (transElement.style[name] !== undefined) {
2207        return endEventNames[name];
2208      }
2209    }
2210  }
2211  $transition.transitionEndEventName = findEndEventName(transitionEndEventNames);
2212  $transition.animationEndEventName = findEndEventName(animationEndEventNames);
2213  return $transition;
2214}]);
2215
2216angular.module('ui.bootstrap.collapse',['ui.bootstrap.transition'])
2217
2218// The collapsible directive indicates a block of html that will expand and collapse
2219.directive('collapse', ['$transition', function($transition) {
2220  // CSS transitions don't work with height: auto, so we have to manually change the height to a
2221  // specific value and then once the animation completes, we can reset the height to auto.
2222  // Unfortunately if you do this while the CSS transitions are specified (i.e. in the CSS class
2223  // "collapse") then you trigger a change to height 0 in between.
2224  // The fix is to remove the "collapse" CSS class while changing the height back to auto - phew!
2225  var fixUpHeight = function(scope, element, height) {
2226    // We remove the collapse CSS class to prevent a transition when we change to height: auto
2227    element.removeClass('collapse');
2228    element.css({ height: height });
2229    // It appears that  reading offsetWidth makes the browser realise that we have changed the
2230    // height already :-/
2231    var x = element[0].offsetWidth;
2232    element.addClass('collapse');
2233  };
2234
2235  return {
2236    link: function(scope, element, attrs) {
2237
2238      var isCollapsed;
2239      var initialAnimSkip = true;
2240
2241      scope.$watch(attrs.collapse, function(value) {
2242        if (value) {
2243          collapse();
2244        } else {
2245          expand();
2246        }
2247      });
2248      
2249
2250      var currentTransition;
2251      var doTransition = function(change) {
2252        if ( currentTransition ) {
2253          currentTransition.cancel();
2254        }
2255        currentTransition = $transition(element,change);
2256        currentTransition.then(
2257          function() { currentTransition = undefined; },
2258          function() { currentTransition = undefined; }
2259        );
2260        return currentTransition;
2261      };
2262
2263      var expand = function() {
2264        if (initialAnimSkip) {
2265          initialAnimSkip = false;
2266          if ( !isCollapsed ) {
2267            fixUpHeight(scope, element, 'auto');
2268            element.addClass('in');
2269          }
2270        } else {
2271          doTransition({ height : element[0].scrollHeight + 'px' })
2272          .then(function() {
2273            // This check ensures that we don't accidentally update the height if the user has closed
2274            // the group while the animation was still running
2275            if ( !isCollapsed ) {
2276              fixUpHeight(scope, element, 'auto');
2277              element.addClass('in');
2278            }
2279          });
2280        }
2281        isCollapsed = false;
2282      };
2283      
2284      var collapse = function() {
2285        isCollapsed = true;
2286        element.removeClass('in');
2287        if (initialAnimSkip) {
2288          initialAnimSkip = false;
2289          fixUpHeight(scope, element, 0);
2290        } else {
2291          fixUpHeight(scope, element, element[0].scrollHeight + 'px');
2292          doTransition({'height':'0'});
2293        }
2294      };
2295    }
2296  };
2297}]);
2298
2299angular.module('ui.bootstrap.accordion', ['ui.bootstrap.collapse'])
2300
2301.constant('accordionConfig', {
2302  closeOthers: true
2303})
2304
2305.controller('AccordionController', ['$scope', '$attrs', 'accordionConfig', function ($scope, $attrs, accordionConfig) {
2306
2307  // This array keeps track of the accordion groups
2308  this.groups = [];
2309
2310  // Keep reference to user's scope to properly assign `is-open`
2311  this.scope = $scope;
2312
2313  // Ensure that all the groups in this accordion are closed, unless close-others explicitly says not to
2314  this.closeOthers = function(openGroup) {
2315    var closeOthers = angular.isDefined($attrs.closeOthers) ? $scope.$eval($attrs.closeOthers) : accordionConfig.closeOthers;
2316    if ( closeOthers ) {
2317      angular.forEach(this.groups, function (group) {
2318        if ( group !== openGroup ) {
2319          group.isOpen = false;

2320        }
2321      });
2322    }
2323  };
2324  
2325  // This is called from the accordion-group directive to add itself to the accordion
2326  this.addGroup = function(groupScope) {
2327    var that = this;
2328    this.groups.push(groupScope);
2329
2330    groupScope.$on('$destroy', function (event) {
2331      that.removeGroup(groupScope);
2332    });
2333  };
2334
2335  // This is called from the accordion-group directive when to remove itself
2336  this.removeGroup = function(group) {
2337    var index = this.groups.indexOf(group);
2338    if ( index !== -1 ) {
2339      this.groups.splice(this.groups.indexOf(group), 1);
2340    }
2341  };
2342
2343}])
2344
2345// The accordion directive simply sets up the directive controller
2346// and adds an accordion CSS class to itself element.
2347.directive('accordion', function () {
2348  return {
2349    restrict:'EA',
2350    controller:'AccordionController',
2351    transclude: true,
2352    replace: false,
2353    templateUrl: 'template/accordion/accordion.html'
2354  };
2355})
2356
2357// The accordion-group directive indicates a block of html that will expand and collapse in an accordion
2358.directive('accordionGroup', ['$parse', '$transition', '$timeout', function($parse, $transition, $timeout) {
2359  return {
2360    require:'^accordion',         // We need this directive to be inside an accordion
2361    restrict:'EA',
2362    transclude:true,              // It transcludes the contents of the directive into the template
2363    replace: true,                // The element containing the directive will be replaced with the template
2364    templateUrl:'template/accordion/accordion-group.html',
2365    scope:{ heading:'@' },        // Create an isolated scope and interpolate the heading attribute onto this scope
2366    controller: ['$scope', function($scope) {
2367      this.setHeading = function(element) {
2368        this.heading = element;
2369      };
2370    }],
2371    link: function(scope, element, attrs, accordionCtrl) {
2372      var getIsOpen, setIsOpen;
2373
2374      accordionCtrl.addGroup(scope);
2375
2376      scope.isOpen = false;
2377      
2378      if ( attrs.isOpen ) {
2379        getIsOpen = $parse(attrs.isOpen);
2380        setIsOpen = getIsOpen.assign;
2381
2382        accordionCtrl.scope.$watch(getIsOpen, function(value) {
2383          scope.isOpen = !!value;
2384        });
2385      }
2386
2387      scope.$watch('isOpen', function(value) {
2388        if ( value ) {
2389          accordionCtrl.closeOthers(scope);
2390        }
2391        if ( setIsOpen ) {
2392          setIsOpen(accordionCtrl.scope, value);
2393        }
2394      });
2395    }
2396  };
2397}])
2398
2399// Use accordion-heading below an accordion-group to provide a heading containing HTML
2400// <accordion-group>
2401//   <accordion-heading>Heading containing HTML - <img src="..."></accordion-heading>
2402// </accordion-group>
2403.directive('accordionHeading', function() {
2404  return {
2405    restrict: 'EA',
2406    transclude: true,   // Grab the contents to be used as the heading
2407    template: '',       // In effect remove this element!
2408    replace: true,
2409    require: '^accordionGroup',
2410    compile: function(element, attr, transclude) {
2411      return function link(scope, element, attr, accordionGroupCtrl) {
2412        // Pass the heading to the accordion-group controller
2413        // so that it can be transcluded into the right place in the template
2414        // [The second parameter to transclude causes the elements to be cloned so that they work in ng-repeat]
2415        accordionGroupCtrl.setHeading(transclude(scope, function() {}));
2416      };
2417    }
2418  };
2419})
2420
2421// Use in the accordion-group template to indicate where you want the heading to be transcluded
2422// You must provide the property on the accordion-group controller that will hold the transcluded element
2423// <div class="accordion-group">
2424//   <div class="accordion-heading" ><a ... accordion-transclude="heading">...</a></div>
2425//   ...
2426// </div>
2427.directive('accordionTransclude', function() {
2428  return {
2429    require: '^accordionGroup',
2430    link: function(scope, element, attr, controller) {
2431      scope.$watch(function() { return controller[attr.accordionTransclude]; }, function(heading) {
2432        if ( heading ) {
2433          element.html('');
2434          element.append(heading);
2435        }
2436      });
2437    }
2438  };
2439});
2440
2441angular.module("ui.bootstrap.alert", []).directive('alert', function () {
2442  return {
2443    restrict:'EA',
2444    templateUrl:'template/alert/alert.html',
2445    transclude:true,
2446    replace:true,
2447    scope: {

2448      type: '=',
2449      close: '&'
2450    },
2451    link: function(scope, iElement, iAttrs) {
2452      scope.closeable = "close" in iAttrs;
2453    }
2454  };
2455});
2456
2457angular.module('ui.bootstrap.bindHtml', [])
2458
2459  .directive('bindHtmlUnsafe', function () {
2460    return function (scope, element, attr) {
2461      element.addClass('ng-binding').data('$binding', attr.bindHtmlUnsafe);
2462      scope.$watch(attr.bindHtmlUnsafe, function bindHtmlUnsafeWatchAction(value) {
2463        element.html(value || '');
2464      });
2465    };
2466  });
2467angular.module('ui.bootstrap.buttons', [])
2468
2469.constant('buttonConfig', {
2470  activeClass: 'active',
2471  toggleEvent: 'click'
2472})
2473
2474.directive('btnRadio', ['buttonConfig', function (buttonConfig) {
2475  var activeClass = buttonConfig.activeClass || 'active';
2476  var toggleEvent = buttonConfig.toggleEvent || 'click';
2477
2478  return {
2479    require: 'ngModel',
2480    link: function (scope, element, attrs, ngModelCtrl) {
2481
2482      //model -> UI
2483      ngModelCtrl.$render = function () {
2484        element.toggleClass(activeClass, angular.equals(ngModelCtrl.$modelValue, scope.$eval(attrs.btnRadio)));
2485      };
2486
2487      //ui->model
2488      element.bind(toggleEvent, function () {
2489        if (!element.hasClass(activeClass)) {
2490          scope.$apply(function () {
2491            ngModelCtrl.$setViewValue(scope.$eval(attrs.btnRadio));
2492            ngModelCtrl.$render();
2493          });
2494        }
2495      });
2496    }
2497  };
2498}])
2499
2500.directive('btnCheckbox', ['buttonConfig', function (buttonConfig) {
2501  var activeClass = buttonConfig.activeClass || 'active';
2502  var toggleEvent = buttonConfig.toggleEvent || 'click';
2503
2504  return {
2505    require: 'ngModel',
2506    link: function (scope, element, attrs, ngModelCtrl) {
2507
2508      function getTrueValue() {
2509        var trueValue = scope.$eval(attrs.btnCheckboxTrue);
2510        return angular.isDefined(trueValue) ? trueValue : true;
2511      }
2512
2513      function getFalseValue() {
2514        var falseValue = scope.$eval(attrs.btnCheckboxFalse);
2515        return angular.isDefined(falseValue) ? falseValue : false;
2516      }
2517
2518      //model -> UI
2519      ngModelCtrl.$render = function () {
2520        element.toggleClass(activeClass, angular.equals(ngModelCtrl.$modelValue, getTrueValue()));
2521      };
2522
2523      //ui->model
2524      element.bind(toggleEvent, function () {
2525        scope.$apply(function () {
2526          ngModelCtrl.$setViewValue(element.hasClass(activeClass) ? getFalseValue() : getTrueValue());
2527          ngModelCtrl.$render();
2528        });
2529      });
2530    }
2531  };
2532}]);
2533
2534/**
2535* @ngdoc overview
2536* @name ui.bootstrap.carousel
2537*
2538* @description
2539* AngularJS version of an image carousel.
2540*
2541*/
2542angular.module('ui.bootstrap.carousel', ['ui.bootstrap.transition'])
2543.controller('CarouselController', ['$scope', '$timeout', '$transition', '$q', function ($scope, $timeout, $transition, $q) {
2544  var self = this,
2545    slides = self.slides = [],
2546    currentIndex = -1,
2547    currentTimeout, isPlaying;
2548  self.currentSlide = null;
2549
2550  /* direction: "prev" or "next" */
2551  self.select = function(nextSlide, direction) {
2552    var nextIndex = slides.indexOf(nextSlide);
2553    //Decide direction if it's not given
2554    if (direction === undefined) {
2555      direction = nextIndex > currentIndex ? "next" : "prev";
2556    }
2557    if (nextSlide && nextSlide !== self.currentSlide) {
2558      if ($scope.$currentTransition) {
2559        $scope.$currentTransition.cancel();
2560        //Timeout so ng-class in template has time to fix classes for finished slide
2561        $timeout(goNext);
2562      } else {
2563        goNext();
2564      }
2565    }
2566    function goNext() {
2567      //If we have a slide to transition from and we have a transition type and we're allowed, go
2568      if (self.currentSlide && angular.isString(direction) && !$scope.noTransition && nextSlide.$element) {
2569        //We shouldn't do class manip in here, but it's the same weird thing bootstrap does. need to fix sometime
2570        nextSlide.$element.addClass(direction);
2571        var reflow = nextSlide.$element[0].offsetWidth; //force reflow
2572
2573        //Set all other slides to stop doing their stuff for the new transition
2574        angular.forEach(slides, function(slide) {
2575          angular.extend(slide, {direction: '', entering: false, leaving: false, active: false});
2576        });
2577        angular.extend(nextSlide, {direction: direction, active: true, entering: true});
2578        angular.extend(self.currentSlide||{}, {direction: direction, leaving: true});
2579
2580        $scope.$currentTransition = $transition(nextSlide.$element, {});
2581        //We have to create new pointers inside a closure since next & current will change
2582        (function(next,current) {
2583          $scope.$currentTransition.then(
2584            function(){ transitionDone(next, current); },
2585            function(){ transitionDone(next, current); }
2586          );
2587        }(nextSlide, self.currentSlide));
2588      } else {
2589        transitionDone(nextSlide, self.currentSlide);
2590      }
2591      self.currentSlide = nextSlide;
2592      currentIndex = nextIndex;
2593      //every time you change slides, reset the timer
2594      restartTimer();
2595    }
2596    function transitionDone(next, current) {
2597      angular.extend(next, {direction: '', active: true, leaving: false, entering: false});
2598      angular.extend(current||{}, {direction: '', active: false, leaving: false, entering: false});
2599      $scope.$currentTransition = null;
2600    }
2601  };
2602
2603  /* Allow outside people to call indexOf on slides array */
2604  self.indexOfSlide = function(slide) {
2605    return slides.indexOf(slide);
2606  };
2607
2608  $scope.next = function() {
2609    var newIndex = (currentIndex + 1) % slides.length;
2610
2611    //Prevent this user-triggered transition from occurring if there is already one in progress
2612    if (!$scope.$currentTransition) {
2613      return self.select(slides[newIndex], 'next');
2614    }
2615  };
2616
2617  $scope.prev = function() {
2618    var newIndex = currentIndex - 1 < 0 ? slides.length - 1 : currentIndex - 1;
2619
2620    //Prevent this user-triggered transition from occurring if there is already one in progress
2621    if (!$scope.$currentTransition) {
2622      return self.select(slides[newIndex], 'prev');
2623    }
2624  };
2625
2626  $scope.select = function(slide) {
2627    self.select(slide);
2628  };
2629
2630  $scope.isActive = function(slide) {
2631     return self.currentSlide === slide;
2632  };
2633
2634  $scope.slides = function() {
2635    return slides;
2636  };
2637
2638  $scope.$watch('interval', restartTimer);
2639  function restartTimer() {
2640    if (currentTimeout) {
2641      $timeout.cancel(currentTimeout);
2642    }
2643    function go() {
2644      if (isPlaying) {
2645        $scope.next();
2646        restartTimer();
2647      } else {
2648        $scope.pause();
2649      }
2650    }
2651    var interval = +$scope.interval;
2652    if (!isNaN(interval) && interval>=0) {
2653      currentTimeout = $timeout(go, interval);
2654    }
2655  }
2656  $scope.play = function() {
2657    if (!isPlaying) {
2658      isPlaying = true;
2659      restartTimer();
2660    }
2661  };
2662  $scope.pause = function() {
2663    if (!$scope.noPause) {
2664      isPlaying = false;